flutter::HostWindow Class Reference

#include <host_window.h>

Inheritance diagram for flutter::HostWindow:

Classes
struct	HostWindowInitializationParams
struct	SavedWindowInfo

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

Static Public Member Functions
static std::unique_ptr< HostWindow >	CreateRegularWindow (WindowManager *window_manager, FlutterWindowsEngine *engine, const WindowSizeRequest &preferred_size, const WindowConstraints &preferred_constraints, LPCWSTR title, bool sized_to_content, bool resizable)
static std::unique_ptr< HostWindow >	CreateDialogWindow (WindowManager *window_manager, FlutterWindowsEngine *engine, const WindowSizeRequest &preferred_size, const WindowConstraints &preferred_constraints, LPCWSTR title, HWND parent, bool sized_to_content, bool resizable)
static std::unique_ptr< HostWindow >	CreateTooltipWindow (WindowManager *window_manager, FlutterWindowsEngine *engine, const WindowConstraints &preferred_constraints, GetWindowPositionCallback get_position_callback, HWND parent)
static std::unique_ptr< HostWindow >	CreatePopupWindow (WindowManager *window_manager, FlutterWindowsEngine *engine, const WindowConstraints &preferred_constraints, GetWindowPositionCallback get_position_callback, HWND parent)
static HostWindow *	GetThisFromHandle (HWND hwnd)
static ActualWindowSize	GetWindowContentSize (HWND hwnd)

Protected Member Functions
void	InitializeFlutterView (HostWindowInitializationParams const &params)
	HostWindow (WindowManager *window_manager, FlutterWindowsEngine *engine)
virtual LRESULT	HandleMessage (HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
void	HandleWindowActivation (HWND hwnd, WPARAM wparam)
void	EnableRecursively (bool enable)
HostWindow *	FindFirstEnabledDescendant () const
WindowArchetype	GetArchetype () const
std::vector< HostWindow * >	GetOwnedWindows () const
void	DisableRecursively ()
	FML_DISALLOW_COPY_AND_ASSIGN (HostWindow)

Static Protected Member Functions
static std::optional< Size >	GetWindowSizeForClientSize (WindowsProcTable const &win32, Size const &client_size, std::optional< Size > smallest, std::optional< Size > biggest, DWORD window_style, DWORD extended_window_style, std::optional< HWND > const &owner_hwnd)
static void	FocusRootViewOf (HostWindow *window)
static LRESULT	WndProc (HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)

Protected Attributes
friend	WindowManager
WindowManager *const	window_manager_ = nullptr
FlutterWindowsEngine *	engine_
std::unique_ptr< FlutterWindowsViewController >	view_controller_
WindowArchetype	archetype_ = WindowArchetype::kRegular
HWND	window_handle_
BoxConstraints	box_constraints_
bool	is_being_destroyed_ = false
bool	is_fullscreen_ = false
SavedWindowInfo	saved_window_info_
Microsoft::WRL::ComPtr< ITaskbarList2 >	task_bar_list_

Detailed Description

Definition at line 29 of file host_window.h.

Constructor & Destructor Documentation

~HostWindow()

flutter::HostWindow::~HostWindow ( )

virtual

Definition at line 315 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);
    }
  }
}

HostWindow()

flutter::HostWindow::HostWindow ( WindowManager *  window_manager, FlutterWindowsEngine *  engine  )

protected

Definition at line 228 of file host_window.cc.

    : window_manager_(window_manager), engine_(engine) {}

Member Function Documentation

CreateDialogWindow()

std::unique_ptr< HostWindow > flutter::HostWindow::CreateDialogWindow ( WindowManager *  window_manager, FlutterWindowsEngine *  engine, const WindowSizeRequest &  preferred_size, const WindowConstraints &  preferred_constraints, LPCWSTR  title, HWND  parent, bool  sized_to_content, bool  resizable  )

static

