#include "flutter/shell/platform/glfw/public/flutter_glfw.h"
#include <GLFW/glfw3.h>
#include <algorithm>
#include <atomic>
#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"

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.

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 37 of file flutter_glfw.cc.

◆ GLFW_TRUE

#define GLFW_TRUE 1

Definition at line 34 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 113 of file flutter_glfw.cc.

◆ UniqueAotDataPtr

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

Definition at line 111 of file flutter_glfw.cc.

◆ UniqueGLFWwindowPtr

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

Definition at line 40 of file flutter_glfw.cc.

Function Documentation

◆ ConfigurePlatformTaskRunner()

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

static

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

References FlutterTaskRunnerDescription::post_task_callback, FlutterTaskRunnerDescription::runs_task_on_current_thread_callback, FlutterTaskRunnerDescription::struct_size, and FlutterTaskRunnerDescription::user_data.

Referenced by RunFlutterEngine().

◆ ConvertToDesktopMessage()

static FlutterDesktopMessage ConvertToDesktopMessage ( const FlutterPlatformMessage & engine_message )

static

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

References FlutterPlatformMessage::channel, FlutterPlatformMessage::message, message, FlutterPlatformMessage::message_size, FlutterPlatformMessage::response_handle, and FlutterDesktopMessage::struct_size.

Referenced by EngineOnFlutterPlatformMessage(), and flutter::FlutterWindowsEngine::HandlePlatformMessage().

◆ CreateShareWindowForWindow()

static UniqueGLFWwindowPtr CreateShareWindowForWindow ( GLFWwindow * window )

static

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

References GLFW_FALSE, and window.

Referenced by FlutterDesktopCreateWindow().

◆ EngineClearContext()

static bool EngineClearContext ( void * user_data )

static

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

References user_data, and FlutterDesktopEngineState::window_controller.

Referenced by RunFlutterEngine().

◆ EngineGetActiveFbo()

static uint32_t EngineGetActiveFbo ( void * user_data )

static

Definition at line 646 of file flutter_glfw.cc.

                                                    {
  return 0;
}

Referenced by RunFlutterEngine().

◆ EngineMakeContextCurrent()

static bool EngineMakeContextCurrent ( void * user_data )

static

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

References user_data, FlutterDesktopWindowControllerState::window, and FlutterDesktopEngineState::window_controller.

Referenced by RunFlutterEngine().

◆ EngineMakeResourceContextCurrent()

static bool EngineMakeResourceContextCurrent ( void * user_data )

static

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

References FlutterDesktopWindowControllerState::resource_window, user_data, and FlutterDesktopEngineState::window_controller.

Referenced by RunFlutterEngine().

◆ EngineOnFlutterPlatformMessage()

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

static

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

References ConvertToDesktopMessage(), GLFWAssignEventCallbacks(), GLFWClearEventCallbacks(), message, FlutterDesktopEngineState::message_dispatcher, FlutterPlatformMessage::struct_size, user_data, window, FlutterDesktopWindowControllerState::window, and FlutterDesktopEngineState::window_controller.

Referenced by RunFlutterEngine().

◆ EnginePresent()

static bool EnginePresent ( void * user_data )

static

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

References user_data, FlutterDesktopWindowControllerState::window, and FlutterDesktopEngineState::window_controller.

Referenced by RunFlutterEngine().

◆ EngineProcResolver()

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

static

Definition at line 652 of file flutter_glfw.cc.

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

References name.

Referenced by RunFlutterEngine().

◆ FlutterDesktopCreateWindow()

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

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

References CreateShareWindowForWindow(), GLFW_FALSE, GLFWClearCanvas(), FlutterDesktopWindowProperties::height, FlutterDesktopWindowProperties::prevent_resize, FlutterDesktopWindowProperties::title, FlutterDesktopWindowProperties::width, and window.

◆ FlutterDesktopDestroyWindow()

void FlutterDesktopDestroyWindow ( FlutterDesktopWindowControllerRef controller )

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

References FlutterDesktopPluginRegistrar::destruction_handler, FlutterDesktopWindowControllerState::engine, and FlutterEngineShutdown().

◆ FlutterDesktopGetEngine()

FlutterDesktopEngineRef FlutterDesktopGetEngine ( FlutterDesktopWindowControllerRef controller )

Definition at line 1047 of file flutter_glfw.cc.

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

