fl_view_renderer.cc File Reference

#include "flutter/shell/platform/linux/fl_view_renderer.h"
#include <gdk/gdkwayland.h>
#include "flutter/shell/platform/linux/fl_compositor.h"
#include "flutter/shell/platform/linux/fl_compositor_opengl.h"
#include "flutter/shell/platform/linux/fl_compositor_software.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_opengl_manager.h"

Go to the source code of this file.

Classes
struct	_FlViewRenderer

Enumerations
enum	{   SIGNAL_FIRST_FRAME ,   LAST_SIGNAL }

Functions
static gboolean	redraw_cb (gpointer user_data)
static void	setup_opengl (FlViewRenderer *self)
static void	setup_software (FlViewRenderer *self)
static void	paint_background (FlViewRenderer *self, cairo_t *cr)
static void	fl_view_renderer_realize (GtkWidget *widget)
static gboolean	fl_view_renderer_draw (GtkWidget *widget, cairo_t *cr)
static void	fl_view_renderer_dispose (GObject *object)
static void	fl_view_renderer_finalize (GObject *object)
static void	fl_view_renderer_class_init (FlViewRendererClass *klass)
static void	fl_view_renderer_init (FlViewRenderer *self)
FlViewRenderer *	fl_view_renderer_new (FlEngine *engine, gboolean sized_to_content)
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)

Variables
static guint	fl_view_renderer_signals [LAST_SIGNAL]

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
SIGNAL_FIRST_FRAME
LAST_SIGNAL

Definition at line 37 of file fl_view_renderer.cc.

{ SIGNAL_FIRST_FRAME, LAST_SIGNAL };

Function Documentation

fl_view_renderer_class_init()

static void fl_view_renderer_class_init ( FlViewRendererClass *  klass )

static