Definition at line 191 of file host_window.cc.

                    {
  return std::unique_ptr<HostWindow>(new HostWindowDialog(
      window_manager, engine, preferred_size,
      FromWindowConstraints(preferred_constraints), title,
      parent ? parent : std::optional<HWND>(), sized_to_content, resizable));
}

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

CreatePopupWindow()

std::unique_ptr< HostWindow > flutter::HostWindow::CreatePopupWindow ( WindowManager *  window_manager, FlutterWindowsEngine *  engine, const WindowConstraints &  preferred_constraints, GetWindowPositionCallback  get_position_callback, HWND  parent  )

static

Definition at line 217 of file host_window.cc.

                 {
  return std::unique_ptr<HostWindowPopup>(new HostWindowPopup(
      window_manager, engine, FromWindowConstraints(preferred_constraints),
      get_position_callback, parent));
}

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

CreateRegularWindow()

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

static

Definition at line 177 of file host_window.cc.

                    {
  return std::unique_ptr<HostWindow>(
      new HostWindowRegular(window_manager, engine, preferred_size,
                            FromWindowConstraints(preferred_constraints), title,
                            sized_to_content, resizable));
}

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

CreateTooltipWindow()

std::unique_ptr< HostWindow > flutter::HostWindow::CreateTooltipWindow ( WindowManager *  window_manager, FlutterWindowsEngine *  engine, const WindowConstraints &  preferred_constraints, GetWindowPositionCallback  get_position_callback, HWND  parent  )

static

Definition at line 206 of file host_window.cc.

                 {
  return std::unique_ptr<HostWindowTooltip>(new HostWindowTooltip(
      window_manager, engine, FromWindowConstraints(preferred_constraints),
      get_position_callback, parent));
}

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

DisableRecursively()

void flutter::HostWindow::DisableRecursively ( )

protected

Definition at line 850 of file host_window.cc.

                                    {
  // Disable the window itself.
  EnableWindow(window_handle_, false);
 
  for (HostWindow* const owned : GetOwnedWindows()) {
    owned->DisableRecursively();
  }
}

EnableRecursively()

void flutter::HostWindow::EnableRecursively ( bool  enable )

protected

Definition at line 798 of file host_window.cc.

                                              {
  EnableWindow(window_handle_, enable);
 
  for (HostWindow* const owned : GetOwnedWindows()) {
    owned->EnableRecursively(enable);
  }
}

FindFirstEnabledDescendant()

HostWindow * flutter::HostWindow::FindFirstEnabledDescendant ( ) const

protected

Definition at line 806 of file host_window.cc.

                                                         {
  if (IsWindowEnabled(window_handle_)) {
    return const_cast<HostWindow*>(this);
  }
 
  for (HostWindow* const owned : GetOwnedWindows()) {
    if (HostWindow* const result = owned->FindFirstEnabledDescendant()) {
      return result;
    }
  }
 
  return nullptr;
}

References FindFirstEnabledDescendant().

Referenced by FindFirstEnabledDescendant().

FML_DISALLOW_COPY_AND_ASSIGN()

flutter::HostWindow::FML_DISALLOW_COPY_AND_ASSIGN ( HostWindow  )

protected

FocusRootViewOf()

void flutter::HostWindow::FocusRootViewOf ( HostWindow *  window )

staticprotected

Definition at line 349 of file host_window.cc.

                                                   {
  auto child_content = window->view_controller_->view()->GetWindowHandle();
  if (window != nullptr && child_content != nullptr) {
    SetFocus(child_content);
  }
};

References view_controller_.

Referenced by flutter::HostWindowDialog::HandleMessage().

GetArchetype()

WindowArchetype flutter::HostWindow::GetArchetype ( ) const

inlineprotected

Definition at line 236 of file host_window.h.

{ return archetype_; }

References archetype_.

GetFlutterViewWindowHandle()

HWND flutter::HostWindow::GetFlutterViewWindowHandle

(

)

const

Definition at line 345 of file host_window.cc.

                                                  {
  return view_controller_->view()->GetWindowHandle();
}

References GetWindowHandle().

Referenced by InternalFlutterWindows_WindowManager_OnDestroyWindow().

