flutter_glfw.cc File Reference

#include "flutter/shell/platform/glfw/public/flutter_glfw.h"
#include <GLFW/glfw3.h>
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cstdlib>
#include <filesystem>
#include <iostream>
#include <string>
#include "flutter/common/constants.h"
#include "flutter/shell/platform/common/client_wrapper/include/flutter/plugin_registrar.h"
#include "flutter/shell/platform/common/incoming_message_dispatcher.h"
#include "flutter/shell/platform/common/path_utils.h"
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/glfw/glfw_event_loop.h"
#include "flutter/shell/platform/glfw/headless_event_loop.h"
#include "flutter/shell/platform/glfw/key_event_handler.h"
#include "flutter/shell/platform/glfw/keyboard_hook_handler.h"
#include "flutter/shell/platform/glfw/platform_handler.h"
#include "flutter/shell/platform/glfw/system_utils.h"
#include "flutter/shell/platform/glfw/text_input_plugin.h"

Go to the source code of this file.

Classes
struct	FlutterDesktopWindowControllerState
struct	FlutterDesktopWindow
struct	AOTDataDeleter
struct	FlutterDesktopEngineState
struct	FlutterDesktopPluginRegistrar
struct	FlutterDesktopMessenger

Macros
#define	GLFW_TRUE   1
#define	GLFW_FALSE   0

Typedefs
using	UniqueGLFWwindowPtr = std::unique_ptr< GLFWwindow, void(*)(GLFWwindow *)>
using	UniqueAotDataPtr = std::unique_ptr< _FlutterEngineAOTData, AOTDataDeleter >
using	FlutterDesktopMessengerReferenceOwner = std::unique_ptr< FlutterDesktopMessenger, decltype(&FlutterDesktopMessengerRelease)>
	Maintains one ref on the FlutterDesktopMessenger's internal reference count. More...

Functions
FlutterDesktopMessengerRef	FlutterDesktopMessengerAddRef (FlutterDesktopMessengerRef messenger)
void	FlutterDesktopMessengerRelease (FlutterDesktopMessengerRef messenger)
bool	FlutterDesktopMessengerIsAvailable (FlutterDesktopMessengerRef messenger)
FlutterDesktopMessengerRef	FlutterDesktopMessengerLock (FlutterDesktopMessengerRef messenger)
void	FlutterDesktopMessengerUnlock (FlutterDesktopMessengerRef messenger)
static FlutterDesktopWindowControllerState *	GetWindowController (GLFWwindow *window)
static UniqueGLFWwindowPtr	CreateShareWindowForWindow (GLFWwindow *window)
static FlutterDesktopMessage	ConvertToDesktopMessage (const FlutterPlatformMessage &engine_message)
static double	GetScreenCoordinatesPerInch ()
static void	SendWindowMetrics (FlutterDesktopWindowControllerState *controller, int width, int height)
static void	ConfigurePlatformTaskRunner (FlutterTaskRunnerDescription *task_runner, FlutterDesktopEngineState *engine_state)
static void	GLFWFramebufferSizeCallback (GLFWwindow *window, int width_px, int height_px)
void	GLFWWindowRefreshCallback (GLFWwindow *window)
static void	SendPointerEventWithData (GLFWwindow *window, const FlutterPointerEvent &event_data)
static void	SetEventLocationFromCursorPosition (GLFWwindow *window, FlutterPointerEvent *event_data)
static void	SetEventPhaseFromCursorButtonState (GLFWwindow *window, FlutterPointerEvent *event_data, int64_t buttons)
static void	GLFWCursorEnterCallback (GLFWwindow *window, int entered)
static void	GLFWCursorPositionCallback (GLFWwindow *window, double x, double y)
static void	GLFWMouseButtonCallback (GLFWwindow *window, int key, int action, int mods)
static void	GLFWScrollCallback (GLFWwindow *window, double delta_x, double delta_y)
static void	GLFWCharCallback (GLFWwindow *window, unsigned int code_point)
static void	GLFWKeyCallback (GLFWwindow *window, int key, int scancode, int action, int mods)
static void	SetHoverCallbacksEnabled (GLFWwindow *window, bool enabled)
static void	GLFWAssignEventCallbacks (GLFWwindow *window)
static void	GLFWClearEventCallbacks (GLFWwindow *window)
static void	EngineOnFlutterPlatformMessage (const FlutterPlatformMessage *engine_message, void *user_data)
static bool	EngineMakeContextCurrent (void *user_data)
static bool	EngineMakeResourceContextCurrent (void *user_data)
static bool	EngineClearContext (void *user_data)
static bool	EnginePresent (void *user_data)
static uint32_t	EngineGetActiveFbo (void *user_data)
static void *	EngineProcResolver (void *user_data, const char *name)
static void	GLFWClearCanvas (GLFWwindow *window)
static void	GLFWErrorCallback (int error_code, const char *description)
UniqueAotDataPtr	LoadAotData (const std::filesystem::path &aot_data_path)
static bool	RunFlutterEngine (FlutterDesktopEngineState *engine_state, const FlutterDesktopEngineProperties &engine_properties, std::unique_ptr< flutter::EventLoop > event_loop)
static void	SetUpLocales (FlutterDesktopEngineState *state)
static void	SetUpCommonEngineState (FlutterDesktopEngineState *state, GLFWwindow *window)
bool	FlutterDesktopInit ()
void	FlutterDesktopTerminate ()
FlutterDesktopWindowControllerRef	FlutterDesktopCreateWindow (const FlutterDesktopWindowProperties &window_properties, const FlutterDesktopEngineProperties &engine_properties)
void	FlutterDesktopDestroyWindow (FlutterDesktopWindowControllerRef controller)
void	FlutterDesktopWindowSetHoverEnabled (FlutterDesktopWindowRef flutter_window, bool enabled)
void	FlutterDesktopWindowSetTitle (FlutterDesktopWindowRef flutter_window, const char *title)
void	FlutterDesktopWindowSetIcon (FlutterDesktopWindowRef flutter_window, uint8_t *pixel_data, int width, int height)
void	FlutterDesktopWindowGetFrame (FlutterDesktopWindowRef flutter_window, int *x, int *y, int *width, int *height)
void	FlutterDesktopWindowSetFrame (FlutterDesktopWindowRef flutter_window, int x, int y, int width, int height)
double	FlutterDesktopWindowGetScaleFactor (FlutterDesktopWindowRef flutter_window)
void	FlutterDesktopWindowSetPixelRatioOverride (FlutterDesktopWindowRef flutter_window, double pixel_ratio)
void	FlutterDesktopWindowSetSizeLimits (FlutterDesktopWindowRef flutter_window, FlutterDesktopSize minimum_size, FlutterDesktopSize maximum_size)
bool	FlutterDesktopRunWindowEventLoopWithTimeout (FlutterDesktopWindowControllerRef controller, uint32_t timeout_milliseconds)
FlutterDesktopWindowRef	FlutterDesktopGetWindow (FlutterDesktopWindowControllerRef controller)
FlutterDesktopEngineRef	FlutterDesktopGetEngine (FlutterDesktopWindowControllerRef controller)
FlutterDesktopPluginRegistrarRef	FlutterDesktopGetPluginRegistrar (FlutterDesktopEngineRef engine, const char *plugin_name)
FlutterDesktopEngineRef	FlutterDesktopRunEngine (const FlutterDesktopEngineProperties &properties)
void	FlutterDesktopRunEngineEventLoopWithTimeout (FlutterDesktopEngineRef engine, uint32_t timeout_milliseconds)
bool	FlutterDesktopShutDownEngine (FlutterDesktopEngineRef engine)
void	FlutterDesktopPluginRegistrarEnableInputBlocking (FlutterDesktopPluginRegistrarRef registrar, const char *channel)
FlutterDesktopMessengerRef	FlutterDesktopPluginRegistrarGetMessenger (FlutterDesktopPluginRegistrarRef registrar)
void	FlutterDesktopPluginRegistrarSetDestructionHandler (FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopOnPluginRegistrarDestroyed callback)
FlutterDesktopWindowRef	FlutterDesktopPluginRegistrarGetWindow (FlutterDesktopPluginRegistrarRef registrar)
bool	FlutterDesktopMessengerSendWithReply (FlutterDesktopMessengerRef messenger, const char *channel, const uint8_t *message, const size_t message_size, const FlutterDesktopBinaryReply reply, void *user_data)
bool	FlutterDesktopMessengerSend (FlutterDesktopMessengerRef messenger, const char *channel, const uint8_t *message, const size_t message_size)
void	FlutterDesktopMessengerSendResponse (FlutterDesktopMessengerRef messenger, const FlutterDesktopMessageResponseHandle *handle, const uint8_t *data, size_t data_length)
void	FlutterDesktopMessengerSetCallback (FlutterDesktopMessengerRef messenger, const char *channel, FlutterDesktopMessageCallback callback, void *user_data)
FlutterDesktopTextureRegistrarRef	FlutterDesktopRegistrarGetTextureRegistrar (FlutterDesktopPluginRegistrarRef registrar)
int64_t	FlutterDesktopTextureRegistrarRegisterExternalTexture (FlutterDesktopTextureRegistrarRef texture_registrar, const FlutterDesktopTextureInfo *texture_info)
void	FlutterDesktopTextureRegistrarUnregisterExternalTexture (FlutterDesktopTextureRegistrarRef texture_registrar, int64_t texture_id, void(*callback)(void *user_data), void *user_data)
bool	FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable (FlutterDesktopTextureRegistrarRef texture_registrar, int64_t texture_id)