References FlutterDesktopWindowControllerState::engine.

◆ FlutterDesktopGetPluginRegistrar()

FlutterDesktopPluginRegistrarRef FlutterDesktopGetPluginRegistrar	(	FlutterDesktopEngineRef	engine,
		const char *	plugin_name
	)

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

References engine.

◆ FlutterDesktopGetWindow()

FlutterDesktopWindowRef FlutterDesktopGetWindow ( FlutterDesktopWindowControllerRef controller )

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

References FlutterDesktopWindowControllerState::window_wrapper.

◆ FlutterDesktopInit()

bool FlutterDesktopInit ( )

Definition at line 850 of file flutter_glfw.cc.

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

References GLFWErrorCallback().

◆ FlutterDesktopMessengerAddRef()

FlutterDesktopMessengerRef FlutterDesktopMessengerAddRef ( FlutterDesktopMessengerRef messenger )

Definition at line 205 of file flutter_glfw.cc.

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

References FlutterDesktopMessenger::AddRef().

Referenced by SetUpCommonEngineState().

◆ FlutterDesktopMessengerIsAvailable()

bool FlutterDesktopMessengerIsAvailable ( FlutterDesktopMessengerRef messenger )

Definition at line 215 of file flutter_glfw.cc.

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

References FlutterDesktopMessenger::GetEngine().

◆ FlutterDesktopMessengerLock()

FlutterDesktopMessengerRef FlutterDesktopMessengerLock ( FlutterDesktopMessengerRef messenger )

Definition at line 219 of file flutter_glfw.cc.

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

References FlutterDesktopMessenger::GetMutex().

◆ FlutterDesktopMessengerRelease()

void FlutterDesktopMessengerRelease ( FlutterDesktopMessengerRef messenger )

Definition at line 211 of file flutter_glfw.cc.

                                                                          {
  messenger->Release();
}

References FlutterDesktopMessenger::Release().

Referenced by SetUpCommonEngineState().

◆ FlutterDesktopMessengerSend()

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

Definition at line 1161 of file flutter_glfw.cc.

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

References channel, FlutterDesktopMessengerSendWithReply(), and message.

◆ FlutterDesktopMessengerSendResponse()

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

Definition at line 1169 of file flutter_glfw.cc.

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

References data, FlutterEngineSendPlatformMessageResponse(), and FlutterDesktopMessenger::GetEngine().

◆ 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 1125 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;
}

References channel, FlutterEngineSendPlatformMessage(), FlutterPlatformMessageCreateResponseHandle(), FlutterPlatformMessageReleaseResponseHandle(), FlutterDesktopMessenger::GetEngine(), kSuccess, message, and user_data.

Referenced by FlutterDesktopMessengerSend().

◆ FlutterDesktopMessengerSetCallback()

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

Definition at line 1178 of file flutter_glfw.cc.

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

References callback, channel, FlutterDesktopMessenger::GetEngine(), FlutterDesktopEngineState::message_dispatcher, and user_data.

◆ FlutterDesktopMessengerUnlock()

void FlutterDesktopMessengerUnlock ( FlutterDesktopMessengerRef messenger )

Definition at line 225 of file flutter_glfw.cc.

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

References FlutterDesktopMessenger::GetMutex().

◆ FlutterDesktopPluginRegistrarEnableInputBlocking()

void FlutterDesktopPluginRegistrarEnableInputBlocking	(	FlutterDesktopPluginRegistrarRef	registrar,
		const char *	channel
	)

Definition at line 1098 of file flutter_glfw.cc.

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

References channel, FlutterDesktopPluginRegistrar::engine, and FlutterDesktopEngineState::message_dispatcher.

◆ FlutterDesktopPluginRegistrarGetMessenger()

FlutterDesktopMessengerRef FlutterDesktopPluginRegistrarGetMessenger ( FlutterDesktopPluginRegistrarRef registrar )

Definition at line 1104 of file flutter_glfw.cc.

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

References FlutterDesktopPluginRegistrar::engine, and FlutterDesktopEngineState::messenger.

◆ FlutterDesktopPluginRegistrarGetWindow()

FlutterDesktopWindowRef FlutterDesktopPluginRegistrarGetWindow ( FlutterDesktopPluginRegistrarRef registrar )

Definition at line 1115 of file flutter_glfw.cc.

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