GetFullscreen()

bool flutter::HostWindow::GetFullscreen ( ) const

virtual

Reimplemented in flutter::HostWindowDialog.

Definition at line 734 of file host_window.cc.

                                     {
  return is_fullscreen_;
}

Referenced by InternalFlutterWindows_WindowManager_GetFullscreen().

GetOwnedWindows()

std::vector< HostWindow * > flutter::HostWindow::GetOwnedWindows ( ) const

protected

Definition at line 820 of file host_window.cc.

                                                         {
  std::vector<HostWindow*> owned_windows;
  struct EnumData {
    HWND owner_window_handle;
    std::vector<HostWindow*>* owned_windows;
  } data{window_handle_, &owned_windows};
 
  EnumWindows(
      [](HWND hwnd, LPARAM lparam) -> BOOL {
        auto* const data = reinterpret_cast<EnumData*>(lparam);
        if (GetWindow(hwnd, GW_OWNER) == data->owner_window_handle) {
          HostWindow* const window = GetThisFromHandle(hwnd);
          if (window && !window->is_being_destroyed_) {
            data->owned_windows->push_back(window);
          }
        }
        return TRUE;
      },
      reinterpret_cast<LPARAM>(&data));
 
  return owned_windows;
}

References is_being_destroyed_.

GetOwnerWindow()

HostWindow * flutter::HostWindow::GetOwnerWindow

(

)

const

Definition at line 843 of file host_window.cc.

                                             {
  if (HWND const owner_window_handle = GetWindow(GetWindowHandle(), GW_OWNER)) {
    return GetThisFromHandle(owner_window_handle);
  }
  return nullptr;
};

Referenced by flutter::HostWindowDialog::HandleMessage(), and flutter::testing::TEST_F().

GetThisFromHandle()

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

static

Definition at line 326 of file host_window.cc.

                                                   {
  wchar_t class_name[256];
  if (!GetClassName(hwnd, class_name, sizeof(class_name) / sizeof(wchar_t))) {
    FML_LOG(ERROR) << "Failed to get class name for window handle " << hwnd
                   << ": " << GetLastErrorAsString();
    return nullptr;
  }
  // Ignore window handles that do not match the expected class name.
  if (wcscmp(class_name, kWindowClassName) != 0) {
    return nullptr;
  }
 
  return reinterpret_cast<HostWindow*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
}

Referenced by flutter::WindowManager::HandleMessage(), InternalFlutterWindows_WindowManager_GetFullscreen(), InternalFlutterWindows_WindowManager_OnDestroyWindow(), InternalFlutterWindows_WindowManager_SetFullscreen(), InternalFlutterWindows_WindowManager_SetWindowConstraints(), InternalFlutterWindows_WindowManager_SetWindowSize(), InternalFlutterWindows_WindowManager_UpdatePopupPosition(), InternalFlutterWindows_WindowManager_UpdateTooltipPosition(), and flutter::testing::TEST_F().

GetWindowContentSize()

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

static

Definition at line 738 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().

GetWindowHandle()

HWND flutter::HostWindow::GetWindowHandle

(

)

const

Definition at line 341 of file host_window.cc.

                                       {
  return window_handle_;
}

Referenced by GetFlutterViewWindowHandle(), and flutter::testing::TEST_F().

GetWindowSizeForClientSize()

std::optional< Size > flutter::HostWindow::GetWindowSizeForClientSize ( WindowsProcTable const &  win32, Size const &  client_size, std::optional< Size >  smallest, std::optional< Size >  biggest, DWORD  window_style, DWORD  extended_window_style, std::optional< HWND > const &  owner_hwnd  )

staticprotected

