flutter::HostWindow Class Reference

#include <host_window.h>

Public Member Functions
virtual	~HostWindow ()
HWND	GetWindowHandle () const
void	SetContentSize (const WindowSizeRequest &size)
void	SetConstraints (const WindowConstraints &constraints)
void	SetFullscreen (bool fullscreen, std::optional< FlutterEngineDisplayId > display_id)
bool	GetFullscreen () const

Static Public Member Functions
static std::unique_ptr< HostWindow >	CreateRegularWindow (WindowManager *controller, FlutterWindowsEngine *engine, const WindowSizeRequest &preferred_size, const WindowConstraints &preferred_constraints, LPCWSTR title)
static HostWindow *	GetThisFromHandle (HWND hwnd)
static ActualWindowSize	GetWindowContentSize (HWND hwnd)

Detailed Description

Definition at line 26 of file host_window.h.

Constructor & Destructor Documentation

~HostWindow()

flutter::HostWindow::~HostWindow ( )

virtual

Definition at line 385 of file host_window.cc.

                        {
  if (view_controller_) {
    // Unregister the window class. Fail silently if other windows are still
    // using the class, as only the last window can successfully unregister it.
    if (!UnregisterClass(kWindowClassName, GetModuleHandle(nullptr))) {
      // Clear the error state after the failed unregistration.
      SetLastError(ERROR_SUCCESS);
    }
  }
}

Member Function Documentation

CreateRegularWindow()

std::unique_ptr< HostWindow > flutter::HostWindow::CreateRegularWindow ( WindowManager *  controller, FlutterWindowsEngine *  engine, const WindowSizeRequest &  preferred_size, const WindowConstraints &  preferred_constraints, LPCWSTR  title  )

static