References FlutterDesktopPluginRegistrar::engine, FlutterDesktopEngineState::window_controller, and FlutterDesktopWindowControllerState::window_wrapper.

◆ FlutterDesktopPluginRegistrarSetDestructionHandler()

void FlutterDesktopPluginRegistrarSetDestructionHandler	(	FlutterDesktopPluginRegistrarRef	registrar,
		FlutterDesktopOnPluginRegistrarDestroyed	callback
	)

Definition at line 1109 of file flutter_glfw.cc.

                                                       {
  registrar->destruction_handler = callback;
}

References callback, and FlutterDesktopPluginRegistrar::destruction_handler.

◆ FlutterDesktopRegistrarGetTextureRegistrar()

FlutterDesktopTextureRegistrarRef FlutterDesktopRegistrarGetTextureRegistrar ( FlutterDesktopPluginRegistrarRef registrar )

Definition at line 1186 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 1061 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 1082 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);
}

References engine.

Referenced by FlutterDesktopRunWindowEventLoopWithTimeout().

◆ FlutterDesktopRunWindowEventLoopWithTimeout()

bool FlutterDesktopRunWindowEventLoopWithTimeout	(	FlutterDesktopWindowControllerRef	controller,
		uint32_t	timeout_milliseconds
	)

Definition at line 1031 of file flutter_glfw.cc.

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

References FlutterDesktopWindowControllerState::engine, FlutterDesktopRunEngineEventLoopWithTimeout(), and FlutterDesktopWindowControllerState::window.

◆ FlutterDesktopShutDownEngine()

bool FlutterDesktopShutDownEngine ( FlutterDesktopEngineRef engine )

Definition at line 1092 of file flutter_glfw.cc.

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

References engine, FlutterEngineShutdown(), and kSuccess.

◆ FlutterDesktopTerminate()

void FlutterDesktopTerminate ( )

Definition at line 856 of file flutter_glfw.cc.

                               {
  glfwTerminate();
}

◆ FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable()

bool FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable	(	FlutterDesktopTextureRegistrarRef	texture_registrar,
		int64_t	texture_id
	)

Definition at line 1207 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 1192 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 1199 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 964 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;
  }
}

References height, width, FlutterDesktopWindow::window, x, and y.

◆ FlutterDesktopWindowGetScaleFactor()

double FlutterDesktopWindowGetScaleFactor ( FlutterDesktopWindowRef flutter_window )

Definition at line 1005 of file flutter_glfw.cc.

                                            {
  return flutter_window->pixels_per_screen_coordinate;
}

References FlutterDesktopWindow::pixels_per_screen_coordinate.

◆ FlutterDesktopWindowSetFrame()

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

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

References height, width, FlutterDesktopWindow::window, x, and y.

◆ FlutterDesktopWindowSetHoverEnabled()

void FlutterDesktopWindowSetHoverEnabled	(	FlutterDesktopWindowRef	flutter_window,
		bool	enabled
	)

Definition at line 944 of file flutter_glfw.cc.

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

References FlutterDesktopWindow::hover_tracking_enabled, SetHoverCallbacksEnabled(), and FlutterDesktopWindow::window.

◆ FlutterDesktopWindowSetIcon()

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

Definition at line 956 of file flutter_glfw.cc.

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

References height, image, width, and FlutterDesktopWindow::window.

◆ FlutterDesktopWindowSetPixelRatioOverride()

void FlutterDesktopWindowSetPixelRatioOverride	(	FlutterDesktopWindowRef	flutter_window,
		double	pixel_ratio
	)

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

References GetWindowController(), FlutterDesktopWindow::pixel_ratio_override, SendWindowMetrics(), and FlutterDesktopWindow::window.

◆ FlutterDesktopWindowSetSizeLimits()

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

Definition at line 1023 of file flutter_glfw.cc.

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

References FlutterDesktopSize::height, FlutterDesktopSize::width, and FlutterDesktopWindow::window.

◆ FlutterDesktopWindowSetTitle()

void FlutterDesktopWindowSetTitle	(	FlutterDesktopWindowRef	flutter_window,
		const char *	title
	)

Definition at line 950 of file flutter_glfw.cc.

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

References window, and FlutterDesktopWindow::window.

◆ GetScreenCoordinatesPerInch()

static double GetScreenCoordinatesPerInch ( )

static

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

References kDpPerInch.

◆ GetWindowController()

