vcl/unx/gtk3/customcellrenderer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <vcl/svapp.hxx>
  11 #include "customcellrenderer.hxx"
  12 #if !GTK_CHECK_VERSION(4, 0, 0)
  13 #include <gtk/gtk-a11y.h>
  14 #endif
  15
  16 namespace
  17 {
  18 struct _CustomCellRendererClass : public GtkCellRendererTextClass
  19 {
  20 };
  21
  22 enum
  23 {
  24     PROP_ID = 10000,
  25     PROP_INSTANCE_TREE_VIEW = 10001
  26 };
  27 }
  28
  29 #if defined __clang__ && GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 68
  30 #pragma clang diagnostic push
  31 #pragma clang diagnostic ignored "-Wdeprecated-volatile"
  32 #endif
  33 G_DEFINE_TYPE(CustomCellRenderer, custom_cell_renderer, GTK_TYPE_CELL_RENDERER_TEXT)
  34 #if defined __clang__ && GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 68
  35 #pragma clang diagnostic pop
  36 #endif
  37
  38 static void custom_cell_renderer_init(CustomCellRenderer* self)
  39 {
  40     {
  41         SolarMutexGuard aGuard;
  42         new (&self->device) VclPtr<VirtualDevice>;
  43     }
  44
  45     // prevent loplugin:unreffun firing on macro generated function
  46     (void)custom_cell_renderer_get_instance_private(self);
  47 }
  48
  49 static void custom_cell_renderer_get_property(GObject* object, guint param_id, GValue* value,
  50                                               GParamSpec* pspec)
  51 {
  52     CustomCellRenderer* cellsurface = CUSTOM_CELL_RENDERER(object);
  53
  54     switch (param_id)
  55     {
  56         case PROP_ID:
  57             g_value_set_string(value, cellsurface->id);
  58             break;
  59         case PROP_INSTANCE_TREE_VIEW:
  60             g_value_set_pointer(value, cellsurface->instance);
  61             break;
  62         default:
  63             G_OBJECT_CLASS(custom_cell_renderer_parent_class)
  64                 ->get_property(object, param_id, value, pspec);
  65             break;
  66     }
  67 }
  68
  69 static void custom_cell_renderer_set_property(GObject* object, guint param_id, const GValue* value,
  70                                               GParamSpec* pspec)
  71 {
  72     CustomCellRenderer* cellsurface = CUSTOM_CELL_RENDERER(object);
  73
  74     switch (param_id)
  75     {
  76         case PROP_ID:
  77             g_free(cellsurface->id);
  78             cellsurface->id = g_value_dup_string(value);
  79             break;
  80         case PROP_INSTANCE_TREE_VIEW:
  81             cellsurface->instance = g_value_get_pointer(value);
  82             break;
  83         default:
  84             G_OBJECT_CLASS(custom_cell_renderer_parent_class)
  85                 ->set_property(object, param_id, value, pspec);
  86             break;
  87     }
  88 }
  89
  90 static bool custom_cell_renderer_get_preferred_size(GtkCellRenderer* cell,
  91                                                     GtkOrientation orientation, gint* minimum_size,
  92                                                     gint* natural_size);
  93
  94 #if GTK_CHECK_VERSION(4, 0, 0)
  95 static void custom_cell_renderer_snapshot(GtkCellRenderer* cell, GtkSnapshot* snapshot,
  96                                           GtkWidget* widget, const GdkRectangle* background_area,
  97                                           const GdkRectangle* cell_area,
  98                                           GtkCellRendererState flags);
  99 #endif
 100
 101 static void custom_cell_renderer_render(GtkCellRenderer* cell, cairo_t* cr, GtkWidget* widget,
 102                                         const GdkRectangle* background_area,
 103                                         const GdkRectangle* cell_area, GtkCellRendererState flags);
 104
 105 static void custom_cell_renderer_finalize(GObject* object)
 106 {
 107     CustomCellRenderer* cellsurface = CUSTOM_CELL_RENDERER(object);
 108
 109     g_free(cellsurface->id);
 110
 111     {
 112         SolarMutexGuard aGuard;
 113         cellsurface->device.disposeAndClear();
 114         cellsurface->device.~VclPtr<VirtualDevice>();
 115     }
 116
 117     G_OBJECT_CLASS(custom_cell_renderer_parent_class)->finalize(object);
 118 }
 119
 120 static void custom_cell_renderer_get_preferred_width(GtkCellRenderer* cell, GtkWidget* widget,
 121                                                      gint* minimum_size, gint* natural_size)
 122 {
 123     if (!custom_cell_renderer_get_preferred_size(cell, GTK_ORIENTATION_HORIZONTAL, minimum_size,
 124                                                  natural_size))
 125     {
 126         // fallback to parent if we're empty
 127         GTK_CELL_RENDERER_CLASS(custom_cell_renderer_parent_class)
 128             ->get_preferred_width(cell, widget, minimum_size, natural_size);
 129     }
 130 }
 131
 132 static void custom_cell_renderer_get_preferred_height(GtkCellRenderer* cell, GtkWidget* widget,
 133                                                       gint* minimum_size, gint* natural_size)
 134 {
 135     if (!custom_cell_renderer_get_preferred_size(cell, GTK_ORIENTATION_VERTICAL, minimum_size,
 136                                                  natural_size))
 137     {
 138         // fallback to parent if we're empty
 139         GTK_CELL_RENDERER_CLASS(custom_cell_renderer_parent_class)
 140             ->get_preferred_height(cell, widget, minimum_size, natural_size);
 141     }
 142 }
 143
 144 static void custom_cell_renderer_get_preferred_height_for_width(GtkCellRenderer* cell,
 145                                                                 GtkWidget* widget, gint /*width*/,
 146                                                                 gint* minimum_height,
 147                                                                 gint* natural_height)
 148 {
 149     gtk_cell_renderer_get_preferred_height(cell, widget, minimum_height, natural_height);
 150 }
 151
 152 static void custom_cell_renderer_get_preferred_width_for_height(GtkCellRenderer* cell,
 153                                                                 GtkWidget* widget, gint /*height*/,
 154                                                                 gint* minimum_width,
 155                                                                 gint* natural_width)
 156 {
 157     gtk_cell_renderer_get_preferred_width(cell, widget, minimum_width, natural_width);
 158 }
 159
 160 void custom_cell_renderer_class_init(CustomCellRendererClass* klass)
 161 {
 162     GtkCellRendererClass* cell_class = GTK_CELL_RENDERER_CLASS(klass);
 163     GObjectClass* object_class = G_OBJECT_CLASS(klass);
 164
 165     /* Hook up functions to set and get our custom cell renderer properties */
 166     object_class->get_property = custom_cell_renderer_get_property;
 167     object_class->set_property = custom_cell_renderer_set_property;
 168
 169     custom_cell_renderer_parent_class = g_type_class_peek_parent(klass);
 170     object_class->finalize = custom_cell_renderer_finalize;
 171
 172     cell_class->get_preferred_width = custom_cell_renderer_get_preferred_width;
 173     cell_class->get_preferred_height = custom_cell_renderer_get_preferred_height;
 174     cell_class->get_preferred_width_for_height
 175         = custom_cell_renderer_get_preferred_width_for_height;
 176     cell_class->get_preferred_height_for_width
 177         = custom_cell_renderer_get_preferred_height_for_width;
 178
 179 #if GTK_CHECK_VERSION(4, 0, 0)
 180     cell_class->snapshot = custom_cell_renderer_snapshot;
 181 #else
 182     cell_class->render = custom_cell_renderer_render;
 183 #endif
 184
 185     g_object_class_install_property(
 186         object_class, PROP_ID,
 187         g_param_spec_string("id", "ID", "The ID of the custom data", nullptr, G_PARAM_READWRITE));
 188
 189     g_object_class_install_property(
 190         object_class, PROP_INSTANCE_TREE_VIEW,
 191         g_param_spec_pointer("instance", "Instance", "The GtkInstanceTreeView", G_PARAM_READWRITE));
 192
 193 #if !GTK_CHECK_VERSION(4, 0, 0)
 194     gtk_cell_renderer_class_set_accessible_type(cell_class, GTK_TYPE_TEXT_CELL_ACCESSIBLE);
 195 #endif
 196 }
 197
 198 GtkCellRenderer* custom_cell_renderer_new()
 199 {
 200     return GTK_CELL_RENDERER(g_object_new(CUSTOM_TYPE_CELL_RENDERER, nullptr));
 201 }
 202
 203 bool custom_cell_renderer_get_preferred_size(GtkCellRenderer* cell, GtkOrientation orientation,
 204                                              gint* minimum_size, gint* natural_size)
 205 {
 206     GValue value = G_VALUE_INIT;
 207     g_value_init(&value, G_TYPE_STRING);
 208     g_object_get_property(G_OBJECT(cell), "id", &value);
 209
 210     const char* pStr = g_value_get_string(&value);
 211
 212     OUString sId(pStr, pStr ? strlen(pStr) : 0, RTL_TEXTENCODING_UTF8);
 213
 214     value = G_VALUE_INIT;
 215     g_value_init(&value, G_TYPE_POINTER);
 216     g_object_get_property(G_OBJECT(cell), "instance", &value);
 217
 218     CustomCellRenderer* cellsurface = CUSTOM_CELL_RENDERER(cell);
 219
 220     Size aSize;
 221
 222     gpointer pWidget = g_value_get_pointer(&value);
 223     if (pWidget)
 224     {
 225         SolarMutexGuard aGuard;
 226         custom_cell_renderer_ensure_device(cellsurface, pWidget);
 227         aSize = custom_cell_renderer_get_size(*cellsurface->device, sId, pWidget);
 228     }
 229
 230     if (orientation == GTK_ORIENTATION_HORIZONTAL)
 231     {
 232         if (minimum_size)
 233             *minimum_size = aSize.Width();
 234
 235         if (natural_size)
 236             *natural_size = aSize.Width();
 237     }
 238     else
 239     {
 240         if (minimum_size)
 241             *minimum_size = aSize.Height();
 242
 243         if (natural_size)
 244             *natural_size = aSize.Height();
 245     }
 246
 247     return true;
 248 }
 249
 250 void custom_cell_renderer_render(GtkCellRenderer* cell, cairo_t* cr, GtkWidget* /*widget*/,
 251                                  const GdkRectangle* /*background_area*/,
 252                                  const GdkRectangle* cell_area, GtkCellRendererState flags)
 253 {
 254     GValue value = G_VALUE_INIT;
 255     g_value_init(&value, G_TYPE_STRING);
 256     g_object_get_property(G_OBJECT(cell), "id", &value);
 257
 258     const char* pStr = g_value_get_string(&value);
 259     OUString sId(pStr, pStr ? strlen(pStr) : 0, RTL_TEXTENCODING_UTF8);
 260
 261     value = G_VALUE_INIT;
 262     g_value_init(&value, G_TYPE_POINTER);
 263     g_object_get_property(G_OBJECT(cell), "instance", &value);
 264
 265     CustomCellRenderer* cellsurface = CUSTOM_CELL_RENDERER(cell);
 266
 267     gpointer pWidget = g_value_get_pointer(&value);
 268     if (!pWidget)
 269         return;
 270
 271     SolarMutexGuard aGuard;
 272
 273     custom_cell_renderer_ensure_device(cellsurface, pWidget);
 274
 275     Size aSize(cell_area->width, cell_area->height);
 276     // false to not bother setting the bg on resize as we'll do that
 277     // ourself via cairo
 278     cellsurface->device->SetOutputSizePixel(aSize, false);
 279
 280     cairo_surface_t* pSurface = get_underlying_cairo_surface(*cellsurface->device);
 281
 282     // fill surface as transparent so it can be blended with the potentially
 283     // selected background
 284     cairo_t* tempcr = cairo_create(pSurface);
 285     cairo_set_source_rgba(tempcr, 0, 0, 0, 0);
 286     cairo_set_operator(tempcr, CAIRO_OPERATOR_SOURCE);
 287     cairo_paint(tempcr);
 288     cairo_destroy(tempcr);
 289     cairo_surface_flush(pSurface);
 290
 291     custom_cell_renderer_render(*cellsurface->device, tools::Rectangle(Point(0, 0), aSize),
 292                                 static_cast<bool>(flags & GTK_CELL_RENDERER_SELECTED), sId,
 293                                 pWidget);
 294
 295     cairo_surface_mark_dirty(pSurface);
 296
 297     cairo_set_source_surface(cr, pSurface, cell_area->x, cell_area->y);
 298     cairo_paint(cr);
 299 }
 300
 301 #if GTK_CHECK_VERSION(4, 0, 0)
 302 static void custom_cell_renderer_snapshot(GtkCellRenderer* cell, GtkSnapshot* snapshot,
 303                                           GtkWidget* widget, const GdkRectangle* background_area,
 304                                           const GdkRectangle* cell_area, GtkCellRendererState flags)
 305 {
 306     graphene_rect_t rect = GRAPHENE_RECT_INIT(
 307         static_cast<float>(cell_area->x), static_cast<float>(cell_area->y),
 308         static_cast<float>(cell_area->width), static_cast<float>(cell_area->height));
 309     cairo_t* cr = gtk_snapshot_append_cairo(GTK_SNAPSHOT(snapshot), &rect);
 310     custom_cell_renderer_render(cell, cr, widget, background_area, cell_area, flags);
 311     cairo_destroy(cr);
 312 }
 313
 314 #endif
 315
 316 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */