From ddb8db58723e0175313bbd00727b18fba3f41967 Mon Sep 17 00:00:00 2001 From: Christian Hergert Date: Thu, 30 Sep 2021 14:56:37 -0700 Subject: [PATCH] cellrendererpercent: subclass private progress implementation We might get this subclassable in GTK soon, but until then just subclass so we can move on and port more things. --- src/libsysprof-ui/meson.build | 1 + .../sysprof-cell-renderer-percent.c | 2 +- .../sysprof-cell-renderer-percent.h | 6 +- .../sysprof-cell-renderer-progress.c | 712 ++++++++++++++++++ .../sysprof-cell-renderer-progress.h | 53 ++ 5 files changed, 770 insertions(+), 4 deletions(-) create mode 100644 src/libsysprof-ui/sysprof-cell-renderer-progress.c create mode 100644 src/libsysprof-ui/sysprof-cell-renderer-progress.h diff --git a/src/libsysprof-ui/meson.build b/src/libsysprof-ui/meson.build index 2ad83acc..f6c6732e 100644 --- a/src/libsysprof-ui/meson.build +++ b/src/libsysprof-ui/meson.build @@ -24,6 +24,7 @@ libsysprof_ui_private_sources = [ 'sysprof-callgraph-page.c', 'sysprof-cell-renderer-duration.c', 'sysprof-cell-renderer-percent.c', + 'sysprof-cell-renderer-progress.c', 'sysprof-color-cycle.c', 'sysprof-counters-aid.c', 'sysprof-cpu-aid.c', diff --git a/src/libsysprof-ui/sysprof-cell-renderer-percent.c b/src/libsysprof-ui/sysprof-cell-renderer-percent.c index d0d25d6d..e23e1fed 100644 --- a/src/libsysprof-ui/sysprof-cell-renderer-percent.c +++ b/src/libsysprof-ui/sysprof-cell-renderer-percent.c @@ -37,7 +37,7 @@ enum { N_PROPS }; -G_DEFINE_TYPE_WITH_PRIVATE (SysprofCellRendererPercent, sysprof_cell_renderer_percent, GTK_TYPE_CELL_RENDERER_PROGRESS) +G_DEFINE_TYPE_WITH_PRIVATE (SysprofCellRendererPercent, sysprof_cell_renderer_percent, SYSPROF_TYPE_CELL_RENDERER_PROGRESS) static GParamSpec *properties [N_PROPS]; diff --git a/src/libsysprof-ui/sysprof-cell-renderer-percent.h b/src/libsysprof-ui/sysprof-cell-renderer-percent.h index b917ea7f..44a8fc04 100644 --- a/src/libsysprof-ui/sysprof-cell-renderer-percent.h +++ b/src/libsysprof-ui/sysprof-cell-renderer-percent.h @@ -20,7 +20,7 @@ #pragma once -#include +#include "sysprof-cell-renderer-progress.h" G_BEGIN_DECLS @@ -37,12 +37,12 @@ typedef struct _SysprofCellRendererPercentClass SysprofCellRendererPercentClass; struct _SysprofCellRendererPercent { - GtkCellRendererProgress parent; + SysprofCellRendererProgress parent; }; struct _SysprofCellRendererPercentClass { - GtkCellRendererProgressClass parent_class; + SysprofCellRendererProgressClass parent_class; /*< private >*/ gpointer _reserved[4]; diff --git a/src/libsysprof-ui/sysprof-cell-renderer-progress.c b/src/libsysprof-ui/sysprof-cell-renderer-progress.c new file mode 100644 index 00000000..a0943b64 --- /dev/null +++ b/src/libsysprof-ui/sysprof-cell-renderer-progress.c @@ -0,0 +1,712 @@ +/* gtkcellrendererprogress.c + * Copyright (C) 2002 Naba Kumar + * heavily modified by Jörgen Scheibengruber + * heavily modified by Marco Pesenti Gritti + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library. If not, see . + */ +/* + * Modified by the GTK+ Team and others 1997-2007. See the AUTHORS + * file for a list of people on the GTK+ Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + */ + +#include "config.h" + +#include +#include + +#include "sysprof-cell-renderer-progress.h" + + +enum +{ + PROP_0, + PROP_VALUE, + PROP_TEXT, + PROP_PULSE, + PROP_TEXT_XALIGN, + PROP_TEXT_YALIGN, + PROP_ORIENTATION, + PROP_INVERTED +}; + +struct _SysprofCellRendererProgressPrivate +{ + int value; + char *text; + char *label; + int min_h; + int min_w; + int pulse; + int offset; + float text_xalign; + float text_yalign; + GtkOrientation orientation; + gboolean inverted; +}; + +static void sysprof_cell_renderer_progress_finalize (GObject *object); +static void sysprof_cell_renderer_progress_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec); +static void sysprof_cell_renderer_progress_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec); +static void sysprof_cell_renderer_progress_set_value (SysprofCellRendererProgress *cellprogress, + int value); +static void sysprof_cell_renderer_progress_set_text (SysprofCellRendererProgress *cellprogress, + const char *text); +static void sysprof_cell_renderer_progress_set_pulse (SysprofCellRendererProgress *cellprogress, + int pulse); +static void compute_dimensions (GtkCellRenderer *cell, + GtkWidget *widget, + const char *text, + int *width, + int *height); +static void sysprof_cell_renderer_progress_snapshot (GtkCellRenderer *cell, + GtkSnapshot *snapshot, + GtkWidget *widget, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, + GtkCellRendererState flags); + + +G_DEFINE_TYPE_WITH_CODE (SysprofCellRendererProgress, sysprof_cell_renderer_progress, GTK_TYPE_CELL_RENDERER, + G_ADD_PRIVATE (SysprofCellRendererProgress) + G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)) + +static void +recompute_label (SysprofCellRendererProgress *cellprogress) +{ + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + char *label; + + if (priv->text) + label = g_strdup (priv->text); + else if (priv->pulse < 0) + label = g_strdup_printf (C_("progress bar label", "%d %%"), priv->value); + else + label = NULL; + + g_free (priv->label); + priv->label = label; +} + +static void +sysprof_cell_renderer_progress_set_value (SysprofCellRendererProgress *cellprogress, + int value) +{ + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + + if (priv->value != value) + { + priv->value = value; + recompute_label (cellprogress); + g_object_notify (G_OBJECT (cellprogress), "value"); + } +} + +static void +sysprof_cell_renderer_progress_set_text (SysprofCellRendererProgress *cellprogress, + const char *text) +{ + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + char *new_text; + + new_text = g_strdup (text); + g_free (priv->text); + priv->text = new_text; + recompute_label (cellprogress); + g_object_notify (G_OBJECT (cellprogress), "text"); +} + +static void +sysprof_cell_renderer_progress_set_pulse (SysprofCellRendererProgress *cellprogress, + int pulse) +{ + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + + if (pulse != priv->pulse) + { + if (pulse <= 0) + priv->offset = 0; + else + priv->offset = pulse; + g_object_notify (G_OBJECT (cellprogress), "pulse"); + } + + priv->pulse = pulse; + recompute_label (cellprogress); +} + +static void +sysprof_cell_renderer_progress_finalize (GObject *object) +{ + SysprofCellRendererProgress *cellprogress = SYSPROF_CELL_RENDERER_PROGRESS (object); + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + + g_free (priv->text); + g_free (priv->label); + + G_OBJECT_CLASS (sysprof_cell_renderer_progress_parent_class)->finalize (object); +} + +static void +sysprof_cell_renderer_progress_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec) +{ + SysprofCellRendererProgress *cellprogress = SYSPROF_CELL_RENDERER_PROGRESS (object); + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + + switch (param_id) + { + case PROP_VALUE: + g_value_set_int (value, priv->value); + break; + case PROP_TEXT: + g_value_set_string (value, priv->text); + break; + case PROP_PULSE: + g_value_set_int (value, priv->pulse); + break; + case PROP_TEXT_XALIGN: + g_value_set_float (value, priv->text_xalign); + break; + case PROP_TEXT_YALIGN: + g_value_set_float (value, priv->text_yalign); + break; + case PROP_ORIENTATION: + g_value_set_enum (value, priv->orientation); + break; + case PROP_INVERTED: + g_value_set_boolean (value, priv->inverted); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + } +} + +static void +sysprof_cell_renderer_progress_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec) +{ + SysprofCellRendererProgress *cellprogress = SYSPROF_CELL_RENDERER_PROGRESS (object); + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + + switch (param_id) + { + case PROP_VALUE: + sysprof_cell_renderer_progress_set_value (cellprogress, + g_value_get_int (value)); + break; + case PROP_TEXT: + sysprof_cell_renderer_progress_set_text (cellprogress, + g_value_get_string (value)); + break; + case PROP_PULSE: + sysprof_cell_renderer_progress_set_pulse (cellprogress, + g_value_get_int (value)); + break; + case PROP_TEXT_XALIGN: + priv->text_xalign = g_value_get_float (value); + break; + case PROP_TEXT_YALIGN: + priv->text_yalign = g_value_get_float (value); + break; + case PROP_ORIENTATION: + if (priv->orientation != g_value_get_enum (value)) + { + priv->orientation = g_value_get_enum (value); + g_object_notify_by_pspec (object, pspec); + } + break; + case PROP_INVERTED: + if (priv->inverted != g_value_get_boolean (value)) + { + priv->inverted = g_value_get_boolean (value); + g_object_notify_by_pspec (object, pspec); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + } +} + +static void +compute_dimensions (GtkCellRenderer *cell, + GtkWidget *widget, + const char *text, + int *width, + int *height) +{ + PangoRectangle logical_rect; + PangoLayout *layout; + int xpad, ypad; + + layout = gtk_widget_create_pango_layout (widget, text); + pango_layout_get_pixel_extents (layout, NULL, &logical_rect); + + gtk_cell_renderer_get_padding (cell, &xpad, &ypad); + + if (width) + *width = logical_rect.width + xpad * 2; + + if (height) + *height = logical_rect.height + ypad * 2; + + g_object_unref (layout); +} + +static void +sysprof_cell_renderer_progress_get_preferred_width (GtkCellRenderer *cell, + GtkWidget *widget, + int *minimum, + int *natural) +{ + SysprofCellRendererProgress *self = SYSPROF_CELL_RENDERER_PROGRESS (cell); + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (self); + int w, h; + int size; + + if (priv->min_w < 0) + { + char *text = g_strdup_printf (C_("progress bar label", "%d %%"), 100); + compute_dimensions (cell, widget, text, + &priv->min_w, + &priv->min_h); + g_free (text); + } + + compute_dimensions (cell, widget, priv->label, &w, &h); + + size = MAX (priv->min_w, w); + + if (minimum != NULL) + *minimum = size; + if (natural != NULL) + *natural = size; +} + +static void +sysprof_cell_renderer_progress_get_preferred_height (GtkCellRenderer *cell, + GtkWidget *widget, + int *minimum, + int *natural) +{ + SysprofCellRendererProgress *self = SYSPROF_CELL_RENDERER_PROGRESS (cell); + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (self); + int w, h; + int size; + + if (priv->min_w < 0) + { + char *text = g_strdup_printf (C_("progress bar label", "%d %%"), 100); + compute_dimensions (cell, widget, text, + &priv->min_w, + &priv->min_h); + g_free (text); + } + + compute_dimensions (cell, widget, priv->label, &w, &h); + + size = MIN (priv->min_h, h); + + if (minimum != NULL) + *minimum = size; + if (natural != NULL) + *natural = size; +} + +static inline int +get_bar_size (int pulse, + int value, + int full_size) +{ + int bar_size; + + if (pulse < 0) + bar_size = full_size * MAX (0, value) / 100; + else if (pulse == 0) + bar_size = 0; + else if (pulse == G_MAXINT) + bar_size = full_size; + else + bar_size = MAX (2, full_size / 5); + + return bar_size; +} + +static inline int +get_bar_position (int start, + int full_size, + int bar_size, + int pulse, + int offset, + gboolean is_rtl) +{ + int position; + + if (pulse < 0 || pulse == 0 || pulse == G_MAXINT) + { + position = is_rtl ? (start + full_size - bar_size) : start; + } + else + { + position = (is_rtl ? offset + 12 : offset) % 24; + if (position > 12) + position = 24 - position; + position = start + full_size * position / 15; + } + + return position; +} + +static void +sysprof_cell_renderer_progress_snapshot (GtkCellRenderer *cell, + GtkSnapshot *snapshot, + GtkWidget *widget, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, + GtkCellRendererState flags) +{ + SysprofCellRendererProgress *cellprogress = SYSPROF_CELL_RENDERER_PROGRESS (cell); + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + GtkStyleContext *context; + GtkBorder padding; + PangoLayout *layout; + PangoRectangle logical_rect; + int x, y, w, h, x_pos, y_pos, bar_position, bar_size, start, full_size; + int xpad, ypad; + GdkRectangle clip; + gboolean is_rtl; + + context = gtk_widget_get_style_context (widget); + is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL; + + gtk_cell_renderer_get_padding (cell, &xpad, &ypad); + x = cell_area->x + xpad; + y = cell_area->y + ypad; + w = cell_area->width - xpad * 2; + h = cell_area->height - ypad * 2; + + gtk_style_context_save (context); + gtk_style_context_add_class (context, "trough"); + + gtk_snapshot_render_background (snapshot, context, x, y, w, h); + gtk_snapshot_render_frame (snapshot, context, x, y, w, h); + + gtk_style_context_get_padding (context, &padding); + + x += padding.left; + y += padding.top; + w -= padding.left + padding.right; + h -= padding.top + padding.bottom; + + gtk_style_context_restore (context); + + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) + { + clip.y = y; + clip.height = h; + + start = x; + full_size = w; + + bar_size = get_bar_size (priv->pulse, priv->value, full_size); + + if (!priv->inverted) + bar_position = get_bar_position (start, full_size, bar_size, + priv->pulse, priv->offset, is_rtl); + else + bar_position = get_bar_position (start, full_size, bar_size, + priv->pulse, priv->offset, !is_rtl); + + clip.width = bar_size; + clip.x = bar_position; + } + else + { + clip.x = x; + clip.width = w; + + start = y; + full_size = h; + + bar_size = get_bar_size (priv->pulse, priv->value, full_size); + + if (priv->inverted) + bar_position = get_bar_position (start, full_size, bar_size, + priv->pulse, priv->offset, TRUE); + else + bar_position = get_bar_position (start, full_size, bar_size, + priv->pulse, priv->offset, FALSE); + + clip.height = bar_size; + clip.y = bar_position; + } + + if (bar_size > 0) + { + gtk_style_context_save (context); + gtk_style_context_add_class (context, "progressbar"); + + gtk_snapshot_render_background (snapshot, context, clip.x, clip.y, clip.width, clip.height); + gtk_snapshot_render_frame (snapshot, context, clip.x, clip.y, clip.width, clip.height); + + gtk_style_context_restore (context); + } + + if (priv->label) + { + float text_xalign; + + layout = gtk_widget_create_pango_layout (widget, priv->label); + pango_layout_get_pixel_extents (layout, NULL, &logical_rect); + + if (gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR) + text_xalign = 1.0 - priv->text_xalign; + else + text_xalign = priv->text_xalign; + + x_pos = x + padding.left + text_xalign * + (w - padding.left - padding.right - logical_rect.width); + + y_pos = y + padding.top + priv->text_yalign * + (h - padding.top - padding.bottom - logical_rect.height); + + gtk_snapshot_push_clip (snapshot, + &GRAPHENE_RECT_INIT( + clip.x, clip.y, + clip.width, clip.height + )); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, "progressbar"); + + gtk_snapshot_render_layout (snapshot, context, + x_pos, y_pos, + layout); + + gtk_style_context_restore (context); + gtk_snapshot_pop (snapshot); + + gtk_style_context_save (context); + gtk_style_context_add_class (context, "trough"); + + if (bar_position > start) + { + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) + { + clip.x = x; + clip.width = bar_position - x; + } + else + { + clip.y = y; + clip.height = bar_position - y; + } + + gtk_snapshot_push_clip (snapshot, + &GRAPHENE_RECT_INIT( + clip.x, clip.y, + clip.width, clip.height + )); + + gtk_snapshot_render_layout (snapshot, context, + x_pos, y_pos, + layout); + + gtk_snapshot_pop (snapshot); + } + + if (bar_position + bar_size < start + full_size) + { + if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) + { + clip.x = bar_position + bar_size; + clip.width = x + w - (bar_position + bar_size); + } + else + { + clip.y = bar_position + bar_size; + clip.height = y + h - (bar_position + bar_size); + } + + gtk_snapshot_push_clip (snapshot, + &GRAPHENE_RECT_INIT( + clip.x, clip.y, + clip.width, clip.height + )); + + gtk_snapshot_render_layout (snapshot, context, + x_pos, y_pos, + layout); + + gtk_snapshot_pop (snapshot); + } + + gtk_style_context_restore (context); + g_object_unref (layout); + } +} + +static void +sysprof_cell_renderer_progress_class_init (SysprofCellRendererProgressClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass); + + object_class->finalize = sysprof_cell_renderer_progress_finalize; + object_class->get_property = sysprof_cell_renderer_progress_get_property; + object_class->set_property = sysprof_cell_renderer_progress_set_property; + + cell_class->get_preferred_width = sysprof_cell_renderer_progress_get_preferred_width; + cell_class->get_preferred_height = sysprof_cell_renderer_progress_get_preferred_height; + cell_class->snapshot = sysprof_cell_renderer_progress_snapshot; + + /** + * SysprofCellRendererProgress:value: + * + * The "value" property determines the percentage to which the + * progress bar will be "filled in". + **/ + g_object_class_install_property (object_class, + PROP_VALUE, + g_param_spec_int ("value", + "Value", + "Value of the progress bar", + 0, 100, 0, + G_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); + + /** + * SysprofCellRendererProgress:text: + * + * The "text" property determines the label which will be drawn + * over the progress bar. Setting this property to %NULL causes the default + * label to be displayed. Setting this property to an empty string causes + * no label to be displayed. + **/ + g_object_class_install_property (object_class, + PROP_TEXT, + g_param_spec_string ("text", + "Text", + "Text on the progress bar", + NULL, + G_PARAM_READWRITE)); + + /** + * SysprofCellRendererProgress:pulse: + * + * Setting this to a non-negative value causes the cell renderer to + * enter "activity mode", where a block bounces back and forth to + * indicate that some progress is made, without specifying exactly how + * much. + * + * Each increment of the property causes the block to move by a little + * bit. + * + * To indicate that the activity has not started yet, set the property + * to zero. To indicate completion, set the property to %G_MAXINT. + */ + g_object_class_install_property (object_class, + PROP_PULSE, + g_param_spec_int ("pulse", + "Pulse", + "Set this to positive values to indicate that some progress is made, but you don’t know how much.", + -1, G_MAXINT, -1, + G_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); + + /** + * SysprofCellRendererProgress:text-xalign: + * + * The "text-xalign" property controls the horizontal alignment of the + * text in the progress bar. Valid values range from 0 (left) to 1 + * (right). Reserved for RTL layouts. + */ + g_object_class_install_property (object_class, + PROP_TEXT_XALIGN, + g_param_spec_float ("text-xalign", + "Text x alignment", + "The horizontal text alignment, from 0 (left) to 1 (right). Reversed for RTL layouts.", + 0.0, 1.0, 0.5, + G_PARAM_READWRITE)); + + /** + * SysprofCellRendererProgress:text-yalign: + * + * The "text-yalign" property controls the vertical alignment of the + * text in the progress bar. Valid values range from 0 (top) to 1 + * (bottom). + */ + g_object_class_install_property (object_class, + PROP_TEXT_YALIGN, + g_param_spec_float ("text-yalign", + "Text y alignment", + "The vertical text alignment, from 0 (top) to 1 (bottom).", + 0.0, 1.0, 0.5, + G_PARAM_READWRITE)); + + g_object_class_override_property (object_class, + PROP_ORIENTATION, + "orientation"); + + g_object_class_install_property (object_class, + PROP_INVERTED, + g_param_spec_boolean ("inverted", + "Inverted", + "Invert the direction in which the progress bar grows", + FALSE, + G_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); +} + +static void +sysprof_cell_renderer_progress_init (SysprofCellRendererProgress *cellprogress) +{ + SysprofCellRendererProgressPrivate *priv = sysprof_cell_renderer_progress_get_instance_private (cellprogress); + + priv->value = 0; + priv->text = NULL; + priv->label = NULL; + priv->min_w = -1; + priv->min_h = -1; + priv->pulse = -1; + priv->offset = 0; + + priv->text_xalign = 0.5; + priv->text_yalign = 0.5; + + priv->orientation = GTK_ORIENTATION_HORIZONTAL, + priv->inverted = FALSE; +} + +/** + * sysprof_cell_renderer_progress_new: + * + * Creates a new `SysprofCellRendererProgress`. + * + * Returns: the new cell renderer + **/ +GtkCellRenderer* +sysprof_cell_renderer_progress_new (void) +{ + return g_object_new (SYSPROF_TYPE_CELL_RENDERER_PROGRESS, NULL); +} diff --git a/src/libsysprof-ui/sysprof-cell-renderer-progress.h b/src/libsysprof-ui/sysprof-cell-renderer-progress.h new file mode 100644 index 00000000..7a006072 --- /dev/null +++ b/src/libsysprof-ui/sysprof-cell-renderer-progress.h @@ -0,0 +1,53 @@ +/* gtkcellrendererprogress.h + * Copyright (C) 2002 Naba Kumar + * modified by Jörgen Scheibengruber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library. If not, see . + */ + +/* + * Modified by the GTK+ Team and others 1997-2004. See the AUTHORS + * file for a list of people on the GTK+ Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + */ + +#pragma once + +#include + +G_BEGIN_DECLS + +#define SYSPROF_TYPE_CELL_RENDERER_PROGRESS (sysprof_cell_renderer_progress_get_type ()) +#define SYSPROF_CELL_RENDERER_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SYSPROF_TYPE_CELL_RENDERER_PROGRESS, SysprofCellRendererProgress)) +#define SYSPROF_IS_CELL_RENDERER_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SYSPROF_TYPE_CELL_RENDERER_PROGRESS)) + +typedef struct _SysprofCellRendererProgress SysprofCellRendererProgress; +typedef struct _SysprofCellRendererProgressClass SysprofCellRendererProgressClass; +typedef struct _SysprofCellRendererProgressPrivate SysprofCellRendererProgressPrivate; + +struct _SysprofCellRendererProgress +{ + GtkCellRenderer parent_instance; +}; + +struct _SysprofCellRendererProgressClass +{ + GtkCellRendererClass parent_class; +}; + +GType sysprof_cell_renderer_progress_get_type (void) G_GNUC_CONST; +GtkCellRenderer *sysprof_cell_renderer_progress_new (void); + +G_END_DECLS