Variables
const int	kFlutterDesktopDontCare = GLFW_DONT_CARE
static constexpr double	kDpPerInch = 160.0

Macro Definition Documentation

GLFW_FALSE

#define GLFW_FALSE   0

Definition at line 36 of file flutter_glfw.cc.

GLFW_TRUE

#define GLFW_TRUE   1

Definition at line 33 of file flutter_glfw.cc.

Typedef Documentation

FlutterDesktopMessengerReferenceOwner

using FlutterDesktopMessengerReferenceOwner = std::unique_ptr<FlutterDesktopMessenger, decltype(&FlutterDesktopMessengerRelease)>

Maintains one ref on the FlutterDesktopMessenger's internal reference count.

Definition at line 112 of file flutter_glfw.cc.

UniqueAotDataPtr

using UniqueAotDataPtr = std::unique_ptr<_FlutterEngineAOTData, AOTDataDeleter>

Definition at line 110 of file flutter_glfw.cc.

UniqueGLFWwindowPtr

using UniqueGLFWwindowPtr = std::unique_ptr<GLFWwindow, void (*)(GLFWwindow*)>

Definition at line 39 of file flutter_glfw.cc.

Function Documentation

ConfigurePlatformTaskRunner()

static void ConfigurePlatformTaskRunner ( FlutterTaskRunnerDescription *  task_runner, FlutterDesktopEngineState *  engine_state  )

static

Definition at line 309 of file flutter_glfw.cc.

                                             {
  task_runner->struct_size = sizeof(FlutterTaskRunnerDescription);
  task_runner->user_data = engine_state;
  task_runner->runs_task_on_current_thread_callback = [](void* state) -> bool {
    return reinterpret_cast<FlutterDesktopEngineState*>(state)
        ->event_loop->RunsTasksOnCurrentThread();
  };
  task_runner->post_task_callback =
      [](FlutterTask task, uint64_t target_time_nanos, void* state) -> void {
    reinterpret_cast<FlutterDesktopEngineState*>(state)->event_loop->PostTask(
        task, target_time_nanos);
  };
}

ConvertToDesktopMessage()

static FlutterDesktopMessage ConvertToDesktopMessage ( const FlutterPlatformMessage &  engine_message )

static

Definition at line 251 of file flutter_glfw.cc.

                                                  {
  FlutterDesktopMessage message = {};
  message.struct_size = sizeof(message);
  message.channel = engine_message.channel;
  message.message = engine_message.message;
  message.message_size = engine_message.message_size;
  message.response_handle = engine_message.response_handle;
  return message;
}

CreateShareWindowForWindow()

static UniqueGLFWwindowPtr CreateShareWindowForWindow ( GLFWwindow *  window )

static

Definition at line 237 of file flutter_glfw.cc.

                                                                          {
  glfwWindowHint(GLFW_DECORATED, GLFW_FALSE);
  glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
#if defined(__linux__)
  glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
  glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
#endif
  GLFWwindow* share_window = glfwCreateWindow(1, 1, "", NULL, window);
  glfwDefaultWindowHints();
  return UniqueGLFWwindowPtr(share_window, glfwDestroyWindow);
}

EngineClearContext()

static bool EngineClearContext ( void *  user_data )

static

Definition at line 621 of file flutter_glfw.cc.

                                                {
  FlutterDesktopEngineState* engine_state =
      static_cast<FlutterDesktopEngineState*>(user_data);
  FlutterDesktopWindowControllerState* window_controller =
      engine_state->window_controller;
  if (!window_controller) {
    return false;
  }
  glfwMakeContextCurrent(nullptr);
  return true;
}

EngineGetActiveFbo()

static uint32_t EngineGetActiveFbo ( void *  user_data )

static

Definition at line 645 of file flutter_glfw.cc.

                                                    {
  return 0;
}

EngineMakeContextCurrent()

static bool EngineMakeContextCurrent ( void *  user_data )

static

Definition at line 597 of file flutter_glfw.cc.

                                                      {
  FlutterDesktopEngineState* engine_state =
      static_cast<FlutterDesktopEngineState*>(user_data);
  FlutterDesktopWindowControllerState* window_controller =
      engine_state->window_controller;
  if (!window_controller) {
    return false;
  }
  glfwMakeContextCurrent(window_controller->window.get());
  return true;
}

EngineMakeResourceContextCurrent()

static bool EngineMakeResourceContextCurrent ( void *  user_data )

static