static FlutterDesktopWindowControllerState * GetWindowController ( GLFWwindow * window )

static

Definition at line 230 of file flutter_glfw.cc.

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

References window.

Referenced by FlutterDesktopWindowSetPixelRatioOverride(), GLFWAssignEventCallbacks(), GLFWCharCallback(), GLFWCursorPositionCallback(), GLFWFramebufferSizeCallback(), GLFWKeyCallback(), GLFWMouseButtonCallback(), GLFWScrollCallback(), GLFWWindowRefreshCallback(), SendPointerEventWithData(), and SetEventPhaseFromCursorButtonState().

◆ GLFWAssignEventCallbacks()

static void GLFWAssignEventCallbacks ( GLFWwindow * window )

static

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

References GetWindowController(), GLFWCharCallback(), GLFWKeyCallback(), GLFWMouseButtonCallback(), GLFWScrollCallback(), SetHoverCallbacksEnabled(), and window.

Referenced by EngineOnFlutterPlatformMessage().

◆ GLFWCharCallback()

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

static

Definition at line 517 of file flutter_glfw.cc.

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

References GetWindowController(), handler, FlutterDesktopWindowControllerState::keyboard_hook_handlers, and window.

Referenced by GLFWAssignEventCallbacks().

◆ GLFWClearCanvas()

static void GLFWClearCanvas ( GLFWwindow * window )

static

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

References window.

Referenced by FlutterDesktopCreateWindow().

◆ GLFWClearEventCallbacks()

static void GLFWClearEventCallbacks ( GLFWwindow * window )

static

Definition at line 557 of file flutter_glfw.cc.

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

References SetHoverCallbacksEnabled(), and window.

Referenced by EngineOnFlutterPlatformMessage().

◆ GLFWCursorEnterCallback()

static void GLFWCursorEnterCallback	(	GLFWwindow *	window,
		int	entered
	)

static

Definition at line 440 of file flutter_glfw.cc.

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

References kAdd, kRemove, FlutterPointerEvent::phase, SendPointerEventWithData(), SetEventLocationFromCursorPosition(), and window.

Referenced by GLFWMouseButtonCallback(), and SetHoverCallbacksEnabled().

◆ GLFWCursorPositionCallback()

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

static

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

References GetWindowController(), SendPointerEventWithData(), SetEventPhaseFromCursorButtonState(), window, x, FlutterPointerEvent::x, and y.

Referenced by GLFWMouseButtonCallback(), and SetHoverCallbacksEnabled().

◆ GLFWErrorCallback()

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

static

Definition at line 674 of file flutter_glfw.cc.

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

Referenced by FlutterDesktopInit().

◆ GLFWFramebufferSizeCallback()

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

static

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

References GetWindowController(), SendWindowMetrics(), width, and window.

◆ GLFWKeyCallback()

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

static

Definition at line 525 of file flutter_glfw.cc.

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

References action, GetWindowController(), handler, key, FlutterDesktopWindowControllerState::keyboard_hook_handlers, scancode, and window.

Referenced by GLFWAssignEventCallbacks().

◆ GLFWMouseButtonCallback()

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

static

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

References action, GetWindowController(), GLFWCursorEnterCallback(), GLFWCursorPositionCallback(), key, kFlutterPointerButtonMousePrimary, kFlutterPointerButtonMouseSecondary, SendPointerEventWithData(), SetEventLocationFromCursorPosition(), SetEventPhaseFromCursorButtonState(), window, and FlutterDesktopWindowControllerState::window_wrapper.

Referenced by GLFWAssignEventCallbacks().

◆ GLFWScrollCallback()

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

static

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

References GetWindowController(), kFlutterPointerSignalKindScroll, SendPointerEventWithData(), SetEventLocationFromCursorPosition(), SetEventPhaseFromCursorButtonState(), and window.

Referenced by GLFWAssignEventCallbacks().

◆ GLFWWindowRefreshCallback()

void GLFWWindowRefreshCallback ( GLFWwindow * window )

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

References GetWindowController(), SendWindowMetrics(), and window.

◆ LoadAotData()

UniqueAotDataPtr LoadAotData ( const std::filesystem::path & aot_data_path )

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

References data, FlutterEngineAOTDataSource::elf_path, FlutterEngineCreateAOTData(), kFlutterEngineAOTDataSourceTypeElfPath, kSuccess, and FlutterEngineAOTDataSource::type.