Definition at line 751 of file host_window.cc.

                                         {
  UINT const dpi = GetDpiForHWND(owner_hwnd ? *owner_hwnd : nullptr);
  double const scale_factor =
      static_cast<double>(dpi) / USER_DEFAULT_SCREEN_DPI;
  RECT rect = {
      .right = static_cast<LONG>(client_size.width() * scale_factor),
      .bottom = static_cast<LONG>(client_size.height() * scale_factor)};
 
  if (!win32.AdjustWindowRectExForDpi(&rect, window_style, FALSE,
                                      extended_window_style, dpi)) {
    FML_LOG(ERROR) << "Failed to run AdjustWindowRectExForDpi: "
                   << GetLastErrorAsString();
    return std::nullopt;
  }
 
  double width = static_cast<double>(rect.right - rect.left);
  double height = static_cast<double>(rect.bottom - rect.top);
 
  // Apply size constraints.
  double const non_client_width = width - (client_size.width() * scale_factor);
  double const non_client_height =
      height - (client_size.height() * scale_factor);
  if (smallest) {
    flutter::Size min_physical_size = ClampToVirtualScreen(
        flutter::Size(smallest->width() * scale_factor + non_client_width,
                      smallest->height() * scale_factor + non_client_height));
    width = std::max(width, min_physical_size.width());
    height = std::max(height, min_physical_size.height());
  }
  if (biggest) {
    flutter::Size max_physical_size = ClampToVirtualScreen(
        flutter::Size(biggest->width() * scale_factor + non_client_width,
                      biggest->height() * scale_factor + non_client_height));
    width = std::min(width, max_physical_size.width());
    height = std::min(height, max_physical_size.height());
  }
 
  return flutter::Size{width, height};
}

References flutter::WindowsProcTable::AdjustWindowRectExForDpi(), and flutter::GetDpiForHWND().

Referenced by flutter::HostWindowSized::ApplyContentSize().

HandleMessage()

LRESULT flutter::HostWindow::HandleMessage ( HWND  hwnd, UINT  message, WPARAM  wparam, LPARAM  lparam  )

protectedvirtual

Reimplemented in flutter::HostWindowTooltip, and flutter::HostWindowDialog.

Definition at line 396 of file host_window.cc.

                                                 {
  auto result = engine_->window_proc_delegate_manager()->OnTopLevelWindowProc(
      window_handle_, message, wparam, lparam);
  if (result) {
    return *result;
  }
 
  switch (message) {
    case WM_DESTROY:
      is_being_destroyed_ = true;
      break;
 
    case WM_NCLBUTTONDOWN: {
      // Fix for 500ms hang after user clicks on the title bar, but before
      // moving mouse. Reference:
      // https://gamedev.net/forums/topic/672094-keeping-things-moving-during-win32-moveresize-events/5254386/
      if (SendMessage(window_handle_, WM_NCHITTEST, wparam, lparam) ==
          HTCAPTION) {
        POINT cursorPos;
        // Get the current cursor position and synthesize WM_MOUSEMOVE to
        // unblock default window proc implementation for WM_NCLBUTTONDOWN at
        // HTCAPTION.
        GetCursorPos(&cursorPos);
        ScreenToClient(window_handle_, &cursorPos);
        PostMessage(window_handle_, WM_MOUSEMOVE, 0,
                    MAKELPARAM(cursorPos.x, cursorPos.y));
      }
      break;
    }
 
    case WM_DPICHANGED: {
      auto* const new_scaled_window_rect = reinterpret_cast<RECT*>(lparam);
      LONG const width =
          new_scaled_window_rect->right - new_scaled_window_rect->left;
      LONG const height =
          new_scaled_window_rect->bottom - new_scaled_window_rect->top;
      SetWindowPos(hwnd, nullptr, new_scaled_window_rect->left,
                   new_scaled_window_rect->top, width, height,
                   SWP_NOZORDER | SWP_NOACTIVATE);
      return 0;
    }
 
    case WM_GETMINMAXINFO: {
      RECT window_rect;
      GetWindowRect(hwnd, &window_rect);
      RECT client_rect;
      GetClientRect(hwnd, &client_rect);
      LONG const non_client_width = (window_rect.right - window_rect.left) -
                                    (client_rect.right - client_rect.left);
      LONG const non_client_height = (window_rect.bottom - window_rect.top) -
                                     (client_rect.bottom - client_rect.top);
 
      UINT const dpi = flutter::GetDpiForHWND(hwnd);
      double const scale_factor =
          static_cast<double>(dpi) / USER_DEFAULT_SCREEN_DPI;
 
      MINMAXINFO* info = reinterpret_cast<MINMAXINFO*>(lparam);
      Size const min_physical_size = ClampToVirtualScreen(Size(
          box_constraints_.smallest().width() * scale_factor + non_client_width,
          box_constraints_.smallest().height() * scale_factor +
              non_client_height));
 
      info->ptMinTrackSize.x = min_physical_size.width();
      info->ptMinTrackSize.y = min_physical_size.height();
      Size const max_physical_size = ClampToVirtualScreen(Size(
          box_constraints_.biggest().width() * scale_factor + non_client_width,
          box_constraints_.biggest().height() * scale_factor +
              non_client_height));
 
      info->ptMaxTrackSize.x = max_physical_size.width();
      info->ptMaxTrackSize.y = max_physical_size.height();
      return 0;
    }
 
    case WM_SIZE: {
      auto child_content = view_controller_->view()->GetWindowHandle();
      if (child_content != nullptr) {
        // Resize and reposition the child content window.
        RECT client_rect;
        GetClientRect(hwnd, &client_rect);
        MoveWindow(child_content, client_rect.left, client_rect.top,
                   client_rect.right - client_rect.left,
                   client_rect.bottom - client_rect.top, TRUE);
      }
      return 0;
    }
 
    case WM_ACTIVATE:
      HandleWindowActivation(hwnd, wparam);
      return 0;
 
    case WM_DWMCOLORIZATIONCOLORCHANGED:
      UpdateTheme(hwnd);
      return 0;
 
    default:
      break;
  }
 
  if (!view_controller_) {
    return 0;
  }
 
  return DefWindowProc(hwnd, message, wparam, lparam);
}

