394 lines
12 KiB
C
394 lines
12 KiB
C
/* ide-cell-renderer-fancy.c
|
|
*
|
|
* Copyright 2017-2019 Christian Hergert <chergert@redhat.com>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*/
|
|
|
|
#define G_LOG_DOMAIN "ide-cell-renderer-fancy"
|
|
|
|
#include "config.h"
|
|
|
|
#include "ide-cell-renderer-fancy.h"
|
|
|
|
#define TITLE_SPACING 3
|
|
|
|
struct _IdeCellRendererFancy
|
|
{
|
|
GtkCellRenderer parent_instance;
|
|
|
|
gchar *title;
|
|
gchar *body;
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_BODY,
|
|
PROP_TITLE,
|
|
N_PROPS
|
|
};
|
|
|
|
G_DEFINE_FINAL_TYPE (IdeCellRendererFancy, ide_cell_renderer_fancy, GTK_TYPE_CELL_RENDERER)
|
|
|
|
static GParamSpec *properties [N_PROPS];
|
|
|
|
static PangoLayout *
|
|
get_layout (IdeCellRendererFancy *self,
|
|
GtkWidget *widget,
|
|
const gchar *text,
|
|
gboolean is_title,
|
|
GtkCellRendererState flags)
|
|
{
|
|
PangoLayout *l;
|
|
PangoAttrList *attrs;
|
|
GtkStyleContext *style = gtk_widget_get_style_context (widget);
|
|
GtkStateFlags state = gtk_style_context_get_state (style);
|
|
GdkRGBA rgba;
|
|
|
|
l = gtk_widget_create_pango_layout (widget, text);
|
|
|
|
if (text == NULL || *text == 0)
|
|
return l;
|
|
|
|
attrs = pango_attr_list_new ();
|
|
|
|
gtk_style_context_get_color (style, state, &rgba);
|
|
pango_attr_list_insert (attrs,
|
|
pango_attr_foreground_new (rgba.red * 65535,
|
|
rgba.green * 65535,
|
|
rgba.blue * 65535));
|
|
|
|
if (is_title)
|
|
{
|
|
pango_attr_list_insert (attrs, pango_attr_scale_new (0.8333));
|
|
pango_attr_list_insert (attrs, pango_attr_foreground_alpha_new (65536 * 0.5));
|
|
}
|
|
|
|
pango_layout_set_attributes (l, attrs);
|
|
pango_attr_list_unref (attrs);
|
|
|
|
return l;
|
|
}
|
|
|
|
static GtkSizeRequestMode
|
|
ide_cell_renderer_fancy_get_request_mode (GtkCellRenderer *cell)
|
|
{
|
|
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_get_preferred_width (GtkCellRenderer *cell,
|
|
GtkWidget *widget,
|
|
gint *min_width,
|
|
gint *nat_width)
|
|
{
|
|
IdeCellRendererFancy *self = (IdeCellRendererFancy *)cell;
|
|
PangoLayout *body;
|
|
PangoLayout *title;
|
|
gint body_width = 0;
|
|
gint title_width = 0;
|
|
gint dummy;
|
|
gint xpad;
|
|
gint ypad;
|
|
|
|
if (min_width == NULL)
|
|
min_width = &dummy;
|
|
|
|
if (nat_width == NULL)
|
|
nat_width = &dummy;
|
|
|
|
g_assert (IDE_IS_CELL_RENDERER_FANCY (self));
|
|
g_assert (GTK_IS_WIDGET (widget));
|
|
g_assert (min_width != NULL);
|
|
g_assert (nat_width != NULL);
|
|
|
|
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
|
|
|
|
body = get_layout (self, widget, self->body, FALSE, 0);
|
|
title = get_layout (self, widget, self->title, TRUE, 0);
|
|
|
|
pango_layout_set_width (body, -1);
|
|
pango_layout_set_width (title, -1);
|
|
|
|
pango_layout_get_pixel_size (body, &body_width, NULL);
|
|
pango_layout_get_pixel_size (title, &title_width, NULL);
|
|
|
|
*min_width = xpad * 2;
|
|
*nat_width = (xpad * 2) + MAX (title_width, body_width);
|
|
|
|
g_object_unref (body);
|
|
g_object_unref (title);
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_get_preferred_height_for_width (GtkCellRenderer *cell,
|
|
GtkWidget *widget,
|
|
gint width,
|
|
gint *min_height,
|
|
gint *nat_height)
|
|
{
|
|
IdeCellRendererFancy *self = (IdeCellRendererFancy *)cell;
|
|
PangoLayout *body;
|
|
PangoLayout *title;
|
|
GtkAllocation alloc;
|
|
gint body_height = 0;
|
|
gint title_height = 0;
|
|
gint xpad;
|
|
gint ypad;
|
|
gint dummy;
|
|
|
|
if (min_height == NULL)
|
|
min_height = &dummy;
|
|
|
|
if (nat_height == NULL)
|
|
nat_height = &dummy;
|
|
|
|
g_assert (IDE_IS_CELL_RENDERER_FANCY (self));
|
|
g_assert (GTK_IS_WIDGET (widget));
|
|
g_assert (min_height != NULL);
|
|
g_assert (nat_height != NULL);
|
|
|
|
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
|
|
|
|
/*
|
|
* HACK: @width is the min_width returned in our get_preferred_width()
|
|
* function. That results in pretty bad values here, so we will
|
|
* do this by assuming we are the onl widget in the tree view.
|
|
*
|
|
* This makes this cell very much not usable for generic situations,
|
|
* but it does make it so we can do text wrapping without resorting
|
|
* to GtkListBox *for our exact usecase only*.
|
|
*
|
|
* The problem here is that we require the widget to already be
|
|
* realized and allocated and that we are the only renderer
|
|
* within the only column (and also, in a treeview) without
|
|
* exotic styling.
|
|
*
|
|
* If we get something absurdly small (like 50) that is because we
|
|
* are hitting our minimum size of (xpad * 2). So this works around
|
|
* the issue and tries to get something reasonable with wrapping
|
|
* at the 200px mark (our ~default width for panels).
|
|
*
|
|
* Furthermore, we need to queue a resize when the column size
|
|
* changes (as it will from resizing the widget). So the tree
|
|
* view must also call gtk_tree_view_column_queue_resize().
|
|
*/
|
|
gtk_widget_get_allocation (widget, &alloc);
|
|
if (alloc.width > width)
|
|
width = alloc.width - (xpad * 2);
|
|
else if (alloc.width < 50)
|
|
width = 200;
|
|
|
|
body = get_layout (self, widget, self->body, FALSE, 0);
|
|
title = get_layout (self, widget, self->title, TRUE, 0);
|
|
|
|
pango_layout_set_width (body, width * PANGO_SCALE);
|
|
pango_layout_set_width (title, width * PANGO_SCALE);
|
|
pango_layout_get_pixel_size (title, NULL, &title_height);
|
|
pango_layout_get_pixel_size (body, NULL, &body_height);
|
|
*min_height = *nat_height = (ypad * 2) + title_height + TITLE_SPACING + body_height;
|
|
|
|
g_object_unref (body);
|
|
g_object_unref (title);
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_render (GtkCellRenderer *renderer,
|
|
cairo_t *cr,
|
|
GtkWidget *widget,
|
|
const GdkRectangle *bg_area,
|
|
const GdkRectangle *cell_area,
|
|
GtkCellRendererState flags)
|
|
{
|
|
IdeCellRendererFancy *self = (IdeCellRendererFancy *)renderer;
|
|
PangoLayout *body;
|
|
PangoLayout *title;
|
|
gint xpad;
|
|
gint ypad;
|
|
gint height;
|
|
|
|
g_assert (IDE_IS_CELL_RENDERER_FANCY (self));
|
|
g_assert (cr != NULL);
|
|
g_assert (GTK_IS_WIDGET (widget));
|
|
g_assert (bg_area != NULL);
|
|
g_assert (cell_area != NULL);
|
|
|
|
gtk_cell_renderer_get_padding (renderer, &xpad, &ypad);
|
|
|
|
body = get_layout (self, widget, self->body, FALSE, flags);
|
|
title = get_layout (self, widget, self->title, TRUE, flags);
|
|
|
|
pango_layout_set_width (title, (cell_area->width - (xpad * 2)) * PANGO_SCALE);
|
|
pango_layout_set_width (body, (cell_area->width - (xpad * 2)) * PANGO_SCALE);
|
|
|
|
cairo_move_to (cr, cell_area->x + xpad, cell_area->y + ypad);
|
|
pango_cairo_show_layout (cr, title);
|
|
|
|
pango_layout_get_pixel_size (title, NULL, &height);
|
|
cairo_move_to (cr, cell_area->x + xpad, cell_area->y +ypad + + height + TITLE_SPACING);
|
|
pango_cairo_show_layout (cr, body);
|
|
|
|
g_object_unref (body);
|
|
g_object_unref (title);
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_finalize (GObject *object)
|
|
{
|
|
IdeCellRendererFancy *self = (IdeCellRendererFancy *)object;
|
|
|
|
g_clear_pointer (&self->body, g_free);
|
|
g_clear_pointer (&self->title, g_free);
|
|
|
|
G_OBJECT_CLASS (ide_cell_renderer_fancy_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
IdeCellRendererFancy *self = IDE_CELL_RENDERER_FANCY (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_BODY:
|
|
g_value_set_string (value, self->body);
|
|
break;
|
|
|
|
case PROP_TITLE:
|
|
g_value_set_string (value, self->title);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
IdeCellRendererFancy *self = IDE_CELL_RENDERER_FANCY (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_BODY:
|
|
ide_cell_renderer_fancy_set_body (self, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_TITLE:
|
|
ide_cell_renderer_fancy_set_title (self, g_value_get_string (value));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_class_init (IdeCellRendererFancyClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
|
|
|
|
object_class->finalize = ide_cell_renderer_fancy_finalize;
|
|
object_class->get_property = ide_cell_renderer_fancy_get_property;
|
|
object_class->set_property = ide_cell_renderer_fancy_set_property;
|
|
|
|
cell_class->get_request_mode = ide_cell_renderer_fancy_get_request_mode;
|
|
cell_class->get_preferred_width = ide_cell_renderer_fancy_get_preferred_width;
|
|
cell_class->get_preferred_height_for_width = ide_cell_renderer_fancy_get_preferred_height_for_width;
|
|
cell_class->render = ide_cell_renderer_fancy_render;
|
|
|
|
/* Note that we do not emit notify for these properties */
|
|
|
|
properties [PROP_BODY] =
|
|
g_param_spec_string ("body",
|
|
"Body",
|
|
"The body of the renderer",
|
|
NULL,
|
|
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
|
|
|
|
properties [PROP_TITLE] =
|
|
g_param_spec_string ("title",
|
|
"Title",
|
|
"The title of the renderer",
|
|
NULL,
|
|
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_properties (object_class, N_PROPS, properties);
|
|
}
|
|
|
|
static void
|
|
ide_cell_renderer_fancy_init (IdeCellRendererFancy *self)
|
|
{
|
|
}
|
|
|
|
const gchar *
|
|
ide_cell_renderer_fancy_get_title (IdeCellRendererFancy *self)
|
|
{
|
|
return self->title;
|
|
}
|
|
|
|
/**
|
|
* ide_cell_renderer_fancy_take_title:
|
|
* @self: a #IdeCellRendererFancy
|
|
* @title: (transfer full) (nullable): the new title
|
|
*
|
|
* Like ide_cell_renderer_fancy_set_title() but takes ownership
|
|
* of @title, saving a string copy.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_cell_renderer_fancy_take_title (IdeCellRendererFancy *self,
|
|
gchar *title)
|
|
{
|
|
if (self->title != title)
|
|
{
|
|
g_free (self->title);
|
|
self->title = title;
|
|
}
|
|
}
|
|
|
|
void
|
|
ide_cell_renderer_fancy_set_title (IdeCellRendererFancy *self,
|
|
const gchar *title)
|
|
{
|
|
ide_cell_renderer_fancy_take_title (self, g_strdup (title));
|
|
}
|
|
|
|
const gchar *
|
|
ide_cell_renderer_fancy_get_body (IdeCellRendererFancy *self)
|
|
{
|
|
return self->body;
|
|
}
|
|
|
|
void
|
|
ide_cell_renderer_fancy_set_body (IdeCellRendererFancy *self,
|
|
const gchar *body)
|
|
{
|
|
if (self->body != body)
|
|
{
|
|
g_free (self->body);
|
|
self->body = g_strdup (body);
|
|
}
|
|
}
|