win8/metro_driver/metro_driver_win7.cc

   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
   8 #include "base/logging.h"
   9
  10 EXTERN_C IMAGE_DOS_HEADER __ImageBase;
  11 int g_window_count = 0;
  12
  13 LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
  14                          WPARAM wparam, LPARAM lparam) {
  15   PAINTSTRUCT ps;
  16   HDC hdc;
  17   switch (message) {
  18     case WM_CREATE:
  19       ++g_window_count;
  20       break;
  21     case WM_PAINT:
  22       hdc = ::BeginPaint(hwnd, &ps);
  23       ::EndPaint(hwnd, &ps);
  24       break;
  25     case WM_LBUTTONUP:
  26       //  TODO(cpu): Remove this test code.
  27       ::InvalidateRect(hwnd, NULL, TRUE);
  28       break;
  29     case WM_CLOSE:
  30       ::DestroyWindow(hwnd);
  31       break;
  32     case WM_DESTROY:
  33       --g_window_count;
  34       if (!g_window_count)
  35         ::PostQuitMessage(0);
  36       break;
  37     default:
  38       return ::DefWindowProc(hwnd, message, wparam, lparam);
  39   }
  40   return 0;
  41 }
  42
  43 HWND CreateMetroTopLevelWindow() {
  44   HINSTANCE hInst = reinterpret_cast<HINSTANCE>(&__ImageBase);
  45   WNDCLASSEXW wcex;
  46   wcex.cbSize = sizeof(wcex);
  47   wcex.style              = CS_HREDRAW | CS_VREDRAW;
  48   wcex.lpfnWndProc        = WndProc;
  49   wcex.cbClsExtra         = 0;
  50   wcex.cbWndExtra         = 0;
  51   wcex.hInstance          = hInst;
  52   wcex.hIcon              = 0;
  53   wcex.hCursor            = LoadCursor(NULL, IDC_ARROW);
  54   wcex.hbrBackground      = (HBRUSH)(COLOR_INACTIVECAPTION+1);
  55   wcex.lpszMenuName       = 0;
  56   wcex.lpszClassName      = L"Windows.UI.Core.CoreWindow";
  57   wcex.hIconSm            = 0;
  58
  59   HWND hwnd = ::CreateWindowExW(0,
  60                                 MAKEINTATOM(::RegisterClassExW(&wcex)),
  61                                 L"metro_win7",
  62                                 WS_POPUP | WS_VISIBLE,
  63                                 0, 0, 1600, 900,
  64                                 NULL, NULL, hInst, NULL);
  65   return hwnd;
  66 }
  67
  68 typedef winfoundtn::ITypedEventHandler<
  69     winapp::Core::CoreApplicationView*,
  70     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
  71
  72 typedef winfoundtn::ITypedEventHandler<
  73     winui::Core::CoreWindow*,
  74     winui::Core::WindowActivatedEventArgs*> WindowActivatedHandler;
  75
  76 typedef winfoundtn::ITypedEventHandler<
  77     winui::Core::CoreWindow*,
  78     winui::Core::AutomationProviderRequestedEventArgs*>
  79         AutomationProviderHandler;
  80
  81 typedef winfoundtn::ITypedEventHandler<
  82     winui::Core::CoreWindow*,
  83     winui::Core::CharacterReceivedEventArgs*> CharEventHandler;
  84
  85 typedef winfoundtn::ITypedEventHandler<
  86     winui::Core::CoreWindow*,
  87     winui::Core::CoreWindowEventArgs*> CoreWindowEventHandler;
  88
  89 typedef winfoundtn::ITypedEventHandler<
  90     winui::Core::CoreWindow*,
  91     winui::Core::InputEnabledEventArgs*> InputEnabledEventHandler;
  92
  93 typedef winfoundtn::ITypedEventHandler<
  94     winui::Core::CoreWindow*,
  95     winui::Core::KeyEventArgs*> KeyEventHandler;
  96
  97 typedef winfoundtn::ITypedEventHandler<
  98     winui::Core::CoreWindow*,
  99     winui::Core::PointerEventArgs*> PointerEventHandler;
 100
 101 typedef winfoundtn::ITypedEventHandler<
 102     winui::Core::CoreWindow*,
 103     winui::Core::WindowSizeChangedEventArgs*> SizeChangedHandler;
 104
 105 typedef winfoundtn::ITypedEventHandler<
 106     winui::Core::CoreWindow*,
 107     winui::Core::TouchHitTestingEventArgs*> TouchHitTestHandler;
 108
 109 typedef winfoundtn::ITypedEventHandler<
 110     winui::Core::CoreWindow*,
 111     winui::Core::VisibilityChangedEventArgs*> VisibilityChangedHandler;
 112
 113 typedef winfoundtn::ITypedEventHandler<
 114     winui::Core::CoreDispatcher*,
 115     winui::Core::AcceleratorKeyEventArgs*> AcceleratorKeyEventHandler;
 116
 117 // The following classes are the emulation of the WinRT system as exposed
 118 // to metro applications. There is one application (ICoreApplication) which
 119 // contains a series of Views (ICoreApplicationView) each one of them
 120 // containing a CoreWindow which represents a surface that can drawn to
 121 // and that receives events.
 122 //
 123 // Here is the general dependency hierachy in terms of interfaces:
 124 //
 125 //  IFrameworkViewSource --> IFrameworkView
 126 //          ^                     |
 127 //          |                     |                          metro app
 128 //  ---------------------------------------------------------------------
 129 //          |                     |                         winRT system
 130 //          |                     v
 131 //  ICoreApplication     ICoreApplicationView
 132 //                                |
 133 //                                v
 134 //                          ICoreWindow -----> ICoreWindowInterop
 135 //                                |                  |
 136 //                                |                  |
 137 //                                v                  V
 138 //                         ICoreDispatcher  <==>  real HWND
 139 //
 140 class CoreDispacherEmulation :
 141     public mswr::RuntimeClass<
 142         winui::Core::ICoreDispatcher,
 143         winui::Core::ICoreAcceleratorKeys> {
 144  public:
 145   // ICoreDispatcher implementation:
 146   virtual HRESULT STDMETHODCALLTYPE get_HasThreadAccess(boolean* value) {
 147     return S_OK;
 148   }
 149
 150   virtual HRESULT STDMETHODCALLTYPE ProcessEvents(
 151       winui::Core::CoreProcessEventsOption options) {
 152     // We don't support the other message pump modes. So we basically enter a
 153     // traditional message loop that we only exit a teardown.
 154     if (options != winui::Core::CoreProcessEventsOption_ProcessUntilQuit)
 155       return E_FAIL;
 156
 157     MSG msg = {0};
 158     while((::GetMessage(&msg, NULL, 0, 0) != 0) && g_window_count > 0) {
 159       ::TranslateMessage(&msg);
 160       ::DispatchMessage(&msg);
 161     }
 162     // TODO(cpu): figure what to do with msg.WParam which we would normally
 163     // return here.
 164     return S_OK;
 165   }
 166
 167   virtual HRESULT STDMETHODCALLTYPE RunAsync(
 168       winui::Core::CoreDispatcherPriority priority,
 169       winui::Core::IDispatchedHandler *agileCallback,
 170       ABI::Windows::Foundation::IAsyncAction** asyncAction) {
 171     return S_OK;
 172   }
 173
 174   virtual HRESULT STDMETHODCALLTYPE RunIdleAsync(
 175       winui::Core::IIdleDispatchedHandler *agileCallback,
 176       winfoundtn::IAsyncAction** asyncAction) {
 177     return S_OK;
 178   }
 179
 180   // ICoreAcceleratorKeys implementation:
 181   virtual HRESULT STDMETHODCALLTYPE add_AcceleratorKeyActivated(
 182       AcceleratorKeyEventHandler* handler,
 183       EventRegistrationToken *pCookie) {
 184     // TODO(cpu): implement this.
 185     return S_OK;
 186   }
 187
 188   virtual HRESULT STDMETHODCALLTYPE remove_AcceleratorKeyActivated(
 189       EventRegistrationToken cookie) {
 190     return S_OK;
 191   }
 192
 193 };
 194
 195 class CoreWindowEmulation
 196     : public mswr::RuntimeClass<
 197         mswr::RuntimeClassFlags<mswr::WinRtClassicComMix>,
 198         winui::Core::ICoreWindow, ICoreWindowInterop> {
 199  public:
 200   CoreWindowEmulation() : core_hwnd_(NULL) {
 201     dispatcher_ = mswr::Make<CoreDispacherEmulation>();
 202     core_hwnd_ = CreateMetroTopLevelWindow();
 203   }
 204
 205   ~CoreWindowEmulation() {
 206     if (core_hwnd_)
 207       ::DestroyWindow(core_hwnd_);
 208   }
 209
 210   // ICoreWindow implementation:
 211   virtual HRESULT STDMETHODCALLTYPE get_AutomationHostProvider(
 212       IInspectable** value) {
 213     return S_OK;
 214   }
 215
 216   virtual HRESULT STDMETHODCALLTYPE get_Bounds(
 217       winfoundtn::Rect* value) {
 218     RECT rect;
 219     if (!::GetClientRect(core_hwnd_, &rect))
 220       return E_FAIL;
 221     value->Width = rect.right;
 222     value->Height = rect.bottom;
 223     return S_OK;
 224   }
 225
 226   virtual HRESULT STDMETHODCALLTYPE get_CustomProperties(
 227       winfoundtn::Collections::IPropertySet** value) {
 228     return S_OK;
 229   }
 230
 231   virtual HRESULT STDMETHODCALLTYPE get_Dispatcher(
 232       winui::Core::ICoreDispatcher** value) {
 233     return dispatcher_.CopyTo(value);
 234   }
 235
 236   virtual HRESULT STDMETHODCALLTYPE get_FlowDirection(
 237       winui::Core::CoreWindowFlowDirection* value) {
 238     return S_OK;
 239   }
 240
 241   virtual HRESULT STDMETHODCALLTYPE put_FlowDirection(
 242       winui::Core::CoreWindowFlowDirection value) {
 243     return S_OK;
 244   }
 245
 246   virtual HRESULT STDMETHODCALLTYPE get_IsInputEnabled(
 247       boolean* value) {
 248     return S_OK;
 249   }
 250
 251   virtual HRESULT STDMETHODCALLTYPE put_IsInputEnabled(
 252       boolean value) {
 253     return S_OK;
 254   }
 255
 256   virtual HRESULT STDMETHODCALLTYPE get_PointerCursor(
 257       winui::Core::ICoreCursor** value) {
 258     return S_OK;
 259   }
 260
 261   virtual HRESULT STDMETHODCALLTYPE put_PointerCursor(
 262        winui::Core::ICoreCursor* value) {
 263     return S_OK;
 264   }
 265
 266   virtual HRESULT STDMETHODCALLTYPE get_PointerPosition(
 267       winfoundtn::Point* value) {
 268     return S_OK;
 269   }
 270
 271   virtual HRESULT STDMETHODCALLTYPE get_Visible(
 272       boolean* value) {
 273     return S_OK;
 274   }
 275
 276   virtual HRESULT STDMETHODCALLTYPE Activate(void) {
 277     // After we fire OnActivate on the View, Chrome calls us back here.
 278     return S_OK;
 279   }
 280
 281   virtual HRESULT STDMETHODCALLTYPE Close(void) {
 282     ::PostMessage(core_hwnd_, WM_CLOSE, 0, 0);
 283     core_hwnd_ = NULL;
 284     return S_OK;
 285   }
 286
 287   virtual HRESULT STDMETHODCALLTYPE GetAsyncKeyState(
 288       ABI::Windows::System::VirtualKey virtualKey,
 289       winui::Core::CoreVirtualKeyStates* KeyState) {
 290     return S_OK;
 291   }
 292
 293   virtual HRESULT STDMETHODCALLTYPE GetKeyState(
 294       ABI::Windows::System::VirtualKey virtualKey,
 295       winui::Core::CoreVirtualKeyStates* KeyState) {
 296     return S_OK;
 297   }
 298
 299   virtual HRESULT STDMETHODCALLTYPE ReleasePointerCapture(void) {
 300     return S_OK;
 301   }
 302
 303   virtual HRESULT STDMETHODCALLTYPE SetPointerCapture(void) {
 304     return S_OK;
 305   }
 306
 307   virtual HRESULT STDMETHODCALLTYPE add_Activated(
 308       WindowActivatedHandler* handler,
 309       EventRegistrationToken* pCookie) {
 310     // TODO(cpu) implement this.
 311     return S_OK;
 312   }
 313
 314   virtual HRESULT STDMETHODCALLTYPE remove_Activated(
 315       EventRegistrationToken cookie) {
 316     return S_OK;
 317   }
 318
 319   virtual HRESULT STDMETHODCALLTYPE add_AutomationProviderRequested(
 320       AutomationProviderHandler* handler,
 321       EventRegistrationToken* cookie) {
 322     return S_OK;
 323   }
 324
 325   virtual HRESULT STDMETHODCALLTYPE remove_AutomationProviderRequested(
 326       EventRegistrationToken cookie) {
 327     return S_OK;
 328   }
 329
 330   virtual HRESULT STDMETHODCALLTYPE add_CharacterReceived(
 331       CharEventHandler* handler,
 332       EventRegistrationToken* pCookie) {
 333     // TODO(cpu) : implement this.
 334     return S_OK;
 335   }
 336
 337   virtual HRESULT STDMETHODCALLTYPE remove_CharacterReceived(
 338       EventRegistrationToken cookie) {
 339     return S_OK;
 340   }
 341
 342   virtual HRESULT STDMETHODCALLTYPE add_Closed(
 343       CoreWindowEventHandler* handler,
 344       EventRegistrationToken* pCookie) {
 345     return S_OK;
 346   }
 347
 348   virtual HRESULT STDMETHODCALLTYPE remove_Closed(
 349       EventRegistrationToken cookie) {
 350     return S_OK;
 351   }
 352
 353   virtual HRESULT STDMETHODCALLTYPE add_InputEnabled(
 354       InputEnabledEventHandler* handler,
 355       EventRegistrationToken* pCookie) {
 356     return S_OK;
 357   }
 358
 359   virtual HRESULT STDMETHODCALLTYPE remove_InputEnabled(
 360       EventRegistrationToken cookie) {
 361     return S_OK;
 362   }
 363
 364   virtual HRESULT STDMETHODCALLTYPE add_KeyDown(
 365       KeyEventHandler* handler,
 366       EventRegistrationToken* pCookie) {
 367     // TODO(cpu): implement this.
 368     return S_OK;
 369   }
 370
 371   virtual HRESULT STDMETHODCALLTYPE remove_KeyDown(
 372       EventRegistrationToken cookie) {
 373     return S_OK;
 374   }
 375
 376   virtual HRESULT STDMETHODCALLTYPE add_KeyUp(
 377       KeyEventHandler* handler,
 378       EventRegistrationToken* pCookie) {
 379     // TODO(cpu): implement this.
 380     return S_OK;
 381   }
 382
 383   virtual HRESULT STDMETHODCALLTYPE remove_KeyUp(
 384       EventRegistrationToken cookie) {
 385     return S_OK;
 386   }
 387
 388   virtual HRESULT STDMETHODCALLTYPE add_PointerCaptureLost(
 389       PointerEventHandler* handler,
 390       EventRegistrationToken* cookie) {
 391     return S_OK;
 392   }
 393
 394   virtual HRESULT STDMETHODCALLTYPE remove_PointerCaptureLost(
 395       EventRegistrationToken cookie) {
 396     return S_OK;
 397   }
 398
 399   virtual HRESULT STDMETHODCALLTYPE add_PointerEntered(
 400       PointerEventHandler* handler,
 401       EventRegistrationToken* cookie) {
 402     return S_OK;
 403   }
 404
 405   virtual HRESULT STDMETHODCALLTYPE remove_PointerEntered(
 406       EventRegistrationToken cookie) {
 407     return S_OK;
 408   }
 409
 410   virtual HRESULT STDMETHODCALLTYPE add_PointerExited(
 411       PointerEventHandler* handler,
 412       EventRegistrationToken* cookie) {
 413     return S_OK;
 414   }
 415
 416   virtual HRESULT STDMETHODCALLTYPE remove_PointerExited(
 417       EventRegistrationToken cookie) {
 418     return S_OK;
 419   }
 420
 421   virtual HRESULT STDMETHODCALLTYPE add_PointerMoved(
 422       PointerEventHandler* handler,
 423       EventRegistrationToken* cookie) {
 424     // TODO(cpu) : implement this.
 425     return S_OK;
 426   }
 427
 428   virtual HRESULT STDMETHODCALLTYPE remove_PointerMoved(
 429       EventRegistrationToken cookie) {
 430     return S_OK;
 431   }
 432
 433   virtual HRESULT STDMETHODCALLTYPE add_PointerPressed(
 434       PointerEventHandler* handler,
 435       EventRegistrationToken* cookie) {
 436     // TODO(cpu): implement this.
 437     return S_OK;
 438   }
 439
 440   virtual HRESULT STDMETHODCALLTYPE remove_PointerPressed(
 441       EventRegistrationToken cookie) {
 442     return S_OK;
 443   }
 444
 445   virtual HRESULT STDMETHODCALLTYPE add_PointerReleased(
 446       PointerEventHandler* handler,
 447       EventRegistrationToken* cookie) {
 448     // TODO(cpu): implement this.
 449     return S_OK;
 450   }
 451
 452   virtual HRESULT STDMETHODCALLTYPE remove_PointerReleased(
 453       EventRegistrationToken cookie) {
 454     return S_OK;
 455   }
 456
 457   virtual HRESULT STDMETHODCALLTYPE add_TouchHitTesting(
 458       TouchHitTestHandler* handler,
 459       EventRegistrationToken* pCookie) {
 460     return S_OK;
 461   }
 462
 463   virtual HRESULT STDMETHODCALLTYPE remove_TouchHitTesting(
 464       EventRegistrationToken cookie) {
 465     return S_OK;
 466   }
 467
 468   virtual HRESULT STDMETHODCALLTYPE add_PointerWheelChanged(
 469       PointerEventHandler* handler,
 470       EventRegistrationToken* cookie) {
 471     return S_OK;
 472   }
 473
 474   virtual HRESULT STDMETHODCALLTYPE remove_PointerWheelChanged(
 475       EventRegistrationToken cookie) {
 476     return S_OK;
 477   }
 478
 479   virtual HRESULT STDMETHODCALLTYPE add_SizeChanged(
 480       SizeChangedHandler* handler,
 481       EventRegistrationToken* pCookie) {
 482     // TODO(cpu): implement this.
 483     return S_OK;
 484   }
 485
 486   virtual HRESULT STDMETHODCALLTYPE remove_SizeChanged(
 487       EventRegistrationToken cookie) {
 488     return S_OK;
 489   }
 490
 491   virtual HRESULT STDMETHODCALLTYPE add_VisibilityChanged(
 492       VisibilityChangedHandler* handler,
 493       EventRegistrationToken* pCookie) {
 494     return S_OK;
 495   }
 496
 497   virtual HRESULT STDMETHODCALLTYPE remove_VisibilityChanged(
 498       EventRegistrationToken cookie) {
 499     return S_OK;
 500   }
 501
 502   // ICoreWindowInterop implementation:
 503   virtual HRESULT STDMETHODCALLTYPE get_WindowHandle(HWND* hwnd) {
 504     if (!core_hwnd_)
 505       return E_FAIL;
 506     *hwnd = core_hwnd_;
 507     return S_OK;
 508   }
 509
 510   virtual HRESULT STDMETHODCALLTYPE put_MessageHandled(
 511     boolean value) {
 512     return S_OK;
 513   }
 514
 515  private:
 516    HWND core_hwnd_;
 517    mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher_;
 518 };
 519
 520 class ActivatedEvent
 521     : public mswr::RuntimeClass<winapp::Activation::IActivatedEventArgs> {
 522  public:
 523   ActivatedEvent(winapp::Activation::ActivationKind activation_kind)
 524     : activation_kind_(activation_kind) {
 525   }
 526
 527   virtual HRESULT STDMETHODCALLTYPE get_Kind(
 528     winapp::Activation::ActivationKind *value) {
 529     *value = activation_kind_;
 530     return S_OK;
 531   }
 532
 533   virtual HRESULT STDMETHODCALLTYPE get_PreviousExecutionState(
 534     winapp::Activation::ApplicationExecutionState *value) {
 535     *value = winapp::Activation::ApplicationExecutionState_ClosedByUser;
 536     return S_OK;
 537   }
 538
 539   virtual HRESULT STDMETHODCALLTYPE get_SplashScreen(
 540     winapp::Activation::ISplashScreen **value) {
 541     return E_FAIL;
 542   }
 543
 544  private:
 545   winapp::Activation::ActivationKind activation_kind_;
 546 };
 547
 548 class CoreApplicationViewEmulation
 549     : public mswr::RuntimeClass<winapp::Core::ICoreApplicationView> {
 550  public:
 551    CoreApplicationViewEmulation() {
 552       core_window_ = mswr::Make<CoreWindowEmulation>();
 553    }
 554
 555   HRESULT Activate() {
 556     if (activated_handler_) {
 557       auto ae = mswr::Make<ActivatedEvent>(
 558         winapp::Activation::ActivationKind_File);
 559       return activated_handler_->Invoke(this, ae.Get());
 560     } else {
 561       return S_OK;
 562     }
 563   }
 564
 565   HRESULT Close() {
 566     return core_window_->Close();
 567   }
 568
 569   // ICoreApplicationView implementation:
 570   virtual HRESULT STDMETHODCALLTYPE get_CoreWindow(
 571     winui::Core::ICoreWindow** value) {
 572     if (!core_window_)
 573       return E_FAIL;
 574     return core_window_.CopyTo(value);
 575   }
 576
 577   virtual HRESULT STDMETHODCALLTYPE add_Activated(
 578      ActivatedHandler* handler,
 579     EventRegistrationToken* token) {
 580     // The real component supports multiple handles but we don't yet.
 581     if (activated_handler_)
 582       return E_FAIL;
 583     activated_handler_ = handler;
 584     return S_OK;
 585   }
 586
 587   virtual HRESULT STDMETHODCALLTYPE remove_Activated(
 588     EventRegistrationToken token) {
 589     // Chrome never unregisters handlers, so we don't care about it.
 590     return S_OK;
 591   }
 592
 593   virtual HRESULT STDMETHODCALLTYPE get_IsMain(
 594     boolean* value) {
 595     return S_OK;
 596   }
 597
 598   virtual HRESULT STDMETHODCALLTYPE get_IsHosted(
 599     boolean* value) {
 600     return S_OK;
 601   }
 602
 603  private:
 604   mswr::ComPtr<CoreWindowEmulation> core_window_;
 605   mswr::ComPtr<ActivatedHandler> activated_handler_;
 606 };
 607
 608 class CoreApplicationWin7Emulation
 609     : public mswr::RuntimeClass<winapp::Core::ICoreApplication,
 610                                 winapp::Core::ICoreApplicationExit> {
 611  public:
 612    // ICoreApplication implementation:
 613
 614   virtual HRESULT STDMETHODCALLTYPE get_Id(
 615       HSTRING* value) {
 616     return S_OK;
 617   }
 618
 619   virtual HRESULT STDMETHODCALLTYPE add_Suspending(
 620       winfoundtn::IEventHandler<winapp::SuspendingEventArgs*>* handler,
 621       EventRegistrationToken* token) {
 622     return S_OK;
 623   }
 624
 625   virtual HRESULT STDMETHODCALLTYPE remove_Suspending(
 626       EventRegistrationToken token) {
 627     return S_OK;
 628   }
 629
 630   virtual HRESULT STDMETHODCALLTYPE add_Resuming(
 631        winfoundtn::IEventHandler<IInspectable*>* handler,
 632       EventRegistrationToken* token) {
 633     return S_OK;
 634   }
 635
 636   virtual HRESULT STDMETHODCALLTYPE remove_Resuming(
 637       EventRegistrationToken token) {
 638     return S_OK;
 639   }
 640
 641   virtual HRESULT STDMETHODCALLTYPE get_Properties(
 642       winfoundtn::Collections::IPropertySet** value) {
 643     return S_OK;
 644   }
 645
 646   virtual HRESULT STDMETHODCALLTYPE GetCurrentView(
 647       winapp::Core::ICoreApplicationView** value) {
 648     return S_OK;
 649   }
 650
 651   virtual HRESULT STDMETHODCALLTYPE Run(
 652       winapp::Core::IFrameworkViewSource* viewSource) {
 653     HRESULT hr = viewSource->CreateView(app_view_.GetAddressOf());
 654     if (FAILED(hr))
 655       return hr;
 656     view_emulation_ = mswr::Make<CoreApplicationViewEmulation>();
 657     hr = app_view_->Initialize(view_emulation_.Get());
 658     if (FAILED(hr))
 659       return hr;
 660     mswr::ComPtr<winui::Core::ICoreWindow> core_window;
 661     hr = view_emulation_->get_CoreWindow(core_window.GetAddressOf());
 662     if (FAILED(hr))
 663       return hr;
 664     hr = app_view_->SetWindow(core_window.Get());
 665     if (FAILED(hr))
 666       return hr;
 667     hr = app_view_->Load(NULL);
 668     if (FAILED(hr))
 669       return hr;
 670     hr = view_emulation_->Activate();
 671     if (FAILED(hr))
 672       return hr;
 673     return app_view_->Run();
 674   }
 675
 676   virtual HRESULT STDMETHODCALLTYPE RunWithActivationFactories(
 677       winfoundtn::IGetActivationFactory* activationFactoryCallback) {
 678     return S_OK;
 679   }
 680
 681   // ICoreApplicationExit implementation:
 682
 683   virtual HRESULT STDMETHODCALLTYPE Exit(void) {
 684     return view_emulation_->Close();
 685   }
 686
 687   virtual HRESULT STDMETHODCALLTYPE add_Exiting(
 688        winfoundtn::IEventHandler<IInspectable*>* handler,
 689       EventRegistrationToken* token) {
 690     return S_OK;
 691   }
 692
 693   virtual HRESULT STDMETHODCALLTYPE remove_Exiting(
 694       EventRegistrationToken token) {
 695     return S_OK;
 696   }
 697
 698  private:
 699   mswr::ComPtr<winapp::Core::IFrameworkView> app_view_;
 700   mswr::ComPtr<CoreApplicationViewEmulation> view_emulation_;
 701 };
 702
 703
 704 mswr::ComPtr<winapp::Core::ICoreApplication> InitWindows7() {
 705   HRESULT hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
 706   if (FAILED(hr))
 707     CHECK(false);
 708   return mswr::Make<CoreApplicationWin7Emulation>();
 709 }
 710