Definition at line 609 of file flutter_glfw.cc.

                                                              {
  FlutterDesktopEngineState* engine_state =
      static_cast<FlutterDesktopEngineState*>(user_data);
  FlutterDesktopWindowControllerState* window_controller =
      engine_state->window_controller;
  if (!window_controller) {
    return false;
  }
  glfwMakeContextCurrent(window_controller->resource_window.get());
  return true;
}

EngineOnFlutterPlatformMessage()

static void EngineOnFlutterPlatformMessage ( const FlutterPlatformMessage *  engine_message, void *  user_data  )

static

Definition at line 566 of file flutter_glfw.cc.

                     {
  if (engine_message->struct_size != sizeof(FlutterPlatformMessage)) {
    std::cerr << "Invalid message size received. Expected: "
              << sizeof(FlutterPlatformMessage) << " but received "
              << engine_message->struct_size << std::endl;
    return;
  }
 
  FlutterDesktopEngineState* engine_state =
      static_cast<FlutterDesktopEngineState*>(user_data);
  GLFWwindow* window = engine_state->window_controller == nullptr
                           ? nullptr
                           : engine_state->window_controller->window.get();
 
  auto message = ConvertToDesktopMessage(*engine_message);
  engine_state->message_dispatcher->HandleMessage(
      message,
      [window] {
        if (window) {
          GLFWClearEventCallbacks(window);
        }
      },
      [window] {
        if (window) {
          GLFWAssignEventCallbacks(window);
        }
      });
}

EnginePresent()

static bool EnginePresent ( void *  user_data )

static

Definition at line 633 of file flutter_glfw.cc.

                                           {
  FlutterDesktopEngineState* engine_state =
      static_cast<FlutterDesktopEngineState*>(user_data);
  FlutterDesktopWindowControllerState* window_controller =
      engine_state->window_controller;
  if (!window_controller) {
    return false;
  }
  glfwSwapBuffers(window_controller->window.get());
  return true;
}

EngineProcResolver()

static void * EngineProcResolver ( void *  user_data, const char *  name  )

static

Definition at line 651 of file flutter_glfw.cc.

                                                                   {
  return reinterpret_cast<void*>(glfwGetProcAddress(name));
}

FlutterDesktopCreateWindow()

FlutterDesktopWindowControllerRef FlutterDesktopCreateWindow	(	const FlutterDesktopWindowProperties &	window_properties,
		const FlutterDesktopEngineProperties &	engine_properties
	)

Definition at line 859 of file flutter_glfw.cc.

                                                             {
  auto state = std::make_unique<FlutterDesktopWindowControllerState>();
 
  // Create the window, and set the state as its user data.
  if (window_properties.prevent_resize) {
    glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
  }
#if defined(__linux__)
  glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
#endif
  state->window = UniqueGLFWwindowPtr(
      glfwCreateWindow(window_properties.width, window_properties.height,
                       window_properties.title, NULL, NULL),
      glfwDestroyWindow);
  glfwDefaultWindowHints();
  GLFWwindow* window = state->window.get();
  if (window == nullptr) {
    return nullptr;
  }
  GLFWClearCanvas(window);
  glfwSetWindowUserPointer(window, state.get());
 
  // Create the share window before starting the engine, since it may call
  // EngineMakeResourceContextCurrent immediately.
  state->resource_window = CreateShareWindowForWindow(window);
 
  state->engine = std::make_unique<FlutterDesktopEngineState>();
  state->engine->window_controller = state.get();
 
  // Create an event loop for the window. It is not running yet.
  auto event_loop = std::make_unique<flutter::GLFWEventLoop>(
      std::this_thread::get_id(),  // main GLFW thread
      [engine_state = state->engine.get()](const auto* task) {
        if (FlutterEngineRunTask(engine_state->flutter_engine, task) !=
            kSuccess) {
          std::cerr << "Could not post an engine task." << std::endl;
        }
      });
 
  // Start the engine.
  if (!RunFlutterEngine(state->engine.get(), engine_properties,
                        std::move(event_loop))) {
    return nullptr;
  }
  SetUpCommonEngineState(state->engine.get(), window);
 
  state->window_wrapper = std::make_unique<FlutterDesktopWindow>();
  state->window_wrapper->window = window;
 
  // Set up the keyboard handlers
  auto internal_plugin_messenger =
      state->engine->internal_plugin_registrar->messenger();
  state->keyboard_hook_handlers.push_back(
      std::make_unique<flutter::KeyEventHandler>(internal_plugin_messenger));
  state->keyboard_hook_handlers.push_back(
      std::make_unique<flutter::TextInputPlugin>(internal_plugin_messenger));
 
  // Trigger an initial size callback to send size information to Flutter.
  state->monitor_screen_coordinates_per_inch = GetScreenCoordinatesPerInch();
  int width_px, height_px;
  glfwGetFramebufferSize(window, &width_px, &height_px);
  GLFWFramebufferSizeCallback(window, width_px, height_px);
 
  // Set up GLFW callbacks for the window.
  glfwSetFramebufferSizeCallback(window, GLFWFramebufferSizeCallback);
  glfwSetWindowRefreshCallback(window, GLFWWindowRefreshCallback);
  GLFWAssignEventCallbacks(window);
 
  return state.release();
}

FlutterDesktopDestroyWindow()

void FlutterDesktopDestroyWindow

(

FlutterDesktopWindowControllerRef

controller

)

Definition at line 932 of file flutter_glfw.cc.

                                                                               {
  controller->engine->messenger->SetEngine(nullptr);
  FlutterDesktopPluginRegistrarRef registrar =
      controller->engine->plugin_registrar.get();
  if (registrar->destruction_handler) {
    registrar->destruction_handler(registrar);
  }
  FlutterEngineShutdown(controller->engine->flutter_engine);
  delete controller;
}

FlutterDesktopGetEngine()

FlutterDesktopEngineRef FlutterDesktopGetEngine

(

FlutterDesktopWindowControllerRef

controller

)

Definition at line 1046 of file flutter_glfw.cc.

                                                  {
  return controller->engine.get();
}

FlutterDesktopGetPluginRegistrar()

FlutterDesktopPluginRegistrarRef FlutterDesktopGetPluginRegistrar	(	FlutterDesktopEngineRef	engine,
		const char *	plugin_name
	)

Definition at line 1051 of file flutter_glfw.cc.

                             {
  // Currently, one registrar acts as the registrar for all plugins, so the
  // name is ignored. It is part of the API to reduce churn in the future when
  // aligning more closely with the Flutter registrar system.
  return engine->plugin_registrar.get();
}

FlutterDesktopGetWindow()

FlutterDesktopWindowRef FlutterDesktopGetWindow

(

FlutterDesktopWindowControllerRef

controller

)

Definition at line 1038 of file flutter_glfw.cc.

                                                  {
  // Currently, one registrar acts as the registrar for all plugins, so the
  // name is ignored. It is part of the API to reduce churn in the future when
  // aligning more closely with the Flutter registrar system.
  return controller->window_wrapper.get();
}

FlutterDesktopInit()

bool FlutterDesktopInit

(

)

