Flutter Linux Embedder
fl_view.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 
7 #include <atk/atk.h>
8 #include <gdk/gdkwayland.h>
9 #include <gtk/gtk-a11y.h>
10 
11 #include <cstring>
12 
13 #include "flutter/common/constants.h"
32 
33 struct _FlView {
35 
36  // Event box the render area goes inside.
37  GtkWidget* event_box;
38 
39  // Handle zoom gestures.
40  GtkGesture* zoom_gesture;
41 
42  // Handle rotation gestures.
43  GtkGesture* rotate_gesture;
44 
45  // The widget rendering the Flutter view.
46  FlViewRenderer* renderer;
47 
48  // Engine this view is showing.
49  FlEngine* engine;
50 
51  // ID for this view.
52  FlutterViewId view_id;
53 
54  // Monitor to track window state.
55  FlWindowStateMonitor* window_state_monitor;
56 
57  // Manages scrolling events.
58  FlScrollingManager* scrolling_manager;
59 
60  // Manages pointer events.
61  FlPointerManager* pointer_manager;
62 
63  // Manages touch events.
64  FlTouchManager* touch_manager;
65 
66  // Accessible tree from Flutter, exposed as an AtkPlug.
67  FlViewAccessible* view_accessible;
68 
69  // TRUE if the view size should be controlled by Flutter.
70  gboolean sized_to_content;
71 
72  GCancellable* cancellable;
73 };
74 
76 
78 
79 static void fl_renderable_iface_init(FlRenderableInterface* iface);
80 
82  FlPluginRegistryInterface* iface);
83 
85  FlView,
86  fl_view,
87  GTK_TYPE_BOX,
88  G_IMPLEMENT_INTERFACE(fl_renderable_get_type(), fl_renderable_iface_init)
89  G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(),
91 
92 // Called when the renderer has rendered its first frame.
93 static void first_frame_cb(FlView* self) {
94  g_signal_emit(self, fl_view_signals[SIGNAL_FIRST_FRAME], 0);
95 }
96 
97 // Signal handler for GtkWidget::delete-event
98 static gboolean window_delete_event_cb(FlView* self) {
99  fl_engine_request_app_exit(self->engine);
100  // Stop the event from propagating.
101  return TRUE;
102 }
103 
104 static void init_scrolling(FlView* self) {
105  g_clear_object(&self->scrolling_manager);
106  self->scrolling_manager =
107  fl_scrolling_manager_new(self->engine, self->view_id);
108 }
109 
110 static void init_touch(FlView* self) {
111  g_clear_object(&self->touch_manager);
112  self->touch_manager = fl_touch_manager_new(self->engine, self->view_id);
113 }
114 
115 static FlutterPointerDeviceKind get_pointer_device_kind(GdkEvent* event) {
116  GdkDevice* device = gdk_event_get_source_device(event);
117  if (device == nullptr) {
118  return kFlutterPointerDeviceKindMouse;
119  }
120 
121  GdkInputSource source = gdk_device_get_source(device);
122  switch (source) {
123  case GDK_SOURCE_PEN:
124  case GDK_SOURCE_CURSOR:
125  case GDK_SOURCE_TABLET_PAD:
126  return kFlutterPointerDeviceKindStylus;
127  case GDK_SOURCE_ERASER:
128  return kFlutterPointerDeviceKindInvertedStylus;
129  case GDK_SOURCE_TOUCHSCREEN:
130  return kFlutterPointerDeviceKindTouch;
131  case GDK_SOURCE_TOUCHPAD: // trackpad device type is reserved for gestures
132  case GDK_SOURCE_TRACKPOINT:
133  case GDK_SOURCE_KEYBOARD:
134  case GDK_SOURCE_MOUSE:
135  return kFlutterPointerDeviceKindMouse;
136  }
137 }
138 
139 // Gets the pointer state for a GDK event.
140 static void get_pointer_device_state(GdkEvent* event,
141  gdouble* rotation,
142  gdouble* pressure) {
143  *rotation = 0.0;
144  *pressure = 0.0;
145  if (event == nullptr) {
146  return;
147  }
148 
149  gdouble pressure_value = 0.0;
150  gdouble rotation_value = 0.0;
151  gdk_event_get_axis(event, GDK_AXIS_PRESSURE, &pressure_value);
152  gdk_event_get_axis(event, GDK_AXIS_ROTATION, &rotation_value);
153  *pressure = pressure_value;
154  *rotation = rotation_value;
155 }
156 
157 // Called when the mouse cursor changes.
158 static void cursor_changed_cb(FlView* self) {
159  FlMouseCursorHandler* handler =
161  const gchar* cursor_name = fl_mouse_cursor_handler_get_cursor_name(handler);
162  GdkWindow* window =
163  gtk_widget_get_window(gtk_widget_get_toplevel(GTK_WIDGET(self)));
164  g_autoptr(GdkCursor) cursor =
165  gdk_cursor_new_from_name(gdk_window_get_display(window), cursor_name);
166  gdk_window_set_cursor(window, cursor);
167 }
168 
169 // Set the mouse cursor.
170 static void setup_cursor(FlView* self) {
171  FlMouseCursorHandler* handler =
173 
174  g_signal_connect_object(handler, "cursor-changed",
175  G_CALLBACK(cursor_changed_cb), self,
176  G_CONNECT_SWAPPED);
177  cursor_changed_cb(self);
178 }
179 
180 // Updates the engine with the current window metrics.
181 static void handle_geometry_changed(FlView* self) {
182  // No updates required when size controlled by Flutter.
183  if (self->sized_to_content) {
184  return;
185  }
186 
187  GtkAllocation allocation;
188  gtk_widget_get_allocation(GTK_WIDGET(self), &allocation);
189  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
190 
191  // Note we can't detect if a window is moved between monitors - this
192  // information is provided by Wayland but GTK only notifies us if the scale
193  // has changed, so moving between two monitors of the same scale doesn't
194  // provide any information.
195 
196  GdkWindow* window =
197  gtk_widget_get_window(gtk_widget_get_toplevel(GTK_WIDGET(self)));
198  // NOTE(robert-ancell) If we haven't got a window we default to display 0.
199  // This is probably indicating a problem with this code in that we
200  // shouldn't be generating anything until the window is created.
201  // Another event with the correct display ID is generated soon after.
202  // I haven't changed this code in case there are side-effects but we
203  // probably shouldn't call handle_geometry_changed after the view is
204  // added but only when the window is realized.
205  FlutterEngineDisplayId display_id = 0;
206  if (window != nullptr) {
207  GdkMonitor* monitor = gdk_display_get_monitor_at_window(
208  gtk_widget_get_display(GTK_WIDGET(self)), window);
210  fl_engine_get_display_monitor(self->engine), monitor);
211  }
212  size_t width = allocation.width, height = allocation.height;
213  size_t min_width = width, min_height = height;
214  size_t max_width = width, max_height = height;
216  self->engine, display_id, self->view_id, min_width * scale_factor,
217  min_height * scale_factor, max_width * scale_factor,
218  max_height * scale_factor, scale_factor);
219 }
220 
221 static void view_added_cb(GObject* object,
222  GAsyncResult* result,
223  gpointer user_data) {
224  g_autoptr(GError) error = nullptr;
225  if (!fl_engine_add_view_finish(FL_ENGINE(object), result, &error)) {
226  if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
227  return;
228  }
229 
230  g_warning("Failed to add view: %s", error->message);
231  // FIXME: Show on the GLArea
232  return;
233  }
234 }
235 
236 // Called when the engine updates accessibility.
237 static void update_semantics_cb(FlView* self,
238  const FlutterSemanticsUpdate2* update) {
239  // A semantics update is routed to a particular view.
240  if (update->view_id != self->view_id) {
241  return;
242  }
243 
244  fl_view_accessible_handle_update_semantics(self->view_accessible, update);
245 }
246 
247 // Invoked by the engine right before the engine is restarted.
248 //
249 // This method should reset states to be as if the engine had just been started,
250 // which usually indicates the user has requested a hot restart (Shift-R in the
251 // Flutter CLI.)
252 static void on_pre_engine_restart_cb(FlView* self) {
253  init_scrolling(self);
254  init_touch(self);
255 }
256 
257 // Implements FlRenderable::present_layers
258 static void fl_view_present_layers(FlRenderable* renderable,
259  const FlutterLayer** layers,
260  size_t layers_count) {
261  FlView* self = FL_VIEW(renderable);
262 
263  // If widget was destroyed then dispose will have been called and the
264  // renderer will be null.
265  if (self->renderer == nullptr) {
266  return;
267  }
268 
270 }
271 
272 // Implements FlPluginRegistry::get_registrar_for_plugin.
273 static FlPluginRegistrar* fl_view_get_registrar_for_plugin(
274  FlPluginRegistry* registry,
275  const gchar* name) {
276  FlView* self = FL_VIEW(registry);
277 
278  return fl_plugin_registrar_new(self,
279  fl_engine_get_binary_messenger(self->engine),
280  fl_engine_get_texture_registrar(self->engine));
281 }
282 
283 static void fl_renderable_iface_init(FlRenderableInterface* iface) {
284  iface->present_layers = fl_view_present_layers;
285 }
286 
288  FlPluginRegistryInterface* iface) {
289  iface->get_registrar_for_plugin = fl_view_get_registrar_for_plugin;
290 }
291 
292 static void sync_modifier_if_needed(FlView* self, GdkEvent* event) {
293  guint event_time = gdk_event_get_time(event);
294  GdkModifierType event_state = static_cast<GdkModifierType>(0);
295  gdk_event_get_state(event, &event_state);
297  fl_engine_get_keyboard_manager(self->engine), event_state, event_time);
298 }
299 
300 static void set_scrolling_position(FlView* self, gdouble x, gdouble y) {
301  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
303  self->scrolling_manager, x * scale_factor, y * scale_factor);
304 }
305 
306 // Signal handler for GtkWidget::button-press-event
307 static gboolean button_press_event_cb(FlView* self,
308  GdkEventButton* button_event) {
309  GdkEvent* event = reinterpret_cast<GdkEvent*>(button_event);
310 
311  // Flutter doesn't handle double and triple click events.
312  GdkEventType event_type = gdk_event_get_event_type(event);
313  if (event_type == GDK_DOUBLE_BUTTON_PRESS ||
314  event_type == GDK_TRIPLE_BUTTON_PRESS) {
315  return FALSE;
316  }
317 
318  guint button = 0;
319  gdk_event_get_button(event, &button);
320 
321  gdouble x = 0.0, y = 0.0;
322  gdk_event_get_coords(event, &x, &y);
323 
324  set_scrolling_position(self, x, y);
325  sync_modifier_if_needed(self, event);
326 
327  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
328  gdouble rotation = 0.0;
329  gdouble pressure = 0.0;
330  get_pointer_device_state(event, &rotation, &pressure);
332  self->pointer_manager, gdk_event_get_time(event),
333  get_pointer_device_kind(event), x * scale_factor, y * scale_factor,
334  button, rotation, pressure);
335 }
336 
337 // Signal handler for GtkWidget::button-release-event
338 static gboolean button_release_event_cb(FlView* self,
339  GdkEventButton* button_event) {
340  GdkEvent* event = reinterpret_cast<GdkEvent*>(button_event);
341 
342  guint button = 0;
343  gdk_event_get_button(event, &button);
344 
345  gdouble x = 0.0, y = 0.0;
346  gdk_event_get_coords(event, &x, &y);
347 
348  set_scrolling_position(self, x, y);
349  sync_modifier_if_needed(self, event);
350 
351  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
352  gdouble rotation = 0.0;
353  gdouble pressure = 0.0;
354  get_pointer_device_state(event, &rotation, &pressure);
356  self->pointer_manager, gdk_event_get_time(event),
357  get_pointer_device_kind(event), x * scale_factor, y * scale_factor,
358  button, rotation, pressure);
359 }
360 
361 // Cancels any pointers and touches that are in contact with this view because
362 // their events are no longer being delivered to it.
363 static gboolean cancel_input(FlView* self, guint event_time) {
364  if (self->touch_manager != nullptr) {
365  fl_touch_manager_cancel_input(self->touch_manager, event_time);
366  }
367 
368  if (self->pointer_manager == nullptr) {
369  return FALSE;
370  }
371  return fl_pointer_manager_cancel_input(self->pointer_manager, event_time);
372 }
373 
374 // Signal handler for GtkWidget::grab-broken-event
375 static gboolean grab_broken_event_cb(FlView* self,
376  GdkEventGrabBroken* grab_broken_event) {
377  GdkEvent* event = reinterpret_cast<GdkEvent*>(grab_broken_event);
378  return cancel_input(self, gdk_event_get_time(event));
379 }
380 
381 // Signal handler for GtkWidget::grab-notify
382 static void grab_notify_cb(FlView* self, gboolean was_grabbed) {
383  // A GTK grab has been taken by another widget, e.g. a menu has been opened.
384  // Events are redirected to that widget, so the button releases that end the
385  // current presses will not be received.
386  if (was_grabbed) {
387  return;
388  }
389 
390  cancel_input(self, gtk_get_current_event_time());
391 }
392 
393 // Signal handler for GtkWidget::unmap
394 static void unmap_cb(FlView* self) {
395  // The view is no longer visible, so no further input events will be
396  // received for the presses currently in progress.
397  cancel_input(self, gtk_get_current_event_time());
398 }
399 
400 // Signal handler for GtkWidget::scroll-event
401 static gboolean scroll_event_cb(FlView* self, GdkEventScroll* event) {
402  // TODO(robert-ancell): Update to use GtkEventControllerScroll when we can
403  // depend on GTK 3.24.
404 
406  self->scrolling_manager, event,
407  gtk_widget_get_scale_factor(GTK_WIDGET(self)));
408  return TRUE;
409 }
410 
411 static gboolean touch_event_cb(FlView* self, GdkEventTouch* event) {
413  self->touch_manager, event,
414  gtk_widget_get_scale_factor(GTK_WIDGET(self)));
415  return TRUE;
416 }
417 
418 // Signal handler for GtkWidget::motion-notify-event
419 static gboolean motion_notify_event_cb(FlView* self,
420  GdkEventMotion* motion_event) {
421  GdkEvent* event = reinterpret_cast<GdkEvent*>(motion_event);
422  sync_modifier_if_needed(self, event);
423 
424  // return if touch event
425  auto event_type = gdk_event_get_event_type(event);
426  if (event_type == GDK_TOUCH_BEGIN || event_type == GDK_TOUCH_UPDATE ||
427  event_type == GDK_TOUCH_END || event_type == GDK_TOUCH_CANCEL) {
428  return FALSE;
429  }
430 
431  gdouble x = 0.0, y = 0.0;
432  gdk_event_get_coords(event, &x, &y);
433  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
434  gdouble rotation = 0.0;
435  gdouble pressure = 0.0;
436  get_pointer_device_state(event, &rotation, &pressure);
438  self->pointer_manager, gdk_event_get_time(event),
439  get_pointer_device_kind(event), x * scale_factor, y * scale_factor,
440  rotation, pressure);
441 }
442 
443 // Signal handler for GtkWidget::enter-notify-event
444 static gboolean enter_notify_event_cb(FlView* self,
445  GdkEventCrossing* crossing_event) {
446  GdkEvent* event = reinterpret_cast<GdkEvent*>(crossing_event);
447  gdouble x = 0.0, y = 0.0;
448  gdk_event_get_coords(event, &x, &y);
449  GdkModifierType state = static_cast<GdkModifierType>(0);
450  gdk_event_get_state(event, &state);
451  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
452  gdouble rotation = 0.0;
453  gdouble pressure = 0.0;
454  get_pointer_device_state(event, &rotation, &pressure);
456  self->pointer_manager, gdk_event_get_time(event),
457  get_pointer_device_kind(event), x * scale_factor, y * scale_factor, state,
458  rotation, pressure);
459 }
460 
461 // Signal handler for GtkWidget::leave-notify-event
462 static gboolean leave_notify_event_cb(FlView* self,
463  GdkEventCrossing* crossing_event) {
464  if (crossing_event->mode != GDK_CROSSING_NORMAL) {
465  return FALSE;
466  }
467 
468  GdkEvent* event = reinterpret_cast<GdkEvent*>(crossing_event);
469  gdouble x = 0.0, y = 0.0;
470  gdk_event_get_coords(event, &x, &y);
471  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
472  gdouble rotation = 0.0;
473  gdouble pressure = 0.0;
474  get_pointer_device_state(event, &rotation, &pressure);
476  self->pointer_manager, gdk_event_get_time(event),
477  get_pointer_device_kind(event), x * scale_factor, y * scale_factor,
478  rotation, pressure);
479 }
480 
481 static void gesture_rotation_begin_cb(FlView* self) {
482  fl_scrolling_manager_handle_rotation_begin(self->scrolling_manager);
483 }
484 
485 static void gesture_rotation_update_cb(FlView* self,
486  gdouble rotation,
487  gdouble delta) {
488  fl_scrolling_manager_handle_rotation_update(self->scrolling_manager,
489  rotation);
490 }
491 
492 static void gesture_rotation_end_cb(FlView* self) {
493  fl_scrolling_manager_handle_rotation_end(self->scrolling_manager);
494 }
495 
496 static void gesture_zoom_begin_cb(FlView* self) {
497  fl_scrolling_manager_handle_zoom_begin(self->scrolling_manager);
498 }
499 
500 static void gesture_zoom_update_cb(FlView* self, gdouble scale) {
501  fl_scrolling_manager_handle_zoom_update(self->scrolling_manager, scale);
502 }
503 
504 static void gesture_zoom_end_cb(FlView* self) {
505  fl_scrolling_manager_handle_zoom_end(self->scrolling_manager);
506 }
507 
508 static void realize_cb(FlView* self) {
509  if (self->view_id != flutter::kFlutterImplicitViewId) {
510  setup_cursor(self);
511  return;
512  }
513 
514  GtkWidget* toplevel_window = gtk_widget_get_toplevel(GTK_WIDGET(self));
515 
516  self->window_state_monitor =
518  GTK_WINDOW(toplevel_window));
519 
520  // Handle requests by the user to close the application.
521  g_signal_connect_object(toplevel_window, "delete-event",
522  G_CALLBACK(window_delete_event_cb), self,
523  G_CONNECT_SWAPPED);
524 
525  // Flutter engine will need to make the context current from raster thread
526  // during initialization.
528 
529  g_autoptr(GError) error = nullptr;
530  if (!fl_engine_start(self->engine, &error)) {
531  g_warning("Failed to start Flutter engine: %s", error->message);
532  return;
533  }
534 
535  setup_cursor(self);
536 
538 }
539 
540 static void size_allocate_cb(FlView* self) {
542 }
543 
544 static void fl_view_notify(GObject* object, GParamSpec* pspec) {
545  FlView* self = FL_VIEW(object);
546 
547  if (strcmp(pspec->name, "scale-factor") == 0) {
549  }
550 
551  if (G_OBJECT_CLASS(fl_view_parent_class)->notify != nullptr) {
552  G_OBJECT_CLASS(fl_view_parent_class)->notify(object, pspec);
553  }
554 }
555 
556 static void fl_view_dispose(GObject* object) {
557  FlView* self = FL_VIEW(object);
558 
559  g_cancellable_cancel(self->cancellable);
560 
561  g_clear_object(&self->zoom_gesture);
562  g_clear_object(&self->rotate_gesture);
563  if (self->engine != nullptr) {
564  // If this view holds the text input focus, clear the handler's widget
565  // pointer so it does not dangle once this view is finalized.
566  FlTextInputHandler* text_input_handler =
567  fl_engine_get_text_input_handler(self->engine);
568  if (text_input_handler != nullptr &&
569  fl_text_input_handler_get_widget(text_input_handler) ==
570  GTK_WIDGET(self)) {
571  fl_text_input_handler_set_widget(text_input_handler, nullptr);
572  }
573 
574  // Release the view ID from the engine.
575  fl_engine_remove_view(self->engine, self->view_id, nullptr, nullptr,
576  nullptr);
577  }
578 
579  g_clear_object(&self->renderer);
580  g_clear_object(&self->engine);
581  g_clear_object(&self->window_state_monitor);
582  g_clear_object(&self->scrolling_manager);
583  g_clear_object(&self->pointer_manager);
584  g_clear_object(&self->touch_manager);
585  g_clear_object(&self->view_accessible);
586  g_clear_object(&self->cancellable);
587 
588  G_OBJECT_CLASS(fl_view_parent_class)->dispose(object);
589 }
590 
591 // Implements GtkWidget::realize.
592 static void fl_view_realize(GtkWidget* widget) {
593  FlView* self = FL_VIEW(widget);
594 
595  GTK_WIDGET_CLASS(fl_view_parent_class)->realize(widget);
596 
597  // Realize the child widgets.
598  gtk_widget_realize(GTK_WIDGET(self->renderer));
599 }
600 
601 static gboolean handle_key_event(FlView* self, GdkEventKey* key_event) {
602  g_autoptr(FlKeyEvent) event = fl_key_event_new_from_gdk_event(
603  gdk_event_copy(reinterpret_cast<GdkEvent*>(key_event)));
604 
606  fl_engine_get_keyboard_manager(self->engine), event, self->cancellable,
607  [](GObject* object, GAsyncResult* result, gpointer user_data) {
608  FlView* self = FL_VIEW(user_data);
609 
610  g_autoptr(FlKeyEvent) redispatch_event = nullptr;
611  g_autoptr(GError) error = nullptr;
612  if (!fl_keyboard_manager_handle_event_finish(
613  FL_KEYBOARD_MANAGER(object), result, &redispatch_event,
614  &error)) {
615  if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
616  return;
617  }
618 
619  g_warning("Failed to handle key event: %s", error->message);
620  }
621 
622  if (redispatch_event != nullptr) {
624  fl_engine_get_text_input_handler(self->engine),
625  redispatch_event)) {
626  fl_keyboard_manager_add_redispatched_event(
627  fl_engine_get_keyboard_manager(self->engine), redispatch_event);
628  gdk_event_put(fl_key_event_get_origin(redispatch_event));
629  }
630  }
631  },
632  self);
633 
634  return TRUE;
635 }
636 
637 // Implements GtkWidget::key_press_event.
638 static gboolean fl_view_focus_in_event(GtkWidget* widget,
639  GdkEventFocus* event) {
640  FlView* self = FL_VIEW(widget);
642  fl_engine_get_text_input_handler(self->engine), widget);
643  return FALSE;
644 }
645 
646 // Implements GtkWidget::key_press_event.
647 static gboolean fl_view_key_press_event(GtkWidget* widget,
648  GdkEventKey* key_event) {
649  FlView* self = FL_VIEW(widget);
650  return handle_key_event(self, key_event);
651 }
652 
653 // Implements GtkWidget::key_release_event.
654 static gboolean fl_view_key_release_event(GtkWidget* widget,
655  GdkEventKey* key_event) {
656  FlView* self = FL_VIEW(widget);
657  return handle_key_event(self, key_event);
658 }
659 
660 static void fl_view_class_init(FlViewClass* klass) {
661  GObjectClass* object_class = G_OBJECT_CLASS(klass);
662  object_class->notify = fl_view_notify;
663  object_class->dispose = fl_view_dispose;
664 
665  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
666  widget_class->realize = fl_view_realize;
667  widget_class->focus_in_event = fl_view_focus_in_event;
668  widget_class->key_press_event = fl_view_key_press_event;
669  widget_class->key_release_event = fl_view_key_release_event;
670 
672  g_signal_new("first-frame", fl_view_get_type(), G_SIGNAL_RUN_LAST, 0,
673  NULL, NULL, NULL, G_TYPE_NONE, 0);
674 
675  gtk_widget_class_set_accessible_type(GTK_WIDGET_CLASS(klass),
676  fl_socket_accessible_get_type());
677 }
678 
679 // Engine related construction.
680 static void setup_engine(FlView* self) {
681  self->view_accessible = fl_view_accessible_new(self->engine, self->view_id);
683  FL_SOCKET_ACCESSIBLE(gtk_widget_get_accessible(GTK_WIDGET(self))),
684  atk_plug_get_id(ATK_PLUG(self->view_accessible)));
685 
686  self->pointer_manager = fl_pointer_manager_new(self->view_id, self->engine);
687 
688  init_scrolling(self);
689  init_touch(self);
690 
691  g_signal_connect_object(self->engine, "on-pre-engine-restart",
692  G_CALLBACK(on_pre_engine_restart_cb), self,
693  G_CONNECT_SWAPPED);
694  g_signal_connect_object(self->engine, "update-semantics",
695  G_CALLBACK(update_semantics_cb), self,
696  G_CONNECT_SWAPPED);
697 
698  switch (fl_engine_get_renderer_type(self->engine)) {
699  case kSoftware:
700  self->renderer = FL_VIEW_RENDERER(
701  fl_view_renderer_software_new(self->engine, self->sized_to_content));
702  break;
703  case kOpenGL:
704  default:
705  if (GDK_IS_WAYLAND_DISPLAY(gtk_widget_get_display(GTK_WIDGET(self)))) {
706  self->renderer = FL_VIEW_RENDERER(fl_view_renderer_subsurface_new(
707  self->engine, self->sized_to_content));
708  } else {
709  self->renderer = FL_VIEW_RENDERER(
710  fl_view_renderer_opengl_new(self->engine, self->sized_to_content));
711  }
712  break;
713  }
714  g_object_ref_sink(self->renderer);
715  gtk_widget_show(GTK_WIDGET(self->renderer));
716  gtk_container_add(GTK_CONTAINER(self->event_box), GTK_WIDGET(self->renderer));
717  g_signal_connect_swapped(self->renderer, "realize", G_CALLBACK(realize_cb),
718  self);
719  g_signal_connect_swapped(self->renderer, "size-allocate",
720  G_CALLBACK(size_allocate_cb), self);
721  g_signal_connect_swapped(self->renderer, "first-frame",
722  G_CALLBACK(first_frame_cb), self);
723 }
724 
725 static void fl_view_init(FlView* self) {
726  self->cancellable = g_cancellable_new();
727 
728  gtk_widget_set_can_focus(GTK_WIDGET(self), TRUE);
729 
730  self->view_id = -1;
731 
732  self->event_box = gtk_event_box_new();
733  gtk_widget_set_hexpand(self->event_box, TRUE);
734  gtk_widget_set_vexpand(self->event_box, TRUE);
735  gtk_container_add(GTK_CONTAINER(self), self->event_box);
736  gtk_widget_show(self->event_box);
737  gtk_widget_add_events(self->event_box,
738  GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK |
739  GDK_BUTTON_RELEASE_MASK | GDK_SCROLL_MASK |
740  GDK_SMOOTH_SCROLL_MASK | GDK_TOUCH_MASK);
741 
742  g_signal_connect_swapped(self->event_box, "button-press-event",
743  G_CALLBACK(button_press_event_cb), self);
744  g_signal_connect_swapped(self->event_box, "button-release-event",
745  G_CALLBACK(button_release_event_cb), self);
746  g_signal_connect_swapped(self->event_box, "grab-broken-event",
747  G_CALLBACK(grab_broken_event_cb), self);
748  g_signal_connect_swapped(self->event_box, "grab-notify",
749  G_CALLBACK(grab_notify_cb), self);
750  g_signal_connect_swapped(self->event_box, "unmap", G_CALLBACK(unmap_cb),
751  self);
752  g_signal_connect_swapped(self->event_box, "scroll-event",
753  G_CALLBACK(scroll_event_cb), self);
754  g_signal_connect_swapped(self->event_box, "motion-notify-event",
755  G_CALLBACK(motion_notify_event_cb), self);
756  g_signal_connect_swapped(self->event_box, "enter-notify-event",
757  G_CALLBACK(enter_notify_event_cb), self);
758  g_signal_connect_swapped(self->event_box, "leave-notify-event",
759  G_CALLBACK(leave_notify_event_cb), self);
760  self->zoom_gesture = gtk_gesture_zoom_new(self->event_box);
761  g_signal_connect_swapped(self->zoom_gesture, "begin",
762  G_CALLBACK(gesture_zoom_begin_cb), self);
763  g_signal_connect_swapped(self->zoom_gesture, "scale-changed",
764  G_CALLBACK(gesture_zoom_update_cb), self);
765  g_signal_connect_swapped(self->zoom_gesture, "end",
766  G_CALLBACK(gesture_zoom_end_cb), self);
767  self->rotate_gesture = gtk_gesture_rotate_new(self->event_box);
768  g_signal_connect_swapped(self->rotate_gesture, "begin",
769  G_CALLBACK(gesture_rotation_begin_cb), self);
770  g_signal_connect_swapped(self->rotate_gesture, "angle-changed",
771  G_CALLBACK(gesture_rotation_update_cb), self);
772  g_signal_connect_swapped(self->rotate_gesture, "end",
773  G_CALLBACK(gesture_rotation_end_cb), self);
774  g_signal_connect_swapped(self->event_box, "touch-event",
775  G_CALLBACK(touch_event_cb), self);
776 }
777 
778 G_MODULE_EXPORT FlView* fl_view_new(FlDartProject* project) {
779  g_autoptr(FlEngine) engine = fl_engine_new(project);
780  FlView* self = FL_VIEW(g_object_new(fl_view_get_type(), nullptr));
781 
782  self->view_id = flutter::kFlutterImplicitViewId;
783  self->engine = FL_ENGINE(g_object_ref(engine));
784 
785  setup_engine(self);
786 
787  fl_engine_set_implicit_view(engine, FL_RENDERABLE(self));
788 
789  return self;
790 }
791 
792 G_MODULE_EXPORT FlView* fl_view_new_for_engine(FlEngine* engine) {
793  FlView* self = FL_VIEW(g_object_new(fl_view_get_type(), nullptr));
794 
795  self->engine = FL_ENGINE(g_object_ref(engine));
796 
797  size_t min_width = 1, min_height = 1, max_width = 1, max_height = 1;
798  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
799  self->view_id = fl_engine_add_view(
800  engine, FL_RENDERABLE(self), min_width, min_height, max_width, max_height,
801  scale_factor, self->cancellable, view_added_cb, self);
802 
803  setup_engine(self);
804 
805  return self;
806 }
807 
808 G_MODULE_EXPORT FlView* fl_view_new_sized_to_content(FlEngine* engine) {
809  FlView* self = FL_VIEW(g_object_new(fl_view_get_type(), nullptr));
810 
811  self->engine = FL_ENGINE(g_object_ref(engine));
812 
813  self->sized_to_content = TRUE;
814  size_t min_width = 1, min_height = 1, max_width = G_MAXSIZE,
815  max_height = G_MAXSIZE;
816  gint scale_factor = gtk_widget_get_scale_factor(GTK_WIDGET(self));
817  self->view_id = fl_engine_add_view(
818  engine, FL_RENDERABLE(self), min_width, min_height, max_width, max_height,
819  scale_factor, self->cancellable, view_added_cb, self);
820 
821  setup_engine(self);
822 
823  return self;
824 }
825 
826 G_MODULE_EXPORT FlEngine* fl_view_get_engine(FlView* self) {
827  g_return_val_if_fail(FL_IS_VIEW(self), nullptr);
828  return self->engine;
829 }
830 
831 G_MODULE_EXPORT
832 int64_t fl_view_get_id(FlView* self) {
833  g_return_val_if_fail(FL_IS_VIEW(self), -1);
834  return self->view_id;
835 }
836 
837 G_MODULE_EXPORT void fl_view_set_background_color(FlView* self,
838  const GdkRGBA* color) {
839  g_return_if_fail(FL_IS_VIEW(self));
840  fl_view_renderer_set_background_color(self->renderer, color);
841 }
842 
843 FlViewAccessible* fl_view_get_accessible(FlView* self) {
844  g_return_val_if_fail(FL_IS_VIEW(self), nullptr);
845  return self->view_accessible;
846 }
g_autoptr(FlEngine) engine
if(engine==nullptr)
FlRenderable * renderable
const char FlTextDirection FlAssertiveness gpointer user_data
FlutterEngineDisplayId fl_display_monitor_get_display_id(FlDisplayMonitor *self, GdkMonitor *monitor)
G_MODULE_EXPORT FlTextureRegistrar * fl_engine_get_texture_registrar(FlEngine *self)
Definition: fl_engine.cc:1603
FlMouseCursorHandler * fl_engine_get_mouse_cursor_handler(FlEngine *self)
Definition: fl_engine.cc:1638
void fl_engine_send_window_metrics_event(FlEngine *self, FlutterEngineDisplayId display_id, FlutterViewId view_id, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio)
Definition: fl_engine.cc:1197
FlOpenGLManager * fl_engine_get_opengl_manager(FlEngine *self)
Definition: fl_engine.cc:751
FlutterRendererType fl_engine_get_renderer_type(FlEngine *self)
Definition: fl_engine.cc:746
FlKeyboardManager * fl_engine_get_keyboard_manager(FlEngine *self)
Definition: fl_engine.cc:1628
FlDisplayMonitor * fl_engine_get_display_monitor(FlEngine *self)
Definition: fl_engine.cc:756
FlTextInputHandler * fl_engine_get_text_input_handler(FlEngine *self)
Definition: fl_engine.cc:1633
void fl_engine_set_implicit_view(FlEngine *self, FlRenderable *renderable)
Definition: fl_engine.cc:959
FlutterViewId fl_engine_add_view(FlEngine *self, FlRenderable *renderable, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:963
void fl_engine_remove_view(FlEngine *self, FlutterViewId view_id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1029
G_MODULE_EXPORT FlBinaryMessenger * fl_engine_get_binary_messenger(FlEngine *self)
Definition: fl_engine.cc:1585
gboolean fl_engine_add_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:1016
void fl_engine_request_app_exit(FlEngine *self)
Definition: fl_engine.cc:1623
gboolean fl_engine_start(FlEngine *self, GError **error)
Definition: fl_engine.cc:761
G_MODULE_EXPORT FlEngine * fl_engine_new(FlDartProject *project)
Definition: fl_engine.cc:732
FlKeyEvent * fl_key_event_new_from_gdk_event(GdkEvent *event)
Definition: fl_key_event.cc:53
void fl_keyboard_manager_handle_event(FlKeyboardManager *self, FlKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
void fl_keyboard_manager_sync_modifier_if_needed(FlKeyboardManager *self, guint state, double event_time)
const gchar * fl_mouse_cursor_handler_get_cursor_name(FlMouseCursorHandler *self)
gboolean fl_opengl_manager_clear_current(FlOpenGLManager *self)
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width
const uint8_t uint32_t uint32_t GError ** error
FlPluginRegistrar * fl_plugin_registrar_new(FlView *view, FlBinaryMessenger *messenger, FlTextureRegistrar *texture_registrar)
FlPointerManager * fl_pointer_manager_new(FlutterViewId view_id, FlEngine *engine)
gboolean fl_pointer_manager_cancel_input(FlPointerManager *self, guint event_time)
gboolean fl_pointer_manager_handle_button_press(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_motion(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_enter(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_state, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_button_release(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
gboolean fl_pointer_manager_handle_leave(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
void fl_scrolling_manager_handle_rotation_begin(FlScrollingManager *self)
void fl_scrolling_manager_set_last_mouse_position(FlScrollingManager *self, gdouble x, gdouble y)
void fl_scrolling_manager_handle_rotation_end(FlScrollingManager *self)
void fl_scrolling_manager_handle_scroll_event(FlScrollingManager *self, GdkEventScroll *scroll_event, gint scale_factor)
FlScrollingManager * fl_scrolling_manager_new(FlEngine *engine, FlutterViewId view_id)
void fl_scrolling_manager_handle_zoom_update(FlScrollingManager *self, gdouble scale)
void fl_scrolling_manager_handle_rotation_update(FlScrollingManager *self, gdouble rotation)
void fl_scrolling_manager_handle_zoom_begin(FlScrollingManager *self)
void fl_scrolling_manager_handle_zoom_end(FlScrollingManager *self)
void fl_socket_accessible_embed(FlSocketAccessible *self, gchar *id)
guint const GValue GParamSpec * pspec
G_BEGIN_DECLS FlSubsurface size_t size_t gint scale
gboolean fl_text_input_handler_filter_keypress(FlTextInputHandler *self, FlKeyEvent *event)
void fl_text_input_handler_set_widget(FlTextInputHandler *self, GtkWidget *widget)
GtkWidget * fl_text_input_handler_get_widget(FlTextInputHandler *self)
void fl_touch_manager_cancel_input(FlTouchManager *self, guint event_time)
void fl_touch_manager_handle_touch_event(FlTouchManager *self, GdkEventTouch *touch_event, gint scale_factor)
FlTouchManager * fl_touch_manager_new(FlEngine *engine, FlutterViewId view_id)
@ LAST_SIGNAL
Definition: fl_view.cc:75
@ SIGNAL_FIRST_FRAME
Definition: fl_view.cc:75
static void gesture_zoom_begin_cb(FlView *self)
Definition: fl_view.cc:496
static void fl_view_realize(GtkWidget *widget)
Definition: fl_view.cc:592
static void init_scrolling(FlView *self)
Definition: fl_view.cc:104
static void get_pointer_device_state(GdkEvent *event, gdouble *rotation, gdouble *pressure)
Definition: fl_view.cc:140
static gboolean button_release_event_cb(FlView *self, GdkEventButton *button_event)
Definition: fl_view.cc:338
static void handle_geometry_changed(FlView *self)
Definition: fl_view.cc:181
static void gesture_rotation_end_cb(FlView *self)
Definition: fl_view.cc:492
static void gesture_rotation_update_cb(FlView *self, gdouble rotation, gdouble delta)
Definition: fl_view.cc:485
static gboolean button_press_event_cb(FlView *self, GdkEventButton *button_event)
Definition: fl_view.cc:307
static gboolean fl_view_key_release_event(GtkWidget *widget, GdkEventKey *key_event)
Definition: fl_view.cc:654
static void gesture_zoom_end_cb(FlView *self)
Definition: fl_view.cc:504
G_DEFINE_TYPE_WITH_CODE(FlView, fl_view, GTK_TYPE_BOX, G_IMPLEMENT_INTERFACE(fl_plugin_registry_get_type(), fl_view_plugin_registry_iface_init)) static void first_frame_cb(FlView *self)
Definition: fl_view.cc:84
static void fl_view_dispose(GObject *object)
Definition: fl_view.cc:556
static void on_pre_engine_restart_cb(FlView *self)
Definition: fl_view.cc:252
FlViewAccessible * fl_view_get_accessible(FlView *self)
Definition: fl_view.cc:843
static gboolean fl_view_key_press_event(GtkWidget *widget, GdkEventKey *key_event)
Definition: fl_view.cc:647
G_MODULE_EXPORT FlView * fl_view_new(FlDartProject *project)
Definition: fl_view.cc:778
static void size_allocate_cb(FlView *self)
Definition: fl_view.cc:540
static void fl_view_notify(GObject *object, GParamSpec *pspec)
Definition: fl_view.cc:544
static gboolean motion_notify_event_cb(FlView *self, GdkEventMotion *motion_event)
Definition: fl_view.cc:419
static void fl_view_present_layers(FlRenderable *renderable, const FlutterLayer **layers, size_t layers_count)
Definition: fl_view.cc:258
static void fl_view_init(FlView *self)
Definition: fl_view.cc:725
static gboolean enter_notify_event_cb(FlView *self, GdkEventCrossing *crossing_event)
Definition: fl_view.cc:444
static void gesture_rotation_begin_cb(FlView *self)
Definition: fl_view.cc:481
static void set_scrolling_position(FlView *self, gdouble x, gdouble y)
Definition: fl_view.cc:300
static guint fl_view_signals[LAST_SIGNAL]
Definition: fl_view.cc:77
G_MODULE_EXPORT FlView * fl_view_new_sized_to_content(FlEngine *engine)
Definition: fl_view.cc:808
G_MODULE_EXPORT FlView * fl_view_new_for_engine(FlEngine *engine)
Definition: fl_view.cc:792
static gboolean grab_broken_event_cb(FlView *self, GdkEventGrabBroken *grab_broken_event)
Definition: fl_view.cc:375
static void fl_view_class_init(FlViewClass *klass)
Definition: fl_view.cc:660
static void setup_cursor(FlView *self)
Definition: fl_view.cc:170
static void fl_renderable_iface_init(FlRenderableInterface *iface)
Definition: fl_view.cc:283
static void unmap_cb(FlView *self)
Definition: fl_view.cc:394
static gboolean fl_view_focus_in_event(GtkWidget *widget, GdkEventFocus *event)
Definition: fl_view.cc:638
static void grab_notify_cb(FlView *self, gboolean was_grabbed)
Definition: fl_view.cc:382
G_MODULE_EXPORT void fl_view_set_background_color(FlView *self, const GdkRGBA *color)
Definition: fl_view.cc:837
G_MODULE_EXPORT FlEngine * fl_view_get_engine(FlView *self)
Definition: fl_view.cc:826
static gboolean cancel_input(FlView *self, guint event_time)
Definition: fl_view.cc:363
static void setup_engine(FlView *self)
Definition: fl_view.cc:680
static void sync_modifier_if_needed(FlView *self, GdkEvent *event)
Definition: fl_view.cc:292
static gboolean handle_key_event(FlView *self, GdkEventKey *key_event)
Definition: fl_view.cc:601
static FlutterPointerDeviceKind get_pointer_device_kind(GdkEvent *event)
Definition: fl_view.cc:115
static void view_added_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_view.cc:221
static gboolean window_delete_event_cb(FlView *self)
Definition: fl_view.cc:98
G_MODULE_EXPORT int64_t fl_view_get_id(FlView *self)
Definition: fl_view.cc:832
static gboolean scroll_event_cb(FlView *self, GdkEventScroll *event)
Definition: fl_view.cc:401
static void fl_view_plugin_registry_iface_init(FlPluginRegistryInterface *iface)
Definition: fl_view.cc:287
static void gesture_zoom_update_cb(FlView *self, gdouble scale)
Definition: fl_view.cc:500
static void init_touch(FlView *self)
Definition: fl_view.cc:110
static void realize_cb(FlView *self)
Definition: fl_view.cc:508
static FlPluginRegistrar * fl_view_get_registrar_for_plugin(FlPluginRegistry *registry, const gchar *name)
Definition: fl_view.cc:273
static void update_semantics_cb(FlView *self, const FlutterSemanticsUpdate2 *update)
Definition: fl_view.cc:237
static gboolean leave_notify_event_cb(FlView *self, GdkEventCrossing *crossing_event)
Definition: fl_view.cc:462
static void cursor_changed_cb(FlView *self)
Definition: fl_view.cc:158
static gboolean touch_event_cb(FlView *self, GdkEventTouch *event)
Definition: fl_view.cc:411
FlViewAccessible * fl_view_accessible_new(FlEngine *engine, FlutterViewId view_id)
void fl_view_accessible_handle_update_semantics(FlViewAccessible *self, const FlutterSemanticsUpdate2 *update)
static void first_frame_cb(FlViewMonitor *self)
const FlutterLayer size_t layers_count
const FlutterLayer ** layers
void fl_view_renderer_set_background_color(FlViewRenderer *self, const GdkRGBA *color)
void fl_view_renderer_present_layers(FlViewRenderer *self, const FlutterLayer **layers, size_t layers_count)
FlWindowStateMonitor * fl_window_state_monitor_new(FlBinaryMessenger *messenger, GtkWindow *window)
FlEngine * engine
Definition: fl_view.cc:49
GtkGesture * zoom_gesture
Definition: fl_view.cc:40
GtkGesture * rotate_gesture
Definition: fl_view.cc:43
FlScrollingManager * scrolling_manager
Definition: fl_view.cc:58
FlViewRenderer * renderer
Definition: fl_view.cc:46
gboolean sized_to_content
Definition: fl_view.cc:70
FlTouchManager * touch_manager
Definition: fl_view.cc:64
FlPointerManager * pointer_manager
Definition: fl_view.cc:61
FlWindowStateMonitor * window_state_monitor
Definition: fl_view.cc:55
GCancellable * cancellable
Definition: fl_view.cc:72
GtkBox parent_instance
Definition: fl_view.cc:34
FlutterViewId view_id
Definition: fl_view.cc:52
GtkWidget * event_box
Definition: fl_view.cc:37
FlViewAccessible * view_accessible
Definition: fl_view.cc:67