Definition at line 257 of file host_window.cc.

                   {
  DWORD window_style = WS_OVERLAPPEDWINDOW;
  DWORD extended_window_style = 0;
  auto const box_constraints = FromWindowConstraints(preferred_constraints);
 
  // TODO(knopp): What about windows sized to content?
  FML_CHECK(preferred_size.has_preferred_view_size);
 
  // Calculate the screen space window rectangle for the new window.
  // Default positioning values (CW_USEDEFAULT) are used
  // if the window has no owner.
  Rect const initial_window_rect = [&]() -> Rect {
    std::optional<Size> const window_size = GetWindowSizeForClientSize(
        *engine->windows_proc_table(),
        Size(preferred_size.preferred_view_width,
             preferred_size.preferred_view_height),
        box_constraints.smallest(), box_constraints.biggest(), window_style,
        extended_window_style, nullptr);
    return {{CW_USEDEFAULT, CW_USEDEFAULT},
            window_size ? *window_size : Size{CW_USEDEFAULT, CW_USEDEFAULT}};
  }();
 
  // Set up the view.
  auto view_window = std::make_unique<FlutterWindow>(
      initial_window_rect.width(), initial_window_rect.height(),
      engine->display_manager(), engine->windows_proc_table());
 
  std::unique_ptr<FlutterWindowsView> view =
      engine->CreateView(std::move(view_window));
  if (view == nullptr) {
    FML_LOG(ERROR) << "Failed to create view";
    return nullptr;
  }
 
  std::unique_ptr<FlutterWindowsViewController> view_controller =
      std::make_unique<FlutterWindowsViewController>(nullptr, std::move(view));
  FML_CHECK(engine->running());
  // The Windows embedder listens to accessibility updates using the
  // view's HWND. The embedder's accessibility features may be stale if
  // the app was in headless mode.
  engine->UpdateAccessibilityFeatures();
 
  // Register the window class.
  if (!IsClassRegistered(kWindowClassName)) {
    auto const idi_app_icon = 101;
    WNDCLASSEX window_class = {};
    window_class.cbSize = sizeof(WNDCLASSEX);
    window_class.style = CS_HREDRAW | CS_VREDRAW;
    window_class.lpfnWndProc = HostWindow::WndProc;
    window_class.hInstance = GetModuleHandle(nullptr);
    window_class.hIcon =
        LoadIcon(window_class.hInstance, MAKEINTRESOURCE(idi_app_icon));
    if (!window_class.hIcon) {
      window_class.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
    }
    window_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
    window_class.lpszClassName = kWindowClassName;
 
    if (!RegisterClassEx(&window_class)) {
      FML_LOG(ERROR) << "Cannot register window class "
                     << WCharBufferToString(kWindowClassName) << ": "
                     << GetLastErrorAsString();
      return nullptr;
    }
  }
 
  // Create the native window.
  HWND hwnd = CreateWindowEx(
      extended_window_style, kWindowClassName, title, window_style,
      initial_window_rect.left(), initial_window_rect.top(),
      initial_window_rect.width(), initial_window_rect.height(), nullptr,
      nullptr, GetModuleHandle(nullptr), engine->windows_proc_table().get());
  if (!hwnd) {
    FML_LOG(ERROR) << "Cannot create window: " << GetLastErrorAsString();
    return nullptr;
  }
 
  // Adjust the window position so its origin aligns with the top-left corner
  // of the window frame, not the window rectangle (which includes the
  // drop-shadow). This adjustment must be done post-creation since the frame
  // rectangle is only available after the window has been created.
  RECT frame_rect;
  DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &frame_rect,
                        sizeof(frame_rect));
  RECT window_rect;
  GetWindowRect(hwnd, &window_rect);
  LONG const left_dropshadow_width = frame_rect.left - window_rect.left;
  LONG const top_dropshadow_height = window_rect.top - frame_rect.top;
  SetWindowPos(hwnd, nullptr, window_rect.left - left_dropshadow_width,
               window_rect.top - top_dropshadow_height, 0, 0,
               SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
  UpdateTheme(hwnd);
 
  SetChildContent(view_controller->view()->GetWindowHandle(), hwnd);
 
  // TODO(loicsharma): Hide the window until the first frame is rendered.
  // Single window apps use the engine's next frame callback to show the
  // window. This doesn't work for multi window apps as the engine cannot have
  // multiple next frame callbacks. If multiple windows are created, only the
  // last one will be shown.
  ShowWindow(hwnd, SW_SHOWNORMAL);
  return std::unique_ptr<HostWindow>(
      new HostWindow(window_manager, engine, WindowArchetype::kRegular,
                     std::move(view_controller), box_constraints, hwnd));
}

References flutter::FlutterWindowsEngine::CreateView(), flutter::FlutterWindowsEngine::display_manager(), flutter::WindowSizeRequest::has_preferred_view_size, flutter::kRegular, flutter::WindowSizeRequest::preferred_view_height, flutter::WindowSizeRequest::preferred_view_width, flutter::FlutterWindowsEngine::running(), flutter::FlutterWindowsEngine::UpdateAccessibilityFeatures(), flutter::WCharBufferToString(), and flutter::FlutterWindowsEngine::windows_proc_table().

Referenced by flutter::WindowManager::CreateRegularWindow().

GetFullscreen()

bool flutter::HostWindow::GetFullscreen

(

)

const

Definition at line 748 of file host_window.cc.

                                     {
  return is_fullscreen_;
}

Referenced by InternalFlutterWindows_WindowManager_GetFullscreen(), SetConstraints(), SetContentSize(), and SetFullscreen().

GetThisFromHandle()

HostWindow * flutter::HostWindow::GetThisFromHandle ( HWND  hwnd )

static

Definition at line 396 of file host_window.cc.

                                                   {
  return reinterpret_cast<HostWindow*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
}

Referenced by InternalFlutterWindows_WindowManager_GetFullscreen(), InternalFlutterWindows_WindowManager_SetFullscreen(), InternalFlutterWindows_WindowManager_SetWindowConstraints(), and InternalFlutterWindows_WindowManager_SetWindowSize().

GetWindowContentSize()

ActualWindowSize flutter::HostWindow::GetWindowContentSize ( HWND  hwnd )

static