Definition at line 849 of file flutter_glfw.cc.

                          {
  // Before making any GLFW calls, set up a logging error handler.
  glfwSetErrorCallback(GLFWErrorCallback);
  return glfwInit();
}

FlutterDesktopMessengerAddRef()

FlutterDesktopMessengerRef FlutterDesktopMessengerAddRef

(

FlutterDesktopMessengerRef

messenger

)

Definition at line 204 of file flutter_glfw.cc.

                                          {
  messenger->AddRef();
  return messenger;
}

FlutterDesktopMessengerIsAvailable()

bool FlutterDesktopMessengerIsAvailable

(

FlutterDesktopMessengerRef

messenger

)

Definition at line 214 of file flutter_glfw.cc.

                                                                              {
  return messenger->GetEngine() != nullptr;
}

FlutterDesktopMessengerLock()

FlutterDesktopMessengerRef FlutterDesktopMessengerLock

(

FlutterDesktopMessengerRef

messenger

)

Definition at line 218 of file flutter_glfw.cc.

                                          {
  messenger->GetMutex().lock();
  return messenger;
}

FlutterDesktopMessengerRelease()

void FlutterDesktopMessengerRelease

(

FlutterDesktopMessengerRef

messenger

)

Definition at line 210 of file flutter_glfw.cc.

                                                                          {
  messenger->Release();
}

FlutterDesktopMessengerSend()

bool FlutterDesktopMessengerSend	(	FlutterDesktopMessengerRef	messenger,
		const char *	channel,
		const uint8_t *	message,
		const size_t	message_size
	)

Definition at line 1160 of file flutter_glfw.cc.

                                                            {
  return FlutterDesktopMessengerSendWithReply(messenger, channel, message,
                                              message_size, nullptr, nullptr);
}

FlutterDesktopMessengerSendResponse()

void FlutterDesktopMessengerSendResponse	(	FlutterDesktopMessengerRef	messenger,
		const FlutterDesktopMessageResponseHandle *	handle,
		const uint8_t *	data,
		size_t	data_length
	)

Definition at line 1168 of file flutter_glfw.cc.

                        {
  FlutterEngineSendPlatformMessageResponse(
      messenger->GetEngine()->flutter_engine, handle, data, data_length);
}

FlutterDesktopMessengerSendWithReply()

bool FlutterDesktopMessengerSendWithReply	(	FlutterDesktopMessengerRef	messenger,
		const char *	channel,
		const uint8_t *	message,
		const size_t	message_size,
		const FlutterDesktopBinaryReply	reply,
		void *	user_data
	)

Definition at line 1124 of file flutter_glfw.cc.

                                                           {
  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
  if (reply != nullptr && user_data != nullptr) {
    FlutterEngineResult result = FlutterPlatformMessageCreateResponseHandle(
        messenger->GetEngine()->flutter_engine, reply, user_data,
        &response_handle);
    if (result != kSuccess) {
      std::cout << "Failed to create response handle\n";
      return false;
    }
  }
 
  FlutterPlatformMessage platform_message = {
      sizeof(FlutterPlatformMessage),
      channel,
      message,
      message_size,
      response_handle,
  };
 
  FlutterEngineResult message_result = FlutterEngineSendPlatformMessage(
      messenger->GetEngine()->flutter_engine, &platform_message);
 
  if (response_handle != nullptr) {
    FlutterPlatformMessageReleaseResponseHandle(
        messenger->GetEngine()->flutter_engine, response_handle);
  }
 
  return message_result == kSuccess;
}

FlutterDesktopMessengerSetCallback()

void FlutterDesktopMessengerSetCallback	(	FlutterDesktopMessengerRef	messenger,
		const char *	channel,
		FlutterDesktopMessageCallback	callback,
		void *	user_data
	)

Definition at line 1177 of file flutter_glfw.cc.

                                                         {
  messenger->GetEngine()->message_dispatcher->SetMessageCallback(
      channel, callback, user_data);
}

FlutterDesktopMessengerUnlock()

void FlutterDesktopMessengerUnlock

(

FlutterDesktopMessengerRef

messenger

)

Definition at line 224 of file flutter_glfw.cc.

                                                                         {
  messenger->GetMutex().unlock();
}

FlutterDesktopPluginRegistrarEnableInputBlocking()

void FlutterDesktopPluginRegistrarEnableInputBlocking	(	FlutterDesktopPluginRegistrarRef	registrar,
		const char *	channel
	)

Definition at line 1097 of file flutter_glfw.cc.

                         {
  registrar->engine->message_dispatcher->EnableInputBlockingForChannel(channel);
}

FlutterDesktopPluginRegistrarGetMessenger()

FlutterDesktopMessengerRef FlutterDesktopPluginRegistrarGetMessenger

(

FlutterDesktopPluginRegistrarRef

registrar

)

Definition at line 1103 of file flutter_glfw.cc.

                                                {
  return registrar->engine->messenger.get();
}

FlutterDesktopPluginRegistrarGetWindow()

FlutterDesktopWindowRef FlutterDesktopPluginRegistrarGetWindow

(

FlutterDesktopPluginRegistrarRef

registrar

)

Definition at line 1114 of file flutter_glfw.cc.

                                                {
  FlutterDesktopWindowControllerState* controller =
      registrar->engine->window_controller;
  if (!controller) {
    return nullptr;
  }
  return controller->window_wrapper.get();
}

FlutterDesktopPluginRegistrarSetDestructionHandler()

void FlutterDesktopPluginRegistrarSetDestructionHandler	(	FlutterDesktopPluginRegistrarRef	registrar,
		FlutterDesktopOnPluginRegistrarDestroyed	callback
	)

Definition at line 1108 of file flutter_glfw.cc.

                                                       {
  registrar->destruction_handler = callback;
}

FlutterDesktopRegistrarGetTextureRegistrar()

FlutterDesktopTextureRegistrarRef FlutterDesktopRegistrarGetTextureRegistrar

(

FlutterDesktopPluginRegistrarRef

registrar

)

Definition at line 1185 of file flutter_glfw.cc.

                                                {
  std::cerr << "GLFW Texture support is not implemented yet." << std::endl;
  return nullptr;
}

FlutterDesktopRunEngine()

FlutterDesktopEngineRef FlutterDesktopRunEngine

(

const FlutterDesktopEngineProperties &

properties

)

Definition at line 1060 of file flutter_glfw.cc.

                                                      {
  auto engine_state = std::make_unique<FlutterDesktopEngineState>();
 
  auto event_loop = std::make_unique<flutter::HeadlessEventLoop>(
      std::this_thread::get_id(),
      [state = engine_state.get()](const auto* task) {
        if (FlutterEngineRunTask(state->flutter_engine, task) != kSuccess) {
          std::cerr << "Could not post an engine task." << std::endl;
        }
      });
 
  if (!RunFlutterEngine(engine_state.get(), properties,
                        std::move(event_loop))) {
    return nullptr;
  }
  SetUpCommonEngineState(engine_state.get(), nullptr);
 
  return engine_state.release();
}

FlutterDesktopRunEngineEventLoopWithTimeout()

void FlutterDesktopRunEngineEventLoopWithTimeout	(	FlutterDesktopEngineRef	engine,
		uint32_t	timeout_milliseconds
	)

Definition at line 1081 of file flutter_glfw.cc.

                                   {
  std::chrono::nanoseconds wait_duration =
      timeout_milliseconds == 0
          ? std::chrono::nanoseconds::max()
          : std::chrono::milliseconds(timeout_milliseconds);
  engine->event_loop->WaitForEvents(wait_duration);
}

FlutterDesktopRunWindowEventLoopWithTimeout()

bool FlutterDesktopRunWindowEventLoopWithTimeout	(	FlutterDesktopWindowControllerRef	controller,
		uint32_t	timeout_milliseconds
	)

Definition at line 1030 of file flutter_glfw.cc.

                                   {
  FlutterDesktopRunEngineEventLoopWithTimeout(controller->engine.get(),
                                              timeout_milliseconds);
  return !glfwWindowShouldClose(controller->window.get());
}

FlutterDesktopShutDownEngine()

bool FlutterDesktopShutDownEngine

(

FlutterDesktopEngineRef

engine

)

Definition at line 1091 of file flutter_glfw.cc.

                                                                  {
  auto result = FlutterEngineShutdown(engine->flutter_engine);
  delete engine;
  return (result == kSuccess);
}

FlutterDesktopTerminate()

void FlutterDesktopTerminate

(

)

Definition at line 855 of file flutter_glfw.cc.

                               {
  glfwTerminate();
}

FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable()

bool FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable	(	FlutterDesktopTextureRegistrarRef	texture_registrar,
		int64_t	texture_id
	)

Definition at line 1206 of file flutter_glfw.cc.

                        {
  std::cerr << "GLFW Texture support is not implemented yet." << std::endl;
  return false;
}

FlutterDesktopTextureRegistrarRegisterExternalTexture()

int64_t FlutterDesktopTextureRegistrarRegisterExternalTexture	(	FlutterDesktopTextureRegistrarRef	texture_registrar,
		const FlutterDesktopTextureInfo *	texture_info
	)

Definition at line 1191 of file flutter_glfw.cc.

                                                   {
  std::cerr << "GLFW Texture support is not implemented yet." << std::endl;
  return -1;
}

FlutterDesktopTextureRegistrarUnregisterExternalTexture()

void FlutterDesktopTextureRegistrarUnregisterExternalTexture	(	FlutterDesktopTextureRegistrarRef	texture_registrar,
		int64_t	texture_id,
		void(*)(void *user_data)	callback,
		void *	user_data
	)

Definition at line 1198 of file flutter_glfw.cc.

                     {
  std::cerr << "GLFW Texture support is not implemented yet." << std::endl;
}

FlutterDesktopWindowGetFrame()

void FlutterDesktopWindowGetFrame	(	FlutterDesktopWindowRef	flutter_window,
		int *	x,
		int *	y,
		int *	width,
		int *	height
	)

Definition at line 963 of file flutter_glfw.cc.

                                               {
  glfwGetWindowPos(flutter_window->window, x, y);
  glfwGetWindowSize(flutter_window->window, width, height);
  // The above gives content area size and position; adjust for the window
  // decoration to give actual window frame.
  int frame_left, frame_top, frame_right, frame_bottom;
  glfwGetWindowFrameSize(flutter_window->window, &frame_left, &frame_top,
                         &frame_right, &frame_bottom);
  if (x) {
    *x -= frame_left;
  }
  if (y) {
    *y -= frame_top;
  }
  if (width) {
    *width += frame_left + frame_right;
  }
  if (height) {
    *height += frame_top + frame_bottom;
  }
}

FlutterDesktopWindowGetScaleFactor()

double FlutterDesktopWindowGetScaleFactor

(

FlutterDesktopWindowRef

flutter_window

)

Definition at line 1004 of file flutter_glfw.cc.

                                            {
  return flutter_window->pixels_per_screen_coordinate;
}

FlutterDesktopWindowSetFrame()

void FlutterDesktopWindowSetFrame	(	FlutterDesktopWindowRef	flutter_window,
		int	x,
		int	y,
		int	width,
		int	height
	)

Definition at line 989 of file flutter_glfw.cc.

                                              {
  // Get the window decoration sizes to adjust, since the GLFW setters take
  // content position and size.
  int frame_left, frame_top, frame_right, frame_bottom;
  glfwGetWindowFrameSize(flutter_window->window, &frame_left, &frame_top,
                         &frame_right, &frame_bottom);
  glfwSetWindowPos(flutter_window->window, x + frame_left, y + frame_top);
  glfwSetWindowSize(flutter_window->window, width - frame_left - frame_right,
                    height - frame_top - frame_bottom);
}

FlutterDesktopWindowSetHoverEnabled()

void FlutterDesktopWindowSetHoverEnabled	(	FlutterDesktopWindowRef	flutter_window,
		bool	enabled
	)

Definition at line 943 of file flutter_glfw.cc.

                                                       {
  flutter_window->hover_tracking_enabled = enabled;
  SetHoverCallbacksEnabled(flutter_window->window, enabled);
}

FlutterDesktopWindowSetIcon()

void FlutterDesktopWindowSetIcon	(	FlutterDesktopWindowRef	flutter_window,
		uint8_t *	pixel_data,
		int	width,
		int	height
	)

Definition at line 955 of file flutter_glfw.cc.

                                             {
  GLFWimage image = {width, height, static_cast<unsigned char*>(pixel_data)};
  glfwSetWindowIcon(flutter_window->window, pixel_data ? 1 : 0, &image);
}

FlutterDesktopWindowSetPixelRatioOverride()

void FlutterDesktopWindowSetPixelRatioOverride	(	FlutterDesktopWindowRef	flutter_window,
		double	pixel_ratio
	)

Definition at line 1009 of file flutter_glfw.cc.

                        {
  flutter_window->pixel_ratio_override = pixel_ratio;
  // Send a metrics update using the new pixel ratio.
  int width_px, height_px;
  glfwGetFramebufferSize(flutter_window->window, &width_px, &height_px);
  if (width_px > 0 && height_px > 0) {
    auto* controller = GetWindowController(flutter_window->window);
    SendWindowMetrics(controller, width_px, height_px);
  }
}

FlutterDesktopWindowSetSizeLimits()

void FlutterDesktopWindowSetSizeLimits	(	FlutterDesktopWindowRef	flutter_window,
		FlutterDesktopSize	minimum_size,
		FlutterDesktopSize	maximum_size
	)

Definition at line 1022 of file flutter_glfw.cc.

                                                                        {
  glfwSetWindowSizeLimits(flutter_window->window, minimum_size.width,
                          minimum_size.height, maximum_size.width,
                          maximum_size.height);
}

FlutterDesktopWindowSetTitle()

void FlutterDesktopWindowSetTitle	(	FlutterDesktopWindowRef	flutter_window,
		const char *	title
	)

