flutter::FlutterWindow Class Reference

#include <flutter_window.h>

Inheritance diagram for flutter::FlutterWindow:

Public Member Functions
	FlutterWindow (FlutterDesktopWindowRef window)
	~FlutterWindow ()=default
	FlutterWindow (FlutterWindow const &)=delete
FlutterWindow &	operator= (FlutterWindow const &)=delete
void	SetHoverEnabled (bool enabled)
void	SetTitle (const std::string &title)
void	SetIcon (uint8_t *pixel_data, int width, int height)
WindowFrame	GetFrame ()
void	SetFrame (const WindowFrame &frame)
double	GetScaleFactor ()
void	SetPixelRatioOverride (double pixel_ratio)
void	SetSizeLimits (FlutterDesktopSize minimum_size, FlutterDesktopSize maximum_size)
	FlutterWindow (int width, int height, std::shared_ptr< WindowsProcTable > windows_proc_table=nullptr, std::unique_ptr< TextInputManager > text_input_manager=nullptr)
virtual	~FlutterWindow ()
void	InitializeChild (const char *title, unsigned int width, unsigned int height)
virtual BOOL	Win32PeekMessage (LPMSG lpMsg, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg) override
virtual uint32_t	Win32MapVkToChar (uint32_t virtual_key) override
virtual UINT	Win32DispatchMessage (UINT Msg, WPARAM wParam, LPARAM lParam) override
virtual void	OnDpiScale (unsigned int dpi)
virtual void	OnResize (unsigned int width, unsigned int height)
virtual void	OnPaint ()
virtual void	OnPointerMove (double x, double y, FlutterPointerDeviceKind device_kind, int32_t device_id, int modifiers_state)
virtual void	OnPointerDown (double x, double y, FlutterPointerDeviceKind device_kind, int32_t device_id, UINT button)
virtual void	OnPointerUp (double x, double y, FlutterPointerDeviceKind device_kind, int32_t device_id, UINT button)
virtual void	OnPointerLeave (double x, double y, FlutterPointerDeviceKind device_kind, int32_t device_id)
virtual void	OnSetCursor ()
virtual void	OnText (const std::u16string &text) override
virtual void	OnKey (int key, int scancode, int action, char32_t character, bool extended, bool was_down, KeyEventCallback callback) override
virtual void	OnComposeBegin ()
virtual void	OnComposeCommit ()
virtual void	OnComposeEnd ()
virtual void	OnComposeChange (const std::u16string &text, int cursor_pos)
virtual void	OnCursorRectUpdated (const Rect &rect) override
virtual void	OnResetImeComposing () override
virtual void	OnUpdateSemanticsEnabled (bool enabled)
virtual void	OnScroll (double delta_x, double delta_y, FlutterPointerDeviceKind device_kind, int32_t device_id)
virtual gfx::NativeViewAccessible	GetNativeViewAccessible ()
virtual void	SetView (WindowBindingHandlerDelegate *view) override
virtual HWND	GetWindowHandle () override
virtual float	GetDpiScale () override
virtual PhysicalWindowBounds	GetPhysicalWindowBounds () override
virtual void	UpdateFlutterCursor (const std::string &cursor_name) override
virtual void	SetFlutterCursor (HCURSOR cursor) override
virtual bool	OnBitmapSurfaceCleared () override
virtual bool	OnBitmapSurfaceUpdated (const void *allocation, size_t row_bytes, size_t height) override
virtual PointerLocation	GetPrimaryPointerLocation () override
virtual void	OnThemeChange ()
virtual AlertPlatformNodeDelegate *	GetAlertDelegate () override
virtual ui::AXPlatformNodeWin *	GetAlert () override
virtual ui::AXFragmentRootDelegateWin *	GetAxFragmentRootDelegate ()
virtual void	OnWindowStateEvent (WindowStateEvent event)
Public Member Functions inherited from flutter::KeyboardManager::WindowDelegate
virtual	~WindowDelegate ()=default
Public Member Functions inherited from flutter::WindowBindingHandler
virtual	~WindowBindingHandler ()=default

Protected Member Functions
	FlutterWindow ()
