#include <host_window.h>

Public Member Functions
virtual	~HostWindow ()

HWND	GetWindowHandle () const

void	SetContentSize (const WindowSizing &size)

Static Public Member Functions
static std::unique_ptr< HostWindow >	CreateRegularWindow (WindowManager controller, FlutterWindowsEngine engine, const WindowSizing &content_size)

static HostWindow *	GetThisFromHandle (HWND hwnd)

Detailed Description

Definition at line 24 of file host_window.h.

Constructor & Destructor Documentation

◆ ~HostWindow()

flutter::HostWindow::~HostWindow ( )

virtual

Definition at line 332 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 WindowSizing &	content_size
	)

static

Definition at line 200 of file host_window.cc.

                                       {
   DWORD window_style = WS_OVERLAPPEDWINDOW;
   DWORD extended_window_style = 0;
   std::optional<Size> smallest = std::nullopt;
   std::optional<Size> biggest = std::nullopt;
  
   if (content_size.has_view_constraints) {
     smallest = Size(content_size.view_min_width, content_size.view_min_height);
     if (content_size.view_max_width > 0 && content_size.view_max_height > 0) {
       biggest = Size(content_size.view_max_width, content_size.view_max_height);
     }
   }
  
   // TODO(knopp): What about windows sized to content?
   FML_CHECK(content_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(content_size.preferred_view_width,
              content_size.preferred_view_height),
         smallest, 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->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 " << kWindowClassName
                      << ": " << GetLastErrorAsString();
       return nullptr;
     }
   }
  
   // Create the native window.
   HWND hwnd = CreateWindowEx(
       extended_window_style, kWindowClassName, L"", 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), BoxConstraints(smallest, biggest), hwnd));
 }

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

◆ GetThisFromHandle()

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

static

Definition at line 343 of file host_window.cc.

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

Referenced by InternalFlutterWindows_WindowManager_SetWindowContentSize().

◆ GetWindowHandle()

HWND flutter::HostWindow::GetWindowHandle ( ) const

Definition at line 347 of file host_window.cc.

                                        {
   return window_handle_;
 }

◆ SetContentSize()

void flutter::HostWindow::SetContentSize ( const WindowSizing & size )

Definition at line 466 of file host_window.cc.

                                                         {
   WINDOWINFO window_info = {.cbSize = sizeof(WINDOWINFO)};
   GetWindowInfo(window_handle_, &window_info);
  
   std::optional<Size> smallest, biggest;
   if (size.has_view_constraints) {
     smallest = Size(size.view_min_width, size.view_min_height);
     if (size.view_max_width > 0 && size.view_max_height > 0) {
       biggest = Size(size.view_max_width, size.view_max_height);
     }
   }
  
   box_constraints_ = BoxConstraints(smallest, biggest);
  
   if (size.has_preferred_view_size) {
     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) {
       SetWindowPos(window_handle_, NULL, 0, 0, window_size->width(),
                    window_size->height(),
                    SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
     }
   }
 }

References flutter::BoxConstraints::biggest(), flutter::WindowSizing::has_preferred_view_size, flutter::WindowSizing::has_view_constraints, flutter::WindowSizing::preferred_view_height, flutter::WindowSizing::preferred_view_width, flutter::BoxConstraints::smallest(), flutter::WindowSizing::view_max_height, flutter::WindowSizing::view_max_width, flutter::WindowSizing::view_min_height, flutter::WindowSizing::view_min_width, and flutter::FlutterWindowsEngine::windows_proc_table().