Definition at line 949 of file flutter_glfw.cc.

                                                     {
  GLFWwindow* window = flutter_window->window;
  glfwSetWindowTitle(window, title);
}

GetScreenCoordinatesPerInch()

static double GetScreenCoordinatesPerInch ( )

static

Definition at line 265 of file flutter_glfw.cc.

                                            {
  auto* primary_monitor = glfwGetPrimaryMonitor();
  if (primary_monitor == nullptr) {
    return kDpPerInch;
  }
  auto* primary_monitor_mode = glfwGetVideoMode(primary_monitor);
  int primary_monitor_width_mm;
  glfwGetMonitorPhysicalSize(primary_monitor, &primary_monitor_width_mm,
                             nullptr);
  if (primary_monitor_width_mm == 0) {
    return kDpPerInch;
  }
  return primary_monitor_mode->width / (primary_monitor_width_mm / 25.4);
}

GetWindowController()

static FlutterDesktopWindowControllerState * GetWindowController ( GLFWwindow *  window )

static

Definition at line 229 of file flutter_glfw.cc.

                        {
  return reinterpret_cast<FlutterDesktopWindowControllerState*>(
      glfwGetWindowUserPointer(window));
}

GLFWAssignEventCallbacks()

static void GLFWAssignEventCallbacks ( GLFWwindow *  window )

static

Definition at line 544 of file flutter_glfw.cc.

                                                         {
  glfwPollEvents();
  glfwSetKeyCallback(window, GLFWKeyCallback);
  glfwSetCharCallback(window, GLFWCharCallback);
  glfwSetMouseButtonCallback(window, GLFWMouseButtonCallback);
  glfwSetScrollCallback(window, GLFWScrollCallback);
  if (GetWindowController(window)->window_wrapper->hover_tracking_enabled) {
    SetHoverCallbacksEnabled(window, true);
  }
}

GLFWCharCallback()

static void GLFWCharCallback ( GLFWwindow *  window, unsigned int  code_point  )

static

Definition at line 516 of file flutter_glfw.cc.

                                                                          {
  for (const auto& handler :
       GetWindowController(window)->keyboard_hook_handlers) {
    handler->CharHook(window, code_point);
  }
}

GLFWClearCanvas()

static void GLFWClearCanvas ( GLFWwindow *  window )

static