Referenced by flutter::HostWindowDialog::HandleMessage(), and flutter::HostWindowTooltip::HandleMessage().

HandleWindowActivation()

void flutter::HostWindow::HandleWindowActivation ( HWND  hwnd, WPARAM  wparam  )

protected

Definition at line 356 of file host_window.cc.

                                                                {
  if (LOWORD(wparam) == WA_INACTIVE) {
    // The window is being deactivated; leave focus untouched. Focusing this
    // window's view would call SetFocus on its content, which reactivates the
    // window (SetFocus activates the parent of the focused window) and pulls it
    // back to the top of the z-order, taking activation from the window that is
    // being activated.
    return;
  }
 
  if (!IsWindowEnabled(hwnd)) {
    // Prevent a disabled window (e.g. the owner of a modal dialog) from being
    // activated using the task switcher by redirecting focus and activation to
    // the first enabled descendant.
    if (HostWindow* const enabled_descendant = FindFirstEnabledDescendant()) {
      SetActiveWindow(enabled_descendant->GetWindowHandle());
      FocusRootViewOf(this);
    }
    return;
  }
 
  FocusRootViewOf(this);
}

Referenced by flutter::HostWindowDialog::HandleMessage().

InitializeFlutterView()

void flutter::HostWindow::InitializeFlutterView ( HostWindowInitializationParams const &  params )

protected

