static gboolean panel_icon_grid_expose(GtkWidget *widget, GdkEventExpose *event)
#endif
{
if (gtk_widget_is_drawable(widget))
{
if (gtk_widget_get_has_window(widget) &&
!gtk_widget_get_app_paintable(widget))
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_render_background(gtk_widget_get_style_context(widget), cr, 0, 0,
gtk_widget_get_allocated_width(widget),
gtk_widget_get_allocated_height(widget));
#else
gtk_paint_flat_box(gtk_widget_get_style(widget),
gtk_widget_get_window(widget),
gtk_widget_get_state(widget), GTK_SHADOW_NONE,
&event->area, widget, "panelicongrid",
0, 0, -1, -1);
#endif
#if GTK_CHECK_VERSION(3, 0, 0)
GTK_WIDGET_CLASS(panel_icon_grid_parent_class)->draw(widget, cr);
#else
GTK_WIDGET_CLASS(panel_icon_grid_parent_class)->expose_event(widget, event);
#endif
}
return FALSE;
}
static
void mw_paint_tip(GtkWidget *widget, GdkEventExpose *event)
{
GtkStyle *style;
GdkWindow *window;
char *tooltiptext = get_tooltip_text();
if(tooltiptext == NULL) tooltiptext = g_strdup("oeps");
pango_layout_set_markup(layout, tooltiptext, strlen(tooltiptext));
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_set_width(layout, 300000);
style = gtk_widget_get_style (tipwindow);
window = gtk_widget_get_window (tipwindow);
gtk_paint_flat_box (style, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, tipwindow, "tooltip", 0, 0, -1, -1);
gtk_paint_layout (style, window, GTK_STATE_NORMAL, TRUE,
NULL, tipwindow, "tooltip", 4, 4, layout);
/*
g_object_unref(layout);
*/
g_free(tooltiptext);
return;
}
static void
run_functions (Test *test)
{
GtkStyle *style = styles[test->style];
if (test->function & FUNCTION_ARROW)
gtk_paint_arrow (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, test->arrow_type, test->fill, 0, 0, 10, 10);
if (test->function & FUNCTION_BOX)
gtk_paint_box (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_SHADOW)
gtk_paint_shadow (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_BOX_GAP)
gtk_paint_box_gap (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10, test->gap_side, 0, 100);
if (test->function & FUNCTION_SHADOW_GAP)
gtk_paint_shadow_gap (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10, test->gap_side, 0, 100);
if (test->function & FUNCTION_CHECK)
gtk_paint_check (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_EXPANDER)
gtk_paint_expander (style, window->window, test->state, NULL, widgets[test->widget], test->detail, 10, 10, test->expander_style);
if (test->function & FUNCTION_EXTENSION)
gtk_paint_extension (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10, test->gap_side);
if (test->function & FUNCTION_FLAT_BOX)
gtk_paint_flat_box (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_FOCUS)
gtk_paint_focus (style, window->window, test->state, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_HANDLE)
gtk_paint_handle (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10, test->orientation);
if (test->function & FUNCTION_OPTION)
gtk_paint_option (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_RESIZE_GRIP)
gtk_paint_resize_grip (style, window->window, test->state, NULL, widgets[test->widget], test->detail, test->edge, 0, 0, 10, 10);
if (test->function & FUNCTION_SLIDER)
gtk_paint_slider (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10, test->orientation);
if (test->function & FUNCTION_TAB)
gtk_paint_tab (style, window->window, test->state, test->shadow, NULL, widgets[test->widget], test->detail, 0, 0, 10, 10);
if (test->function & FUNCTION_HLINE)
gtk_paint_hline (style, window->window, test->state, NULL, widgets[test->widget], test->detail, 1, 10, 4);
if (test->function & FUNCTION_VLINE)
gtk_paint_vline (style, window->window, test->state, NULL, widgets[test->widget], test->detail, 1, 10, 4);
}
static VALUE
style_paint_flat_box(VALUE self, VALUE gdkwindow, VALUE state_type, VALUE shadow_type, VALUE area, VALUE widget, VALUE detail, VALUE x, VALUE y, VALUE width, VALUE height)
{
gtk_paint_flat_box(_SELF(self), GDK_WINDOW(RVAL2GOBJ(gdkwindow)),
RVAL2STATE(state_type), RVAL2SHADOW(shadow_type), RVAL2REC(area),
GTK_WIDGET(RVAL2GOBJ(widget)), RVAL2CSTR(detail),
NUM2INT(x), NUM2INT(y), NUM2INT(width), NUM2INT(height));
return self;
}
static gint
expose_handler (GtkTooltips *tooltips)
{
gtk_paint_flat_box (gtk_widget_get_style (tip), gtk_widget_get_window (tip),
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, tip, "tooltip",
0, 0, -1, -1);
return FALSE;
}
static gboolean
pidgin_tooltip_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
if (pidgin_tooltip.paint_tooltip) {
gtk_paint_flat_box(widget->style, widget->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, "tooltip", 0, 0, -1, -1);
pidgin_tooltip.paint_tooltip(widget, data);
}
return FALSE;
}
gboolean
gimp_overlay_child_expose (GimpOverlayBox *box,
GimpOverlayChild *child,
GdkEventExpose *event)
{
GtkWidget *widget;
g_return_val_if_fail (GIMP_IS_OVERLAY_BOX (box), FALSE);
g_return_val_if_fail (child != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
widget = GTK_WIDGET (box);
if (event->window == gtk_widget_get_window (widget))
{
GtkAllocation child_allocation;
GdkRectangle bounds;
gtk_widget_get_allocation (child->widget, &child_allocation);
gimp_overlay_child_transform_bounds (child, &child_allocation, &bounds);
if (gtk_widget_get_visible (child->widget) &&
gdk_rectangle_intersect (&event->area, &bounds, NULL))
{
GdkPixmap *pixmap = gdk_offscreen_window_get_pixmap (child->window);
cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget));
gdk_cairo_region (cr, event->region);
cairo_clip (cr);
cairo_transform (cr, &child->matrix);
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint_with_alpha (cr, child->opacity);
cairo_destroy (cr);
}
}
else if (event->window == child->window)
{
if (! gtk_widget_get_app_paintable (child->widget))
gtk_paint_flat_box (gtk_widget_get_style (child->widget),
event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, NULL,
0, 0, -1, -1);
gtk_container_propagate_expose (GTK_CONTAINER (widget),
child->widget,
event);
return TRUE;
}
return FALSE;
}
static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
{
GtkPizza *pizza = GTK_PIZZA(widget);
gtk_paint_flat_box (win->m_widget->style,
pizza->bin_window, GTK_STATE_NORMAL,
GTK_SHADOW_NONE,
rect,
win->m_widget,
(char *)"base",
0, 0, -1, -1);
}
static gint
tooltips_paint_window(GtkWidget *window)
{
// draw tooltip style border around the text
gtk_paint_flat_box(window->style, window->window,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, window, "tooltip",
0, 0,
window->allocation.width, window->allocation.height);
return FALSE;
}
static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
{
GtkPizza *pizza = GTK_PIZZA(widget);
gtk_paint_flat_box (win->m_widget->style,
pizza->bin_window, GTK_STATE_NORMAL,
GTK_SHADOW_NONE,
&gdk_event->area,
win->m_widget,
(char *)"base",
0, 0, -1, -1);
return FALSE;
}
static gint tree_tips_paint(TreeTips *tips)
{
if (!tips->window) return FALSE;
if (!GTK_WIDGET_VISIBLE(tips->window)) return FALSE;
gtk_paint_flat_box (tips->window->style, tips->window->window,
GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
NULL, tips->window, "treetip",
0, 0, -1, -1);
gtk_paint_shadow (tips->window->style, tips->window->window,
GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
NULL, tips->window, "treetip",
0, 0, -1, -1);
return FALSE;
}
static gboolean
gtk_tooltip_paint_window (GtkTooltip *tooltip)
{
gtk_paint_flat_box (tooltip->window->style,
tooltip->window->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL,
tooltip->window,
"tooltip",
0, 0,
tooltip->window->allocation.width,
tooltip->window->allocation.height);
return FALSE;
}
caret_state_indicator_paint_window(GtkWidget *window)
#endif
{
#if GTK_CHECK_VERSION(2, 90, 0)
gtk_render_frame(gtk_widget_get_style_context(window), cr,
0, 0,
gtk_widget_get_allocated_width(window),
gtk_widget_get_allocated_height(window));
#else
gtk_paint_flat_box(gtk_widget_get_style(window),
gtk_widget_get_window(window),
GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, GTK_WIDGET(window),
"tooltip", 0, 0, -1, -1);
#endif
return FALSE;
}
static gint
gtk_icon_entry_expose (GtkWidget *widget, GdkEventExpose *event)
{
GtkIconEntry *entry;
GtkIconEntryPrivate *priv;
g_return_val_if_fail (GTK_IS_ICON_ENTRY (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
entry = GTK_ICON_ENTRY (widget);
priv = GTK_ICON_ENTRY_GET_PRIVATE (entry);
if (GTK_WIDGET_DRAWABLE (widget))
{
gboolean found = FALSE;
int i;
for (i = 0; i < MAX_ICONS && !found; i++)
{
EntryIconInfo *icon_info = &priv->icons[i];
if (event->window == icon_info->window)
{
gint width;
GtkAllocation text_area_alloc;
get_text_area_size (entry, &text_area_alloc);
gdk_drawable_get_size (icon_info->window, &width, NULL);
gtk_paint_flat_box (widget->style, icon_info->window,
GTK_WIDGET_STATE (widget), GTK_SHADOW_NONE,
NULL, widget, "entry_bg",
0, 0, width, text_area_alloc.height);
draw_icon (widget, i);
found = TRUE;
}
}
if (!found)
GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
}
return FALSE;
}
static void
gtk_expander_paint_prelight (GtkExpander *expander)
{
GtkWidget *widget;
GtkContainer *container;
GtkExpanderPrivate *priv;
GdkRectangle area;
gboolean interior_focus;
int focus_width;
int focus_pad;
int expander_size;
int expander_spacing;
priv = expander->priv;
widget = GTK_WIDGET (expander);
container = GTK_CONTAINER (expander);
gtk_widget_style_get (widget,
"interior-focus", &interior_focus,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
"expander-size", &expander_size,
"expander-spacing", &expander_spacing,
NULL);
area.x = widget->allocation.x + container->border_width;
area.y = widget->allocation.y + container->border_width;
area.width = widget->allocation.width - (2 * container->border_width);
if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
area.height = priv->label_widget->allocation.height;
else
area.height = 0;
area.height += interior_focus ? (focus_width + focus_pad) * 2 : 0;
area.height = MAX (area.height, expander_size + 2 * expander_spacing);
area.height += !interior_focus ? (focus_width + focus_pad) * 2 : 0;
gtk_paint_flat_box (widget->style, widget->window,
GTK_STATE_PRELIGHT,
GTK_SHADOW_ETCHED_OUT,
&area, widget, "expander",
area.x, area.y,
area.width, area.height);
}
static void
gtk_ellipsis_paint (GtkEllipsis *ellipsis)
{
GtkWidget *widget;
GtkContainer *container;
GtkEllipsisPrivate *priv;
GtkStateType state;
GdkRectangle area;
int focus_width;
int focus_pad;
widget = GTK_WIDGET (ellipsis);
container = GTK_CONTAINER (ellipsis);
priv = ellipsis->priv;
if (priv->expanded)
return;
state = widget->state;
if (priv->prelight && state != GTK_STATE_SELECTED)
state = GTK_STATE_PRELIGHT;
if (state == GTK_STATE_NORMAL)
return;
gtk_widget_style_get (widget,
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
area.x = widget->allocation.x + container->border_width;
area.y = widget->allocation.y + container->border_width;
area.width = widget->allocation.width - (2 * container->border_width);
area.height = (focus_width + focus_pad) * 2;
if (priv->label && GTK_WIDGET_VISIBLE (priv->label))
area.height += priv->label->allocation.height;
gtk_paint_flat_box (widget->style, widget->window,
state,
GTK_SHADOW_ETCHED_OUT,
&area, widget, "ellipsis",
area.x, area.y,
area.width, area.height);
}
static gboolean paint_ucview_info_box( GtkWidget *widget,
GdkEventExpose *event,
gpointer user_data )
{
gtk_paint_flat_box( widget->style,
widget->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL,
widget,
"tooltip",
widget->allocation.x + 1,
widget->allocation.y + 1,
widget->allocation.width - 2,
widget->allocation.height - 2);
return FALSE;
}
static gboolean
lyric_show_viewport_expose(GtkWidget *widget,GdkEventExpose *event)
{
LyricShowViewport *lsv;
lsv = LYRIC_SHOW_VIEWPORT(widget);
GdkWindow *view = gtk_viewport_get_view_window(GTK_VIEWPORT(widget));
#if 1 ///必须启用否则widget大小变化时view上的东西不会被自动清除，界面混乱
gint view_width,view_height;
view_width = gdk_window_get_width(view);
view_height = gdk_window_get_height(view);
gtk_paint_flat_box(widget->style,
view,
GTK_STATE_NORMAL,
GTK_SHADOW_NONE,
NULL,
widget,
NULL,
0,0,
view_width,
view_height);
#endif
GTK_WIDGET_CLASS(lyric_show_viewport_parent_class)->expose_event(widget,event);
/// g_warning("is_pressed:%d",lsv->priv->is_pressed);
if(lsv->priv->is_pressed)
{
gtk_paint_hline(widget->style,
gtk_viewport_get_bin_window(GTK_VIEWPORT(widget)),
GTK_STATE_NORMAL,
NULL,
widget,
NULL,
0,widget->allocation.width,
lsv->priv->pos+lsv->priv->pressed_pos+widget->allocation.height/2.0);
}
return FALSE;
}
static gboolean
gtk_tooltip_paint_window (GtkTooltip *tooltip)
{
guchar tooltip_alpha;
gint tooltip_radius;
gtk_widget_style_get (tooltip->window,
"tooltip-alpha", &tooltip_alpha,
"tooltip-radius", &tooltip_radius,
NULL);
if (tooltip_alpha != 255 || tooltip_radius != 0)
{
cairo_t *cr;
cr = gdk_cairo_create (tooltip->window->window);
fill_background (tooltip->window, cr,
&tooltip->window->style->bg [GTK_STATE_NORMAL],
&tooltip->window->style->bg [GTK_STATE_SELECTED],
tooltip_alpha);
cairo_destroy (cr);
update_shape (tooltip);
}
else
{
gtk_paint_flat_box (tooltip->window->style,
tooltip->window->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL,
tooltip->window,
"tooltip",
0, 0,
tooltip->window->allocation.width,
tooltip->window->allocation.height);
}
return FALSE;
}
static void
pager_paint_frame(pager_priv *pg, gint no, GtkStateType state)
{
gint x, y, w, h, border;
ENTER;
RET();
//desk_set_dirty(pg->desks[no]);
border = gtk_container_get_border_width(GTK_CONTAINER(pg->box));
w = pg->box->allocation.width;
h = pg->desks[0]->da->allocation.height + border;
x = 0;
y = h * no;
h += border;
DBG("%d: %d %d %d %d\n", no, x, y, w, h);
gtk_paint_flat_box(pg->box->style, pg->box->window,
state,
GTK_SHADOW_NONE,
NULL, pg->box, "box",
x + 1, y + 1,w, h);
RET();
}
static gint
moz_gtk_entry_paint(GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state,
GtkWidget* widget, GtkTextDirection direction)
{
GtkStateType bg_state = state->disabled ?
GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL;
gint x, y, width = rect->width, height = rect->height;
GtkStyle* style;
gboolean interior_focus;
gboolean theme_honors_transparency = FALSE;
gint focus_width;
gtk_widget_set_direction(widget, direction);
style = gtk_widget_get_style(widget);
gtk_widget_style_get(widget,
"interior-focus", &interior_focus,
"focus-line-width", &focus_width,
"honors-transparent-bg-hint", &theme_honors_transparency,
NULL);
/* gtkentry.c uses two windows, one for the entire widget and one for the
* text area inside it. The background of both windows is set to the "base"
* color of the new state in gtk_entry_state_changed, but only the inner
* textarea window uses gtk_paint_flat_box when exposed */
TSOffsetStyleGCs(style, rect->x, rect->y);
/* This gets us a lovely greyish disabledish look */
gtk_widget_set_sensitive(widget, !state->disabled);
/* GTK fills the outer widget window with the base color before drawing the widget.
* Some older themes rely on this behavior, but many themes nowadays use rounded
* corners on their widgets. While most GTK apps are blissfully unaware of this
* problem due to their use of the default window background, we render widgets on
* many kinds of backgrounds on the web.
* If the theme is able to cope with transparency, then we can skip pre-filling
* and notify the theme it will paint directly on the canvas. */
if (theme_honors_transparency) {
g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
} else {
gdk_draw_rectangle(drawable, style->base_gc[bg_state], TRUE,
cliprect->x, cliprect->y, cliprect->width, cliprect->height);
g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(FALSE));
}
/* Get the position of the inner window, see _gtk_entry_get_borders */
x = XTHICKNESS(style);
y = YTHICKNESS(style);
if (!interior_focus) {
x += focus_width;
y += focus_width;
}
/* Simulate an expose of the inner window */
gtk_paint_flat_box(style, drawable, bg_state, GTK_SHADOW_NONE,
cliprect, widget, "entry_bg", rect->x + x,
rect->y + y, rect->width - 2*x, rect->height - 2*y);
/* Now paint the shadow and focus border.
* We do like in gtk_entry_draw_frame, we first draw the shadow, a tad
* smaller when focused if the focus is not interior, then the focus. */
x = rect->x;
y = rect->y;
if (state->focused && !state->disabled) {
/* This will get us the lit borders that focused textboxes enjoy on
* some themes. */
GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
if (!interior_focus) {
/* Indent the border a little bit if we have exterior focus
(this is what GTK does to draw native entries) */
x += focus_width;
y += focus_width;
width -= 2 * focus_width;
height -= 2 * focus_width;
}
}
gtk_paint_shadow(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
cliprect, widget, "entry", x, y, width, height);
if (state->focused && !state->disabled) {
if (!interior_focus) {
gtk_paint_focus(style, drawable, GTK_STATE_NORMAL, cliprect,
widget, "entry",
rect->x, rect->y, rect->width, rect->height);
}
/* Now unset the focus flag. We don't want other entries to look
* like they're focused too! */
GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
}
return MOZ_GTK_SUCCESS;
}
gboolean eek_preview_expose_event( GtkWidget* widget, GdkEventExpose* event )
{
/* g_message("Exposed!!! %s", GTK_WIDGET_HAS_FOCUS(widget) ? "XXX" : "---" ); */
gint insetX = 0;
gint insetY = 0;
(void)event;
/*
gint lower = widget->allocation.width;
lower = (widget->allocation.height < lower) ? widget->allocation.height : lower;
if ( lower > 16 ) {
insetX++;
if ( lower > 18 ) {
insetX++;
if ( lower > 22 ) {
insetX++;
if ( lower > 24 ) {
insetX++;
if ( lower > 32 ) {
insetX++;
}
}
}
}
insetY = insetX;
}
*/
if ( GTK_WIDGET_DRAWABLE( widget ) ) {
GtkStyle* style = gtk_widget_get_style( widget );
if ( insetX > 0 || insetY > 0 ) {
gtk_paint_flat_box( style,
widget->window,
(GtkStateType)GTK_WIDGET_STATE(widget),
GTK_SHADOW_NONE,
NULL,
widget,
NULL,
0, 0,
widget->allocation.width, widget->allocation.height);
}
GdkGC *gc = gdk_gc_new( widget->window );
EekPreview* preview = EEK_PREVIEW(widget);
GdkColor fg = {0, preview->_r, preview->_g, preview->_b};
gdk_colormap_alloc_color( gdk_colormap_get_system(), &fg, FALSE, TRUE );
gdk_gc_set_foreground( gc, &fg );
gdk_draw_rectangle( widget->window,
gc,
TRUE,
insetX, insetY,
widget->allocation.width - (insetX * 2), widget->allocation.height - (insetY * 2) );
if ( preview->_linked ) {
/* Draw arrow */
GdkRectangle possible = {insetX, insetY, (widget->allocation.width - (insetX * 2)), (widget->allocation.height - (insetY * 2)) };
GdkRectangle area = {possible.x, possible.y, possible.width / 2, possible.height / 2 };
/* Make it square */
if ( area.width > area.height )
area.width = area.height;
if ( area.height > area.width )
area.height = area.width;
/* Center it horizontally */
if ( area.width < possible.width ) {
int diff = (possible.width - area.width) / 2;
area.x += diff;
}
if ( preview->_linked & PREVIEW_LINK_IN ) {
gtk_paint_arrow( style,
widget->window,
(GtkStateType)widget->state,
GTK_SHADOW_ETCHED_IN,
NULL, /* clip area. &area, */
widget, /* may be NULL */
NULL, /* detail */
GTK_ARROW_DOWN,
FALSE,
area.x, area.y,
area.width, area.height
);
}
if ( preview->_linked & PREVIEW_LINK_OUT ) {
GdkRectangle otherArea = {area.x, area.y, area.width, area.height};
if ( otherArea.height < possible.height ) {
otherArea.y = possible.y + (possible.height - otherArea.height);
}
gtk_paint_arrow( style,
widget->window,
(GtkStateType)widget->state,
GTK_SHADOW_ETCHED_OUT,
NULL, /* clip area. &area, */
widget, /* may be NULL */
NULL, /* detail */
GTK_ARROW_UP,
FALSE,
otherArea.x, otherArea.y,
otherArea.width, otherArea.height
);
}
if ( preview->_linked & PREVIEW_LINK_OTHER ) {
GdkRectangle otherArea = {insetX, area.y, area.width, area.height};
if ( otherArea.height < possible.height ) {
otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
}
gtk_paint_arrow( style,
widget->window,
(GtkStateType)widget->state,
GTK_SHADOW_ETCHED_OUT,
NULL, /* clip area. &area, */
widget, /* may be NULL */
NULL, /* detail */
GTK_ARROW_LEFT,
FALSE,
otherArea.x, otherArea.y,
otherArea.width, otherArea.height
);
}
}
if ( GTK_WIDGET_HAS_FOCUS(widget) ) {
gtk_paint_focus( style,
widget->window,
GTK_STATE_NORMAL,
NULL, /* GdkRectangle *area, */
widget,
NULL,
0 + 1, 0 + 1,
widget->allocation.width - 2, widget->allocation.height - 2 );
}
}
return FALSE;
}
static gboolean
gtk_offscreen_box_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkOffscreenBox *offscreen_box = GTK_OFFSCREEN_BOX (widget);
if (gtk_widget_is_drawable (widget))
{
if (event->window == widget->window)
{
GdkPixmap *pixmap;
GtkAllocation child_area;
cairo_t *cr;
int start_y = 0;
if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1))
{
pixmap = gdk_offscreen_window_get_pixmap (offscreen_box->offscreen_window1);
child_area = offscreen_box->child1->allocation;
cr = gdk_cairo_create (widget->window);
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
start_y += child_area.height;
}
if (offscreen_box->child2 && gtk_widget_get_visible (offscreen_box->child2))
{
pixmap = gdk_offscreen_window_get_pixmap (offscreen_box->offscreen_window2);
child_area = offscreen_box->child2->allocation;
cr = gdk_cairo_create (widget->window);
/* transform */
cairo_translate (cr, 0, start_y);
cairo_translate (cr, child_area.width / 2, child_area.height / 2);
cairo_rotate (cr, offscreen_box->angle);
cairo_translate (cr, -child_area.width / 2, -child_area.height / 2);
/* paint */
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
}
}
else if (event->window == offscreen_box->offscreen_window1)
{
gtk_paint_flat_box (widget->style, event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, "blah",
0, 0, -1, -1);
if (offscreen_box->child1)
gtk_container_propagate_expose (GTK_CONTAINER (widget),
offscreen_box->child1,
event);
}
else if (event->window == offscreen_box->offscreen_window2)
{
gtk_paint_flat_box (widget->style, event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, "blah",
0, 0, -1, -1);
if (offscreen_box->child2)
gtk_container_propagate_expose (GTK_CONTAINER (widget),
offscreen_box->child2,
event);
}
}
return FALSE;
}
static void e_reflow_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
int x, int y, int width, int height)
{
int x_rect, y_rect, width_rect, height_rect;
gdouble running_width;
EReflow *reflow = E_REFLOW(item);
int i;
double column_width;
if (GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->draw)
GNOME_CANVAS_ITEM_CLASS(e_reflow_parent_class)->draw (item, drawable, x, y, width, height);
column_width = reflow->column_width;
running_width = E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
x_rect = running_width;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
/* Compute first column to draw. */
i = x;
i /= column_width + E_REFLOW_FULL_GUTTER;
running_width += i * (column_width + E_REFLOW_FULL_GUTTER);
for ( ; i < reflow->column_count; i++) {
if ( running_width > x + width )
break;
x_rect = running_width;
gtk_paint_flat_box(GTK_WIDGET(item->canvas)->style,
drawable,
GTK_STATE_ACTIVE,
GTK_SHADOW_NONE,
NULL,
GTK_WIDGET(item->canvas),
"reflow",
x_rect - x,
y_rect - y,
width_rect,
height_rect);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
if (reflow->column_drag) {
int start_line = e_reflow_pick_line(reflow,
gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas))->value);
i = x - start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width = start_line * (column_width + E_REFLOW_FULL_GUTTER);
column_width = reflow->temp_column_width;
running_width -= start_line * (column_width + E_REFLOW_FULL_GUTTER);
i += start_line * (column_width + E_REFLOW_FULL_GUTTER);
running_width += E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
x_rect = running_width;
y_rect = E_REFLOW_BORDER_WIDTH;
width_rect = E_REFLOW_DIVIDER_WIDTH;
height_rect = reflow->height - (E_REFLOW_BORDER_WIDTH * 2);
/* Compute first column to draw. */
i /= column_width + E_REFLOW_FULL_GUTTER;
running_width += i * (column_width + E_REFLOW_FULL_GUTTER);
for ( ; i < reflow->column_count; i++) {
if ( running_width > x + width )
break;
x_rect = running_width;
gdk_draw_rectangle(drawable,
GTK_WIDGET(item->canvas)->style->fg_gc[GTK_STATE_NORMAL],
TRUE,
x_rect - x,
y_rect - y,
width_rect - 1,
height_rect - 1);
running_width += E_REFLOW_DIVIDER_WIDTH + E_REFLOW_BORDER_WIDTH + column_width + E_REFLOW_BORDER_WIDTH;
}
}
}
static gboolean
gtk_mirror_bin_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
gint width, height;
if (gtk_widget_is_drawable (widget))
{
if (event->window == widget->window)
{
GdkPixmap *pixmap;
cairo_t *cr;
cairo_matrix_t matrix;
cairo_pattern_t *mask;
if (bin->child && gtk_widget_get_visible (bin->child))
{
pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
gdk_drawable_get_size (pixmap, &width, &height);
cr = gdk_cairo_create (widget->window);
cairo_save (cr);
cairo_rectangle (cr, 0, 0, width, height);
cairo_clip (cr);
/* paint the offscreen child */
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint (cr);
cairo_restore (cr);
cairo_matrix_init (&matrix, 1.0, 0.0, 0.3, 1.0, 0.0, 0.0);
cairo_matrix_scale (&matrix, 1.0, -1.0);
cairo_matrix_translate (&matrix, -10, - 3 * height - 10);
cairo_transform (cr, &matrix);
cairo_rectangle (cr, 0, height, width, height);
cairo_clip (cr);
gdk_cairo_set_source_pixmap (cr, pixmap, 0, height);
/* create linear gradient as mask-pattern to fade out the source */
mask = cairo_pattern_create_linear (0.0, height, 0.0, 2*height);
cairo_pattern_add_color_stop_rgba (mask, 0.0, 0.0, 0.0, 0.0, 0.0);
cairo_pattern_add_color_stop_rgba (mask, 0.25, 0.0, 0.0, 0.0, 0.01);
cairo_pattern_add_color_stop_rgba (mask, 0.5, 0.0, 0.0, 0.0, 0.25);
cairo_pattern_add_color_stop_rgba (mask, 0.75, 0.0, 0.0, 0.0, 0.5);
cairo_pattern_add_color_stop_rgba (mask, 1.0, 0.0, 0.0, 0.0, 1.0);
/* paint the reflection */
cairo_mask (cr, mask);
cairo_pattern_destroy (mask);
cairo_destroy (cr);
}
}
else if (event->window == bin->offscreen_window)
{
gtk_paint_flat_box (widget->style, event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, "blah",
0, 0, -1, -1);
if (bin->child)
gtk_container_propagate_expose (GTK_CONTAINER (widget),
bin->child,
event);
}
}
return FALSE;
}
void WidgetRenderingContext::gtkPaintFlatBox(const IntRect& rect, GtkWidget* widget, GtkStateType stateType, GtkShadowType shadowType, const gchar* detail)
{
GdkRectangle paintRect = { m_paintRect.x + rect.x(), m_paintRect.y + rect.y(), rect.width(), rect.height() };
gtk_paint_flat_box(gtk_widget_get_style(widget), m_target, stateType, shadowType, &paintRect,
widget, detail, paintRect.x, paintRect.y, paintRect.width, paintRect.height);
}
void draw_column_data (DdbListview *listview, cairo_t *cr, DdbListviewIter it, DdbListviewIter group_it, int column, int group_y, int group_height, int group_pinned, int grp_next_y, int x, int y, int width, int height) {
const char *ctitle;
int cwidth;
int calign_right;
col_info_t *cinf;
int minheight;
int res = ddb_listview_column_get_info (listview, column, &ctitle, &cwidth, &calign_right, &minheight, (void **)&cinf);
if (res == -1) {
return;
}
DB_playItem_t *playing_track = deadbeef->streamer_get_playing_track ();
int theming = !gtkui_override_listview_colors ();
if (cinf->id == DB_COLUMN_ALBUM_ART) {
if (theming) {
#if GTK_CHECK_VERSION(3,0,0)
cairo_rectangle (cr, x, y, width, height);
cairo_clip (cr);
gtk_paint_flat_box (gtk_widget_get_style (theme_treeview), cr, GTK_STATE_NORMAL, GTK_SHADOW_NONE, theme_treeview, "cell_even_ruled", x-1, y, width+2, height);
cairo_reset_clip (cr);
#else
GdkRectangle clip = {
.x = x,
.y = y,
.width = width,
.height = height,
};
gtk_paint_flat_box (gtk_widget_get_style (theme_treeview), gtk_widget_get_window (listview->list), GTK_STATE_NORMAL, GTK_SHADOW_NONE, &clip, theme_treeview, "cell_even_ruled", x-1, y, width+2, height);
#endif
}
else {
GdkColor clr;
gtkui_get_listview_even_row_color (&clr);
cairo_set_source_rgb (cr, clr.red/65535.f, clr.green/65535.f, clr.blue/65535.f);
cairo_rectangle (cr, x, y, width, height);
cairo_fill (cr);
}
int real_art_width = width - ART_PADDING_HORZ * 2;
if (real_art_width > 0 && group_it) {
const char *album = deadbeef->pl_find_meta (group_it, "album");
const char *artist = deadbeef->pl_find_meta (group_it, "artist");
if (!album || !*album) {
album = deadbeef->pl_find_meta (group_it, "title");
}
if (listview->new_cover_size != real_art_width) {
listview->new_cover_size = real_art_width;
if (listview->cover_refresh_timeout_id) {
g_source_remove (listview->cover_refresh_timeout_id);
listview->cover_refresh_timeout_id = 0;
}
if (listview->cover_size == -1) {
listview->cover_size = real_art_width;
}
else {
if (!listview->cover_refresh_timeout_id) {
listview->cover_refresh_timeout_id = g_timeout_add (1000, deferred_cover_load_cb, listview);
}
}
}
int art_width = listview->cover_size;
int art_y = y; // dest y
int art_h = height;
int sy; // source y
if (group_y < ART_PADDING_VERT) {
art_y = y - group_y + ART_PADDING_VERT;
art_h = height - (art_y - y);
sy = group_y;
}
else {
sy = group_y - ART_PADDING_VERT;
}
int h = cwidth - group_y;
h = min (height, art_h);
int hq = 0;
GdkPixbuf *pixbuf = get_cover_art_callb (deadbeef->pl_find_meta (((DB_playItem_t *)group_it), ":URI"), artist, album, real_art_width == art_width ? art_width : -1, redraw_playlist_single, listview);
if (!pixbuf) {
pixbuf = cover_get_default_pixbuf ();
}
if (pixbuf) {
art_width = gdk_pixbuf_get_width (pixbuf);
float art_scale = (float)real_art_width / art_width;
int pw = real_art_width;
int ph;
if (gdk_pixbuf_get_width (pixbuf) < gdk_pixbuf_get_height (pixbuf)) {
art_scale *= (float)gdk_pixbuf_get_width (pixbuf) / gdk_pixbuf_get_height (pixbuf);
}
if (group_pinned == 1 && gtkui_groups_pinned) {
ph = group_height;
}
else {
ph = pw;
}
if (sy < ph)
{
cairo_save (cr);
if (group_pinned == 1 && gtkui_groups_pinned) {
int ph_real = gdk_pixbuf_get_height (pixbuf);
if (grp_next_y <= ph_real * art_scale + listview->grouptitle_height) {
cairo_rectangle (cr, x + ART_PADDING_HORZ, grp_next_y - ph_real * art_scale, pw, ph);
cairo_translate (cr, (x + ART_PADDING_HORZ)-0, grp_next_y - ph_real * art_scale);
}
else {
cairo_rectangle (cr, x + ART_PADDING_HORZ, listview->grouptitle_height, pw, ph);
cairo_translate (cr, (x + ART_PADDING_HORZ)-0, listview->grouptitle_height);
}
}
else {
ph -= sy;
ph = min (ph, h);
cairo_rectangle (cr, x + ART_PADDING_HORZ, art_y, pw, ph);
cairo_translate (cr, (x + ART_PADDING_HORZ)-0, art_y - sy);
}
cairo_scale (cr, art_scale, art_scale);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_pattern_set_filter (cairo_get_source(cr), gtkui_is_default_pixbuf (pixbuf) ? CAIRO_FILTER_GAUSSIAN : CAIRO_FILTER_FAST);
cairo_fill (cr);
cairo_restore (cr);
}
g_object_unref (pixbuf);
}
}
}
static void
gtk_real_check_item_draw_indicator (GtkCheckItem *check_item,
GdkRectangle *area)
{
GtkWidget *widget;
GtkToggleButton *toggle_button;
GtkStateType state_type;
GdkRectangle restrict_area;
GdkRectangle new_area;
GdkGC *fg_gc = NULL;
gint width, height;
gint x, y;
gint border;
GdkWindow *window;
g_return_if_fail (check_item != NULL);
g_return_if_fail (GTK_IS_CHECK_ITEM (check_item));
widget = GTK_WIDGET (check_item);
toggle_button = GTK_TOGGLE_BUTTON (check_item);
if (GTK_WIDGET_DRAWABLE (check_item))
{
window = widget->window;
state_type = GTK_WIDGET_STATE (widget);
if (state_type != GTK_STATE_NORMAL &&
state_type != GTK_STATE_PRELIGHT)
state_type = GTK_STATE_NORMAL;
restrict_area.x = widget->allocation.x + GTK_CONTAINER (widget)->border_width;
restrict_area.y = widget->allocation.y + GTK_CONTAINER (widget)->border_width;
restrict_area.width = widget->allocation.width - ( 2 * GTK_CONTAINER (widget)->border_width);
restrict_area.height = widget->allocation.height - ( 2 * GTK_CONTAINER (widget)->border_width);
if (gdk_rectangle_intersect (area, &restrict_area, &new_area))
{
if (state_type != GTK_STATE_NORMAL)
gtk_paint_flat_box (widget->style, window, state_type,
GTK_SHADOW_ETCHED_OUT,
area, widget, "checkitem",
new_area.x, new_area.y,
new_area.width, new_area.height);
}
x = widget->allocation.x + CHECK_ITEM_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
y = widget->allocation.y + (widget->allocation.height - CHECK_ITEM_CLASS (widget)->indicator_size) / 2;
width = CHECK_ITEM_CLASS (widget)->indicator_size;
height = CHECK_ITEM_CLASS (widget)->indicator_size;
if(!GTK_BIN(widget)->child){
x = widget->allocation.x + widget->allocation.width/2 - width/2;
y = widget->allocation.y + widget->allocation.height/2 - height/2;
}
if (GTK_TOGGLE_BUTTON (widget)->active)
{
state_type = GTK_STATE_ACTIVE;
}
else
{
state_type = GTK_STATE_NORMAL;
}
fg_gc = gdk_gc_new(window);
gdk_gc_set_foreground(fg_gc, &widget->style->white);
gdk_draw_rectangle(window,
fg_gc,
TRUE,
x, y, width, height);
gtk_draw_shadow (widget->style, window, GTK_STATE_NORMAL,
GTK_SHADOW_IN, x, y, width, height);
if(state_type == GTK_STATE_ACTIVE){
GdkPoint points[3];
border = widget->style->klass->xthickness;
gdk_gc_set_foreground(fg_gc, &widget->style->black);
x += border;
y += border;
points[0].x = x+1;
points[0].y = y+6;
points[1].x = x+3;
points[1].y = y+height-2*border-2;
points[2].x = x+width-2*border-2;
points[2].y = y+3;
gdk_draw_lines(window, fg_gc, points, 3);
points[0].x = x+1;
points[0].y = y+5;
points[1].x = x+3;
points[1].y = y+height-2*border-3;
points[2].x = x+width-2*border-2;
points[2].y = y+2;
gdk_draw_lines(window, fg_gc, points, 3);
points[0].x = x+1;
points[0].y = y+4;
points[1].x = x+3;
points[1].y = y+height-2*border-4;
points[2].x = x+width-2*border-2;
points[2].y = y+1;
gdk_draw_lines(window, fg_gc, points, 3);
}
}
gdk_gc_unref(fg_gc);
}
void draw_column_data (DdbListview *listview, cairo_t *cr, DdbListviewIter it, DdbListviewIter group_it, int column, int group_y, int x, int y, int width, int height) {
const char *ctitle;
int cwidth;
int calign_right;
col_info_t *cinf;
int minheight;
int res = ddb_listview_column_get_info (listview, column, &ctitle, &cwidth, &calign_right, &minheight, (void **)&cinf);
if (res == -1) {
return;
}
DB_playItem_t *playing_track = deadbeef->streamer_get_playing_track ();
int theming = !gtkui_override_listview_colors ();
if (cinf->id == DB_COLUMN_ALBUM_ART) {
if (theming) {
#if GTK_CHECK_VERSION(3,0,0)
cairo_rectangle (cr, x, y, width, height);
cairo_clip (cr);
gtk_paint_flat_box (gtk_widget_get_style (theme_treeview), cr, GTK_STATE_NORMAL, GTK_SHADOW_NONE, theme_treeview, "cell_even_ruled", x-1, y, width+2, height);
cairo_reset_clip (cr);
#else
GdkRectangle clip = {
.x = x,
.y = y,
.width = width,
.height = height,
};
gtk_paint_flat_box (gtk_widget_get_style (theme_treeview), gtk_widget_get_window (listview->list), GTK_STATE_NORMAL, GTK_SHADOW_NONE, &clip, theme_treeview, "cell_even_ruled", x-1, y, width+2, height);
#endif
}
else {
GdkColor clr;
gtkui_get_listview_even_row_color (&clr);
cairo_set_source_rgb (cr, clr.red/65535.f, clr.green/65535.f, clr.blue/65535.f);
cairo_rectangle (cr, x, y, width, height);
cairo_fill (cr);
}
int art_width = width - ART_PADDING_HORZ * 2;
int art_y = y; // dest y
int art_h = height;
int sy; // source y
if (group_y < ART_PADDING_VERT) {
art_y = y - group_y + ART_PADDING_VERT;
art_h = height - (art_y - y);
sy = group_y;
}
else {
sy = group_y - ART_PADDING_VERT;
}
if (art_width > 0) {
if (group_it) {
int h = cwidth - group_y;
h = min (height, art_h);
const char *album = deadbeef->pl_find_meta (group_it, "album");
const char *artist = deadbeef->pl_find_meta (group_it, "artist");
if (!album || !*album) {
album = deadbeef->pl_find_meta (group_it, "title");
}
GdkPixbuf *pixbuf = get_cover_art (deadbeef->pl_find_meta (((DB_playItem_t *)group_it), ":URI"), artist, album, art_width);
if (pixbuf) {
int pw = gdk_pixbuf_get_width (pixbuf);
int ph = gdk_pixbuf_get_height (pixbuf);
if (sy < ph)
{
pw = min (art_width, pw);
ph -= sy;
ph = min (ph, h);
gdk_cairo_set_source_pixbuf (cr, pixbuf, (x + ART_PADDING_HORZ)-0, (art_y)-sy);
cairo_rectangle (cr, x + ART_PADDING_HORZ, art_y, pw, ph);
cairo_fill (cr);
}
g_object_unref (pixbuf);
}
}
}
}
static void
draw_ping_graph (Netinfo *netinfo)
{
cairo_t *cr;
GtkStyle *style;
GtkWidget *widget;
PangoLayout *layout;
gint ntodisplay = 5;
gint rangemin, rangemax;
PingGraphBarData *bar_data;
gdouble max;
gint width, height;
gint font_height, offset;
gint bar_height, separator_height;
gdouble scale_factor;
gint line1h, line2h;
gint index;
gint step, x, h;
gchar *tmpstr;
widget = netinfo->graph;
cr = gdk_cairo_create (gtk_widget_get_window(widget));
style = gtk_widget_get_style(widget);
rangemax = packets_transmitted;
rangemin = MAX (0, rangemax - ntodisplay);
bar_data = g_newa (PingGraphBarData, ntodisplay);
max = get_bar_data (netinfo, bar_data, ntodisplay, rangemin,
rangemax);
/* Created up here so we can get the geometry info. */
layout = gtk_widget_create_pango_layout (widget, _("Time (ms):"));
/* We guess that the first label is representative. */
pango_layout_get_pixel_size (layout, NULL, &font_height);
width = gtk_widget_get_allocated_width (widget);
height = gtk_widget_get_allocated_height (widget);
offset = 0.05*height;
bar_height = height - 2.5*font_height - offset;
scale_factor = bar_height / max;
separator_height = bar_height + offset;
line1h = bar_height + 0.125*font_height + offset;
line2h = bar_height + 1.25*font_height + offset;
gtk_paint_box (style, cr, GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
widget, NULL, 0, 0, width, height);
gtk_paint_layout (style, cr, GTK_STATE_NORMAL, TRUE,
widget, NULL, 0.02*width, line1h,
layout);
g_object_unref (layout);
layout = gtk_widget_create_pango_layout (widget, _("Seq. No.:"));
gtk_paint_layout (style, cr, GTK_STATE_NORMAL, TRUE,
widget, NULL, 0.02*width, line2h,
layout);
g_object_unref (layout);
gtk_paint_hline (style, cr, GTK_STATE_NORMAL, widget, NULL,
0.02*width, 0.98*width, separator_height);
index = 0;
step = width / (ntodisplay + 1.0);
for (x = 1.5*step; x < width; x += step) {
if (bar_data[index].valid) {
h = scale_factor*bar_data[index].value;
gtk_paint_flat_box (style, cr, GTK_STATE_SELECTED,
GTK_SHADOW_ETCHED_IN, widget,
NULL, x - 0.4*step,
offset + bar_height - h,
0.8*step, h);
tmpstr = g_strdup_printf ("%.2f", bar_data[index].value);
} else {
tmpstr = g_strdup ("-");
}
draw_centered_text (widget, cr, x, line1h, tmpstr);
g_free (tmpstr);
if (index + rangemin + 1 <= rangemax) {
tmpstr = g_strdup_printf ("%d", index + rangemin + 1);
} else {
tmpstr = g_strdup ("-");
}
draw_centered_text (widget, cr, x, line2h, tmpstr);
g_free (tmpstr);
index++;
}
cairo_destroy (cr);
}
