static void
shell_search_renderer_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
ShellSearchRendererPrivate *priv = SHELL_SEARCH_RENDERER (cell)->priv;
PangoRectangle rect;
GtkStyleContext *context;
gint layout_height;
gint vcenter_offset;
context = gtk_widget_get_style_context (widget);
shell_search_renderer_set_layout (SHELL_SEARCH_RENDERER (cell), widget);
pango_layout_get_pixel_extents (priv->layout, NULL, &rect);
pango_layout_get_pixel_size (priv->layout, NULL, &layout_height);
vcenter_offset = (cell_area->height - layout_height) / 2;
cairo_save (cr);
gtk_render_layout (context, cr,
cell_area->x,
cell_area->y + vcenter_offset,
priv->layout);
cairo_restore (cr);
}
static gboolean fm_list_view_draw(GtkWidget* view_, cairo_t* cr, FMListView* view)
{
g_return_val_if_fail(FM_IS_LIST_VIEW(view), FALSE);
GOFDirectoryAsync *dir = fm_directory_view_get_current_directory (FM_DIRECTORY_VIEW (view));
if (gof_directory_async_is_empty (dir))
{
PangoLayout* layout = gtk_widget_create_pango_layout(GTK_WIDGET(view), NULL);
gchar *str = g_strconcat("<span size='x-large'>", _("This folder is empty."), "</span>", NULL);
pango_layout_set_markup (layout, str, -1);
PangoRectangle extents;
/* Get hayout height and width */
pango_layout_get_extents(layout, NULL, &extents);
gdouble width = pango_units_to_double(extents.width);
gdouble height = pango_units_to_double(extents.height);
gtk_render_layout(gtk_widget_get_style_context(GTK_WIDGET(view)), cr,
(double)gtk_widget_get_allocated_width(GTK_WIDGET(view))/2 - width/2,
(double)gtk_widget_get_allocated_height(GTK_WIDGET(view))/2 - height/2,
layout);
}
return FALSE;
}
static gboolean
gnm_notebook_button_draw (GtkWidget *widget, cairo_t *cr)
{
GnmNotebookButton *nbb = GNM_NOTEBOOK_BUTTON (widget);
GnmNotebook *nb = GNM_NOTEBOOK (gtk_widget_get_parent (widget));
GtkStyleContext *context = gtk_widget_get_style_context (widget);
gboolean is_active = (widget == gnm_notebook_get_current_label (nb));
GtkStateFlags state =
is_active ? GTK_STATE_FLAG_ACTIVE : GTK_STATE_FLAG_NORMAL;
GtkBorder padding;
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
gtk_style_context_get_padding (context, state, &padding);
gnm_notebook_button_ensure_layout (nbb);
gtk_render_layout (context, cr,
padding.left + (is_active ? nbb->x_offset_active : nbb->x_offset),
0,
is_active ? nbb->layout_active : nbb->layout);
gtk_style_context_restore (context);
return FALSE;
}
void LeftMargin::drawMarginLineNum(GtkTextView *textView, cairo_t *cr, int lineNum, int yPos)
{
GtkWidget *widget = GTK_WIDGET(textView);
if(mMarginLayout)
{
char str[8];
snprintf(str, sizeof(str), "%d", lineNum);
pango_layout_set_text(mMarginLayout, str, -1);
gtk_render_layout(gtk_widget_get_style_context(widget), cr,
mTextWidth, yPos, mMarginLayout);
}
}
static void
draw_text (GtkWidget *widget,
cairo_t *cr,
gint x,
gint y,
gint width,
gint height,
const gchar *text,
GtkStateFlags state)
{
GtkStyleContext *label_context;
GtkStyleContext *selection_context;
GtkStyleContext *context;
PangoLayout *layout;
/* This information is taken from the GtkLabel docs, see "CSS nodes" */
const char *path[2] = {
"label.view",
"selection"
};
label_context = get_style (NULL, path[0]);
selection_context = get_style (label_context, path[1]);
gtk_style_context_set_state (label_context, state);
if (state & GTK_STATE_FLAG_SELECTED)
context = selection_context;
else
context = label_context;
layout = gtk_widget_create_pango_layout (widget, text);
gtk_render_background (context, cr, x, y, width, height);
gtk_render_frame (context, cr, x, y, width, height);
gtk_render_layout (context, cr, x, y, layout);
g_object_unref (layout);
g_object_unref (selection_context);
g_object_unref (label_context);
}
static gboolean
label_draw(GtkWidget *label, cairo_t *cr, gpointer data)
{
UIMCandWinHorizontalGtk *horizontal_cwin = data;
struct index_button *selected;
GtkWidget *selected_label = NULL;
GdkRGBA *bg_color, *fg_color;
GtkStyleContext *context;
PangoLayout *layout;
gint x, y;
GtkStateFlags state;
selected = horizontal_cwin->selected;
if (selected)
selected_label = gtk_bin_get_child(GTK_BIN(selected->button));
layout = gtk_label_get_layout(GTK_LABEL(label));
gtk_label_get_layout_offsets(GTK_LABEL(label), &x, &y);
context = gtk_widget_get_style_context(label);
if (label == selected_label)
state = GTK_STATE_FLAG_SELECTED;
else
state = GTK_STATE_FLAG_NORMAL;
gtk_style_context_get (context, state, "background-color", &bg_color, "color", &fg_color, NULL);
cairo_save(cr);
gdk_cairo_set_source_rgba(cr, bg_color);
cairo_paint(cr);
cairo_restore(cr);
gdk_rgba_free(bg_color);
gdk_rgba_free(fg_color);
gtk_style_context_set_state (context, state);
gtk_render_layout (context, cr, x, y, layout);
return FALSE;
}
static void internal_text_render(GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
guint flags)
{
CustomCellRendererFlexi *cellflexi = CUSTOM_CELL_RENDERER_FLEXI (cell);
PangoLayout *layout;
gint width, height;
gint x_offset, y_offset;
gint xpad;
gint ypad;
UNUSED(background_area);
UNUSED(flags);
layout = internal_text_create_layout(widget,cellflexi);
g_assert(layout!=NULL);
internal_text_get_size_layout (cell, widget, layout,
cell_area,
&x_offset, &y_offset,
&width, &height);
gtk_cell_renderer_get_padding(cell,&xpad,&ypad);
width -= xpad*2;
height -= ypad*2;
gtk_render_layout(gtk_widget_get_style_context(widget),
cr,
cell_area->x + x_offset + xpad,
cell_area->y + y_offset + ypad,
layout);
g_object_unref(layout);
}
static gboolean rc_ui_scrollable_label_draw(GtkWidget *widget, cairo_t *cr)
{
RCUiScrollableLabel *label;
RCUiScrollableLabelPrivate *priv;
GtkAllocation allocation;
gint width, height;
GtkStyleContext *style_context;
g_return_val_if_fail(widget!=NULL || cr!=NULL, FALSE);
g_return_val_if_fail(RC_UI_IS_SCROLLABLE_LABEL(widget), FALSE);
label = RC_UI_SCROLLABLE_LABEL(widget);
priv = label->priv;
style_context = gtk_widget_get_style_context(widget);
pango_layout_get_pixel_size(priv->layout, &width, &height);
gtk_widget_get_allocation(widget, &allocation);
if(width > allocation.width)
priv->current_x = (gint)((gdouble)(allocation.width -
width) * priv->percent);
else
priv->current_x = 0;
gtk_render_layout(style_context, cr, priv->current_x,
(allocation.height - height) / 2, priv->layout);
return TRUE;
}
static void
draw(GtkWidget *widget, cairo_t *cr, gpointer data)
{
CalibArea *calib_area = (CalibArea*)data;
int i;
double x;
double y;
PangoLayout *layout;
PangoRectangle logical_rect;
GtkStyleContext *context;
char *markup;
resize_display(calib_area);
context = gtk_widget_get_style_context (widget);
/* Black background and reset the operator */
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
/* If calibration is successful, just draw the tick */
if (calib_area->icon_success) {
draw_success_icon (calib_area, cr);
return;
}
/* Print the help lines */
layout = pango_layout_new (gtk_widget_get_pango_context (widget));
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
markup = g_strdup_printf ("<span foreground=\"white\"><big><b>%s</b></big>\n<big>%s</big></span>",
_(HELP_TEXT_TITLE),
_(HELP_TEXT_MAIN));
pango_layout_set_markup (layout, markup, -1);
g_free (markup);
pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
x = (calib_area->display_width - logical_rect.width) / 2 + logical_rect.x;
y = (calib_area->display_height - logical_rect.height) / 2 - logical_rect.height - 40 + logical_rect.y;
gtk_render_layout (context, cr,
x + logical_rect.x,
y + logical_rect.y,
layout);
g_object_unref (layout);
/* Draw the points */
cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
i = calib_area->calibrator.num_clicks;
cairo_set_line_width(cr, 1);
cairo_move_to(cr, calib_area->X[i] - CROSS_LINES, calib_area->Y[i] - 0.5);
cairo_rel_line_to(cr, CROSS_LINES*2, 0);
cairo_move_to(cr, calib_area->X[i] - 0.5, calib_area->Y[i] - CROSS_LINES);
cairo_rel_line_to(cr, 0, CROSS_LINES*2);
cairo_stroke(cr);
cairo_set_line_width(cr, 2);
cairo_arc(cr, calib_area->X[i] - 0.5, calib_area->Y[i] - 0.5, CROSS_CIRCLE, 0.0, 2.0 * M_PI);
cairo_stroke(cr);
cairo_set_line_width(cr, 5);
cairo_arc(cr, calib_area->X[i] - 0.5, calib_area->Y[i] - 0.5, CROSS_CIRCLE2, 0.0, 2.0 * M_PI);
cairo_stroke(cr);
/* Draw the clock background */
cairo_arc(cr, calib_area->display_width/2, calib_area->display_height/2, CLOCK_RADIUS/2, 0.0, 2.0 * M_PI);
cairo_set_source_rgb(cr, 0.5, 0.5, 0.5);
cairo_fill_preserve(cr);
cairo_stroke(cr);
cairo_set_line_width(cr, CLOCK_LINE_WIDTH);
cairo_arc(cr, calib_area->display_width/2, calib_area->display_height/2, (CLOCK_RADIUS - CLOCK_LINE_WIDTH - CLOCK_LINE_PADDING)/2,
3/2.0*M_PI, (3/2.0*M_PI) + ((double)calib_area->time_elapsed/(double)MAX_TIME) * 2*M_PI);
cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
cairo_stroke(cr);
/* Draw the message (if any) */
if (calib_area->message != NULL)
{
cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
/* Frame the message */
layout = pango_layout_new (gtk_widget_get_pango_context (widget));
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
markup = g_strdup_printf ("<span foreground=\"white\"><big>%s</big></span>",
_(calib_area->message));
pango_layout_set_markup (layout, markup, -1);
g_free (markup);
pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
x = (calib_area->display_width - logical_rect.width) / 2 + logical_rect.x;
y = (calib_area->display_height - logical_rect.height + CLOCK_RADIUS) / 2 + 60 + logical_rect.y;
cairo_set_line_width(cr, 2);
cairo_rectangle(cr, x - 10 - 0.5 , y - 10 - 0.5,
logical_rect.width + 20 + 1, logical_rect.height + 20 + 1);
cairo_stroke (cr);
/* Print the message */
gtk_render_layout (context, cr,
x + logical_rect.x,
y + logical_rect.y,
layout);
g_object_unref (layout);
}
}
static void
gutter_renderer_text_draw (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
GtkSourceGutterRendererText *text = GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer);
gint width;
gint height;
PangoAttrList *attr_list;
gfloat xalign;
gfloat yalign;
GtkSourceGutterRendererAlignmentMode mode;
GtkTextView *view;
gint x = 0;
gint y = 0;
GtkStyleContext *context;
/* Chain up to draw background */
if (GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->draw != NULL)
{
GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->draw (renderer,
cr,
background_area,
cell_area,
start,
end,
state);
}
view = gtk_source_gutter_renderer_get_view (renderer);
if (text->priv->is_markup)
{
pango_layout_set_markup (text->priv->cached_layout,
text->priv->text,
-1);
}
else
{
pango_layout_set_text (text->priv->cached_layout,
text->priv->text,
-1);
}
attr_list = pango_layout_get_attributes (text->priv->cached_layout);
if (!attr_list)
{
pango_layout_set_attributes (text->priv->cached_layout,
pango_attr_list_copy (text->priv->cached_attr_list));
}
else
{
pango_attr_list_insert (attr_list,
pango_attribute_copy (text->priv->fg_attr));
}
pango_layout_get_pixel_size (text->priv->cached_layout, &width, &height);
gtk_source_gutter_renderer_get_alignment (renderer,
&xalign,
&yalign);
mode = gtk_source_gutter_renderer_get_alignment_mode (renderer);
switch (mode)
{
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL:
x = cell_area->x + (cell_area->width - width) * xalign;
y = cell_area->y + (cell_area->height - height) * yalign;
break;
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST:
center_on (renderer,
cell_area,
start,
width,
height,
xalign,
yalign,
&x,
&y);
break;
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST:
center_on (renderer,
cell_area,
end,
width,
height,
xalign,
yalign,
&x,
&y);
break;
}
context = gtk_widget_get_style_context (GTK_WIDGET (view));
gtk_render_layout (context, cr, x, y, text->priv->cached_layout);
}
static gboolean
gtk_switch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
GtkStyleContext *context;
GdkRectangle handle;
PangoLayout *layout;
PangoRectangle rect;
gint label_x, label_y;
GtkBorder padding;
GtkStateFlags state;
gint x, y, width, height;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
gtk_style_context_get_padding (context, state, &padding);
gtk_style_context_restore (context);
x = 0;
y = 0;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TROUGH);
gtk_render_background (context, cr, x, y, width, height);
gtk_render_frame (context, cr, x, y, width, height);
width -= padding.left + padding.right;
height -= padding.top + padding.bottom;
x += padding.left;
y += padding.top;
handle.y = y;
handle.width = width / 2;
handle.height = height;
/* Translators: if the "on" state label requires more than three
* glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for
* the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON"));
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + ((width / 2) - rect.width) / 2;
label_y = y + (height - rect.height) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
/* Translators: if the "off" state label requires more than three
* glyphs then use WHITE CIRCLE (U+25CB) as the text for the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "OFF"));
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + (width / 2) + ((width / 2) - rect.width) / 2;
label_y = y + (height - rect.height) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
if (priv->is_dragging)
handle.x = x + priv->handle_x;
else if (priv->is_active)
handle.x = x + width - handle.width;
else
handle.x = x;
gtk_style_context_restore (context);
gtk_switch_paint_handle (widget, cr, &handle);
if (gtk_widget_has_visible_focus (widget))
{
gint focus_width, focus_pad, pad;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
pad = focus_pad + focus_width;
gtk_render_focus (context, cr,
handle.x + pad, handle.y + pad,
handle.width - pad*2, handle.height - pad*2);
}
return FALSE;
}
static void
gd_two_lines_renderer_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell);
GtkStyleContext *context;
gint line_one_height;
GtkStateFlags state;
GdkRectangle area, render_area = *cell_area;
gint xpad, ypad, x_offset_1, x_offset_2, y_offset;
PangoLayout *layout_one, *layout_two;
PangoRectangle layout_rect;
/* fetch common information */
context = gtk_widget_get_style_context (widget);
gd_two_lines_renderer_prepare_layouts (self, cell_area, widget, &layout_one, &layout_two);
gd_two_lines_renderer_get_size (cell, widget,
layout_one, layout_two,
NULL, NULL,
cell_area,
&x_offset_1, &x_offset_2, &y_offset);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
area = *cell_area;
area.x += xpad;
area.y += ypad;
/* now render the first layout */
pango_layout_get_pixel_extents (layout_one, NULL, &layout_rect);
render_area = area;
render_area.x += x_offset_1 - layout_rect.x;
gtk_render_layout (context, cr,
render_area.x,
render_area.y,
layout_one);
/* render the second layout */
if (layout_two != NULL)
{
pango_layout_get_pixel_size (layout_one,
NULL, &line_one_height);
gtk_style_context_save (context);
apply_subtitle_style_to_layout (context, layout_two, flags);
state = gtk_cell_renderer_get_state (cell, widget, flags);
gtk_style_context_set_state (context, state);
pango_layout_get_pixel_extents (layout_two, NULL, &layout_rect);
render_area = area;
render_area.x += x_offset_2 - layout_rect.x;
render_area.y += line_one_height;
gtk_render_layout (context, cr,
render_area.x,
render_area.y,
layout_two);
gtk_style_context_restore (context);
}
g_clear_object (&layout_one);
g_clear_object (&layout_two);
}
static void fm_cell_renderer_text_render(GtkCellRenderer *cell,
GdkDrawable *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags)
#endif
{
FmCellRendererText *self = FM_CELL_RENDERER_TEXT(cell);
#if GTK_CHECK_VERSION(3, 0, 0)
GtkStyleContext* style;
GtkStateFlags state;
#else
GtkStyle* style;
GtkStateType state;
#endif
gchar* text;
gint text_width;
gint text_height;
gint x_offset;
gint y_offset;
gint x_align_offset;
GdkRectangle rect;
PangoWrapMode wrap_mode;
gint wrap_width;
PangoAlignment alignment;
gfloat xalign, yalign;
gint xpad, ypad;
/* FIXME: this is time-consuming since it invokes pango_layout.
* if we want to fix this, we must implement the whole cell
* renderer ourselves instead of derived from GtkCellRendererText. */
PangoContext* context = gtk_widget_get_pango_context(widget);
PangoLayout* layout = pango_layout_new(context);
g_object_get(G_OBJECT(cell),
"wrap-mode" , &wrap_mode,
"wrap-width", &wrap_width,
"alignment" , &alignment,
"text", &text,
NULL);
pango_layout_set_alignment(layout, alignment);
/* Setup the wrapping. */
if (wrap_width < 0)
{
pango_layout_set_width(layout, -1);
pango_layout_set_wrap(layout, PANGO_WRAP_CHAR);
}
else
{
pango_layout_set_width(layout, wrap_width * PANGO_SCALE);
pango_layout_set_wrap(layout, wrap_mode);
if(self->height > 0)
{
/* FIXME: add custom ellipsize from object? */
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
pango_layout_set_height(layout, self->height * PANGO_SCALE);
}
else
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
}
pango_layout_set_text(layout, text, -1);
pango_layout_set_auto_dir(layout, TRUE);
pango_layout_get_pixel_size(layout, &text_width, &text_height);
gtk_cell_renderer_get_alignment(cell, &xalign, &yalign);
gtk_cell_renderer_get_padding(cell, &xpad, &ypad);
/* Calculate the real x and y offsets. */
x_offset = ((gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL) ? (1.0 - xalign) : xalign)
* (cell_area->width - text_width - (2 * xpad));
x_offset = MAX(x_offset, 0);
y_offset = yalign * (cell_area->height - text_height - (2 * ypad));
y_offset = MAX (y_offset, 0);
if(flags & (GTK_CELL_RENDERER_SELECTED|GTK_CELL_RENDERER_FOCUSED))
{
rect.x = cell_area->x + x_offset;
rect.y = cell_area->y + y_offset;
rect.width = text_width + (2 * xpad);
rect.height = text_height + (2 * ypad);
}
#if GTK_CHECK_VERSION(3, 0, 0)
style = gtk_widget_get_style_context(widget);
#else
style = gtk_widget_get_style(widget);
#endif
if(flags & GTK_CELL_RENDERER_SELECTED) /* item is selected */
{
#if GTK_CHECK_VERSION(3, 0, 0)
GdkRGBA clr;
if(flags & GTK_CELL_RENDERER_INSENSITIVE) /* insensitive */
state = GTK_STATE_FLAG_INSENSITIVE;
else
state = GTK_STATE_FLAG_SELECTED;
gtk_style_context_get_background_color(style, state, &clr);
gdk_cairo_rectangle(cr, &rect);
gdk_cairo_set_source_rgba(cr, &clr);
#else
cairo_t *cr = gdk_cairo_create (window);
GdkColor clr;
if(flags & GTK_CELL_RENDERER_INSENSITIVE) /* insensitive */
state = GTK_STATE_INSENSITIVE;
else
state = GTK_STATE_SELECTED;
clr = style->bg[state];
/* paint the background */
if(expose_area)
{
gdk_cairo_rectangle(cr, expose_area);
cairo_clip(cr);
}
gdk_cairo_rectangle(cr, &rect);
cairo_set_source_rgb(cr, clr.red / 65535., clr.green / 65535., clr.blue / 65535.);
#endif
cairo_fill (cr);
#if !GTK_CHECK_VERSION(3, 0, 0)
cairo_destroy (cr);
#endif
}
#if !GTK_CHECK_VERSION(3, 0, 0)
else
state = GTK_STATE_NORMAL;
#endif
x_align_offset = (alignment == PANGO_ALIGN_CENTER) ? (wrap_width - text_width) / 2 : 0;
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_render_layout(style, cr,
cell_area->x + x_offset + xpad - x_align_offset,
cell_area->y + y_offset + ypad, layout);
#else
gtk_paint_layout(style, window, state, TRUE,
expose_area, widget, "cellrenderertext",
cell_area->x + x_offset + xpad - x_align_offset,
cell_area->y + y_offset + ypad, layout);
#endif
g_object_unref(layout);
if(G_UNLIKELY( flags & GTK_CELL_RENDERER_FOCUSED) ) /* focused */
{
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_render_focus(style, cr, rect.x, rect.y, rect.width, rect.height);
#else
gtk_paint_focus(style, window, state, background_area,
widget, "cellrenderertext", rect.x, rect.y,
rect.width, rect.height);
#endif
}
if(flags & GTK_CELL_RENDERER_PRELIT) /* hovered */
g_object_set(G_OBJECT(widget), "tooltip-text", text, NULL);
else
g_object_set(G_OBJECT(widget), "tooltip-text", NULL, NULL);
g_free(text);
}
static void
freetuxtv_cellrenderer_channelslist_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
guint flags)
#endif
{
FreetuxTVCellRendererChannelsList *self = FREETUXTV_CELLRENDERER_CHANNELSLIST (cell);
gint width, height;
PangoLayout *layout;
gboolean is_selected = FALSE;
gboolean is_playing = FALSE;
if ((flags & GTK_CELL_RENDERER_SELECTED) != 0){
is_selected = TRUE;
}
if(self->type == CELLRENDERER_TYPE_CHANNEL){
if(self->is_playing){
is_playing = TRUE;
}
}
#if GTK_API_VERSION == 3
// Set the cell state
GtkStateFlags state = GTK_STATE_FLAG_NORMAL;
if(is_selected){
if(self->type == CELLRENDERER_TYPE_CHANNEL){
state = GTK_STATE_FLAG_SELECTED;
}else{
state = GTK_STATE_FLAG_ACTIVE;
}
}
// Define the style of the row.
GtkStyleContext *pStyleContext;
pStyleContext = gtk_widget_get_style_context (GTK_WIDGET(widget));
gtk_style_context_save(pStyleContext);
gtk_style_context_set_state(pStyleContext, state);
if(self->type == CELLRENDERER_TYPE_CHANNEL){
gtk_style_context_add_class (pStyleContext, GTK_STYLE_CLASS_CELL);
}else{
gtk_style_context_add_class (pStyleContext, GTK_STYLE_CLASS_BUTTON);
}
freetuxtv_cellrenderer_channelslist_get_preferred_width(cell, widget, NULL, &width);
freetuxtv_cellrenderer_channelslist_get_preferred_height_for_width(cell, widget, width, NULL, &height);
#else
GtkStyle* pStyle;
pStyle = widget->style;
GtkStateType state;
state = GTK_STATE_NORMAL;
if(is_selected){
state = GTK_STATE_SELECTED;
}
freetuxtv_cellrenderer_channelslist_get_size (cell, widget, cell_area,
NULL, NULL,
&width, &height);
#endif
// Build the layout
layout = gtk_widget_create_pango_layout (widget, self->name);
//pango_layout_set_width(layout, 700);
//pango_layout_set_height(layout, 20);
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
if(is_playing){
PangoFontDescription *desc;
desc = pango_font_description_new();
pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_style (desc, PANGO_STYLE_ITALIC);
pango_layout_set_font_description (layout, desc);
pango_font_description_free(desc);
}
// gtk_paint_flat_box (widget->style, window, GTK_STATE_SELECTED,
// GTK_SHADOW_NONE , NULL, widget,
// NULL,
// 0, cell_area->y,
// cell_area->x + width, cell_area->height);
// gtk_paint_hline (widget->style, window, state,
// NULL, widget, NULL,
// 0, widget->allocation.width, cell_area->y);
// gtk_paint_hline (widget->style, window, state,
// NULL, widget, NULL,
// cell_area->x, cell_area->width, cell_area->y + 2);
// gtk_paint_hline (widget->style, window, state,
// NULL, widget, NULL,
// 0, 176, cell_area->y + 3);
GdkPixbuf* logo;
// If the cell contain a channel
if(self->type == CELLRENDERER_TYPE_CHANNEL){
// Backgroung of the cell
#if GTK_API_VERSION == 3
gtk_style_context_set_state (pStyleContext, state);
// gtk_style_context_set_background (pStyleContext, window); // This block the main loop
gtk_render_background (pStyleContext, cr,
0, cell_area->y,
cell_area->x + width, cell_area->height);
gtk_render_frame (pStyleContext, cr, 0, cell_area->y, cell_area->x + width, cell_area->height);
#else
if(state != GTK_STATE_NORMAL){
// gtk_style_set_background (pStyle, window, state); // This block the main loop
gtk_style_apply_default_background (pStyle, window, TRUE, state, NULL,
0, cell_area->y, cell_area->x + width, cell_area->height);
}
#endif
//static int count = 0;
//count++;
//g_print("cell(%d) : %d %d\n", count, cell_area->x, width);
// Display the logo and text of the cell
logo = gdk_pixbuf_new_from_file(self->logo, NULL);
int cell_xpad;
int cell_ypad;
#if GTK_API_VERSION == 3
gtk_cell_renderer_get_padding (cell, &cell_xpad, &cell_ypad);
// Render the logo
gdk_cairo_set_source_pixbuf(cr, logo,
(double)cell_xpad + 1.0, cell_area->y + (double)cell_ypad + 1.0);
cairo_paint(cr);
// Render the channel name
gtk_render_layout (pStyleContext, cr,
cell_xpad * 2 + gdk_pixbuf_get_width(logo) + 5,
cell_area->y + 15,
layout);
#else
cell_xpad = cell->xpad;
cell_ypad = cell->ypad;
// Render the logo
gdk_draw_pixbuf (GDK_DRAWABLE(window), NULL, logo,
0, 0, cell_xpad + 1, cell_area->y + cell_ypad + 1,
-1, -1,
GDK_RGB_DITHER_NONE, 0,0);
// Render the channel name
gtk_paint_layout (widget->style, window, state,
TRUE, NULL, widget, NULL,
cell->xpad * 2 + gdk_pixbuf_get_width(logo) + 5, cell_area->y + 15,
layout);
#endif
if(logo){
g_object_unref(logo);
logo = NULL;
}
}
// If the cell contain a group
if(self->type == CELLRENDERER_TYPE_CHANNELS_GROUP){
#if GTK_API_VERSION == 3
int x = background_area->x;
int y = background_area->y;
width = background_area->width;
height = background_area->height;
// Background of the cell
gtk_render_background (pStyleContext, cr,
x, y, width, height);
gtk_render_frame (pStyleContext, cr,
x, y, width, height);
//g_print("cell_bg %s : x=%d, y=%d\n", self->name, background_area->x, background_area->y);
//g_print("cell %s : x=%d, y=%d, w=%d, h=%d\n", self->name, x, y, width, height);
// Render the group name
gtk_render_layout (pStyleContext, cr,
cell_area->x, cell_area->y + 3,
layout);
#else
// Background of the cell
gtk_style_apply_default_background (widget->style, window, TRUE,
state, NULL,
0, cell_area->y, cell_area->x + width, cell_area->height);
// Render the group name
gtk_paint_layout (widget->style, window, state,
TRUE, NULL, widget, NULL,
cell_area->x, cell_area->y + 3, layout);
#endif
}
#if GTK_API_VERSION == 3
gtk_style_context_restore(pStyleContext);
#endif
}
static void
gd_two_lines_renderer_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell);
GtkStyleContext *context;
gint line_one_height;
GtkStateFlags state;
GdkRectangle render_area = *cell_area;
gint xpad, ypad, x_offset_1, x_offset_2, y_offset;
PangoLayout *layout_one, *layout_two;
context = gtk_widget_get_style_context (widget);
gd_two_lines_renderer_prepare_layouts (self, widget, &layout_one, &layout_two);
gd_two_lines_renderer_get_size (cell, widget,
layout_one, layout_two,
NULL, NULL,
cell_area,
&x_offset_1, &x_offset_2, &y_offset);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
render_area.x += xpad + x_offset_1;
render_area.y += ypad;
pango_layout_set_width (layout_one,
(cell_area->width - x_offset_1 - 2 * xpad) * PANGO_SCALE);
gtk_render_layout (context, cr,
render_area.x,
render_area.y,
layout_one);
if (layout_two != NULL)
{
pango_layout_get_pixel_size (layout_one,
NULL, &line_one_height);
gtk_style_context_save (context);
gtk_style_context_add_class (context, "dim-label");
state = gtk_cell_renderer_get_state (cell, widget, flags);
gtk_style_context_set_state (context, state);
render_area.x += - x_offset_1 + x_offset_2;
render_area.y += line_one_height;
pango_layout_set_width (layout_two,
(cell_area->width - x_offset_2 - 2 * xpad) * PANGO_SCALE);
gtk_render_layout (context, cr,
render_area.x,
render_area.y,
layout_two);
gtk_style_context_restore (context);
}
g_clear_object (&layout_one);
g_clear_object (&layout_two);
}
static void
gd_tagged_entry_tag_draw (GdTaggedEntryTag *tag,
cairo_t *cr,
GdTaggedEntry *entry)
{
GtkStyleContext *context;
GtkStateFlags state;
GtkAllocation background_allocation, layout_allocation, button_allocation;
context = gd_tagged_entry_tag_get_context (tag, entry);
gd_tagged_entry_tag_get_relative_allocations (tag, entry, context,
&background_allocation,
&layout_allocation,
&button_allocation);
cairo_save (cr);
gtk_cairo_transform_to_window (cr, GTK_WIDGET (entry), tag->window);
gtk_style_context_save (context);
state = gd_tagged_entry_tag_get_state (tag, entry);
gtk_style_context_set_state (context, state);
gtk_render_background (context, cr,
background_allocation.x, background_allocation.y,
background_allocation.width, background_allocation.height);
gtk_render_frame (context, cr,
background_allocation.x, background_allocation.y,
background_allocation.width, background_allocation.height);
gtk_render_layout (context, cr,
layout_allocation.x, layout_allocation.y,
tag->layout);
gtk_style_context_restore (context);
if (!entry->button_visible || !tag->has_close_button)
goto done;
gtk_style_context_add_class (context, GTK_STYLE_CLASS_BUTTON);
state = gd_tagged_entry_tag_get_button_state (tag, entry);
gtk_style_context_set_state (context, state);
/* if the state changed since last time we draw the pixbuf,
* clear and redraw it.
*/
if (state != tag->last_button_state)
{
g_clear_pointer (&tag->close_surface, cairo_surface_destroy);
gd_tagged_entry_tag_ensure_close_surface (tag, context);
tag->last_button_state = state;
}
gtk_render_background (context, cr,
button_allocation.x, button_allocation.y,
button_allocation.width, button_allocation.height);
gtk_render_frame (context, cr,
button_allocation.x, button_allocation.y,
button_allocation.width, button_allocation.height);
gtk_render_icon_surface (context, cr,
tag->close_surface,
button_allocation.x, button_allocation.y);
done:
cairo_restore (cr);
g_object_unref (context);
}
static void
marlin_text_renderer_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
MarlinTextRenderer *text_renderer = MARLIN_TEXT_RENDERER (cell);
GtkStyleContext *context;
GtkStateFlags state;
gint x0, x1, y0, y1;
gint text_width;
gint text_height;
gint x_offset;
gint y_offset;
gint xpad, ypad;
gfloat xalign, yalign;
gboolean selected;
/* setup the new widget */
marlin_text_renderer_set_widget (text_renderer, widget);
state = gtk_widget_get_state_flags (widget);
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
state |= GTK_STATE_FLAG_SELECTED;
}
else if ((flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT
&& gtk_widget_get_state (widget) == GTK_STATE_PRELIGHT)
{
state = GTK_STATE_PRELIGHT;
}
else
{
state = gtk_widget_get_sensitive (widget) ? GTK_STATE_FLAG_NORMAL : GTK_STATE_INSENSITIVE;
}
/* render small/normal text depending on the zoom_level */
if (text_renderer->zoom_level < MARLIN_ZOOM_LEVEL_NORMAL)
{
if (text_renderer->follow_prelit && (flags & GTK_CELL_RENDERER_PRELIT) != 0)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small_underline_single ());
else
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_small ());
} else {
if (text_renderer->follow_prelit && (flags & GTK_CELL_RENDERER_PRELIT) != 0)
pango_layout_set_attributes (text_renderer->layout, eel_pango_attr_list_underline_single ());
else
pango_layout_set_attributes (text_renderer->layout, NULL);
}
/* setup the wrapping */
if (text_renderer->wrap_width < 0)
{
pango_layout_set_width (text_renderer->layout, -1);
pango_layout_set_wrap (text_renderer->layout, PANGO_WRAP_CHAR);
}
else
{
pango_layout_set_width (text_renderer->layout, text_renderer->wrap_width * PANGO_SCALE);
pango_layout_set_wrap (text_renderer->layout, text_renderer->wrap_mode);
}
/* ellipsize to max lines except for selected or prelit items */
pango_layout_set_ellipsize (text_renderer->layout, PANGO_ELLIPSIZE_END);
pango_layout_set_height (text_renderer->layout, -3);
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED ||
(flags & GTK_CELL_RENDERER_PRELIT) == GTK_CELL_RENDERER_PRELIT) {
pango_layout_set_ellipsize (text_renderer->layout, PANGO_ELLIPSIZE_NONE);
}
gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
if (xalign == 0.5f)
pango_layout_set_alignment (text_renderer->layout, PANGO_ALIGN_CENTER);
pango_layout_set_text (text_renderer->layout, text_renderer->text, -1);
/* calculate the real text dimension */
pango_layout_get_pixel_size (text_renderer->layout, &text_width, &text_height);
/* take into account the state indicator (required for calculation) */
if (text_renderer->follow_state)
{
text_width += 2 * text_renderer->focus_width;
text_height += 2 * text_renderer->focus_width;
}
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
/* calculate the real x-offset */
x_offset = ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ? (1.0 - xalign) : xalign)
* (cell_area->width - text_width - (2 * xpad));
x_offset = MAX (x_offset, 0);
/* calculate the real y-offset */
y_offset = yalign * (cell_area->height - text_height - (2 * ypad));
y_offset = MAX (y_offset, 0);
context = gtk_widget_get_style_context (gtk_widget_get_parent (widget));
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
selected = ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED && text_renderer->follow_state);
/* render the state indicator */
if (selected || text_renderer->background != NULL)
{
/* calculate the text bounding box (including the focus padding/width) */
x0 = cell_area->x + x_offset;
y0 = cell_area->y + y_offset;
x1 = x0 + text_width;
y1 = y0 + text_height;
cairo_move_to (cr, x0 + 5, y0);
cairo_line_to (cr, x1 - 5, y0);
cairo_curve_to (cr, x1 - 5, y0, x1, y0, x1, y0 + 5);
cairo_line_to (cr, x1, y1 - 5);
cairo_curve_to (cr, x1, y1 - 5, x1, y1, x1 - 5, y1);
cairo_line_to (cr, x0 + 5, y1);
cairo_curve_to (cr, x0 + 5, y1, x0, y1, x0, y1 - 5);
cairo_line_to (cr, x0, y0 + 5);
cairo_curve_to (cr, x0, y0 + 5, x0, y0, x0 + 5, y0);
GdkRGBA color;
if(text_renderer->background != NULL && !selected)
{
if(!gdk_rgba_parse(&color, text_renderer->background))
{
g_critical("Can't parse this color value: %s", text_renderer->background);
gtk_style_context_get_background_color (context, state, &color);
}
}
else
{
gtk_style_context_get_background_color (context, state, &color);
}
gdk_cairo_set_source_rgba (cr, &color);
cairo_fill (cr);
}
/* draw the focus indicator */
if (text_renderer->follow_state && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
{
gtk_render_focus (context, cr, cell_area->x + x_offset, cell_area->y + y_offset, text_width, text_height);
}
/* get proper sizing for the layout drawing */
if (text_renderer->follow_state)
{
text_width -= 2 * text_renderer->focus_width;
text_height -= 2 * text_renderer->focus_width;
x_offset += text_renderer->focus_width;
y_offset += text_renderer->focus_width;
}
/* draw the text */
if (xalign == 0.5f)
x_offset = (cell_area->width - text_renderer->wrap_width)/2;
gtk_render_layout (context, cr,
cell_area->x + x_offset + xpad,
cell_area->y + y_offset + ypad,
text_renderer->layout);
gtk_style_context_restore (context);
}
static gboolean
gtk_switch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
GtkStyleContext *context;
GdkRectangle handle;
PangoLayout *layout;
PangoRectangle rect;
gint label_x, label_y;
GtkStateFlags state;
GtkBorder padding;
gint focus_width, focus_pad;
gint x, y, width, height;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
if (priv->is_active)
state |= GTK_STATE_FLAG_ACTIVE;
gtk_style_context_get_padding (context, state, &padding);
x = 0;
y = 0;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
if (gtk_widget_has_focus (widget))
gtk_render_focus (context, cr, x, y, width, height);
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
x += focus_width + focus_pad;
y += focus_width + focus_pad;
width -= 2 * (focus_width + focus_pad);
height -= 2 * (focus_width + focus_pad);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TROUGH);
gtk_render_background (context, cr, x, y, width, height);
gtk_render_frame (context, cr, x, y, width, height);
/* XXX the +1/-1 it's pixel wriggling after checking with the default
* theme and xmag
*/
handle.y = y + padding.top + 1;
handle.width = (width - padding.left - padding.right) / 2;
handle.height = (height - padding.top - padding.bottom) - 1;
/* Translators: if the "on" state label requires more than three
* glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for
* the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON"));
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + padding.left
+ ((width / 2) - rect.width - padding.left - padding.right) / 2;
label_y = y + padding.top
+ (height - rect.height - padding.top - padding.bottom) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
/* Translators: if the "off" state label requires more than three
* glyphs then use WHITE CIRCLE (U+25CB) as the text for the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "OFF"));
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + padding.left
+ (width / 2)
+ ((width / 2) - rect.width - padding.left - padding.right) / 2;
label_y = y + padding.top
+ (height - rect.height - padding.top - padding.bottom) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
if (priv->is_dragging)
handle.x = x + priv->handle_x;
else if (priv->is_active)
handle.x = x + width - handle.width - padding.right;
else
handle.x = x + padding.left;
gtk_style_context_restore (context);
gtk_switch_paint_handle (widget, cr, &handle);
return FALSE;
}
static void
draw_month_grid (GcalYearView *year_view,
GtkWidget *widget,
cairo_t *cr,
gint month_nr,
gint *weeks_counter)
{
GcalYearViewPrivate *priv = year_view->priv;
GtkStyleContext *context;
GtkStateFlags state_flags;
PangoLayout *layout, *slayout;
PangoFontDescription *font_desc, *sfont_desc;
GdkRGBA color;
gint layout_width, layout_height, i, j, sw;
gint x, y, column, row, box_side, box_padding_top, box_padding_start;
gint days_delay, days, shown_rows, sunday_idx;
gchar *str, *nr_day, *nr_week;
gboolean selected_day;
cairo_save (cr);
context = gtk_widget_get_style_context (widget);
state_flags = gtk_widget_get_state_flags (widget);
sw = 1 - 2 * priv->k;
box_side = priv->navigator_grid->box_side;
x = priv->navigator_grid->coordinates[month_nr].x;
y = priv->navigator_grid->coordinates[month_nr].y;
gtk_style_context_get (context, state_flags | GTK_STATE_FLAG_SELECTED, "font", &sfont_desc, NULL);
slayout = gtk_widget_create_pango_layout (widget, NULL);
pango_layout_set_font_description (slayout, sfont_desc);
/* header */
gtk_style_context_save (context);
gtk_style_context_add_class (context, "header");
str = g_strdup (gcal_get_month_name (month_nr));
gtk_style_context_get (context, state_flags, "font", &font_desc, NULL);
layout = gtk_widget_create_pango_layout (widget, str);
pango_layout_set_font_description (layout, font_desc);
pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
gtk_render_layout (context, cr, x + (box_side * 8 - layout_width) / 2, y + (box_side - layout_height) / 2,
layout);
gtk_render_background (context, cr,
x + (box_side * 8 - layout_width) / 2, y + (box_side - layout_height) / 2,
layout_width, layout_width);
pango_font_description_free (font_desc);
g_free (str);
gtk_style_context_restore (context);
/* separator line */
gtk_style_context_save (context);
gtk_style_context_add_class (context, "lines");
gtk_style_context_get_color (context, state_flags, &color);
cairo_set_line_width (cr, 0.2);
gdk_cairo_set_source_rgba (cr, &color);
cairo_move_to (cr, x + box_side / 2, y + box_side + 0.4);
cairo_rel_line_to (cr, 7 * box_side, 0);
cairo_stroke (cr);
gtk_style_context_restore (context);
/* days */
gtk_style_context_save (context);
gtk_style_context_add_class (context, "days");
gtk_style_context_get (context, state_flags, "font", &font_desc, NULL);
pango_layout_set_font_description (layout, font_desc);
days_delay = (time_day_of_week (1, month_nr, priv->date->year) - priv->first_weekday + 7) % 7;
days = days_delay + icaltime_days_in_month (month_nr + 1, priv->date->year);
shown_rows = ceil (days / 7.0);
sunday_idx = priv->k * 6 + sw * ((7 - priv->first_weekday) % 7);
for (i = 0; i < 7 * shown_rows; i++)
{
column = i % 7;
row = i / 7;
j = 7 * ((i + 7 * priv->k) / 7) + sw * (i % 7) + (1 - priv->k);
if (j <= days_delay)
continue;
else if (j > days)
continue;
j -= days_delay;
nr_day = g_strdup_printf ("%d", j);
pango_layout_set_text (layout, nr_day, -1);
pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
box_padding_top = (box_side - layout_height) / 2 > 0 ? (box_side - layout_height) / 2 : 0;
box_padding_start = (box_side - layout_width) / 2 > 0 ? (box_side - layout_width) / 2 : 0;
selected_day = FALSE;
if (priv->selected_data->start_day != 0)
{
ButtonData selected_data = *(priv->selected_data);
order_selected_data (&selected_data);
if (month_nr > selected_data.start_month && month_nr < selected_data.end_month)
{
selected_day = TRUE;
}
else if (month_nr == selected_data.start_month && month_nr == selected_data.end_month)
{
selected_day = j >= selected_data.start_day && j <= selected_data.end_day;
}
else if (month_nr == selected_data.start_month && j >= selected_data.start_day)
{
selected_day = TRUE;
}
else if (month_nr == selected_data.end_month && j <= selected_data.end_day)
{
selected_day = TRUE;
}
}
if (priv->date->year == priv->current_date->year && month_nr + 1 == priv->current_date->month &&
j == priv->current_date->day)
{
PangoLayout *clayout;
PangoFontDescription *cfont_desc;
gtk_style_context_save (context);
gtk_style_context_add_class (context, "current");
clayout = gtk_widget_create_pango_layout (widget, nr_day);
gtk_style_context_get (context, state_flags, "font", &cfont_desc, NULL);
pango_layout_set_font_description (clayout, cfont_desc);
pango_layout_get_pixel_size (clayout, &layout_width, &layout_height);
box_padding_top = (box_side - layout_height) / 2 > 0 ? (box_side - layout_height) / 2 : 0;
box_padding_start = (box_side - layout_width) / 2 > 0 ? (box_side - layout_width) / 2 : 0;
/* FIXME: hardcoded padding of the number background */
gtk_render_background (context, cr,
box_side * (column + 0.5 + priv->k) + x + sw * box_padding_start - priv->k * layout_width - 2.0,
box_side * (row + 1) + y + box_padding_top - 1.0,
layout_width + 4.0, layout_height + 2.0);
gtk_render_layout (context, cr,
box_side * (column + 0.5 + priv->k) + x + sw * box_padding_start - priv->k * layout_width,
box_side * (row + 1) + y + box_padding_top,
clayout);
gtk_style_context_restore (context);
pango_font_description_free (cfont_desc);
g_object_unref (clayout);
}
else if (selected_day)
{
gtk_style_context_set_state (context, state_flags | GTK_STATE_FLAG_SELECTED);
pango_layout_set_text (slayout, nr_day, -1);
pango_layout_get_pixel_size (slayout, &layout_width, &layout_height);
box_padding_top = (box_side - layout_height) / 2 > 0 ? (box_side - layout_height) / 2 : 0;
box_padding_start = (box_side - layout_width) / 2 > 0 ? (box_side - layout_width) / 2 : 0;
gtk_render_layout (context, cr,
box_side * (column + 0.5 + priv->k) + x + sw * box_padding_start - priv->k * layout_width,
box_side * (row + 1) + y + box_padding_top,
slayout);
gtk_style_context_set_state (context, state_flags);
}
else if (column == sunday_idx)
{
gtk_style_context_save (context);
gtk_style_context_add_class (context, "sunday");
gtk_render_layout (context, cr,
box_side * (column + 0.5 + priv->k) + x + sw * box_padding_start - priv->k * layout_width,
box_side * (row + 1) + y + box_padding_top,
layout);
gtk_style_context_restore (context);
}
else
{
gtk_render_layout (context, cr,
box_side * (column + 0.5 + priv->k) + x + sw * box_padding_start - priv->k * layout_width,
box_side * (row + 1) + y + box_padding_top,
layout);
}
g_free (nr_day);
}
pango_font_description_free (font_desc);
gtk_style_context_restore (context);
/* week numbers */
gtk_style_context_save (context);
gtk_style_context_add_class (context, "week-numbers");
gtk_style_context_get (context, state_flags, "font", &font_desc, NULL);
pango_layout_set_font_description (layout, font_desc);
for (i = 0; i < shown_rows; i++)
{
if (i == 0)
{
if (days_delay == 0)
*weeks_counter = *weeks_counter + 1;
}
else
*weeks_counter = *weeks_counter + 1;
nr_week = g_strdup_printf ("%d", *weeks_counter);
pango_layout_set_text (layout, nr_week, -1);
pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
box_padding_top = (box_side - layout_height) / 2 > 0 ? (box_side - layout_height) / 2 : 0;
box_padding_start = ((box_side / 2) - layout_width) / 2 > 0 ? ((box_side / 2) - layout_width) / 2 : 0;
gtk_render_layout (context, cr,
x + sw * box_padding_start + priv->k * (8 * box_side - layout_width),
box_side * (i + 1) + y + box_padding_top,
layout);
g_free (nr_week);
}
gtk_style_context_restore (context);
pango_font_description_free (sfont_desc);
g_object_unref (slayout);
pango_font_description_free (font_desc);
g_object_unref (layout);
cairo_restore (cr);
}
static gboolean
gtk_switch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
GtkStyleContext *context;
GdkRectangle handle;
PangoLayout *layout;
PangoFontDescription *desc;
const PangoFontDescription *style_desc;
PangoRectangle rect;
gint label_x, label_y;
GtkStateFlags state;
GtkBorder padding;
gint focus_width, focus_pad;
gint x, y, width, height;
gint font_size, style_font_size;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
if (priv->is_active)
state |= GTK_STATE_FLAG_ACTIVE;
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SLIDER);
gtk_style_context_get_padding (context, state, &padding);
gtk_style_context_restore (context);
x = 0;
y = 0;
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
if (gtk_widget_has_focus (widget))
gtk_render_focus (context, cr, x, y, width, height);
x += focus_width + focus_pad;
y += focus_width + focus_pad;
width -= 2 * (focus_width + focus_pad);
height -= 2 * (focus_width + focus_pad);
gtk_style_context_save (context);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TROUGH);
gtk_style_context_set_state (context, state);
gtk_render_background (context, cr, x, y, width, height);
gtk_render_frame (context, cr, x, y, width, height);
width -= padding.left + padding.right;
height -= padding.top + padding.bottom;
x += padding.left;
y += padding.top;
handle.y = y;
handle.width = width / 2;
handle.height = height;
/* Translators: if the "on" state label requires more than three
* glyphs then use MEDIUM VERTICAL BAR (U+2759) as the text for
* the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "ON"));
/* FIXME: this should be really done in the theme, but overriding font size
* from it doesn't currently work. So we have to hardcode this here and
* below for the "OFF" label.
*/
desc = pango_font_description_new ();
style_desc = gtk_style_context_get_font (context, state);
style_font_size = pango_font_description_get_size (style_desc);
font_size = MAX (style_font_size - 1 * PANGO_SCALE, ceil (style_font_size * PANGO_SCALE_SMALL));
pango_font_description_set_size (desc, font_size);
pango_layout_set_font_description (layout, desc);
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + ((width / 2) - rect.width) / 2;
label_y = y + (height - rect.height) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
/* Translators: if the "off" state label requires more than three
* glyphs then use WHITE CIRCLE (U+25CB) as the text for the state
*/
layout = gtk_widget_create_pango_layout (widget, C_("switch", "OFF"));
pango_layout_set_font_description (layout, desc);
pango_layout_get_extents (layout, NULL, &rect);
pango_extents_to_pixels (&rect, NULL);
label_x = x + (width / 2) + ((width / 2) - rect.width) / 2;
label_y = y + (height - rect.height) / 2;
gtk_render_layout (context, cr, label_x, label_y, layout);
g_object_unref (layout);
if (priv->is_dragging)
handle.x = x + priv->handle_x;
else if (priv->is_active)
handle.x = x + width - handle.width;
else
handle.x = x;
gtk_style_context_restore (context);
gtk_switch_paint_handle (widget, cr, &handle);
pango_font_description_free (desc);
return FALSE;
}
static void
gutter_renderer_text_draw (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
GtkSourceGutterRendererText *text = GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer);
GtkTextView *view;
gint width;
gint height;
gfloat xalign;
gfloat yalign;
GtkSourceGutterRendererAlignmentMode mode;
gint x = 0;
gint y = 0;
GtkStyleContext *context;
/* Chain up to draw background */
if (GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->draw != NULL)
{
GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->draw (renderer,
cr,
background_area,
cell_area,
start,
end,
state);
}
view = gtk_source_gutter_renderer_get_view (renderer);
if (text->priv->is_markup)
{
pango_layout_set_markup (text->priv->cached_layout,
text->priv->text,
-1);
}
else
{
pango_layout_set_text (text->priv->cached_layout,
text->priv->text,
-1);
}
pango_layout_get_pixel_size (text->priv->cached_layout, &width, &height);
gtk_source_gutter_renderer_get_alignment (renderer,
&xalign,
&yalign);
/* Avoid calculations if we don't wrap text */
if (gtk_text_view_get_wrap_mode (view) == GTK_WRAP_NONE)
{
mode = GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL;
}
else
{
mode = gtk_source_gutter_renderer_get_alignment_mode (renderer);
}
switch (mode)
{
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL:
x = cell_area->x + (cell_area->width - width) * xalign;
y = cell_area->y + (cell_area->height - height) * yalign;
break;
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST:
center_on (view,
cell_area,
start,
width,
height,
xalign,
yalign,
&x,
&y);
break;
case GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST:
center_on (view,
cell_area,
end,
width,
height,
xalign,
yalign,
&x,
&y);
break;
default:
g_assert_not_reached ();
}
context = gtk_widget_get_style_context (GTK_WIDGET (view));
gtk_render_layout (context, cr, x, y, text->priv->cached_layout);
}
static gboolean
gcal_week_view_draw_hours (GcalWeekView *self,
cairo_t *cr,
GtkWidget *widget)
{
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
GdkRGBA color;
gboolean ltr;
gint i, width, height;
gint font_width;
PangoLayout *layout;
PangoFontDescription *font_desc;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
gtk_style_context_save (context);
gtk_style_context_add_class (context, "hours");
gtk_style_context_get_color (context, state, &color);
gtk_style_context_get_padding (context, state, &padding);
gtk_style_context_get (context, state, "font", &font_desc, NULL);
layout = pango_cairo_create_layout (cr);
pango_layout_set_font_description (layout, font_desc);
gdk_cairo_set_source_rgba (cr, &color);
/* Gets the size of the widget */
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
/* Draws the hours in the sidebar */
for (i = 0; i < 24; i++)
{
gchar *hours;
if (self->use_24h_format)
{
hours = g_strdup_printf ("%02d:00", i);
}
else
{
hours = g_strdup_printf ("%d %s",
i % 12 == 0 ? 12 : i % 12,
i > 12 ? _("PM") : _("AM"));
}
pango_layout_set_text (layout, hours, -1);
pango_layout_get_pixel_size (layout, &font_width, NULL);
gtk_render_layout (context,
cr,
ltr ? padding.left : width - font_width - padding.right,
(height / 24) * i + padding.top,
layout);
g_free (hours);
}
gtk_style_context_restore (context);
gtk_style_context_save (context);
gtk_style_context_add_class (context, "lines");
gtk_style_context_get_color (context, state, &color);
gdk_cairo_set_source_rgba (cr, &color);
cairo_set_line_width (cr, 0.65);
if (!ltr)
{
cairo_move_to (cr, 0.5, 0);
cairo_rel_line_to (cr, 0, height);
}
/* Draws the horizontal complete lines */
for (i = 1; i < 24; i++)
{
cairo_move_to (cr, 0, (height / 24) * i + 0.4);
cairo_rel_line_to (cr, width, 0);
}
cairo_stroke (cr);
cairo_set_dash (cr, dashed, 2, 0);
/* Draws the horizontal dashed lines */
for (i = 0; i < 24; i++)
{
cairo_move_to (cr, 0, (height / 24) * i + (height / 48) + 0.4);
cairo_rel_line_to (cr, width, 0);
}
cairo_stroke (cr);
gtk_style_context_restore (context);
pango_font_description_free (font_desc);
g_object_unref (layout);
return FALSE;
}
static gboolean
draw_navigator (GcalYearView *year_view,
cairo_t *cr,
GtkWidget *widget)
{
GcalYearViewPrivate *priv;
GtkStyleContext *context;
GtkStateFlags state_flags;
gint header_padding_left, header_padding_top, header_height, layout_width, layout_height;
gint width, height, box_side, real_padding_left, real_padding_top, i, sw, weeks_counter;
gchar *header_str;
PangoLayout *header_layout;
PangoFontDescription *font_desc;
priv = year_view->priv;
context = gtk_widget_get_style_context (GTK_WIDGET (year_view));
state_flags = gtk_widget_get_state_flags (GTK_WIDGET (year_view));
sw = 1 - 2 * priv->k;
width = gtk_widget_get_allocated_width (widget);
/* read header from CSS code related to the view */
gtk_style_context_save (context);
gtk_style_context_add_class (context, "first-view-header");
header_str = g_strdup_printf ("%d", priv->date->year);
gtk_style_context_get (context, state_flags,
"padding-left", &header_padding_left, "padding-top", &header_padding_top,
"font", &font_desc, NULL);
gtk_style_context_restore (context);
/* draw header on navigator */
context = gtk_widget_get_style_context (widget);
state_flags = gtk_widget_get_state_flags (GTK_WIDGET (year_view));
header_layout = gtk_widget_create_pango_layout (widget, header_str);
pango_layout_set_font_description (header_layout, font_desc);
pango_layout_get_pixel_size (header_layout, &layout_width, &layout_height);
/* XXX: here the color of the text isn't read from year-view but from navigator widget,
* which has the same color on the CSS file */
gtk_render_layout (context, cr,
priv->k * (width - layout_width) + sw * header_padding_left, header_padding_top, header_layout);
pango_font_description_free (font_desc);
g_object_unref (header_layout);
g_free (header_str);
header_height = header_padding_top * 2 + layout_height;
height = gtk_widget_get_allocated_height (widget) - header_height;
if (((width / 4) / 8) < ((height / 3) / 7))
box_side = (width / 4) / 8;
else
box_side = (height / 3) / 7;
real_padding_left = (width - (8 * 4 * box_side)) / 5;
real_padding_top = (height - (7 * 3 * box_side)) / 4;
priv->navigator_grid->box_side = box_side;
weeks_counter = 1;
for (i = 0; i < 12; i++)
{
gint row = i / 4;
gint column = priv->k * 3 + sw * (i % 4);
priv->navigator_grid->coordinates[i].x = (column + 1) * real_padding_left + column * box_side * 8;
priv->navigator_grid->coordinates[i].y = (row + 1) * real_padding_top + row * box_side * 7 + header_height;
draw_month_grid (year_view, widget, cr, i, &weeks_counter);
}
return FALSE;
}
static void
gnc_header_draw_offscreen (GncHeader *header)
{
SheetBlockStyle *style = header->style;
Table *table = header->sheet->table;
VirtualLocation virt_loc;
VirtualCell *vcell;
guint32 color_type;
GtkStyleContext *stylectxt = gtk_widget_get_style_context (GTK_WIDGET(header));
GdkRGBA color;
int row_offset;
CellBlock *cb;
int i;
cairo_t *cr;
virt_loc.vcell_loc.virt_row = 0;
virt_loc.vcell_loc.virt_col = 0;
virt_loc.phys_row_offset = 0;
virt_loc.phys_col_offset = 0;
gtk_style_context_save (stylectxt);
// Get the background color type and apply the css class
color_type = gnc_table_get_bg_color (table, virt_loc, NULL);
gnucash_get_style_classes (header->sheet, stylectxt, color_type);
if (header->surface)
cairo_surface_destroy (header->surface);
header->surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
header->width,
header->height);
cr = cairo_create (header->surface);
// Fill background color of header
gtk_render_background (stylectxt, cr, 0, 0, header->width, header->height);
gdk_rgba_parse (&color, "black");
cairo_set_source_rgb (cr, color.red, color.green, color.blue);
cairo_rectangle (cr, 0.5, 0.5, header->width - 1.0, header->height - 1.0);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
// Draw bottom horizontal line, makes bottom line thicker
cairo_move_to (cr, 0.5, header->height - 1.5);
cairo_line_to (cr, header->width - 1.0, header->height - 1.5);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
/*font = gnucash_register_font;*/
vcell = gnc_table_get_virtual_cell
(table, table->current_cursor_loc.vcell_loc);
cb = vcell ? vcell->cellblock : NULL;
row_offset = 0;
for (i = 0; i < style->nrows; i++)
{
int col_offset = 0;
int h = 0, j;
virt_loc.phys_row_offset = i;
/* TODO: This routine is duplicated in several places.
Can we abstract at least the cell drawing routine?
That way we'll be sure everything is drawn
consistently, and cut down on maintenance issues. */
for (j = 0; j < style->ncols; j++)
{
CellDimensions *cd;
double text_x, text_y, text_w, text_h;
BasicCell *cell;
const char *text;
int w;
PangoLayout *layout;
virt_loc.phys_col_offset = j;
cd = gnucash_style_get_cell_dimensions (style, i, j);
h = cd->pixel_height;
if (header->in_resize && (j == header->resize_col))
w = header->resize_col_width;
else
w = cd->pixel_width;
cell = gnc_cellblock_get_cell (cb, i, j);
if (!cell || !cell->cell_name)
{
col_offset += w;
continue;
}
cairo_rectangle (cr, col_offset - 0.5, row_offset + 0.5, w, h);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
virt_loc.vcell_loc =
table->current_cursor_loc.vcell_loc;
text = gnc_table_get_label (table, virt_loc);
if (!text)
text = "";
layout = gtk_widget_create_pango_layout (GTK_WIDGET (header->sheet), text);
switch (gnc_table_get_align (table, virt_loc))
{
default:
case CELL_ALIGN_LEFT:
pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
break;
case CELL_ALIGN_RIGHT:
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
break;
case CELL_ALIGN_CENTER:
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
break;
}
text_x = col_offset + CELL_HPADDING;
text_y = row_offset + 1;
text_w = MAX (0, w - (2 * CELL_HPADDING));
text_h = h - 2;
cairo_save (cr);
cairo_rectangle (cr, text_x, text_y, text_w, text_h);
cairo_clip (cr);
gtk_render_layout (stylectxt, cr, text_x, text_y, layout);
cairo_restore (cr);
g_object_unref (layout);
col_offset += w;
}
row_offset += h;
}
gtk_style_context_restore (stylectxt);
cairo_destroy (cr);
}