Definition at line 663 of file flutter_glfw.cc.

                                                {
  glfwMakeContextCurrent(window);
  // This color is Material Blue Grey.
  glClearColor(236.0f / 255.0f, 239.0f / 255.0f, 241.0f / 255.0f, 0.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glFlush();
  glfwSwapBuffers(window);
  glfwMakeContextCurrent(nullptr);
}

GLFWClearEventCallbacks()

static void GLFWClearEventCallbacks ( GLFWwindow *  window )

static

Definition at line 556 of file flutter_glfw.cc.

                                                        {
  glfwSetKeyCallback(window, nullptr);
  glfwSetCharCallback(window, nullptr);
  glfwSetMouseButtonCallback(window, nullptr);
  glfwSetScrollCallback(window, nullptr);
  SetHoverCallbacksEnabled(window, false);
}

GLFWCursorEnterCallback()

static void GLFWCursorEnterCallback ( GLFWwindow *  window, int  entered  )

static

Definition at line 439 of file flutter_glfw.cc.

                                                                     {
  FlutterPointerEvent event = {};
  event.phase =
      entered ? FlutterPointerPhase::kAdd : FlutterPointerPhase::kRemove;
  SetEventLocationFromCursorPosition(window, &event);
  SendPointerEventWithData(window, event);
}

GLFWCursorPositionCallback()

static void GLFWCursorPositionCallback ( GLFWwindow *  window, double  x, double  y  )

static

Definition at line 448 of file flutter_glfw.cc.

                                                                               {
  FlutterPointerEvent event = {};
  event.x = x;
  event.y = y;
  auto* controller = GetWindowController(window);
  SetEventPhaseFromCursorButtonState(window, &event, controller->buttons);
  SendPointerEventWithData(window, event);
}

GLFWErrorCallback()

static void GLFWErrorCallback ( int  error_code, const char *  description  )

static

Definition at line 673 of file flutter_glfw.cc.

                                                                       {
  std::cerr << "GLFW error " << error_code << ": " << description << std::endl;
}

GLFWFramebufferSizeCallback()

static void GLFWFramebufferSizeCallback ( GLFWwindow *  window, int  width_px, int  height_px  )

static

Definition at line 327 of file flutter_glfw.cc.

                                                       {
  int width;
  glfwGetWindowSize(window, &width, nullptr);
  auto* controller = GetWindowController(window);
  controller->window_wrapper->pixels_per_screen_coordinate =
      width > 0 ? width_px / width : 1;
 
  SendWindowMetrics(controller, width_px, height_px);
  controller->window_wrapper->skip_next_window_refresh = true;
}

GLFWKeyCallback()

static void GLFWKeyCallback ( GLFWwindow *  window, int  key, int  scancode, int  action, int  mods  )

static

Definition at line 524 of file flutter_glfw.cc.

                                      {
  for (const auto& handler :
       GetWindowController(window)->keyboard_hook_handlers) {
    handler->KeyboardHook(window, key, scancode, action, mods);
  }
}

GLFWMouseButtonCallback()

static void GLFWMouseButtonCallback ( GLFWwindow *  window, int  key, int  action, int  mods  )

static

Definition at line 458 of file flutter_glfw.cc.

                                              {
  int64_t button;
  if (key == GLFW_MOUSE_BUTTON_LEFT) {
    button = FlutterPointerMouseButtons::kFlutterPointerButtonMousePrimary;
  } else if (key == GLFW_MOUSE_BUTTON_RIGHT) {
    button = FlutterPointerMouseButtons::kFlutterPointerButtonMouseSecondary;
  } else {
    return;
  }
 
  auto* controller = GetWindowController(window);
  controller->buttons = (action == GLFW_PRESS) ? controller->buttons | button
                                               : controller->buttons & ~button;
 
  FlutterPointerEvent event = {};
  SetEventPhaseFromCursorButtonState(window, &event, controller->buttons);
  SetEventLocationFromCursorPosition(window, &event);
  SendPointerEventWithData(window, event);
 
  // If mouse tracking isn't already enabled, turn it on for the duration of
  // the drag to generate kMove events.
  bool hover_enabled =
      GetWindowController(window)->window_wrapper->hover_tracking_enabled;
  if (!hover_enabled) {
    glfwSetCursorPosCallback(window, (controller->buttons != 0)
                                         ? GLFWCursorPositionCallback
                                         : nullptr);
  }
  // Disable enter/exit events while the mouse button is down; GLFW will send
  // an exit event when the mouse button is released, and the pointer should
  // stay valid until then.
  if (hover_enabled) {
    glfwSetCursorEnterCallback(
        window, (controller->buttons != 0) ? nullptr : GLFWCursorEnterCallback);
  }
}

GLFWScrollCallback()

static void GLFWScrollCallback ( GLFWwindow *  window, double  delta_x, double  delta_y  )

static

Definition at line 499 of file flutter_glfw.cc.

                                               {
  FlutterPointerEvent event = {};
  SetEventLocationFromCursorPosition(window, &event);
  auto* controller = GetWindowController(window);
  SetEventPhaseFromCursorButtonState(window, &event, controller->buttons);
  event.signal_kind = FlutterPointerSignalKind::kFlutterPointerSignalKindScroll;
  // TODO(chrome-bot): See if this can be queried from the OS; this value is
  // chosen arbitrarily to get something that feels reasonable.
  const int kScrollOffsetMultiplier = 20;
  event.scroll_delta_x = delta_x * kScrollOffsetMultiplier;
  event.scroll_delta_y = -delta_y * kScrollOffsetMultiplier;
  SendPointerEventWithData(window, event);
}

GLFWWindowRefreshCallback()

void GLFWWindowRefreshCallback

(

GLFWwindow *

window

)

Definition at line 341 of file flutter_glfw.cc.

                                                   {
  auto* controller = GetWindowController(window);
  if (controller->window_wrapper->skip_next_window_refresh) {
    controller->window_wrapper->skip_next_window_refresh = false;
    return;
  }
  // There's no engine API to request a redraw explicitly, so instead send a
  // window metrics event with the current size to trigger it.
  int width_px, height_px;
  glfwGetFramebufferSize(window, &width_px, &height_px);
  if (width_px > 0 && height_px > 0) {
    SendWindowMetrics(controller, width_px, height_px);
  }
}

LoadAotData()

UniqueAotDataPtr LoadAotData

(

const std::filesystem::path &

aot_data_path

)

Definition at line 679 of file flutter_glfw.cc.

                                                                     {
  if (aot_data_path.empty()) {
    std::cerr
        << "Attempted to load AOT data, but no aot_data_path was provided."
        << std::endl;
    return nullptr;
  }
  std::string path_string = aot_data_path.string();
  if (!std::filesystem::exists(aot_data_path)) {
    std::cerr << "Can't load AOT data from " << path_string << "; no such file."
              << std::endl;
    return nullptr;
  }
  FlutterEngineAOTDataSource source = {};
  source.type = kFlutterEngineAOTDataSourceTypeElfPath;
  source.elf_path = path_string.c_str();
  FlutterEngineAOTData data = nullptr;
  auto result = FlutterEngineCreateAOTData(&source, &data);
  if (result != kSuccess) {
    std::cerr << "Failed to load AOT data from: " << path_string << std::endl;
    return nullptr;
  }
  return UniqueAotDataPtr(data);
}

RunFlutterEngine()

static bool RunFlutterEngine ( FlutterDesktopEngineState *  engine_state, const FlutterDesktopEngineProperties &  engine_properties, std::unique_ptr< flutter::EventLoop >  event_loop  )

static

Definition at line 711 of file flutter_glfw.cc.

                                                {
  // FlutterProjectArgs is expecting a full argv, so when processing it for
  // flags the first item is treated as the executable and ignored. Add a dummy
  // value so that all provided arguments are used.
  std::vector<const char*> argv = {"placeholder"};
  if (engine_properties.switches_count > 0) {
    argv.insert(argv.end(), &engine_properties.switches[0],
                &engine_properties.switches[engine_properties.switches_count]);
  }
 
  std::filesystem::path assets_path =
      std::filesystem::u8path(engine_properties.assets_path);
  std::filesystem::path icu_path =
      std::filesystem::u8path(engine_properties.icu_data_path);
  std::filesystem::path aot_library_path =
      std::filesystem::u8path(engine_properties.aot_library_path);
  if (assets_path.is_relative() || icu_path.is_relative() ||
      (!aot_library_path.empty() && aot_library_path.is_relative())) {
    // Treat relative paths as relative to the directory of this executable.
    std::filesystem::path executable_location =
        flutter::GetExecutableDirectory();
    if (executable_location.empty()) {
      std::cerr << "Unable to find executable location to resolve paths."
                << std::endl;
      return false;
    }
    assets_path = std::filesystem::path(executable_location) / assets_path;
    icu_path = std::filesystem::path(executable_location) / icu_path;
    if (!aot_library_path.empty()) {
      aot_library_path =
          std::filesystem::path(executable_location) / aot_library_path;
    }
  }
  // Configure a task runner using the event loop.
  engine_state->event_loop = std::move(event_loop);
  FlutterTaskRunnerDescription platform_task_runner = {};
  ConfigurePlatformTaskRunner(&platform_task_runner, engine_state);
  FlutterCustomTaskRunners task_runners = {};
  task_runners.struct_size = sizeof(FlutterCustomTaskRunners);
  task_runners.platform_task_runner = &platform_task_runner;
 
  FlutterRendererConfig config = {};
  config.type = kOpenGL;
  config.open_gl.struct_size = sizeof(config.open_gl);
  config.open_gl.make_current = EngineMakeContextCurrent;
  config.open_gl.clear_current = EngineClearContext;
  config.open_gl.present = EnginePresent;
  config.open_gl.fbo_callback = EngineGetActiveFbo;
  config.open_gl.make_resource_current = EngineMakeResourceContextCurrent;
  // Don't provide a resolver in headless mode, since headless mode should
  // work even if GLFW initialization failed.
  if (engine_state->window_controller != nullptr) {
    config.open_gl.gl_proc_resolver = EngineProcResolver;
  }
  const std::string assets_path_string = assets_path.string();
  const std::string icu_path_string = icu_path.string();
  FlutterProjectArgs args = {};
  args.struct_size = sizeof(FlutterProjectArgs);
  args.assets_path = assets_path_string.c_str();
  args.icu_data_path = icu_path_string.c_str();
  args.command_line_argc = static_cast<int>(argv.size());
  args.command_line_argv = &argv[0];
  args.platform_message_callback = EngineOnFlutterPlatformMessage;
  args.custom_task_runners = &task_runners;
 
  if (FlutterEngineRunsAOTCompiledDartCode()) {
    engine_state->aot_data = LoadAotData(aot_library_path);
    if (!engine_state->aot_data) {
      std::cerr << "Unable to start engine without AOT data." << std::endl;
      return false;
    }
    args.aot_data = engine_state->aot_data.get();
  }
 
  FLUTTER_API_SYMBOL(FlutterEngine) engine = nullptr;
  auto result = FlutterEngineRun(FLUTTER_ENGINE_VERSION, &config, &args,
                                 engine_state, &engine);
  if (result != kSuccess || engine == nullptr) {
    std::cerr << "Failed to start Flutter engine: error " << result
              << std::endl;
    return false;
  }
  engine_state->flutter_engine = engine;
  return true;
}

SendPointerEventWithData()

static void SendPointerEventWithData ( GLFWwindow *  window, const FlutterPointerEvent &  event_data  )

static

Definition at line 360 of file flutter_glfw.cc.

                                                                            {
  auto* controller = GetWindowController(window);
  // If sending anything other than an add, and the pointer isn't already added,
  // synthesize an add to satisfy Flutter's expectations about events.
  if (!controller->pointer_currently_added &&
      event_data.phase != FlutterPointerPhase::kAdd) {
    FlutterPointerEvent event = {};
    event.phase = FlutterPointerPhase::kAdd;
    event.x = event_data.x;
    event.y = event_data.y;
    SendPointerEventWithData(window, event);
  }
  // Don't double-add (e.g., if events are delivered out of order, so an add has
  // already been synthesized).
  if (controller->pointer_currently_added &&
      event_data.phase == FlutterPointerPhase::kAdd) {
    return;
  }
 
  FlutterPointerEvent event = event_data;
  // Set metadata that's always the same regardless of the event.
  event.struct_size = sizeof(event);
  event.timestamp =
      std::chrono::duration_cast<std::chrono::microseconds>(
          std::chrono::high_resolution_clock::now().time_since_epoch())
          .count();
  event.device_kind = FlutterPointerDeviceKind::kFlutterPointerDeviceKindMouse;
  event.buttons =
      (event.phase == FlutterPointerPhase::kAdd) ? 0 : controller->buttons;
 
  // Convert all screen coordinates to pixel coordinates.
  double pixels_per_coordinate =
      controller->window_wrapper->pixels_per_screen_coordinate;
  event.x *= pixels_per_coordinate;
  event.y *= pixels_per_coordinate;
  event.scroll_delta_x *= pixels_per_coordinate;
  event.scroll_delta_y *= pixels_per_coordinate;
  // The GLFW embedder doesn't support multiple views. We assume all pointer
  // events come from the only view, the implicit view.
  event.view_id = flutter::kFlutterImplicitViewId;
 
  FlutterEngineSendPointerEvent(controller->engine->flutter_engine, &event, 1);
 
  if (event_data.phase == FlutterPointerPhase::kAdd) {
    controller->pointer_currently_added = true;
  } else if (event_data.phase == FlutterPointerPhase::kRemove) {
    controller->pointer_currently_added = false;
  } else if (event_data.phase == FlutterPointerPhase::kDown) {
    controller->pointer_currently_down = true;
  } else if (event_data.phase == FlutterPointerPhase::kUp) {
    controller->pointer_currently_down = false;
  }
}

SendWindowMetrics()

static void SendWindowMetrics ( FlutterDesktopWindowControllerState *  controller, int  width, int  height  )

static

Definition at line 282 of file flutter_glfw.cc.

                                          {
  double dpi = controller->window_wrapper->pixels_per_screen_coordinate *
               controller->monitor_screen_coordinates_per_inch;
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = width;
  event.height = height;
  if (controller->window_wrapper->pixel_ratio_override == 0.0) {
    // The Flutter pixel_ratio is defined as DPI/dp. Limit the ratio to a
    // minimum of 1 to avoid rendering a smaller UI on standard resolution
    // monitors.
    event.pixel_ratio = std::max(dpi / kDpPerInch, 1.0);
  } else {
    event.pixel_ratio = controller->window_wrapper->pixel_ratio_override;
  }
  // The GLFW embedder doesn't support multiple views. We assume all pointer
  // events come from the only view, the implicit view.
  event.view_id = flutter::kFlutterImplicitViewId;
  FlutterEngineSendWindowMetricsEvent(controller->engine->flutter_engine,
                                      &event);
}

SetEventLocationFromCursorPosition()

static void SetEventLocationFromCursorPosition ( GLFWwindow *  window, FlutterPointerEvent *  event_data  )

static

Definition at line 416 of file flutter_glfw.cc.

                                     {
  glfwGetCursorPos(window, &event_data->x, &event_data->y);
}

SetEventPhaseFromCursorButtonState()

static void SetEventPhaseFromCursorButtonState ( GLFWwindow *  window, FlutterPointerEvent *  event_data, int64_t  buttons  )

static

Definition at line 426 of file flutter_glfw.cc.

                                                                {
  auto* controller = GetWindowController(window);
  event_data->phase =
      (buttons == 0)
          ? (controller->pointer_currently_down ? FlutterPointerPhase::kUp
                                                : FlutterPointerPhase::kHover)
          : (controller->pointer_currently_down ? FlutterPointerPhase::kMove
                                                : FlutterPointerPhase::kDown);
}

SetHoverCallbacksEnabled()

static void SetHoverCallbacksEnabled ( GLFWwindow *  window, bool  enabled  )

static

Definition at line 536 of file flutter_glfw.cc.

                                                                       {
  glfwSetCursorEnterCallback(window,
                             enabled ? GLFWCursorEnterCallback : nullptr);
  glfwSetCursorPosCallback(window,
                           enabled ? GLFWCursorPositionCallback : nullptr);
}

SetUpCommonEngineState()

static void SetUpCommonEngineState ( FlutterDesktopEngineState *  state, GLFWwindow *  window  )

static

Definition at line 825 of file flutter_glfw.cc.

                                                       {
  // Messaging.
  state->messenger = FlutterDesktopMessengerReferenceOwner(
      FlutterDesktopMessengerAddRef(new FlutterDesktopMessenger()),
      &FlutterDesktopMessengerRelease);
  state->messenger->SetEngine(state);
  state->message_dispatcher =
      std::make_unique<flutter::IncomingMessageDispatcher>(
          state->messenger.get());
 
  // Plugins.
  state->plugin_registrar = std::make_unique<FlutterDesktopPluginRegistrar>();
  state->plugin_registrar->engine = state;
  state->internal_plugin_registrar =
      std::make_unique<flutter::PluginRegistrar>(state->plugin_registrar.get());
 
  // System channel handler.
  state->platform_handler = std::make_unique<flutter::PlatformHandler>(
      state->internal_plugin_registrar->messenger(), window);
 
  SetUpLocales(state);
}

SetUpLocales()

static void SetUpLocales ( FlutterDesktopEngineState *  state )

static

Definition at line 801 of file flutter_glfw.cc.

                                                           {
  std::vector<flutter::LanguageInfo> languages =
      flutter::GetPreferredLanguageInfo();
  std::vector<FlutterLocale> flutter_locales =
      flutter::ConvertToFlutterLocale(languages);
  // Convert the locale list to the locale pointer list that must be provided.
  std::vector<const FlutterLocale*> flutter_locale_list;
  flutter_locale_list.reserve(flutter_locales.size());
  std::transform(flutter_locales.begin(), flutter_locales.end(),
                 std::back_inserter(flutter_locale_list),
                 [](const auto& arg) -> const auto* { return &arg; });
  FlutterEngineResult result = FlutterEngineUpdateLocales(
      state->flutter_engine, flutter_locale_list.data(),
      flutter_locale_list.size());
  if (result != kSuccess) {
    std::cerr << "Failed to set up Flutter locales." << std::endl;
  }
}

Variable Documentation

kDpPerInch

constexpr double kDpPerInch = 160.0

staticconstexpr

Definition at line 45 of file flutter_glfw.cc.

kFlutterDesktopDontCare

const int kFlutterDesktopDontCare = GLFW_DONT_CARE

Definition at line 43 of file flutter_glfw.cc.