Referenced by RunFlutterEngine().

◆ RunFlutterEngine()

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

static

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

References FlutterDesktopEngineState::aot_data, FlutterDesktopEngineProperties::aot_library_path, args, argv, FlutterDesktopEngineProperties::assets_path, FlutterOpenGLRendererConfig::clear_current, ConfigurePlatformTaskRunner(), engine, EngineClearContext(), EngineGetActiveFbo(), EngineMakeContextCurrent(), EngineMakeResourceContextCurrent(), EngineOnFlutterPlatformMessage(), EnginePresent(), EngineProcResolver(), FlutterDesktopEngineState::event_loop, FlutterOpenGLRendererConfig::fbo_callback, FLUTTER_API_SYMBOL, FLUTTER_ENGINE_VERSION, FlutterEngineRun(), FlutterEngineRunsAOTCompiledDartCode(), flutter::GetExecutableDirectory(), FlutterOpenGLRendererConfig::gl_proc_resolver, FlutterDesktopEngineProperties::icu_data_path, kOpenGL, kSuccess, LoadAotData(), FlutterOpenGLRendererConfig::make_current, FlutterOpenGLRendererConfig::make_resource_current, FlutterRendererConfig::open_gl, FlutterCustomTaskRunners::platform_task_runner, FlutterOpenGLRendererConfig::present, FlutterOpenGLRendererConfig::struct_size, FlutterCustomTaskRunners::struct_size, FlutterProjectArgs::struct_size, FlutterDesktopEngineProperties::switches, FlutterDesktopEngineProperties::switches_count, FlutterRendererConfig::type, and FlutterDesktopEngineState::window_controller.

◆ SendPointerEventWithData()

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

static

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

References FlutterEngineSendPointerEvent(), GetWindowController(), kAdd, kDown, flutter::kFlutterImplicitViewId, kFlutterPointerDeviceKindMouse, kRemove, kUp, FlutterPointerEvent::phase, SendPointerEventWithData(), FlutterPointerEvent::struct_size, window, FlutterPointerEvent::x, and FlutterPointerEvent::y.

Referenced by GLFWCursorEnterCallback(), GLFWCursorPositionCallback(), GLFWMouseButtonCallback(), GLFWScrollCallback(), and SendPointerEventWithData().

◆ SendWindowMetrics()

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

static

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

References FlutterDesktopWindowControllerState::engine, FlutterEngineSendWindowMetricsEvent(), height, kDpPerInch, flutter::kFlutterImplicitViewId, FlutterDesktopWindowControllerState::monitor_screen_coordinates_per_inch, FlutterWindowMetricsEvent::struct_size, width, and FlutterDesktopWindowControllerState::window_wrapper.

Referenced by FlutterDesktopWindowSetPixelRatioOverride(), GLFWFramebufferSizeCallback(), and GLFWWindowRefreshCallback().

◆ SetEventLocationFromCursorPosition()

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

static

Definition at line 417 of file flutter_glfw.cc.

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

References window, FlutterPointerEvent::x, and FlutterPointerEvent::y.

Referenced by GLFWCursorEnterCallback(), GLFWMouseButtonCallback(), and GLFWScrollCallback().

◆ SetEventPhaseFromCursorButtonState()

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

static

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

References GetWindowController(), kDown, kHover, kMove, kUp, FlutterPointerEvent::phase, and window.

Referenced by GLFWCursorPositionCallback(), GLFWMouseButtonCallback(), and GLFWScrollCallback().

◆ SetHoverCallbacksEnabled()

static void SetHoverCallbacksEnabled	(	GLFWwindow *	window,
		bool	enabled
	)

static

Definition at line 537 of file flutter_glfw.cc.

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

References GLFWCursorEnterCallback(), GLFWCursorPositionCallback(), and window.

Referenced by FlutterDesktopWindowSetHoverEnabled(), GLFWAssignEventCallbacks(), and GLFWClearEventCallbacks().

◆ SetUpCommonEngineState()

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

static

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

References FlutterDesktopMessengerAddRef(), FlutterDesktopMessengerRelease(), FlutterDesktopEngineState::internal_plugin_registrar, FlutterDesktopEngineState::message_dispatcher, FlutterDesktopEngineState::messenger, FlutterDesktopEngineState::platform_handler, FlutterDesktopEngineState::plugin_registrar, SetUpLocales(), and window.