Definition at line 232 of file host_window.cc.

                                                  {
  // Set up the view.
  auto view_window = std::make_unique<FlutterWindow>(
      params.initial_window_rect.width(), params.initial_window_rect.height(),
      engine_->display_manager(), engine_->windows_proc_table());
 
  std::unique_ptr<FlutterWindowsView> view =
      engine_->CreateView(std::move(view_window), params.is_sized_to_content,
                          params.box_constraints, params.sizing_delegate);
  FML_CHECK(view != nullptr);
 
  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;
 
    FML_CHECK(RegisterClassEx(&window_class));
  }
 
  // Create the native window.
  window_handle_ = CreateWindowEx(
      params.extended_window_style, kWindowClassName, params.title,
      params.window_style, params.initial_window_rect.left(),
      params.initial_window_rect.top(), params.initial_window_rect.width(),
      params.initial_window_rect.height(),
      params.owner_window ? *params.owner_window : nullptr, nullptr,
      GetModuleHandle(nullptr), engine_->windows_proc_table().get());
  FML_CHECK(window_handle_ != 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(window_handle_, DWMWA_EXTENDED_FRAME_BOUNDS,
                        &frame_rect, sizeof(frame_rect));
  RECT window_rect;
  GetWindowRect(window_handle_, &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(window_handle_, nullptr,
               window_rect.left - left_dropshadow_width,
               window_rect.top - top_dropshadow_height, 0, 0,
               SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
  UpdateTheme(window_handle_);
 
  SetChildContent(view_controller_->view()->GetWindowHandle(), window_handle_);
 
  // Defer showing the window until the first frame is rendered so the user
  // doesn't see a blank window. Each view has its own first-frame callback,
  // so this works correctly for multi-window apps.
  view_controller_->view()->SetFirstFrameCallback(
      [hwnd = window_handle_, cmd_show = params.nCmdShow]() {
        if (::IsWindow(hwnd)) {
          ShowWindow(hwnd, cmd_show);
        }
      });
  archetype_ = params.archetype;
  SetWindowLongPtr(window_handle_, GWLP_USERDATA,
                   reinterpret_cast<LONG_PTR>(this));
}

References flutter::HostWindow::HostWindowInitializationParams::box_constraints, flutter::FlutterWindowsEngine::CreateView(), flutter::FlutterWindowsEngine::display_manager(), engine_, flutter::HostWindow::HostWindowInitializationParams::extended_window_style, flutter::HostWindow::HostWindowInitializationParams::initial_window_rect, flutter::HostWindow::HostWindowInitializationParams::is_sized_to_content, flutter::HostWindow::HostWindowInitializationParams::nCmdShow, flutter::HostWindow::HostWindowInitializationParams::owner_window, flutter::FlutterWindowsEngine::running(), flutter::HostWindow::HostWindowInitializationParams::sizing_delegate, flutter::HostWindow::HostWindowInitializationParams::title, flutter::FlutterWindowsEngine::UpdateAccessibilityFeatures(), view_controller_, window_handle_, flutter::HostWindow::HostWindowInitializationParams::window_style, flutter::FlutterWindowsEngine::windows_proc_table(), and WndProc().

Referenced by flutter::HostWindowDialog::HostWindowDialog(), and flutter::HostWindowRegular::HostWindowRegular().

SetConstraints()

void flutter::HostWindow::SetConstraints

(

const WindowConstraints &

constraints

)

Definition at line 547 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);
    }
  }
}

Referenced by InternalFlutterWindows_WindowManager_SetWindowConstraints().

SetContentSize()

void flutter::HostWindow::SetContentSize

(

const WindowSizeRequest &

size

)

Definition at line 505 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 flutter::WindowSizeRequest::has_preferred_view_size.

Referenced by InternalFlutterWindows_WindowManager_SetWindowSize().

SetFullscreen()

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

virtual

Reimplemented in flutter::HostWindowDialog.

Definition at line 588 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::GetDpiForHWND().

Referenced by InternalFlutterWindows_WindowManager_SetFullscreen().

UpdateModalStateLayer()

void flutter::HostWindow::UpdateModalStateLayer

(

)

Definition at line 859 of file host_window.cc.

                                       {
  auto children = GetOwnedWindows();
 
  if (children.empty()) {
    // Leaf window in the active path, enable it.
    EnableWindow(window_handle_, true);
  } else {
    // Non-leaf window in the active path, disable it and process children.
    EnableWindow(window_handle_, false);
 
    // On same level of window hierarchy the most recently created window
    // will remain enabled.
    auto latest_child = *std::max_element(
        children.begin(), children.end(), [](HostWindow* a, HostWindow* b) {
          return a->view_controller_->view()->view_id() <
                 b->view_controller_->view()->view_id();
        });
 
    for (HostWindow* const child : children) {
      if (child == latest_child) {
        child->UpdateModalStateLayer();
      } else {
        child->DisableRecursively();
      }
    }
  }
}