Definition at line 194 of file fl_view_renderer.cc.

                                                                    {
  G_OBJECT_CLASS(klass)->dispose = fl_view_renderer_dispose;
  G_OBJECT_CLASS(klass)->finalize = fl_view_renderer_finalize;
 
  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
  widget_class->realize = fl_view_renderer_realize;
  widget_class->draw = fl_view_renderer_draw;
 
  fl_view_renderer_signals[SIGNAL_FIRST_FRAME] =
      g_signal_new("first-frame", fl_view_renderer_get_type(),
                   G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
}

References fl_view_renderer_dispose(), fl_view_renderer_draw(), fl_view_renderer_finalize(), fl_view_renderer_realize(), fl_view_renderer_signals, and SIGNAL_FIRST_FRAME.

fl_view_renderer_dispose()

static void fl_view_renderer_dispose ( GObject *  object )

static

Definition at line 171 of file fl_view_renderer.cc.

                                                      {
  FlViewRenderer* self = FL_VIEW_RENDERER(object);
 
  g_clear_object(&self->render_context);
  g_clear_object(&self->engine);
  g_clear_pointer(&self->background_color, gdk_rgba_free);
 
  G_OBJECT_CLASS(fl_view_renderer_parent_class)->dispose(object);
}

Referenced by fl_view_renderer_class_init().

fl_view_renderer_draw()

static gboolean fl_view_renderer_draw ( GtkWidget *  widget, cairo_t *  cr  )

static

Definition at line 145 of file fl_view_renderer.cc.

                                                                      {
  FlViewRenderer* self = FL_VIEW_RENDERER(widget);
 
  paint_background(self, cr);
 
  // The compositor is created when the widget is realized; if it is not yet
  // available there is nothing to render beyond the background.
  if (self->compositor == nullptr) {
    return TRUE;
  }
 
  if (self->render_context) {
    gdk_gl_context_make_current(self->render_context);
  }
 
  gboolean wait_for_frame = !self->sized_to_content;
  gboolean result = fl_compositor_render(
      self->compositor, cr, gtk_widget_get_window(widget), wait_for_frame);
 
  if (self->render_context) {
    gdk_gl_context_clear_current();
  }
 
  return result;
}

References fl_compositor_render(), paint_background(), and TRUE.

Referenced by fl_view_renderer_class_init().

fl_view_renderer_finalize()

static void fl_view_renderer_finalize ( GObject *  object )

static

Definition at line 181 of file fl_view_renderer.cc.

                                                       {
  FlViewRenderer* self = FL_VIEW_RENDERER(object);
 
  // The compositor is released here rather than in dispose() so it outlives a
  // forced dispose (e.g. gtk_widget_destroy()) and is only freed once the last
  // reference is dropped. This keeps it alive for the raster thread, which
  // holds a strong reference on the view (and thus this renderer) while
  // presenting.
  g_clear_object(&self->compositor);
 
  G_OBJECT_CLASS(fl_view_renderer_parent_class)->finalize(object);
}

Referenced by fl_view_renderer_class_init().

fl_view_renderer_init()

static void fl_view_renderer_init ( FlViewRenderer *  self )

static

Definition at line 207 of file fl_view_renderer.cc.

                                                        {
  GdkRGBA default_background = {
      .red = 0.0, .green = 0.0, .blue = 0.0, .alpha = 1.0};
  self->background_color = gdk_rgba_copy(&default_background);
}

fl_view_renderer_new()

FlViewRenderer* fl_view_renderer_new	(	FlEngine *	engine,
		gboolean	sized_to_content
	)

Definition at line 213 of file fl_view_renderer.cc.

                                                                {
  g_return_val_if_fail(FL_IS_ENGINE(engine), nullptr);
 
  FlViewRenderer* self =
      FL_VIEW_RENDERER(g_object_new(fl_view_renderer_get_type(), nullptr));
 
  self->engine = FL_ENGINE(g_object_ref(engine));
  self->sized_to_content = sized_to_content;
 
  return self;
}

References sized_to_content.

Referenced by setup_engine().

fl_view_renderer_present_layers()

void fl_view_renderer_present_layers	(	FlViewRenderer *	renderer,
		const FlutterLayer **	layers,
		size_t	layers_count
	)

fl_view_renderer_present_layers: @renderer: an #FlViewRenderer. @layers: layers to draw. @layers_count: number of layers.

Composites a frame into the renderer. This method can be called from any thread.

Definition at line 233 of file fl_view_renderer.cc.

                                                          {
  g_return_if_fail(FL_IS_VIEW_RENDERER(self));
 
  // Frames may be presented before the widget is realized and the compositor
  // is set up; ignore them.
  if (self->compositor == nullptr) {
    return;
  }
 
  fl_compositor_present_layers(self->compositor, layers, layers_count);
 
  // Perform the redraw in the GTK thread.
  g_idle_add(redraw_cb, g_object_ref(self));
}

References fl_compositor_present_layers(), layers, layers_count, and redraw_cb().

Referenced by fl_view_present_layers().

fl_view_renderer_realize()

static void fl_view_renderer_realize ( GtkWidget *  widget )

static

Definition at line 127 of file fl_view_renderer.cc.

                                                        {
  FlViewRenderer* self = FL_VIEW_RENDERER(widget);
 
  GTK_WIDGET_CLASS(fl_view_renderer_parent_class)->realize(widget);
 
  switch (fl_engine_get_renderer_type(self->engine)) {
    case kOpenGL:
      setup_opengl(self);
      break;
    case kSoftware:
      setup_software(self);
      break;
    default:
      break;
  }
}

References fl_engine_get_renderer_type(), setup_opengl(), and setup_software().

Referenced by fl_view_renderer_class_init().

fl_view_renderer_set_background_color()

void fl_view_renderer_set_background_color	(	FlViewRenderer *	renderer,
		const GdkRGBA *	color
	)

fl_view_renderer_set_background_color: @renderer: an #FlViewRenderer. @color: the background color.

Sets the background color drawn behind the Flutter frame.

Definition at line 226 of file fl_view_renderer.cc.

                                                                 {
  g_return_if_fail(FL_IS_VIEW_RENDERER(self));
  gdk_rgba_free(self->background_color);
  self->background_color = gdk_rgba_copy(color);
}

Referenced by fl_view_set_background_color().

paint_background()

static void paint_background ( FlViewRenderer *  self, cairo_t *  cr  )

static

Definition at line 114 of file fl_view_renderer.cc.

                                                                {
  // Don't bother drawing if fully transparent - the widget above this will
  // already be drawn by GTK.
  if (self->background_color->red == 0 && self->background_color->green == 0 &&
      self->background_color->blue == 0 && self->background_color->alpha == 0) {
    return;
  }
 
  gdk_cairo_set_source_rgba(cr, self->background_color);
  cairo_paint(cr);
}

Referenced by fl_view_renderer_draw().

redraw_cb()

static gboolean redraw_cb ( gpointer  user_data )

static

Definition at line 44 of file fl_view_renderer.cc.

                                              {
  g_autoptr(FlViewRenderer) self = FL_VIEW_RENDERER(user_data);
 
  if (self->compositor == nullptr) {
    return G_SOURCE_REMOVE;
  }
 
  if (!self->have_first_frame) {
    self->have_first_frame = TRUE;
    g_signal_emit(self, fl_view_renderer_signals[SIGNAL_FIRST_FRAME], 0);
  }
 
  // If Flutter is controlling the window size, then resize the view if
  // necessary.
  GtkWidget* render_widget = GTK_WIDGET(self);
  GtkAllocation allocation;
  gtk_widget_get_allocation(render_widget, &allocation);
  gint scale_factor = gtk_widget_get_scale_factor(render_widget);
  size_t width = allocation.width * scale_factor;
  size_t height = allocation.height * scale_factor;
  size_t frame_width, frame_height;
  fl_compositor_get_frame_size(self->compositor, &frame_width, &frame_height);
  gboolean frame_size_matches = width == frame_width && height == frame_height;
  if (self->sized_to_content && !frame_size_matches) {
    gtk_widget_set_size_request(render_widget, frame_width / scale_factor,
                                frame_height / scale_factor);
    GtkWidget* toplevel = gtk_widget_get_toplevel(render_widget);
    if (GTK_IS_WINDOW(toplevel)) {
      // Resize to smallest size, so that the window will shrink to fit the new
      // size of the render area.
      gtk_window_resize(GTK_WINDOW(toplevel), 1, 1);
    }
    return G_SOURCE_REMOVE;
  }
 
  gtk_widget_queue_draw(render_widget);
 
  return G_SOURCE_REMOVE;
}

References fl_compositor_get_frame_size(), fl_view_renderer_signals, g_autoptr(), height, SIGNAL_FIRST_FRAME, TRUE, user_data, and width.

Referenced by fl_view_renderer_present_layers().

setup_opengl()

static void setup_opengl ( FlViewRenderer *  self )

static

Definition at line 84 of file fl_view_renderer.cc.

                                               {
  g_autoptr(GError) error = nullptr;
 
  self->render_context = gdk_window_create_gl_context(
      gtk_widget_get_window(GTK_WIDGET(self)), &error);
  if (self->render_context == nullptr) {
    g_warning("Failed to create OpenGL context: %s", error->message);
    return;
  }
 
  if (!gdk_gl_context_realize(self->render_context, &error)) {
    g_warning("Failed to realize OpenGL context: %s", error->message);
    return;
  }
 
  // If using Wayland, then EGL is in use and we can access the frame
  // from the Flutter context using EGLImage. If not (i.e. X11 using GLX)
  // then we have to copy the texture via the CPU.
  gboolean shareable =
      GDK_IS_WAYLAND_DISPLAY(gtk_widget_get_display(GTK_WIDGET(self)));
  self->compositor = FL_COMPOSITOR(fl_compositor_opengl_new(
      fl_engine_get_task_runner(self->engine),
      fl_engine_get_opengl_manager(self->engine), shareable));
}

References error, fl_compositor_opengl_new(), fl_engine_get_opengl_manager(), fl_engine_get_task_runner(), g_autoptr(), and shareable.

Referenced by fl_view_renderer_realize().

setup_software()

static void setup_software ( FlViewRenderer *  self )

static

Definition at line 109 of file fl_view_renderer.cc.

                                                 {
  self->compositor = FL_COMPOSITOR(
      fl_compositor_software_new(fl_engine_get_task_runner(self->engine)));
}

References fl_compositor_software_new(), and fl_engine_get_task_runner().

Referenced by fl_view_renderer_realize().

Variable Documentation

fl_view_renderer_signals

guint fl_view_renderer_signals[LAST_SIGNAL]

static

Definition at line 39 of file fl_view_renderer.cc.

Referenced by fl_view_renderer_class_init(), and redraw_cb().