◆ SetUpLocales()

static void SetUpLocales ( FlutterDesktopEngineState * state )

static

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

References flutter::ConvertToFlutterLocale(), FlutterEngineUpdateLocales(), flutter::GetPreferredLanguageInfo(), and kSuccess.

Referenced by SetUpCommonEngineState().

Variable Documentation

◆ kDpPerInch

constexpr double kDpPerInch = 160.0

staticconstexpr

Definition at line 46 of file flutter_glfw.cc.

Referenced by GetScreenCoordinatesPerInch(), and SendWindowMetrics().

◆ kFlutterDesktopDontCare

const int kFlutterDesktopDontCare = GLFW_DONT_CARE

Definition at line 44 of file flutter_glfw.cc.

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ GLFW_FALSE

◆ GLFW_TRUE

Typedef Documentation

◆ FlutterDesktopMessengerReferenceOwner

◆ UniqueAotDataPtr

◆ UniqueGLFWwindowPtr

Function Documentation

◆ ConfigurePlatformTaskRunner()

◆ ConvertToDesktopMessage()

◆ CreateShareWindowForWindow()

◆ EngineClearContext()

◆ EngineGetActiveFbo()

◆ EngineMakeContextCurrent()

◆ EngineMakeResourceContextCurrent()

◆ EngineOnFlutterPlatformMessage()

◆ EnginePresent()

◆ EngineProcResolver()

◆ FlutterDesktopCreateWindow()

◆ FlutterDesktopDestroyWindow()

◆ FlutterDesktopGetEngine()

◆ FlutterDesktopGetPluginRegistrar()

◆ FlutterDesktopGetWindow()

◆ FlutterDesktopInit()

◆ FlutterDesktopMessengerAddRef()

◆ FlutterDesktopMessengerIsAvailable()

◆ FlutterDesktopMessengerLock()

◆ FlutterDesktopMessengerRelease()

◆ FlutterDesktopMessengerSend()

◆ FlutterDesktopMessengerSendResponse()

◆ FlutterDesktopMessengerSendWithReply()

◆ FlutterDesktopMessengerSetCallback()

◆ FlutterDesktopMessengerUnlock()

◆ FlutterDesktopPluginRegistrarEnableInputBlocking()

◆ FlutterDesktopPluginRegistrarGetMessenger()

◆ FlutterDesktopPluginRegistrarGetWindow()

◆ FlutterDesktopPluginRegistrarSetDestructionHandler()

◆ FlutterDesktopRegistrarGetTextureRegistrar()

◆ FlutterDesktopRunEngine()

◆ FlutterDesktopRunEngineEventLoopWithTimeout()

◆ FlutterDesktopRunWindowEventLoopWithTimeout()

◆ FlutterDesktopShutDownEngine()

◆ FlutterDesktopTerminate()

◆ FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable()

◆ FlutterDesktopTextureRegistrarRegisterExternalTexture()

◆ FlutterDesktopTextureRegistrarUnregisterExternalTexture()

◆ FlutterDesktopWindowGetFrame()

◆ FlutterDesktopWindowGetScaleFactor()

◆ FlutterDesktopWindowSetFrame()

◆ FlutterDesktopWindowSetHoverEnabled()

◆ FlutterDesktopWindowSetIcon()

◆ FlutterDesktopWindowSetPixelRatioOverride()

◆ FlutterDesktopWindowSetSizeLimits()

◆ FlutterDesktopWindowSetTitle()

◆ GetScreenCoordinatesPerInch()

◆ GetWindowController()

◆ GLFWAssignEventCallbacks()

◆ GLFWCharCallback()

◆ GLFWClearCanvas()

◆ GLFWClearEventCallbacks()

◆ GLFWCursorEnterCallback()

◆ GLFWCursorPositionCallback()

◆ GLFWErrorCallback()

◆ GLFWFramebufferSizeCallback()

◆ GLFWKeyCallback()

◆ GLFWMouseButtonCallback()

◆ GLFWScrollCallback()

◆ GLFWWindowRefreshCallback()

◆ LoadAotData()

◆ RunFlutterEngine()

◆ SendPointerEventWithData()

◆ SendWindowMetrics()

◆ SetEventLocationFromCursorPosition()

◆ SetEventPhaseFromCursorButtonState()

◆ SetHoverCallbacksEnabled()