virtual LRESULT	Win32DefWindowProc (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
std::wstring	NarrowToWide (const char *source)
LRESULT	HandleMessage (UINT const message, WPARAM const wparam, LPARAM const lparam) noexcept
virtual LRESULT	OnGetObject (UINT const message, WPARAM const wparam, LPARAM const lparam)
virtual void	OnImeSetContext (UINT const message, WPARAM const wparam, LPARAM const lparam)
virtual void	OnImeStartComposition (UINT const message, WPARAM const wparam, LPARAM const lparam)
virtual void	OnImeComposition (UINT const message, WPARAM const wparam, LPARAM const lparam)
virtual void	OnImeEndComposition (UINT const message, WPARAM const wparam, LPARAM const lparam)
virtual void	OnImeRequest (UINT const message, WPARAM const wparam, LPARAM const lparam)
virtual void	AbortImeComposing ()
virtual void	UpdateCursorRect (const Rect &rect)
UINT	GetCurrentDPI ()
UINT	GetCurrentWidth ()
UINT	GetCurrentHeight ()
virtual float	GetScrollOffsetMultiplier ()

Protected Attributes
std::unique_ptr< AlertPlatformNodeDelegate >	alert_delegate_
std::unique_ptr< ui::AXPlatformNodeWin >	alert_node_
std::unique_ptr< DirectManipulationOwner >	direct_manipulation_owner_

Friends
class	WindowAXFragmentRootDelegate

Additional Inherited Members
Public Types inherited from flutter::KeyboardManager::WindowDelegate
using	KeyEventCallback = std::function< void(bool)>

Detailed Description

Definition at line 26 of file flutter_window.h.

Constructor & Destructor Documentation

FlutterWindow() [1/4]

flutter::FlutterWindow::FlutterWindow ( FlutterDesktopWindowRef  window )

inlineexplicit

Definition at line 28 of file flutter_window.h.

: window_(window) {}

~FlutterWindow() [1/2]

flutter::FlutterWindow::~FlutterWindow ( )

default

Definition at line 154 of file flutter_window.cc.

                              {
  Destroy();
}

FlutterWindow() [2/4]

flutter::FlutterWindow::FlutterWindow ( FlutterWindow const &  )

delete

FlutterWindow() [3/4]

flutter::FlutterWindow::FlutterWindow	(	int	width,
		int	height,
		std::shared_ptr< WindowsProcTable >	windows_proc_table = nullptr,
		std::unique_ptr< TextInputManager >	text_input_manager = nullptr
	)

Definition at line 119 of file flutter_window.cc.

    : touch_id_generator_(kMinTouchDeviceId, kMaxTouchDeviceId),
      windows_proc_table_(std::move(windows_proc_table)),
      text_input_manager_(std::move(text_input_manager)),
      ax_fragment_root_(nullptr) {
  // Get the DPI of the primary monitor as the initial DPI. If Per-Monitor V2 is
  // supported, |current_dpi_| should be updated in the
  // kWmDpiChangedBeforeParent message.
  current_dpi_ = GetDpiForHWND(nullptr);
 
  // Get initial value for wheel scroll lines
  // TODO: Listen to changes for this value
  // https://github.com/flutter/flutter/issues/107248
  UpdateScrollOffsetMultiplier();
 
  if (windows_proc_table_ == nullptr) {
    windows_proc_table_ = std::make_unique<WindowsProcTable>();
  }
  if (text_input_manager_ == nullptr) {
    text_input_manager_ = std::make_unique<TextInputManager>();
  }
  keyboard_manager_ = std::make_unique<KeyboardManager>(this);
 
  InitializeChild("FLUTTERVIEW", width, height);
  current_cursor_ = ::LoadCursor(nullptr, IDC_ARROW);
}

~FlutterWindow() [2/2]

virtual flutter::FlutterWindow::~FlutterWindow ( )

virtual

FlutterWindow() [4/4]

flutter::FlutterWindow::FlutterWindow ( )

protected

Definition at line 151 of file flutter_window.cc.

    : touch_id_generator_(kMinTouchDeviceId, kMaxTouchDeviceId) {}

Member Function Documentation

AbortImeComposing()

void flutter::FlutterWindow::AbortImeComposing ( )

protectedvirtual

Definition at line 905 of file flutter_window.cc.

                                      {
  text_input_manager_->AbortComposing();
}

GetAlert()

ui::AXPlatformNodeWin * flutter::FlutterWindow::GetAlert ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 364 of file flutter_window.cc.

                                             {
  CreateAxFragmentRoot();
  return alert_node_.get();
}

GetAlertDelegate()

AlertPlatformNodeDelegate * flutter::FlutterWindow::GetAlertDelegate ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 359 of file flutter_window.cc.

                                                           {
  CreateAxFragmentRoot();
  return alert_delegate_.get();
}

GetAxFragmentRootDelegate()

ui::AXFragmentRootDelegateWin * flutter::FlutterWindow::GetAxFragmentRootDelegate ( )

virtual

Definition at line 355 of file flutter_window.cc.

                                                                      {
  return binding_handler_delegate_->GetAxFragmentRootDelegate();
}

GetCurrentDPI()

UINT flutter::FlutterWindow::GetCurrentDPI ( )

protected

Definition at line 913 of file flutter_window.cc.

                                  {
  return current_dpi_;
}

GetCurrentHeight()

UINT flutter::FlutterWindow::GetCurrentHeight ( )

protected

Definition at line 921 of file flutter_window.cc.

                                     {
  return current_height_;
}

GetCurrentWidth()

UINT flutter::FlutterWindow::GetCurrentWidth ( )

protected

Definition at line 917 of file flutter_window.cc.

                                    {
  return current_width_;
}

GetDpiScale()

float flutter::FlutterWindow::GetDpiScale ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 171 of file flutter_window.cc.

                                 {
  return static_cast<float>(GetCurrentDPI()) / static_cast<float>(base_dpi);
}

GetFrame()

WindowFrame flutter::FlutterWindow::GetFrame ( )

inline

Definition at line 61 of file flutter_window.h.

                         {
    WindowFrame frame = {};
    FlutterDesktopWindowGetFrame(window_, &frame.left, &frame.top, &frame.width,
                                 &frame.height);
    return frame;
  }

GetNativeViewAccessible()

gfx::NativeViewAccessible flutter::FlutterWindow::GetNativeViewAccessible ( )

virtual

Definition at line 336 of file flutter_window.cc.

                                                               {
  if (binding_handler_delegate_ == nullptr) {
    return nullptr;
  }
 
  return binding_handler_delegate_->GetNativeViewAccessible();
}

GetPhysicalWindowBounds()

PhysicalWindowBounds flutter::FlutterWindow::GetPhysicalWindowBounds ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 175 of file flutter_window.cc.

                                                            {
  return {GetCurrentWidth(), GetCurrentHeight()};
}

GetPrimaryPointerLocation()

PointerLocation flutter::FlutterWindow::GetPrimaryPointerLocation ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 344 of file flutter_window.cc.

                                                         {
  POINT point;
  GetCursorPos(&point);
  ScreenToClient(GetWindowHandle(), &point);
  return {(size_t)point.x, (size_t)point.y};
}

GetScaleFactor()

double flutter::FlutterWindow::GetScaleFactor ( )

inline

Definition at line 79 of file flutter_window.h.

                          {
    return FlutterDesktopWindowGetScaleFactor(window_);
  }

GetScrollOffsetMultiplier()

float flutter::FlutterWindow::GetScrollOffsetMultiplier ( )

protectedvirtual

Definition at line 925 of file flutter_window.cc.

                                               {
  return scroll_offset_multiplier_;
}

GetWindowHandle()

HWND flutter::FlutterWindow::GetWindowHandle ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 463 of file flutter_window.cc.

                                    {
  return window_handle_;
}

HandleMessage()

LRESULT flutter::FlutterWindow::HandleMessage ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectednoexcept

Definition at line 532 of file flutter_window.cc.

                                                           {
  LPARAM result_lparam = lparam;
  int xPos = 0, yPos = 0;
  UINT width = 0, height = 0;
  UINT button_pressed = 0;
  FlutterPointerDeviceKind device_kind;
 
  switch (message) {
    case kWmDpiChangedBeforeParent:
      current_dpi_ = GetDpiForHWND(window_handle_);
      OnDpiScale(current_dpi_);
      return 0;
    case WM_SIZE:
      width = LOWORD(lparam);
      height = HIWORD(lparam);
 
      current_width_ = width;
      current_height_ = height;
      HandleResize(width, height);
 
      OnWindowStateEvent(width == 0 && height == 0 ? WindowStateEvent::kHide
                                                   : WindowStateEvent::kShow);
      break;
    case WM_PAINT:
      OnPaint();
      break;
    case WM_TOUCH: {
      UINT num_points = LOWORD(wparam);
      touch_points_.resize(num_points);
      auto touch_input_handle = reinterpret_cast<HTOUCHINPUT>(lparam);
      if (GetTouchInputInfo(touch_input_handle, num_points,
                            touch_points_.data(), sizeof(TOUCHINPUT))) {
        for (const auto& touch : touch_points_) {
          // Generate a mapped ID for the Windows-provided touch ID
          auto touch_id = touch_id_generator_.GetGeneratedId(touch.dwID);
 
          POINT pt = {TOUCH_COORD_TO_PIXEL(touch.x),
                      TOUCH_COORD_TO_PIXEL(touch.y)};
          ScreenToClient(window_handle_, &pt);
          auto x = static_cast<double>(pt.x);
          auto y = static_cast<double>(pt.y);
 
          if (touch.dwFlags & TOUCHEVENTF_DOWN) {
            OnPointerDown(x, y, kFlutterPointerDeviceKindTouch, touch_id,
                          WM_LBUTTONDOWN);
          } else if (touch.dwFlags & TOUCHEVENTF_MOVE) {
            OnPointerMove(x, y, kFlutterPointerDeviceKindTouch, touch_id, 0);
          } else if (touch.dwFlags & TOUCHEVENTF_UP) {
            OnPointerUp(x, y, kFlutterPointerDeviceKindTouch, touch_id,
                        WM_LBUTTONDOWN);
            OnPointerLeave(x, y, kFlutterPointerDeviceKindTouch, touch_id);
            touch_id_generator_.ReleaseNumber(touch.dwID);
          }
        }
        CloseTouchInputHandle(touch_input_handle);
      }
      return 0;
    }
    case WM_MOUSEMOVE:
      device_kind = GetFlutterPointerDeviceKind();
      if (device_kind == kFlutterPointerDeviceKindMouse) {
        TrackMouseLeaveEvent(window_handle_);
 
        xPos = GET_X_LPARAM(lparam);
        yPos = GET_Y_LPARAM(lparam);
        mouse_x_ = static_cast<double>(xPos);
        mouse_y_ = static_cast<double>(yPos);
 
        int mods = 0;
        if (wparam & MK_CONTROL) {
          mods |= kControl;
        }
        if (wparam & MK_SHIFT) {
          mods |= kShift;
        }
        OnPointerMove(mouse_x_, mouse_y_, device_kind, kDefaultPointerDeviceId,
                      mods);
      }
      break;
    case WM_MOUSELEAVE:
      device_kind = GetFlutterPointerDeviceKind();
      if (device_kind == kFlutterPointerDeviceKindMouse) {
        OnPointerLeave(mouse_x_, mouse_y_, device_kind,
                       kDefaultPointerDeviceId);
      }
 
      // Once the tracked event is received, the TrackMouseEvent function
      // resets. Set to false to make sure it's called once mouse movement is
      // detected again.
      tracking_mouse_leave_ = false;
      break;
    case WM_SETCURSOR: {
      UINT hit_test_result = LOWORD(lparam);
      if (hit_test_result == HTCLIENT) {
        OnSetCursor();
        return TRUE;
      }
      break;
    }
    case WM_SETFOCUS:
      OnWindowStateEvent(WindowStateEvent::kFocus);
      ::CreateCaret(window_handle_, nullptr, 1, 1);
      break;
    case WM_KILLFOCUS:
      OnWindowStateEvent(WindowStateEvent::kUnfocus);
      ::DestroyCaret();
      break;
    case WM_LBUTTONDOWN:
    case WM_RBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_XBUTTONDOWN:
      device_kind = GetFlutterPointerDeviceKind();
      if (device_kind != kFlutterPointerDeviceKindMouse) {
        break;
      }
 
      if (message == WM_LBUTTONDOWN) {
        // Capture the pointer in case the user drags outside the client area.
        // In this case, the "mouse leave" event is delayed until the user
        // releases the button. It's only activated on left click given that
        // it's more common for apps to handle dragging with only the left
        // button.
        SetCapture(window_handle_);
      }
      button_pressed = message;
      if (message == WM_XBUTTONDOWN) {
        button_pressed = GET_XBUTTON_WPARAM(wparam);
      }
      xPos = GET_X_LPARAM(lparam);
      yPos = GET_Y_LPARAM(lparam);
      OnPointerDown(static_cast<double>(xPos), static_cast<double>(yPos),
                    device_kind, kDefaultPointerDeviceId, button_pressed);
      break;
    case WM_LBUTTONUP:
    case WM_RBUTTONUP:
    case WM_MBUTTONUP:
    case WM_XBUTTONUP:
      device_kind = GetFlutterPointerDeviceKind();
      if (device_kind != kFlutterPointerDeviceKindMouse) {
        break;
      }
 
      if (message == WM_LBUTTONUP) {
        ReleaseCapture();
      }
      button_pressed = message;
      if (message == WM_XBUTTONUP) {
        button_pressed = GET_XBUTTON_WPARAM(wparam);
      }
      xPos = GET_X_LPARAM(lparam);
      yPos = GET_Y_LPARAM(lparam);
      OnPointerUp(static_cast<double>(xPos), static_cast<double>(yPos),
                  device_kind, kDefaultPointerDeviceId, button_pressed);
      break;
    case WM_MOUSEWHEEL:
      OnScroll(0.0,
               -(static_cast<short>(HIWORD(wparam)) /
                 static_cast<double>(WHEEL_DELTA)),
               kFlutterPointerDeviceKindMouse, kDefaultPointerDeviceId);
      break;
    case WM_MOUSEHWHEEL:
      OnScroll((static_cast<short>(HIWORD(wparam)) /
                static_cast<double>(WHEEL_DELTA)),
               0.0, kFlutterPointerDeviceKindMouse, kDefaultPointerDeviceId);
      break;
    case WM_GETOBJECT: {
      LRESULT lresult = OnGetObject(message, wparam, lparam);
      if (lresult) {
        return lresult;
      }
      break;
    }
    case WM_TIMER:
      if (wparam == kDirectManipulationTimer) {
        direct_manipulation_owner_->Update();
        return 0;
      }
      break;
    case DM_POINTERHITTEST: {
      if (direct_manipulation_owner_) {
        UINT contact_id = GET_POINTERID_WPARAM(wparam);
        POINTER_INPUT_TYPE pointer_type;
        if (windows_proc_table_->GetPointerType(contact_id, &pointer_type) &&
            pointer_type == PT_TOUCHPAD) {
          direct_manipulation_owner_->SetContact(contact_id);
        }
      }
      break;
    }
    case WM_INPUTLANGCHANGE:
      // TODO(cbracken): pass this to TextInputManager to aid with
      // language-specific issues.
      break;
    case WM_IME_SETCONTEXT:
      OnImeSetContext(message, wparam, lparam);
      // Strip the ISC_SHOWUICOMPOSITIONWINDOW bit from lparam before passing it
      // to DefWindowProc() so that the composition window is hidden since
      // Flutter renders the composing string itself.
      result_lparam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
      break;
    case WM_IME_STARTCOMPOSITION:
      OnImeStartComposition(message, wparam, lparam);
      // Suppress further processing by DefWindowProc() so that the default
      // system IME style isn't used, but rather the one set in the
      // WM_IME_SETCONTEXT handler.
      return TRUE;
    case WM_IME_COMPOSITION:
      OnImeComposition(message, wparam, lparam);
      if (lparam & GCS_RESULTSTR || lparam & GCS_COMPSTR) {
        // Suppress further processing by DefWindowProc() since otherwise it
        // will emit the result string as WM_CHAR messages on commit. Instead,
        // committing the composing text to the EditableText string is handled
        // in TextInputModel::CommitComposing, triggered by
        // OnImeEndComposition().
        return TRUE;
      }
      break;
    case WM_IME_ENDCOMPOSITION:
      OnImeEndComposition(message, wparam, lparam);
      return TRUE;
    case WM_IME_REQUEST:
      OnImeRequest(message, wparam, lparam);
      break;
    case WM_UNICHAR: {
      // Tell third-pary app, we can support Unicode.
      if (wparam == UNICODE_NOCHAR)
        return TRUE;
      // DefWindowProc will send WM_CHAR for this WM_UNICHAR.
      break;
    }
    case WM_THEMECHANGED:
      OnThemeChange();
      break;
    case WM_DEADCHAR:
    case WM_SYSDEADCHAR:
    case WM_CHAR:
    case WM_SYSCHAR:
    case WM_KEYDOWN:
    case WM_SYSKEYDOWN:
    case WM_KEYUP:
    case WM_SYSKEYUP:
      if (keyboard_manager_->HandleMessage(message, wparam, lparam)) {
        return 0;
      }
      break;
  }
 
  return Win32DefWindowProc(window_handle_, message, wparam, result_lparam);
}

InitializeChild()

void flutter::FlutterWindow::InitializeChild	(	const char *	title,
		unsigned int	width,
		unsigned int	height
	)

Definition at line 428 of file flutter_window.cc.

                                                         {
  Destroy();
  std::wstring converted_title = NarrowToWide(title);
 
  WNDCLASS window_class = RegisterWindowClass(converted_title);
 
  auto* result = CreateWindowEx(
      0, window_class.lpszClassName, converted_title.c_str(),
      WS_CHILD | WS_VISIBLE, CW_DEFAULT, CW_DEFAULT, width, height,
      HWND_MESSAGE, nullptr, window_class.hInstance, this);
 
  if (result == nullptr) {
    auto error = GetLastError();
    LPWSTR message = nullptr;
    size_t size = FormatMessageW(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        reinterpret_cast<LPWSTR>(&message), 0, NULL);
    OutputDebugString(message);
    LocalFree(message);
  }
  SetUserObjectInformationA(GetCurrentProcess(),
                            UOI_TIMERPROC_EXCEPTION_SUPPRESSION, FALSE, 1);
  // SetTimer is not precise, if a 16 ms interval is requested, it will instead
  // often fire in an interval of 32 ms. Providing a value of 14 will ensure it
  // runs every 16 ms, which will allow for 60 Hz trackpad gesture events, which
  // is the maximal frequency supported by SetTimer.
  SetTimer(result, kDirectManipulationTimer, 14, nullptr);
  direct_manipulation_owner_ = std::make_unique<DirectManipulationOwner>(this);
  direct_manipulation_owner_->Init(width, height);
}

NarrowToWide()

std::wstring flutter::FlutterWindow::NarrowToWide ( const char *  source )

protected

Definition at line 485 of file flutter_window.cc.

                                                         {
  size_t length = strlen(source);
  size_t outlen = 0;
  std::wstring wideTitle(length, L'#');
  mbstowcs_s(&outlen, &wideTitle[0], length + 1, source, length);
  return wideTitle;
}

OnBitmapSurfaceCleared()

bool flutter::FlutterWindow::OnBitmapSurfaceCleared ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 311 of file flutter_window.cc.

                                           {
  HDC dc = ::GetDC(GetWindowHandle());
  bool result = ::PatBlt(dc, 0, 0, current_width_, current_height_, BLACKNESS);
  ::ReleaseDC(GetWindowHandle(), dc);
  return result;
}

OnBitmapSurfaceUpdated()

bool flutter::FlutterWindow::OnBitmapSurfaceUpdated ( const void *  allocation, size_t  row_bytes, size_t  height  )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 318 of file flutter_window.cc.

                                                          {
  HDC dc = ::GetDC(GetWindowHandle());
  BITMAPINFO bmi = {};
  bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth = row_bytes / 4;
  bmi.bmiHeader.biHeight = -height;
  bmi.bmiHeader.biPlanes = 1;
  bmi.bmiHeader.biBitCount = 32;
  bmi.bmiHeader.biCompression = BI_RGB;
  bmi.bmiHeader.biSizeImage = 0;
  int ret = ::SetDIBitsToDevice(dc, 0, 0, row_bytes / 4, height, 0, 0, 0,
                                height, allocation, &bmi, DIB_RGB_COLORS);
  ::ReleaseDC(GetWindowHandle(), dc);
  return ret != 0;
}

OnComposeBegin()

void flutter::FlutterWindow::OnComposeBegin ( )

virtual

Definition at line 265 of file flutter_window.cc.

                                   {
  binding_handler_delegate_->OnComposeBegin();
}

OnComposeChange()

void flutter::FlutterWindow::OnComposeChange ( const std::u16string &  text, int  cursor_pos  )

virtual

Definition at line 277 of file flutter_window.cc.

                                                    {
  binding_handler_delegate_->OnComposeChange(text, cursor_pos);
}

OnComposeCommit()

void flutter::FlutterWindow::OnComposeCommit ( )

virtual

Definition at line 269 of file flutter_window.cc.

                                    {
  binding_handler_delegate_->OnComposeCommit();
}

OnComposeEnd()

void flutter::FlutterWindow::OnComposeEnd ( )

virtual

Definition at line 273 of file flutter_window.cc.

                                 {
  binding_handler_delegate_->OnComposeEnd();
}

OnCursorRectUpdated()

void flutter::FlutterWindow::OnCursorRectUpdated ( const Rect &  rect )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 299 of file flutter_window.cc.

                                                        {
  // Convert the rect from Flutter logical coordinates to device coordinates.
  auto scale = GetDpiScale();
  Point origin(rect.left() * scale, rect.top() * scale);
  Size size(rect.width() * scale, rect.height() * scale);
  UpdateCursorRect(Rect(origin, size));
}

OnDpiScale()

void flutter::FlutterWindow::OnDpiScale ( unsigned int  dpi )

virtual

Definition at line 188 of file flutter_window.cc.

{};

OnGetObject()

LRESULT flutter::FlutterWindow::OnGetObject ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectedvirtual

Definition at line 784 of file flutter_window.cc.

                                                        {
  LRESULT reference_result = static_cast<LRESULT>(0L);
 
  // Only the lower 32 bits of lparam are valid when checking the object id
  // because it sometimes gets sign-extended incorrectly (but not always).
  DWORD obj_id = static_cast<DWORD>(static_cast<DWORD_PTR>(lparam));
 
  bool is_uia_request = static_cast<DWORD>(UiaRootObjectId) == obj_id;
  bool is_msaa_request = static_cast<DWORD>(OBJID_CLIENT) == obj_id;
 
  if (is_uia_request || is_msaa_request) {
    // On Windows, we don't get a notification that the screen reader has been
    // enabled or disabled. There is an API to query for screen reader state,
    // but that state isn't set by all screen readers, including by Narrator,
    // the screen reader that ships with Windows:
    // https://docs.microsoft.com/en-us/windows/win32/winauto/screen-reader-parameter
    //
    // Instead, we enable semantics in Flutter if Windows issues queries for
    // Microsoft Active Accessibility (MSAA) COM objects.
    OnUpdateSemanticsEnabled(true);
  }
 
  gfx::NativeViewAccessible root_view = GetNativeViewAccessible();
  // TODO(schectman): UIA is currently disabled by default.
  // https://github.com/flutter/flutter/issues/114547
  if (root_view) {
    CreateAxFragmentRoot();
    if (is_uia_request) {
#ifdef FLUTTER_ENGINE_USE_UIA
      // Retrieve UIA object for the root view.
      Microsoft::WRL::ComPtr<IRawElementProviderSimple> root;
      if (SUCCEEDED(
              ax_fragment_root_->GetNativeViewAccessible()->QueryInterface(
                  IID_PPV_ARGS(&root)))) {
        // Return the UIA object via UiaReturnRawElementProvider(). See:
        // https://docs.microsoft.com/en-us/windows/win32/winauto/wm-getobject
        reference_result = UiaReturnRawElementProvider(window_handle_, wparam,
                                                       lparam, root.Get());
      } else {
        FML_LOG(ERROR) << "Failed to query AX fragment root.";
      }
#endif  // FLUTTER_ENGINE_USE_UIA
    } else if (is_msaa_request) {
      // Create the accessibility root if it does not already exist.
      // Return the IAccessible for the root view.
      Microsoft::WRL::ComPtr<IAccessible> root;
      ax_fragment_root_->GetNativeViewAccessible()->QueryInterface(
          IID_PPV_ARGS(&root));
      reference_result = LresultFromObject(IID_IAccessible, wparam, root.Get());
    }
  }
  return reference_result;
}

OnImeComposition()

void flutter::FlutterWindow::OnImeComposition ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectedvirtual

Definition at line 855 of file flutter_window.cc.

                                                          {
  // Update the IME window position.
  text_input_manager_->UpdateImeWindow();
 
  if (lparam == 0) {
    OnComposeChange(u"", 0);
    OnComposeCommit();
  }
 
  // Process GCS_RESULTSTR at fisrt, because Google Japanese Input and ATOK send
  // both GCS_RESULTSTR and GCS_COMPSTR to commit composed text and send new
  // composing text.
  if (lparam & GCS_RESULTSTR) {
    // Commit but don't end composing.
    // Read the committed composing string.
    long pos = text_input_manager_->GetComposingCursorPosition();
    std::optional<std::u16string> text = text_input_manager_->GetResultString();
    if (text) {
      OnComposeChange(text.value(), pos);
      OnComposeCommit();
    }
  }
  if (lparam & GCS_COMPSTR) {
    // Read the in-progress composing string.
    long pos = text_input_manager_->GetComposingCursorPosition();
    std::optional<std::u16string> text =
        text_input_manager_->GetComposingString();
    if (text) {
      OnComposeChange(text.value(), pos);
    }
  }
}

OnImeEndComposition()

void flutter::FlutterWindow::OnImeEndComposition ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectedvirtual

Definition at line 890 of file flutter_window.cc.

                                                             {
  text_input_manager_->DestroyImeWindow();
  OnComposeEnd();
}

OnImeRequest()

void flutter::FlutterWindow::OnImeRequest ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectedvirtual

Definition at line 897 of file flutter_window.cc.

                                                      {
  // TODO(cbracken): Handle IMR_RECONVERTSTRING, IMR_DOCUMENTFEED,
  // and IMR_QUERYCHARPOSITION messages.
  // https://github.com/flutter/flutter/issues/74547
}

OnImeSetContext()

void flutter::FlutterWindow::OnImeSetContext ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectedvirtual

Definition at line 840 of file flutter_window.cc.

                                                         {
  if (wparam != 0) {
    text_input_manager_->CreateImeWindow();
  }
}

OnImeStartComposition()

void flutter::FlutterWindow::OnImeStartComposition ( UINT const  message, WPARAM const  wparam, LPARAM const  lparam  )

protectedvirtual

Definition at line 848 of file flutter_window.cc.

                                                               {
  text_input_manager_->CreateImeWindow();
  OnComposeBegin();
}

OnKey()

void flutter::FlutterWindow::OnKey ( int  key, int  scancode, int  action, char32_t  character, bool  extended, bool  was_down, KeyEventCallback  callback  )

overridevirtual

Implements flutter::KeyboardManager::WindowDelegate.

Definition at line 254 of file flutter_window.cc.

                                                     {
  binding_handler_delegate_->OnKey(key, scancode, action, character, extended,
                                   was_down, std::move(callback));
}

OnPaint()

void flutter::FlutterWindow::OnPaint ( )

virtual

Definition at line 198 of file flutter_window.cc.

                            {
  if (binding_handler_delegate_ != nullptr) {
    binding_handler_delegate_->OnWindowRepaint();
  }
}

OnPointerDown()

void flutter::FlutterWindow::OnPointerDown ( double  x, double  y, FlutterPointerDeviceKind  device_kind, int32_t  device_id, UINT  button  )

virtual

Definition at line 213 of file flutter_window.cc.

                                               {
  uint64_t flutter_button = ConvertWinButtonToFlutterButton(button);
  if (flutter_button != 0) {
    binding_handler_delegate_->OnPointerDown(
        x, y, device_kind, device_id,
        static_cast<FlutterPointerMouseButtons>(flutter_button));
  }
}

OnPointerLeave()

void flutter::FlutterWindow::OnPointerLeave ( double  x, double  y, FlutterPointerDeviceKind  device_kind, int32_t  device_id  )

virtual

Definition at line 239 of file flutter_window.cc.

                                                      {
  binding_handler_delegate_->OnPointerLeave(x, y, device_kind, device_id);
}

OnPointerMove()

void flutter::FlutterWindow::OnPointerMove ( double  x, double  y, FlutterPointerDeviceKind  device_kind, int32_t  device_id, int  modifiers_state  )

virtual

Definition at line 204 of file flutter_window.cc.

                                                       {
  binding_handler_delegate_->OnPointerMove(x, y, device_kind, device_id,
                                           modifiers_state);
}

OnPointerUp()

void flutter::FlutterWindow::OnPointerUp ( double  x, double  y, FlutterPointerDeviceKind  device_kind, int32_t  device_id, UINT  button  )

virtual

Definition at line 226 of file flutter_window.cc.

                                             {
  uint64_t flutter_button = ConvertWinButtonToFlutterButton(button);
  if (flutter_button != 0) {
    binding_handler_delegate_->OnPointerUp(
        x, y, device_kind, device_id,
        static_cast<FlutterPointerMouseButtons>(flutter_button));
  }
}

OnResetImeComposing()

void flutter::FlutterWindow::OnResetImeComposing ( )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 307 of file flutter_window.cc.

                                        {
  AbortImeComposing();
}

OnResize()

void flutter::FlutterWindow::OnResize ( unsigned int  width, unsigned int  height  )

virtual

Definition at line 192 of file flutter_window.cc.

                                                                    {
  if (binding_handler_delegate_ != nullptr) {
    binding_handler_delegate_->OnWindowSizeChanged(width, height);
  }
}

OnScroll()

void flutter::FlutterWindow::OnScroll ( double  delta_x, double  delta_y, FlutterPointerDeviceKind  device_kind, int32_t  device_id  )

virtual

Definition at line 286 of file flutter_window.cc.

                                                {
  POINT point;
  GetCursorPos(&point);
 
  ScreenToClient(GetWindowHandle(), &point);
  binding_handler_delegate_->OnScroll(point.x, point.y, delta_x, delta_y,
                                      GetScrollOffsetMultiplier(), device_kind,
                                      device_id);
}

OnSetCursor()

void flutter::FlutterWindow::OnSetCursor ( )

virtual

Definition at line 246 of file flutter_window.cc.

                                {
  ::SetCursor(current_cursor_);
}

OnText()

void flutter::FlutterWindow::OnText ( const std::u16string &  text )

overridevirtual

Implements flutter::KeyboardManager::WindowDelegate.

Definition at line 250 of file flutter_window.cc.

                                                   {
  binding_handler_delegate_->OnText(text);
}

OnThemeChange()

void flutter::FlutterWindow::OnThemeChange ( )

virtual

Definition at line 351 of file flutter_window.cc.

                                  {
  binding_handler_delegate_->OnHighContrastChanged();
}

OnUpdateSemanticsEnabled()

void flutter::FlutterWindow::OnUpdateSemanticsEnabled ( bool  enabled )

virtual

Definition at line 282 of file flutter_window.cc.

                                                         {
  binding_handler_delegate_->OnUpdateSemanticsEnabled(enabled);
}

OnWindowStateEvent()

void flutter::FlutterWindow::OnWindowStateEvent ( WindowStateEvent  event )

virtual

Definition at line 369 of file flutter_window.cc.

                                                             {
  switch (event) {
    case WindowStateEvent::kShow:
      restored_ = true;
      break;
    case WindowStateEvent::kHide:
      restored_ = false;
      focused_ = false;
      break;
    case WindowStateEvent::kFocus:
      focused_ = true;
      break;
    case WindowStateEvent::kUnfocus:
      focused_ = false;
      break;
  }
  HWND hwnd = GetWindowHandle();
  if (hwnd && binding_handler_delegate_) {
    binding_handler_delegate_->OnWindowStateEvent(hwnd, event);
  }
}

operator=()

FlutterWindow & flutter::FlutterWindow::operator= ( FlutterWindow const &  )

delete

SetFlutterCursor()

void flutter::FlutterWindow::SetFlutterCursor ( HCURSOR  cursor )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 183 of file flutter_window.cc.

                                                   {
  current_cursor_ = cursor;
  ::SetCursor(current_cursor_);
}

SetFrame()

void flutter::FlutterWindow::SetFrame ( const WindowFrame &  frame )

inline

Definition at line 70 of file flutter_window.h.

                                          {
    FlutterDesktopWindowSetFrame(window_, frame.left, frame.top, frame.width,
                                 frame.height);
  }

SetHoverEnabled()

void flutter::FlutterWindow::SetHoverEnabled ( bool  enabled )

inline

Definition at line 41 of file flutter_window.h.

                                     {
    FlutterDesktopWindowSetHoverEnabled(window_, enabled);
  }

SetIcon()

void flutter::FlutterWindow::SetIcon ( uint8_t *  pixel_data, int  width, int  height  )

inline

Definition at line 55 of file flutter_window.h.

                                                           {
    FlutterDesktopWindowSetIcon(window_, pixel_data, width, height);
  }

SetPixelRatioOverride()

void flutter::FlutterWindow::SetPixelRatioOverride ( double  pixel_ratio )

inline

Definition at line 87 of file flutter_window.h.

                                                 {
    FlutterDesktopWindowSetPixelRatioOverride(window_, pixel_ratio);
  }

SetSizeLimits()

void flutter::FlutterWindow::SetSizeLimits ( FlutterDesktopSize  minimum_size, FlutterDesktopSize  maximum_size  )

inline

Definition at line 93 of file flutter_window.h.

                                                      {
    FlutterDesktopWindowSetSizeLimits(window_, minimum_size, maximum_size);
  }

SetTitle()

void flutter::FlutterWindow::SetTitle ( const std::string &  title )

inline

Definition at line 46 of file flutter_window.h.

                                        {
    FlutterDesktopWindowSetTitle(window_, title.c_str());
  }

SetView()

void flutter::FlutterWindow::SetView ( WindowBindingHandlerDelegate *  view )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 158 of file flutter_window.cc.

                                                                {
  binding_handler_delegate_ = window;
  if (direct_manipulation_owner_) {
    direct_manipulation_owner_->SetBindingHandlerDelegate(window);
  }
  if (restored_ && window) {
    OnWindowStateEvent(WindowStateEvent::kShow);
  }
  if (focused_ && window) {
    OnWindowStateEvent(WindowStateEvent::kFocus);
  }
}

UpdateCursorRect()

void flutter::FlutterWindow::UpdateCursorRect ( const Rect &  rect )

protectedvirtual

Definition at line 909 of file flutter_window.cc.

                                                     {
  text_input_manager_->UpdateCaretRect(rect);
}

UpdateFlutterCursor()

void flutter::FlutterWindow::UpdateFlutterCursor ( const std::string &  cursor_name )

overridevirtual

Implements flutter::WindowBindingHandler.

Definition at line 179 of file flutter_window.cc.

                                                                    {
  SetFlutterCursor(GetCursorByName(cursor_name));
}

Win32DefWindowProc()

LRESULT flutter::FlutterWindow::Win32DefWindowProc ( HWND  hWnd, UINT  Msg, WPARAM  wParam, LPARAM  lParam  )

protectedvirtual

Reimplemented in flutter::testing::MockWindow.

Definition at line 929 of file flutter_window.cc.

                                                         {
  return ::DefWindowProc(hWnd, Msg, wParam, lParam);
}

Win32DispatchMessage()

UINT flutter::FlutterWindow::Win32DispatchMessage ( UINT  Msg, WPARAM  wParam, LPARAM  lParam  )

overridevirtual

Implements flutter::KeyboardManager::WindowDelegate.

Definition at line 479 of file flutter_window.cc.

                                                        {
  return ::SendMessage(window_handle_, Msg, wParam, lParam);
}

Win32MapVkToChar()

uint32_t flutter::FlutterWindow::Win32MapVkToChar ( uint32_t  virtual_key )

overridevirtual

Implements flutter::KeyboardManager::WindowDelegate.

Definition at line 475 of file flutter_window.cc.

                                                             {
  return ::MapVirtualKey(virtual_key, MAPVK_VK_TO_CHAR);
}

Win32PeekMessage()

BOOL flutter::FlutterWindow::Win32PeekMessage ( LPMSG  lpMsg, UINT  wMsgFilterMin, UINT  wMsgFilterMax, UINT  wRemoveMsg  )

overridevirtual

Implements flutter::KeyboardManager::WindowDelegate.

Definition at line 467 of file flutter_window.cc.

                                                      {
  return ::PeekMessage(lpMsg, window_handle_, wMsgFilterMin, wMsgFilterMax,
                       wRemoveMsg);
}

Friends And Related Symbol Documentation

WindowAXFragmentRootDelegate

friend class WindowAXFragmentRootDelegate

friend

Definition at line 385 of file flutter_window.h.

Member Data Documentation

alert_delegate_

std::unique_ptr<AlertPlatformNodeDelegate> flutter::FlutterWindow::alert_delegate_

protected

Definition at line 274 of file flutter_window.h.

alert_node_

std::unique_ptr<ui::AXPlatformNodeWin> flutter::FlutterWindow::alert_node_

protected

Definition at line 277 of file flutter_window.h.

direct_manipulation_owner_

std::unique_ptr<DirectManipulationOwner> flutter::FlutterWindow::direct_manipulation_owner_

protected

Definition at line 281 of file flutter_window.h.

---

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

• shell/platform/glfw/client_wrapper/include/flutter/flutter_window.h
• shell/platform/windows/flutter_window.h
• shell/platform/windows/flutter_window.cc