Definition at line 752 of file host_window.cc.

                                                           {
  RECT rect;
  GetClientRect(hwnd, &rect);
  double const dpr = FlutterDesktopGetDpiForHWND(hwnd) /
                     static_cast<double>(USER_DEFAULT_SCREEN_DPI);
  double const width = rect.right / dpr;
  double const height = rect.bottom / dpr;
  return {
      .width = rect.right / dpr,
      .height = rect.bottom / dpr,
  };
}

References FlutterDesktopGetDpiForHWND().

Referenced by InternalFlutterWindows_WindowManager_GetWindowContentSize(), SetConstraints(), and SetFullscreen().

GetWindowHandle()

HWND flutter::HostWindow::GetWindowHandle

(

)

const

Definition at line 400 of file host_window.cc.

                                       {
  return window_handle_;
}

SetConstraints()

void flutter::HostWindow::SetConstraints

(

const WindowConstraints &

constraints

)

Definition at line 561 of file host_window.cc.

                                                                    {
  box_constraints_ = FromWindowConstraints(constraints);
 
  if (GetFullscreen()) {
    std::optional<Size> const window_size = GetWindowSizeForClientSize(
        *engine_->windows_proc_table(),
        Size(saved_window_info_.client_size.width,
             saved_window_info_.client_size.height),
        box_constraints_.smallest(), box_constraints_.biggest(),
        saved_window_info_.style, saved_window_info_.ex_style, nullptr);
    if (!window_size) {
      return;
    }
 
    saved_window_info_.rect.right =
        saved_window_info_.rect.left + static_cast<LONG>(window_size->width());
    saved_window_info_.rect.bottom =
        saved_window_info_.rect.top + static_cast<LONG>(window_size->height());
  } else {
    auto const client_size = GetWindowContentSize(window_handle_);
    auto const current_size = Size(client_size.width, client_size.height);
    WINDOWINFO window_info = {.cbSize = sizeof(WINDOWINFO)};
    GetWindowInfo(window_handle_, &window_info);
    std::optional<Size> const window_size = GetWindowSizeForClientSize(
        *engine_->windows_proc_table(), current_size,
        box_constraints_.smallest(), box_constraints_.biggest(),
        window_info.dwStyle, window_info.dwExStyle, nullptr);
 
    if (window_size && current_size != window_size) {
      SetWindowPos(window_handle_, NULL, 0, 0, window_size->width(),
                   window_size->height(),
                   SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
  }
}

References GetFullscreen(), GetWindowContentSize(), and flutter::FlutterWindowsEngine::windows_proc_table().

Referenced by InternalFlutterWindows_WindowManager_SetWindowConstraints().

SetContentSize()

void flutter::HostWindow::SetContentSize

(

const WindowSizeRequest &

size

)

Definition at line 519 of file host_window.cc.

                                                             {
  if (!size.has_preferred_view_size) {
    return;
  }
 
  if (GetFullscreen()) {
    std::optional<Size> const window_size = GetWindowSizeForClientSize(
        *engine_->windows_proc_table(),
        Size(size.preferred_view_width, size.preferred_view_height),
        box_constraints_.smallest(), box_constraints_.biggest(),
        saved_window_info_.style, saved_window_info_.ex_style, nullptr);
    if (!window_size) {
      return;
    }
 
    saved_window_info_.client_size =
        ActualWindowSize{.width = size.preferred_view_width,
                         .height = size.preferred_view_height};
    saved_window_info_.rect.right =
        saved_window_info_.rect.left + static_cast<LONG>(window_size->width());
    saved_window_info_.rect.bottom =
        saved_window_info_.rect.top + static_cast<LONG>(window_size->height());
  } else {
    WINDOWINFO window_info = {.cbSize = sizeof(WINDOWINFO)};
    GetWindowInfo(window_handle_, &window_info);
 
    std::optional<Size> const window_size = GetWindowSizeForClientSize(
        *engine_->windows_proc_table(),
        Size(size.preferred_view_width, size.preferred_view_height),
        box_constraints_.smallest(), box_constraints_.biggest(),
        window_info.dwStyle, window_info.dwExStyle, nullptr);
 
    if (!window_size) {
      return;
    }
 
    SetWindowPos(window_handle_, NULL, 0, 0, window_size->width(),
                 window_size->height(),
                 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  }
}

References GetFullscreen(), flutter::WindowSizeRequest::has_preferred_view_size, flutter::WindowSizeRequest::preferred_view_height, flutter::WindowSizeRequest::preferred_view_width, flutter::ActualWindowSize::width, and flutter::FlutterWindowsEngine::windows_proc_table().

Referenced by InternalFlutterWindows_WindowManager_SetWindowSize().

SetFullscreen()

void flutter::HostWindow::SetFullscreen	(	bool	fullscreen,
		std::optional< FlutterEngineDisplayId >	display_id
	)

Definition at line 602 of file host_window.cc.

                                                    {
  if (fullscreen == GetFullscreen()) {
    return;
  }
 
  if (fullscreen) {
    WINDOWINFO window_info = {.cbSize = sizeof(WINDOWINFO)};
    GetWindowInfo(window_handle_, &window_info);
    saved_window_info_.style = window_info.dwStyle;
    saved_window_info_.ex_style = window_info.dwExStyle;
    // Store the original window rect, DPI, and monitor info to detect changes
    // and more accurately restore window placements when exiting fullscreen.
    ::GetWindowRect(window_handle_, &saved_window_info_.rect);
    saved_window_info_.client_size = GetWindowContentSize(window_handle_);
    saved_window_info_.dpi = GetDpiForHWND(window_handle_);
    saved_window_info_.monitor =
        MonitorFromWindow(window_handle_, MONITOR_DEFAULTTONEAREST);
    saved_window_info_.monitor_info.cbSize =
        sizeof(saved_window_info_.monitor_info);
    GetMonitorInfo(saved_window_info_.monitor,
                   &saved_window_info_.monitor_info);
  }
 
  if (fullscreen) {
    // Next, get the raw HMONITOR that we want to be fullscreened on
    HMONITOR monitor =
        MonitorFromWindow(window_handle_, MONITOR_DEFAULTTONEAREST);
    if (display_id) {
      if (auto const display =
              engine_->display_manager()->FindById(display_id.value())) {
        monitor = reinterpret_cast<HMONITOR>(display->display_id);
      }
    }
 
    MONITORINFO monitor_info;
    monitor_info.cbSize = sizeof(monitor_info);
    if (!GetMonitorInfo(monitor, &monitor_info)) {
      FML_LOG(ERROR) << "Cannot set window fullscreen because the monitor info "
                        "was not found";
    }
 
    auto const width = RectWidth(monitor_info.rcMonitor);
    auto const height = RectHeight(monitor_info.rcMonitor);
    WINDOWINFO window_info = {.cbSize = sizeof(WINDOWINFO)};
    GetWindowInfo(window_handle_, &window_info);
 
    // Set new window style and size.
    SetWindowLong(window_handle_, GWL_STYLE,
                  saved_window_info_.style & ~(WS_CAPTION | WS_THICKFRAME));
    SetWindowLong(
        window_handle_, GWL_EXSTYLE,
        saved_window_info_.ex_style & ~(WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE |
                                        WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
 
    // We call SetWindowPos first to set the window flags immediately. This
    // makes it so that the WM_GETMINMAXINFO gets called with the correct window
    // and content sizes.
    SetWindowPos(window_handle_, NULL, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 
    SetWindowPos(window_handle_, nullptr, monitor_info.rcMonitor.left,
                 monitor_info.rcMonitor.top, width, height,
                 SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
  } else {
    // Restore the window style and bounds saved prior to entering fullscreen.
    // Use WS_VISIBLE for windows shown after SetFullscreen: crbug.com/1062251.
    // Making multiple window adjustments here is ugly, but if SetWindowPos()
    // doesn't redraw, the taskbar won't be repainted.
    SetWindowLong(window_handle_, GWL_STYLE,
                  saved_window_info_.style | WS_VISIBLE);
    SetWindowLong(window_handle_, GWL_EXSTYLE, saved_window_info_.ex_style);
 
    // We call SetWindowPos first to set the window flags immediately. This
    // makes it so that the WM_GETMINMAXINFO gets called with the correct window
    // and content sizes.
    SetWindowPos(window_handle_, NULL, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
 
    HMONITOR monitor =
        MonitorFromRect(&saved_window_info_.rect, MONITOR_DEFAULTTONEAREST);
    MONITORINFO monitor_info;
    monitor_info.cbSize = sizeof(monitor_info);
    GetMonitorInfo(monitor, &monitor_info);
 
    auto window_rect = saved_window_info_.rect;
 
    // Adjust the window bounds to restore, if displays were disconnected,
    // virtually rearranged, or otherwise changed metrics during fullscreen.
    if (monitor != saved_window_info_.monitor ||
        !AreRectsEqual(saved_window_info_.monitor_info.rcWork,
                       monitor_info.rcWork)) {
      window_rect = AdjustToFit(monitor_info.rcWork, window_rect);
    }
 
    auto const fullscreen_dpi = GetDpiForHWND(window_handle_);
    SetWindowPos(window_handle_, nullptr, window_rect.left, window_rect.top,
                 RectWidth(window_rect), RectHeight(window_rect),
                 SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
    auto const final_dpi = GetDpiForHWND(window_handle_);
    if (final_dpi != saved_window_info_.dpi || final_dpi != fullscreen_dpi) {
      // Reissue SetWindowPos if the DPI changed from saved or fullscreen DPIs.
      // The first call may misinterpret bounds spanning displays, if the
      // fullscreen display's DPI does not match the target display's DPI.
      //
      // Scale and clamp the bounds if the final DPI changed from the saved DPI.
      // This more accurately matches the original placement, while avoiding
      // unexpected offscreen placement in a recongifured multi-screen space.
      if (final_dpi != saved_window_info_.dpi) {
        auto const scale =
            final_dpi / static_cast<float>(saved_window_info_.dpi);
        auto const width = static_cast<LONG>(scale * RectWidth(window_rect));
        auto const height = static_cast<LONG>(scale * RectHeight(window_rect));
        window_rect.right = window_rect.left + width;
        window_rect.bottom = window_rect.top + height;
        window_rect = AdjustToFit(monitor_info.rcWork, window_rect);
      }
 
      SetWindowPos(window_handle_, nullptr, window_rect.left, window_rect.top,
                   RectWidth(window_rect), RectHeight(window_rect),
                   SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
    }
  }
 
  if (!task_bar_list_) {
    HRESULT hr =
        ::CoCreateInstance(CLSID_TaskbarList, nullptr, CLSCTX_INPROC_SERVER,
                           IID_PPV_ARGS(&task_bar_list_));
    if (SUCCEEDED(hr) && FAILED(task_bar_list_->HrInit())) {
      task_bar_list_ = nullptr;
    }
  }
 
  // As per MSDN marking the window as fullscreen should ensure that the
  // taskbar is moved to the bottom of the Z-order when the fullscreen window
  // is activated. If the window is not fullscreen, the Shell falls back to
  // heuristics to determine how the window should be treated, which means
  // that it could still consider the window as fullscreen. :(
  if (task_bar_list_) {
    task_bar_list_->MarkFullscreenWindow(window_handle_, !!fullscreen);
  }
 
  is_fullscreen_ = fullscreen;
}

References flutter::AreRectsEqual(), flutter::FlutterWindowsEngine::display_manager(), flutter::GetDpiForHWND(), GetFullscreen(), GetWindowContentSize(), flutter::RectHeight(), and flutter::RectWidth().

Referenced by InternalFlutterWindows_WindowManager_SetFullscreen().

---

The documentation for this class was generated from the following files:

• shell/platform/windows/host_window.h
• shell/platform/windows/host_window.cc