static void border(GtkWidget* widget, GtkStateFlags state, GdkRGBA& gdkRGBA)
{
GtkStyleContext* sc = gtk_widget_get_style_context(widget);
gtk_style_context_get_border_color(sc, state, &gdkRGBA);
if (gdkRGBA.alpha <= 0)
{
widget = gtk_widget_get_parent(GTK_WIDGET(ContainerWidget()));
sc = gtk_widget_get_style_context(widget);
gtk_style_context_get_border_color(sc, state, &gdkRGBA);
}
}
static void
ig_reload_style (GnmItemGrid *ig)
{
GocItem *item = GOC_ITEM (ig);
GtkStyleContext *context = goc_item_get_style_context (item);
GtkBorder border;
GtkStateFlags state = GTK_STATE_FLAG_NORMAL;
GnmPane *pane = GNM_PANE (item->canvas);
gtk_style_context_save (context);
gtk_style_context_add_region (context, "function-marker", 0);
gtk_style_context_get_color (context, GTK_STATE_FLAG_NORMAL,
&ig->function_marker_color);
gtk_style_context_get_border_color (context, state,
&ig->function_marker_border_color);
gtk_style_context_restore (context);
gtk_style_context_save (context);
gtk_style_context_add_region (context, "pane-divider", 0);
gtk_style_context_get_color (context, GTK_STATE_FLAG_NORMAL,
&ig->pane_divider_color);
gtk_style_context_get_border (context, GTK_STATE_FLAG_NORMAL, &border);
ig->pane_divider_width = border.top; /* Hack? */
gtk_style_context_restore (context);
/* ---------------------------------------- */
context = gtk_widget_get_style_context (GTK_WIDGET (pane));
gtk_widget_style_get (GTK_WIDGET (pane),
"function-indicator-size",
&ig->function_marker_size,
NULL);
}
static void border(GtkWidget* widget, GtkStateFlags state, GdkRGBA& gdkRGBA)
{
GtkStyleContext* sc = gtk_widget_get_style_context(widget);
gtk_style_context_get_border_color(sc, state, &gdkRGBA);
}
static gboolean budgie_popover_draw(GtkWidget *widget,
cairo_t *cr,
gboolean draw)
{
BudgiePopover *self = BUDGIE_POPOVER(widget);
GtkStyleContext *style;
GtkAllocation alloc;
GtkPositionType gap_side;
GdkRGBA color;
gdouble x, y, tail_height, gap_width;
gdouble margin, width, height, gap1, gap2;
x = 0;
y = 0;
tail_height = 12;
gap_width = 24;
margin = 11;
x += margin;
y += margin;
style = gtk_widget_get_style_context(widget);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
gtk_widget_get_allocation(widget, &alloc);
/* Have parent class do drawing, so we gain shadows */
((GtkWidgetClass*)budgie_popover_parent_class)->draw(widget, cr);
/* Remove height of tail, and margin, from our rendered size */
width = alloc.width;
height = alloc.height - tail_height;
height -= margin;
width -= margin*2;
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
gap1 = (alloc.width/2)-(gap_width/2);
gap1 = self->widg_x;
gap2 = gap1 + gap_width;
gap2 -= margin;
gap_side = self->top == TRUE ? GTK_POS_TOP : GTK_POS_BOTTOM;
/* Render a gap in the bottom center for our arrow */
gtk_render_frame_gap(style, cr, x, y, width, height,
gap_side, gap1, gap2);
/* Fill in the background (pre-clip) */
gtk_render_background(style, cr, x, y, width, height);
/* Clip to the tail, fill in the arrow background */
cairo_save(cr);
if (self->top)
budgie_tail_path(cr, gap1, gap_width, y-margin, tail_height, self->top);
else
budgie_tail_path(cr, gap1, gap_width, height+margin, tail_height, self->top);
cairo_clip(cr);
if (self->top)
gtk_render_background(style, cr, x, y-tail_height, alloc.width, alloc.height);
else
gtk_render_background(style, cr, x, y, alloc.width, alloc.height);
cairo_restore(cr);
/* Draw in the border */
gtk_style_context_get_border_color(style, gtk_widget_get_state_flags(widget), &color);
gdk_cairo_set_source_rgba(cr, &color);
cairo_set_line_width(cr, 1);
if (self->top)
budgie_tail_path(cr, gap1, gap_width, y-margin, tail_height, self->top);
else
budgie_tail_path(cr, gap1, gap_width, height+margin, tail_height, self->top);
cairo_stroke(cr);
/* Draw children */
gtk_container_propagate_draw(GTK_CONTAINER(widget),
gtk_bin_get_child(GTK_BIN(widget)),
cr);
return TRUE;
}
static gboolean
gtk_bubble_window_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkStyleContext *context;
GtkAllocation allocation;
GtkWidget *child;
GtkBorder border;
GdkRGBA border_color;
gint rect_x1, rect_x2, rect_y1, rect_y2;
gint initial_x, initial_y, final_x, final_y;
gint gap_start, gap_end;
GtkPositionType gap_side;
GtkStateFlags state;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_widget_get_allocation (widget, &allocation);
if (gtk_widget_is_composited (widget))
{
cairo_save (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba (cr, 0, 0, 0, 0);
cairo_paint (cr);
cairo_restore (cr);
}
gtk_bubble_window_get_rect_coords (GTK_BUBBLE_WINDOW (widget),
&rect_x1, &rect_y1,
&rect_x2, &rect_y2);
/* Render the rect background */
gtk_render_background (context, cr,
rect_x1, rect_y1,
rect_x2 - rect_x1, rect_y2 - rect_y1);
gtk_bubble_window_get_gap_coords (GTK_BUBBLE_WINDOW (widget),
&initial_x, &initial_y,
NULL, NULL,
&final_x, &final_y,
&gap_side);
if (POS_IS_VERTICAL (gap_side))
{
gap_start = initial_x;
gap_end = final_x;
}
else
{
gap_start = initial_y;
gap_end = final_y;
}
/* Now render the frame, without the gap for the arrow tip */
gtk_render_frame_gap (context, cr,
rect_x1, rect_y1,
rect_x2 - rect_x1, rect_y2 - rect_y1,
gap_side,
gap_start, gap_end);
/* Clip to the arrow shape */
cairo_save (cr);
gtk_bubble_window_apply_tail_path (GTK_BUBBLE_WINDOW (widget), cr);
cairo_clip (cr);
/* Render the arrow background */
gtk_render_background (context, cr,
0, 0,
allocation.width, allocation.height);
/* Render the border of the arrow tip */
gtk_style_context_get_border (context, state, &border);
if (border.bottom > 0)
{
gtk_style_context_get_border_color (context, state, &border_color);
gtk_bubble_window_apply_tail_path (GTK_BUBBLE_WINDOW (widget), cr);
gdk_cairo_set_source_rgba (cr, &border_color);
cairo_set_line_width (cr, border.bottom);
cairo_stroke (cr);
}
/* We're done */
cairo_restore (cr);
child = gtk_bin_get_child (GTK_BIN (widget));
if (child)
gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
return TRUE;
}
static gboolean
swatch_draw (GtkWidget *widget,
cairo_t *cr)
{
GtkColorSwatch *swatch = (GtkColorSwatch*)widget;
GtkThemingBackground background;
gdouble width, height;
GtkStyleContext *context;
GtkStateFlags state;
GtkIconTheme *theme;
GtkIconInfo *icon_info = NULL;
theme = gtk_icon_theme_get_default ();
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
cairo_save (cr);
gtk_style_context_save (context);
gtk_style_context_set_state (context, state);
_gtk_theming_background_init_from_context (&background, context,
0, 0, width, height,
GTK_JUNCTION_NONE);
if (swatch->priv->has_color)
{
cairo_pattern_t *pattern;
cairo_matrix_t matrix;
if (swatch->priv->use_alpha)
{
cairo_save (cr);
_gtk_rounded_box_path (&background.padding_box, cr);
cairo_clip_preserve (cr);
cairo_set_source_rgb (cr, 0.33, 0.33, 0.33);
cairo_fill_preserve (cr);
pattern = _gtk_color_chooser_get_checkered_pattern ();
cairo_matrix_init_scale (&matrix, 0.125, 0.125);
cairo_pattern_set_matrix (pattern, &matrix);
cairo_set_source_rgb (cr, 0.66, 0.66, 0.66);
cairo_mask (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
background.bg_color = swatch->priv->color;
}
else
{
background.bg_color = swatch->priv->color;
background.bg_color.alpha = 1.0;
}
_gtk_theming_background_render (&background, cr);
}
else
_gtk_theming_background_render (&background, cr);
gtk_render_frame (context, cr,
0, 0, width, height);
if (gtk_widget_has_visible_focus (widget))
{
cairo_set_line_width (cr, 2);
if (swatch->priv->has_color && INTENSITY (swatch->priv->color.red, swatch->priv->color.green, swatch->priv->color.blue) < 0.5)
cairo_set_source_rgba (cr, 1., 1., 1., 0.4);
else
cairo_set_source_rgba (cr, 0., 0., 0., 0.4);
_gtk_rounded_box_shrink (&background.padding_box, 3, 3, 3, 3);
_gtk_rounded_box_path (&background.padding_box, cr);
cairo_stroke (cr);
}
if (swatch->priv->icon)
{
icon_info = gtk_icon_theme_lookup_icon (theme, swatch->priv->icon, 16,
GTK_ICON_LOOKUP_GENERIC_FALLBACK
| GTK_ICON_LOOKUP_USE_BUILTIN);
}
else if ((state & GTK_STATE_FLAG_SELECTED) != 0)
{
GdkRGBA bg, border;
GtkBorder border_width;
GIcon *gicon;
gtk_style_context_add_class (context, "color-active-badge");
_gtk_theming_background_init_from_context (&background, context,
(width - 2 * ACTIVE_BADGE_RADIUS) / 2, (height - 2 * ACTIVE_BADGE_RADIUS) / 2,
2 * ACTIVE_BADGE_RADIUS, 2* ACTIVE_BADGE_RADIUS,
GTK_JUNCTION_NONE);
if (_gtk_theming_background_has_background_image (&background))
{
_gtk_theming_background_render (&background, cr);
}
else
{
gtk_style_context_get_background_color (context, state, &bg);
gtk_style_context_get_border_color (context, state, &border);
gtk_style_context_get_border (context, state, &border_width);
cairo_new_sub_path (cr);
cairo_arc (cr, width / 2, height / 2, ACTIVE_BADGE_RADIUS, 0, 2 * G_PI);
cairo_close_path (cr);
gdk_cairo_set_source_rgba (cr, &bg);
cairo_fill_preserve (cr);
gdk_cairo_set_source_rgba (cr, &border);
cairo_set_line_width (cr, border_width.left);
cairo_stroke (cr);
gicon = g_themed_icon_new ("object-select-symbolic");
/* fallback for themes that don't have object-select-symbolic */
g_themed_icon_append_name (G_THEMED_ICON (gicon), "gtk-apply");
icon_info = gtk_icon_theme_lookup_by_gicon (theme, gicon, 16,
GTK_ICON_LOOKUP_GENERIC_FALLBACK
| GTK_ICON_LOOKUP_USE_BUILTIN);
g_object_unref (gicon);
}
}
if (icon_info != NULL)
{
GdkPixbuf *pixbuf;
pixbuf = gtk_icon_info_load_symbolic_for_context (icon_info, context,
NULL, NULL);
if (pixbuf != NULL)
{
gtk_render_icon (context, cr, pixbuf,
(width - gdk_pixbuf_get_width (pixbuf)) / 2,
(height - gdk_pixbuf_get_height (pixbuf)) / 2);
g_object_unref (pixbuf);
}
g_object_unref (icon_info);
}
cairo_restore (cr);
gtk_style_context_restore (context);
return FALSE;
}