WndProc()

LRESULT flutter::HostWindow::WndProc ( HWND  hwnd, UINT  message, WPARAM  wparam, LPARAM  lparam  )

staticprotected

Definition at line 380 of file host_window.cc.

                                           {
  if (message == WM_NCCREATE) {
    auto* const create_struct = reinterpret_cast<CREATESTRUCT*>(lparam);
    auto* const windows_proc_table =
        static_cast<WindowsProcTable*>(create_struct->lpCreateParams);
    windows_proc_table->EnableNonClientDpiScaling(hwnd);
  } else if (HostWindow* const window = GetThisFromHandle(hwnd)) {
    return window->HandleMessage(hwnd, message, wparam, lparam);
  }
 
  return DefWindowProc(hwnd, message, wparam, lparam);
}

References flutter::WindowsProcTable::EnableNonClientDpiScaling(), and message.

Referenced by InitializeFlutterView().

Member Data Documentation

archetype_

WindowArchetype flutter::HostWindow::archetype_ = WindowArchetype::kRegular

protected

Definition at line 262 of file host_window.h.

Referenced by GetArchetype().

box_constraints_

BoxConstraints flutter::HostWindow::box_constraints_

protected

Definition at line 268 of file host_window.h.

Referenced by flutter::HostWindowSized::ApplyContentSize().

engine_

FlutterWindowsEngine* flutter::HostWindow::engine_

protected

Definition at line 254 of file host_window.h.

Referenced by flutter::HostWindowSized::ApplyContentSize(), flutter::HostWindowDialog::HandleMessage(), and InitializeFlutterView().

is_being_destroyed_

bool flutter::HostWindow::is_being_destroyed_ = false

protected

Definition at line 271 of file host_window.h.

Referenced by GetOwnedWindows(), and flutter::HostWindowDialog::HandleMessage().

is_fullscreen_

bool flutter::HostWindow::is_fullscreen_ = false

protected

Definition at line 274 of file host_window.h.

saved_window_info_

SavedWindowInfo flutter::HostWindow::saved_window_info_

protected

Definition at line 277 of file host_window.h.

task_bar_list_

Microsoft::WRL::ComPtr<ITaskbarList2> flutter::HostWindow::task_bar_list_

protected

Definition at line 280 of file host_window.h.

view_controller_

std::unique_ptr<FlutterWindowsViewController> flutter::HostWindow::view_controller_

protected

Definition at line 259 of file host_window.h.

Referenced by flutter::HostWindowSized::ApplyContentSize(), FocusRootViewOf(), flutter::WindowManager::HandleMessage(), InitializeFlutterView(), flutter::HostWindowPopup::UpdatePosition(), flutter::HostWindowTooltip::UpdatePosition(), flutter::HostWindowDialog::~HostWindowDialog(), flutter::HostWindowPopup::~HostWindowPopup(), flutter::HostWindowRegular::~HostWindowRegular(), flutter::HostWindowSized::~HostWindowSized(), and flutter::HostWindowTooltip::~HostWindowTooltip().

window_handle_

HWND flutter::HostWindow::window_handle_

protected

Definition at line 265 of file host_window.h.

Referenced by flutter::HostWindowSized::ApplyContentSize(), flutter::HostWindowDialog::HandleMessage(), flutter::HostWindowDialog::HostWindowDialog(), InitializeFlutterView(), flutter::HostWindowPopup::UpdatePosition(), and flutter::HostWindowTooltip::UpdatePosition().

window_manager_

WindowManager* const flutter::HostWindow::window_manager_ = nullptr

protected

Definition at line 251 of file host_window.h.

WindowManager

friend flutter::HostWindow::WindowManager

protected

Definition at line 170 of file host_window.h.

---

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

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