static gint panels_expose(GtkWidget *widget, GdkEventExpose *event)
{
Panels *panels;
GtkWidget *child;
GList *children;
GdkEventExpose child_event;
g_return_val_if_fail(widget != NULL, FALSE);
g_return_val_if_fail(IS_PANELS(widget), FALSE);
g_return_val_if_fail(event != NULL, FALSE);
if (GTK_WIDGET_DRAWABLE(widget)) {
panels = PANELS(widget);
child_event = *event;
for (children = panels->children;
children && (child = children->data);
children = children->next) {
if (child &&
GTK_WIDGET_DRAWABLE(child) &&
GTK_WIDGET_NO_WINDOW(child) &&
gtk_widget_intersect(child, &event->area,
&child_event.area))
gtk_widget_event(child, (GdkEvent *)&child_event);
}
}
return FALSE;
}
static gint columns_expose(GtkWidget *widget, GdkEventExpose *event)
{
Columns *cols;
ColumnsChild *child;
GList *children;
GdkEventExpose child_event;
g_return_val_if_fail(widget != NULL, FALSE);
g_return_val_if_fail(IS_COLUMNS(widget), FALSE);
g_return_val_if_fail(event != NULL, FALSE);
if (GTK_WIDGET_DRAWABLE(widget)) {
cols = COLUMNS(widget);
child_event = *event;
for (children = cols->children; children && (child = children->data);
children = children->next) {
if (child->widget && GTK_WIDGET_DRAWABLE(child->widget) &&
GTK_WIDGET_NO_WINDOW(child->widget) &&
gtk_widget_intersect(child->widget, &event->area, &child_event.area))
gtk_widget_event(child->widget, (GdkEvent *)&child_event);
}
}
return FALSE;
}
static void
gtk_form_draw(GtkWidget *widget, GdkRectangle *area)
{
GtkForm *form;
GList *children;
GtkFormChild *child;
GdkRectangle child_area;
g_return_if_fail(GTK_IS_FORM(widget));
if (GTK_WIDGET_DRAWABLE(widget))
{
form = GTK_FORM(widget);
children = form->children;
while (children)
{
child = children->data;
if (GTK_WIDGET_DRAWABLE(child->widget)
&& gtk_widget_intersect(child->widget, area, &child_area))
gtk_widget_draw(child->widget, &child_area);
children = children->next;
}
}
}
/*
* Override GtkContainer's focus movement so the user can
* explicitly specify the tab order.
*/
static gint columns_focus(GtkContainer *container, GtkDirectionType dir)
{
Columns *cols;
GList *pos;
GtkWidget *focuschild;
g_return_val_if_fail(container != NULL, FALSE);
g_return_val_if_fail(IS_COLUMNS(container), FALSE);
cols = COLUMNS(container);
if (!GTK_WIDGET_DRAWABLE(cols) ||
!GTK_WIDGET_IS_SENSITIVE(cols))
return FALSE;
if (!GTK_WIDGET_CAN_FOCUS(container) &&
(dir == GTK_DIR_TAB_FORWARD || dir == GTK_DIR_TAB_BACKWARD)) {
focuschild = container->focus_child;
gtk_container_set_focus_child(container, NULL);
if (dir == GTK_DIR_TAB_FORWARD)
pos = cols->taborder;
else
pos = g_list_last(cols->taborder);
while (pos) {
GtkWidget *child = pos->data;
if (focuschild) {
if (focuschild == child) {
focuschild = NULL; /* now we can start looking in here */
if (GTK_WIDGET_DRAWABLE(child) &&
GTK_IS_CONTAINER(child) &&
!GTK_WIDGET_HAS_FOCUS(child)) {
if (gtk_container_focus(GTK_CONTAINER(child), dir))
return TRUE;
}
}
} else if (GTK_WIDGET_DRAWABLE(child)) {
if (GTK_IS_CONTAINER(child)) {
if (gtk_container_focus(GTK_CONTAINER(child), dir))
return TRUE;
} else if (GTK_WIDGET_CAN_FOCUS(child)) {
gtk_widget_grab_focus(child);
return TRUE;
}
}
if (dir == GTK_DIR_TAB_FORWARD)
pos = pos->next;
else
pos = pos->prev;
}
return FALSE;
} else
return columns_inherited_focus(container, dir);
}
static gint
awt_gtk_panel_expose (GtkWidget *widget,
GdkEventExpose *event)
{
AWTGtkPanel *panel;
GtkWidget *child;
GdkEventExpose child_event;
GList *children;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (GTK_WIDGET_DRAWABLE (widget))
{
panel = AWT_GTK_PANEL (widget);
child_event = *event;
children = panel->children;
while (children)
{
child = children->data;
children = children->next;
if (GTK_WIDGET_NO_WINDOW (child) &&
gtk_widget_intersect (child, &event->area,
&child_event.area))
gtk_widget_event (child, (GdkEvent*) &child_event);
}
}
return FALSE;
}
static void
awt_gtk_panel_draw (GtkWidget *widget,
GdkRectangle *area)
{
AWTGtkPanel *panel;
GtkWidget *child;
GdkRectangle child_area;
GList *children;
g_return_if_fail (widget != NULL);
if (GTK_WIDGET_DRAWABLE (widget))
{
panel = AWT_GTK_PANEL (widget);
awt_gtk_panel_paint (widget, area);
children = panel->children;
while (children)
{
child = children->data;
children = children->next;
if (gtk_widget_intersect (child, area, &child_area))
gtk_widget_draw (child, &child_area);
}
}
}
/*
From gtkcontainer.c
*/
void
_container_propagate_expose (GtkContainer *container,
GtkWidget *child,
GdkEventExpose *event)
{
GdkEvent *child_event;
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (GTK_IS_WIDGET (child));
g_return_if_fail (event != NULL);
g_assert (child->parent == GTK_WIDGET (container));
if (GTK_WIDGET_DRAWABLE (child) &&
GTK_WIDGET_NO_WINDOW (child) &&
(child->window == event->window)&&
AWN_IS_CAIRO_MENU_ITEM(child))
{
child_event = gdk_event_new (GDK_EXPOSE);
child_event->expose = *event;
g_object_ref (child_event->expose.window);
child_event->expose.region = gtk_widget_region_intersect (child, event->region);
if (!gdk_region_empty (child_event->expose.region))
{
gdk_region_get_clipbox (child_event->expose.region, &child_event->expose.area);
gtk_widget_send_expose (child, child_event);
}
gdk_event_free (child_event);
}
}
static void
gwy_vruler_draw_ticks(GwyRuler *ruler)
{
GtkWidget *widget;
GdkGC *gc;
gint width, height;
gint xthickness;
gint ythickness;
if (!GTK_WIDGET_DRAWABLE(ruler))
return;
widget = GTK_WIDGET(ruler);
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
xthickness = widget->style->xthickness;
ythickness = widget->style->ythickness;
height = widget->allocation.height;
width = widget->allocation.width - 2*xthickness;
gdk_draw_line(ruler->backing_store, gc,
height + xthickness,
ythickness,
height + xthickness,
widget->allocation.height - ythickness);
gwy_vruler_real_draw_ticks(ruler, height,
xthickness + MINIMUM_INCR, MINIMUM_INCR);
}
static void
sp_gradient_image_update (SPGradientImage *image)
{
GtkAllocation *allocation;
if (!image->px) return;
allocation = &((GtkWidget *) image)->allocation;
if (image->gradient) {
nr_render_checkerboard_rgb (image->px, allocation->width, VBLOCK, 3 * allocation->width, 0, 0);
sp_gradient_render_vector_block_rgb (image->gradient,
image->px, allocation->width, VBLOCK, 3 * allocation->width,
0, allocation->width, TRUE);
} else {
NRPixBlock pb;
nr_pixblock_setup_extern (&pb, NR_PIXBLOCK_MODE_R8G8B8,
0, 0, allocation->width, VBLOCK,
image->px, 3 * allocation->width, TRUE, FALSE);
nr_pixblock_render_gray_noise (&pb, NULL);
nr_pixblock_release (&pb);
}
if (GTK_WIDGET_DRAWABLE (image)) {
gtk_widget_queue_draw (GTK_WIDGET (image));
}
}
static int screensaver_idle_handler(gpointer user_data) {
ScreenSaver *self = SCREENSAVER(user_data);
iterative_map_calculate_motion(ITERATIVE_MAP(self->frame_renders[self->current_frame]), 100000,
TRUE, PARAMETER_INTERPOLATOR(parameter_holder_interpolate_linear),
&self->frame_parameters[self->current_frame]);
if (GTK_WIDGET_DRAWABLE(self->view)) {
histogram_view_set_imager(HISTOGRAM_VIEW(self->view),
HISTOGRAM_IMAGER(self->frame_renders[self->current_frame]));
histogram_view_update(HISTOGRAM_VIEW(self->view));
self->current_frame += self->direction;
if (self->current_frame >= self->num_frames) {
self->current_frame = self->num_frames-2;
self->direction = -1;
}
if (self->current_frame < 0) {
self->current_frame = 1;
self->direction = 1;
}
}
return 1;
}
/**
* ppg_ruler_size_allocate:
* @ruler: (in): A #PpgRuler.
*
* Handle the "size-allocate" for the #GtkWidget. The pixmap for the
* background is created and drawn if necessary.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_ruler_size_allocate (GtkWidget *widget,
GtkAllocation *alloc)
{
PpgRuler *ruler = (PpgRuler *)widget;
PpgRulerPrivate *priv;
GdkColormap *colormap;
GdkVisual *visual;
g_return_if_fail(PPG_IS_RULER(ruler));
priv = ruler->priv;
GTK_WIDGET_CLASS(ppg_ruler_parent_class)->size_allocate(widget, alloc);
if (priv->ruler) {
g_object_unref(priv->ruler);
}
priv->ruler = gdk_pixmap_new(NULL, alloc->width, alloc->height, 32);
visual = gdk_visual_get_best_with_depth(32);
colormap = gdk_colormap_new(visual, FALSE);
gdk_drawable_set_colormap(priv->ruler, colormap);
if (GTK_WIDGET_DRAWABLE(widget)) {
ppg_ruler_draw_ruler(ruler);
}
}
static gboolean
gtk_vkb_button_expose (GtkWidget *widget, GdkEventExpose *event)
{
GtkVkbButton *button = GTK_VKB_BUTTON(widget);
GtkWidget *child;
GList *children;
GList *tmplist;
g_return_val_if_fail(widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_VKB_BUTTON(widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if(GTK_WIDGET_DRAWABLE(widget)){
GtkStateType state = GTK_WIDGET_STATE(widget);
if (!button->bg_pixmap) {
gdk_window_set_background(widget->window, &button->bgcolor[state]);
gdk_window_clear(widget->window);
}
children = gtk_container_get_children(GTK_CONTAINER(widget));
tmplist = children;
while (tmplist) {
child = GTK_WIDGET(tmplist->data);
tmplist = tmplist->next;
gtk_container_propagate_expose(GTK_CONTAINER(widget),
child, event);
}
g_list_free(children);
}
return FALSE;
}
static gboolean
immerse_clamp_detail_offset(ImmerseControls *controls,
gdouble xpos, gdouble ypos)
{
xpos = CLAMP(xpos, 0.0, controls->xmax);
ypos = CLAMP(ypos, 0.0, controls->ymax);
if (xpos != controls->args->xpos || ypos != controls->args->ypos) {
gchar *s;
controls->args->xpos = xpos;
controls->args->ypos = ypos;
s = g_strdup_printf("(%.*f, %.*f) %s",
controls->vf->precision + 1,
xpos/controls->vf->magnitude,
controls->vf->precision + 1,
ypos/controls->vf->magnitude,
controls->vf->units);
gtk_label_set_text(GTK_LABEL(controls->pos), s);
g_free(s);
if (GTK_WIDGET_DRAWABLE(controls->view))
gtk_widget_queue_draw(controls->view);
return TRUE;
}
return FALSE;
}
/* Pøidání textového popisu události do seznamu zachycených událostí we
* widgetu */
static void gtk_ev_push_text(GtkEv *ev, const gchar* text)
{
g_return_if_fail(ev);
if(text) {
gchar** event;
event = g_strsplit(text, "\n", 10);
ev->list = g_list_prepend(ev->list, event);
ev->list_len ++;
if(ev->list_end == NULL)
ev->list_end = ev->list;
if(ev->list_len > 100) {
GList* prev = ev->list_end->prev;
prev->next = NULL;
g_strfreev(ev->list_end->data);
g_list_free_1(ev->list_end);
ev->list_end = prev;
ev->list_len--;
}
}
if(GTK_WIDGET_DRAWABLE(ev))
gtk_widget_queue_draw_area(GTK_WIDGET(ev), ev->list_rect.x,
ev->list_rect.y, ev->list_rect.width,
ev->list_rect.height);
}
static gboolean
hildon_vvolumebar_expose (GtkWidget *widget,
GdkEventExpose *event)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(HILDON_VOLUMEBAR(widget));
g_assert (priv);
if (GTK_WIDGET_DRAWABLE (widget)) {
/* Paint background */
gtk_paint_box (widget->style, widget->window,
GTK_WIDGET_STATE (priv->volumebar), GTK_SHADOW_OUT,
NULL, widget, "background",
widget->allocation.x,
widget->allocation.y,
widget->allocation.width,
widget->allocation.height);
/* The contents of the widget can paint themselves */
(*GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
}
return FALSE;
}
/* This should only be called when toggle_button->draw_indicator
* is true.
*/
static void
gtk_check_item_paint (GtkWidget *widget,
GdkRectangle *area)
{
GtkCheckItem *check_item;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CHECK_ITEM (widget));
check_item = GTK_CHECK_ITEM (widget);
if (GTK_WIDGET_DRAWABLE (widget))
{
gint border_width;
gtk_check_item_draw_indicator (check_item, area);
border_width = GTK_CONTAINER (widget)->border_width;
if (GTK_WIDGET_HAS_FOCUS (widget))
gtk_paint_focus (widget->style, widget->window,
NULL, widget, "checkitem",
border_width + widget->allocation.x,
border_width + widget->allocation.y,
widget->allocation.width - 2 * border_width - 1,
widget->allocation.height - 2 * border_width - 1);
}
}
/* Kreslicí funkce spoleèná pro gtk_ev_draw() a gtk_ev_expose(), která kreslí
* hlavní okno widgetu */
static void gtk_ev_paint(GtkEv *ev, GdkRectangle *area)
{
GtkWidget *widget;
g_return_if_fail(ev);
g_return_if_fail(area);
widget = GTK_WIDGET(ev);
if(!GTK_WIDGET_DRAWABLE(widget))
return; /* Not visible and mapped */
gdk_window_clear_area(widget->window, area->x, area->y, area->width,
area->height);
gdk_gc_set_clip_rectangle(widget->style->black_gc, area);
/* Èerný rámeèek kolem vnitøního okna */
gdk_draw_rectangle(widget->window, widget->style->black_gc, FALSE,
ev->ev_win_rect.x-1, ev->ev_win_rect.y-1,
ev->ev_win_rect.width+2, ev->ev_win_rect.height+2);
gdk_gc_set_clip_rectangle(widget->style->black_gc, NULL);
/* Text (seznam zachycených událostí) */
if(ev->list) {
GdkRectangle intersect;
if(gdk_rectangle_intersect(&ev->list_rect, area, &intersect)) {
static const gint space = 2;
gint line, step, first_baseline;
GList *p;
GdkFont *font = gtk_style_get_font(widget->style);
step = font->ascent + font->descent + space;
first_baseline = ev->list_rect.y + font->ascent + space;
line = 0;
for(p = ev->list; p; p = g_list_next(p)) {
gchar **pev = p->data;
gint i;
for(i = 0; pev[i]; i++) {
gtk_paint_string(widget->style, widget->window,
widget->state, &intersect, widget,
(char *) "ev", ev->list_rect.x,
first_baseline + line*step, pev[i]);
line++;
}
if(first_baseline + line*step - 2*step >
intersect.y + intersect.height)
break;
}
}
}
/* Grafické zvýraznìní, kdy¾ má okno focus */
if(GTK_WIDGET_HAS_FOCUS(widget))
gtk_paint_focus(widget->style, widget->window, GTK_WIDGET_STATE(widget),
area, widget, (char *) "ev", 0, 0, -1, -1);
}
/* Kreslicí funkce spoleèná pro gtk_ev_draw() a gtk_ev_expose(), která kreslí
* vnitøní okno widgetu */
static void gtk_ev_paint_ev_win(GtkEv *ev, GdkRectangle *area)
{
GtkWidget *widget;
gint width, x, y;
const char *title = "Event Window";
GdkFont *font;
g_return_if_fail(ev);
g_return_if_fail(area);
widget = GTK_WIDGET(ev);
font = gtk_style_get_font(widget->style);
if(!GTK_WIDGET_DRAWABLE(ev))
return;
gdk_window_clear_area(ev->ev_win, area->x, area->y,
area->width, area->height);
gdk_gc_set_clip_rectangle(widget->style->black_gc, area);
width = gdk_string_width(font, title);
x = (ev->ev_win_rect.width - width)/2;
y = font->ascent + 2;
gdk_draw_string(ev->ev_win, font, widget->style->black_gc, x, y, title);
gdk_gc_set_clip_rectangle(widget->style->black_gc, NULL);
}
static void
gimp_histogram_editor_frozen_update (GimpHistogramEditor *editor,
const GParamSpec *pspec)
{
GimpHistogramView *view = GIMP_HISTOGRAM_BOX (editor->box)->view;
if (gimp_viewable_preview_is_frozen (GIMP_VIEWABLE (editor->drawable)))
{
/* Only do the background histogram if the histogram is visible.
* This is a workaround for the fact that recalculating the
* histogram is expensive and that it is only validated when it
* is shown. So don't slow down painting by doing something that
* is not even seen by the user.
*/
if (! editor->bg_histogram && GTK_WIDGET_DRAWABLE (editor))
{
if (gimp_histogram_editor_validate (editor))
editor->bg_histogram = gimp_histogram_duplicate (editor->histogram);
gimp_histogram_view_set_background (view, editor->bg_histogram);
}
}
else if (editor->bg_histogram)
{
gimp_histogram_unref (editor->bg_histogram);
editor->bg_histogram = NULL;
gimp_histogram_view_set_background (view, NULL);
}
}
/* update the animation information for each widget. This will also queue a redraw
* and stop the animation if it is done. */
static gboolean
update_animation_info (gpointer key, gpointer value, gpointer user_data)
{
(void) user_data;
AnimationInfo *animation_info = value;
GtkWidget *widget = key;
g_assert ((widget != NULL) && (animation_info != NULL));
/* remove the widget from the hash table if it is not drawable */
if (!GTK_WIDGET_DRAWABLE (widget))
{
return TRUE;
}
if (GE_IS_PROGRESS_BAR (widget))
{
gfloat fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (widget));
/* stop animation for filled/not filled progress bars */
if (fraction <= 0.0 || fraction >= 1.0)
return TRUE;
}
force_widget_redraw (widget);
/* stop at stop_time */
if (animation_info->stop_time != 0 &&
g_timer_elapsed (animation_info->timer, NULL) > animation_info->stop_time)
return TRUE;
return FALSE;
}
static void
gtk_check_item_draw (GtkWidget *widget,
GdkRectangle *area)
{
GtkCheckItem *check_item;
GtkToggleButton *toggle_button;
GtkBin *bin;
GdkRectangle child_area;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CHECK_ITEM (widget));
g_return_if_fail (area != NULL);
check_item = GTK_CHECK_ITEM (widget);
toggle_button = GTK_TOGGLE_BUTTON (widget);
bin = GTK_BIN (widget);
if (GTK_WIDGET_DRAWABLE (widget))
{
if (toggle_button->draw_indicator)
{
gtk_check_item_paint (widget, area);
if (bin->child && gtk_widget_intersect (bin->child, area, &child_area))
gtk_widget_draw (bin->child, &child_area);
}
else
{
if (GTK_WIDGET_CLASS (parent_class)->draw)
(* GTK_WIDGET_CLASS (parent_class)->draw) (widget, area);
}
}
}
gboolean nsgtk_widget_is_drawable(GtkWidget *widget)
{
#if GTK_CHECK_VERSION(2,18,0)
return gtk_widget_is_drawable(widget);
#else
return GTK_WIDGET_DRAWABLE(widget);
#endif
}
void
sp_color_preview_set_rgba32 (SPColorPreview *cp, guint32 rgba)
{
cp->rgba = rgba;
if (GTK_WIDGET_DRAWABLE (cp)) {
gtk_widget_queue_draw (GTK_WIDGET (cp));
}
}
static void
gtk_hruler_draw_pos (GtkRuler *ruler)
{
GtkWidget *widget;
GdkGC *gc;
int i;
gint x, y;
gint width, height;
gint bs_width, bs_height;
gint xthickness;
gint ythickness;
gfloat increment;
g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_HRULER (ruler));
if (GTK_WIDGET_DRAWABLE (ruler))
{
widget = GTK_WIDGET (ruler);
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
xthickness = widget->style->klass->xthickness;
ythickness = widget->style->klass->ythickness;
width = widget->allocation.width;
height = widget->allocation.height - ythickness * 2;
bs_width = height / 2;
bs_width |= 1; /* make sure it's odd */
bs_height = bs_width / 2 + 1;
if ((bs_width > 0) && (bs_height > 0))
{
/* If a backing store exists, restore the ruler */
if (ruler->backing_store && ruler->non_gr_exp_gc)
gdk_draw_pixmap (ruler->widget.window,
ruler->non_gr_exp_gc,
ruler->backing_store,
ruler->xsrc, ruler->ysrc,
ruler->xsrc, ruler->ysrc,
bs_width, bs_height);
increment = (gfloat) width / (ruler->upper - ruler->lower);
x = ROUND ((ruler->position - ruler->lower) * increment) + (xthickness - bs_width) / 2 - 1;
y = (height + bs_height) / 2 + ythickness;
for (i = 0; i < bs_height; i++)
gdk_draw_line (widget->window, gc,
x + i, y + i,
x + bs_width - 1 - i, y + i);
ruler->xsrc = x;
ruler->ysrc = y;
}
}
}
void scope_setdata(Scope *scope, short *samples)
{
g_return_if_fail(scope != NULL);
g_return_if_fail(IS_SCOPE(scope));
memcpy(scope->y, samples, sizeof(scope->y));
if (GTK_WIDGET_DRAWABLE(GTK_WIDGET(scope))) {
if (!scope->idlefunc)
scope->idlefunc = gtk_idle_add_priority(PRIO, idle_callback, scope);
}
}
static gint idle_callback(gpointer data)
{
g_return_val_if_fail(data != NULL, FALSE);
g_return_val_if_fail(IS_SCOPE(data), FALSE);
SCOPE(data)->idlefunc = 0;
if (!GTK_WIDGET_DRAWABLE(GTK_WIDGET(data)))
return FALSE;
draw(SCOPE(data));
return FALSE; /* don't call this callback again */
}
static void
on_hide (GtkWindow *window)
{
GtkWindow *parent = gtk_window_get_transient_for (window);
if (parent && GTK_WIDGET_DRAWABLE (parent))
gtk_window_present (parent);
g_signal_handlers_disconnect_by_func (window, (gpointer) on_hide, NULL);
}
void scope_setmarker(Scope *scope, int pointer)
{
g_return_if_fail(scope != NULL);
g_return_if_fail(IS_SCOPE(scope));
if (pointer >= 0 && pointer < SCOPE_WIDTH)
scope->pointer = pointer;
if (GTK_WIDGET_DRAWABLE(GTK_WIDGET(scope))) {
if (!scope->idlefunc)
scope->idlefunc = g_idle_add_full(PRIO, idle_callback, scope, NULL);
}
}
static void
gtk_hex_entry_draw (GtkWidget *widget,
GdkRectangle *area)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (widget));
g_return_if_fail (area != NULL);
if (GTK_WIDGET_DRAWABLE (widget))
gtk_hex_entry_paint (widget, area);
}
static void columns_draw(GtkWidget *widget, GdkRectangle *area)
{
Columns *cols;
ColumnsChild *child;
GList *children;
GdkRectangle child_area;
g_return_if_fail(widget != NULL);
g_return_if_fail(IS_COLUMNS(widget));
if (GTK_WIDGET_DRAWABLE(widget)) {
cols = COLUMNS(widget);
for (children = cols->children; children && (child = children->data);
children = children->next) {
if (child->widget && GTK_WIDGET_DRAWABLE(child->widget) &&
gtk_widget_intersect(child->widget, area, &child_area))
gtk_widget_draw(child->widget, &child_area);
}
}
}
