static gint
moz_gtk_scrolled_window_paint(GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state)
{
GtkStyle* style;
GtkAllocation allocation;
GtkWidget* widget;
ensure_scrolled_window_widget();
widget = gParts->scrolledWindowWidget;
gtk_widget_get_allocation(widget, &allocation);
allocation.x = rect->x;
allocation.y = rect->y;
allocation.width = rect->width;
allocation.height = rect->height;
gtk_widget_set_allocation(widget, &allocation);
style = gtk_widget_get_style(widget);
TSOffsetStyleGCs(style, rect->x - 1, rect->y - 1);
gtk_paint_shadow(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
cliprect, gParts->scrolledWindowWidget, "scrolled_window",
rect->x, rect->y, rect->width, rect->height);
return MOZ_GTK_SUCCESS;
}
static void
gimv_zalbum_prepare_cell (GimvZAlbum *album,
GimvZAlbumCell *cell,
GdkRectangle *cell_area,
GdkRectangle *area)
{
GtkWidget *widget;
GdkRectangle intersect_area;
widget = GTK_WIDGET(album);
if (gdk_rectangle_intersect (area, cell_area, &intersect_area))
gdk_draw_rectangle (widget->window,
widget->style->bg_gc[CELL_STATE(cell)], TRUE,
intersect_area.x, intersect_area.y,
intersect_area.width, intersect_area.height);
gtk_paint_shadow (widget->style, widget->window,
CELL_STATE(cell), GTK_SHADOW_OUT,
NULL, NULL, NULL,
cell_area->x, cell_area->y,
cell_area->width, cell_area->height);
cell_area->x += CELL_PADDING;
cell_area->y += CELL_PADDING;
cell_area->width -= CELL_PADDING * 2;
cell_area->height -= CELL_PADDING * 2;
}
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_shadow(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_shadow(_SELF(self), GDK_WINDOW(RVAL2GOBJ(gdkwindow)),
RVAL2STATE(state_type), RVAL2SHADOW(shadow_type), RVAL2REC(area),
GTK_WIDGET(RVAL2GOBJ(widget)),
NIL_P(detail) ? NULL : RVAL2CSTR(detail),
NUM2INT(x), NUM2INT(y), NUM2INT(width), NUM2INT(height));
return self;
}
static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
{
if (!win->m_hasVMT || gdk_event->count > 0 ||
gdk_event->window != gtk_widget_get_window(widget))
{
return false;
}
gtk_paint_shadow (gtk_widget_get_style(widget),
gtk_widget_get_window(widget),
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, NULL, NULL, // FIXME: No clipping?
0, 0,
win->m_width, win->m_height);
int style = win->GetWindowStyle();
wxClientDC dc(win);
wxDCImpl *impl = dc.GetImpl();
wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl );
gtk_impl->m_gdkwindow = gtk_widget_get_window(widget); // Hack alert
if (style & wxRESIZE_BORDER)
{
dc.SetBrush( *wxGREY_BRUSH );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );
}
if (win->m_miniTitle && !win->GetTitle().empty())
{
dc.SetFont( *wxSMALL_FONT );
wxBrush brush( LightContrastColour( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) ) );
dc.SetBrush( brush );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle( win->m_miniEdge-1,
win->m_miniEdge-1,
win->m_width - (2*(win->m_miniEdge-1)),
15 );
dc.SetTextForeground( *wxWHITE );
dc.DrawText( win->GetTitle(), 6, 4 );
if (style & wxCLOSE_BOX)
dc.DrawBitmap( win->m_closeButton, win->m_width-18, 3, true );
}
return false;
}
static void
gimv_zalbum_cell_draw_default (GimvZList *list, gpointer cell, GdkRectangle *cell_area)
{
g_return_if_fail (GIMV_IS_ZALBUM (list));
if (!GTK_WIDGET_MAPPED (list)) return;
gtk_paint_shadow(GTK_WIDGET(list)->style, GTK_WIDGET(list)->window,
CELL_STATE(cell), GTK_SHADOW_OUT,
NULL, NULL, NULL,
cell_area->x, cell_area->y,
cell_area->width, cell_area->height);
}
static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxMiniFrame *win )
{
// don't need to install idle handler, its done from "event" signal
if (!win->m_hasVMT) return;
if (gdk_event->count > 0) return;
GtkPizza *pizza = GTK_PIZZA(widget);
gtk_paint_shadow (widget->style,
pizza->bin_window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, NULL, NULL, // FIXME: No clipping?
0, 0,
win->m_width, win->m_height);
int style = win->GetWindowStyle();
wxClientDC dc(win);
// Hack alert
dc.m_window = pizza->bin_window;
if (style & wxRESIZE_BORDER)
{
dc.SetBrush( *wxGREY_BRUSH );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );
}
if (!win->GetTitle().empty() &&
((style & wxCAPTION) ||
(style & wxTINY_CAPTION_HORIZ) ||
(style & wxTINY_CAPTION_VERT)))
{
dc.SetFont( *wxSMALL_FONT );
int height = dc.GetCharHeight();
wxBrush brush( LightContrastColour( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) ) );
dc.SetBrush( brush );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle( 3, 3, win->m_width - 7, height );
dc.SetTextForeground( *wxWHITE );
dc.DrawText( win->GetTitle(), 6, 3 );
if (style & wxCLOSE_BOX)
dc.DrawBitmap( win->m_closeButton, win->m_width-19, 2, true );
}
}
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 void
dma_data_view_paint (GtkWidget *widget,
cairo_t *cr)
{
DmaDataView *view = DMA_DATA_VIEW (widget);
if (view->shadow_type != GTK_SHADOW_NONE)
{
gtk_paint_shadow (gtk_widget_get_style (widget),
cr,
GTK_STATE_NORMAL, view->shadow_type,
widget, "dma_data_view",
view->frame.x,
view->frame.y,
view->frame.width,
view->frame.height);
}
}
static gboolean
gtk_source_completion_info_expose (GtkWidget *widget,
GdkEventExpose *expose)
{
GTK_WIDGET_CLASS (gtk_source_completion_info_parent_class)->expose_event (widget, expose);
gtk_paint_shadow (widget->style,
widget->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL,
widget,
NULL,
widget->allocation.x,
widget->allocation.y,
widget->allocation.width,
widget->allocation.height);
return FALSE;
}
static gboolean ctk_curve_expose_event(
GtkWidget *widget,
GdkEventExpose *event
)
#endif
{
gint width, height;
CtkCurve *ctk_curve;
GtkAllocation allocation;
ctk_curve = CTK_CURVE(widget);
ctk_widget_get_allocation(widget, &allocation);
width = allocation.width - 2 * gtk_widget_get_style(widget)->xthickness;
height = allocation.height - 2 * gtk_widget_get_style(widget)->ythickness;
#ifdef CTK_GTK3
gtk_render_frame(gtk_widget_get_style_context(widget),
cr, 0, 0, allocation.width, allocation.height);
cairo_set_operator(ctk_curve->c_context, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(cr, ctk_curve->c_surface, 0, 0);
cairo_paint(cr);
#else
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
&event->area, widget, "ctk_curve", 0, 0,
allocation.width, allocation.height);
gdk_gc_set_function(ctk_curve->gdk_gc, GDK_COPY);
gdk_draw_drawable(widget->window, ctk_curve->gdk_gc, ctk_curve->gdk_pixmap,
0, 0, widget->style->xthickness,
widget->style->ythickness,
width, height);
#endif
return FALSE;
}
/* This is our expose-event handler when the window is *not* in a compositing manager.
* We just draw a rectangular frame by hand. We do this with hardcoded drawing code,
* instead of GtkFrame, to avoid changing the window's internal widget hierarchy: in
* either case (composited or non-composited), callers can assume that this works
* identically to a GtkWindow without any intermediate widgetry.
*/
static void
expose_when_not_composited (GtkWidget *widget, GdkEventExpose *event)
{
MsdOsdWindow *window;
GtkAllocation allocation;
window = MSD_OSD_WINDOW (widget);
gtk_widget_get_allocation (widget, &allocation);
gtk_paint_shadow (gtk_widget_get_style (widget),
gtk_widget_get_window (widget),
gtk_widget_get_state (widget),
GTK_SHADOW_OUT,
&event->area,
widget,
NULL, /* NULL detail -> themes should use the MsdOsdWindow widget name, probably */
0,
0,
allocation.width,
allocation.height);
}
static gboolean gtkCanvasBorderExposeEvent(GtkWidget *widget, GdkEventExpose *evt, void* user)
#endif
{
#if GTK_CHECK_VERSION(3, 0, 0)
GtkStyleContext* context = gtk_widget_get_style_context (widget);
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
gtk_style_context_save (context);
gtk_style_context_add_class(context, GTK_STYLE_CLASS_FRAME);
gtk_render_frame (context, cr, 0, 0, allocation.width, allocation.height);
gtk_style_context_restore (context);
#else
GdkWindow* window = iupgtkGetWindow(widget);
GtkStyle *style = gtk_widget_get_style(widget);
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
gtk_paint_shadow(style, window, GTK_STATE_NORMAL, GTK_SHADOW_IN,
&evt->area, widget, "scrolled_window",
allocation.x, allocation.y, allocation.width, allocation.height);
#endif
(void)user;
return FALSE;
}
static void
gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags)
{
GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
GtkStyle *style = gtk_widget_get_style (widget);
GdkRectangle toggle_rect;
GdkRectangle draw_rect;
GtkStateType state;
gboolean active;
gint xpad;
gint ypad;
if (! toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, window, widget,
background_area,
cell_area, expose_area,
flags);
return;
}
gimp_cell_renderer_toggle_get_size (cell, widget, cell_area,
&toggle_rect.x,
&toggle_rect.y,
&toggle_rect.width,
&toggle_rect.height);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
toggle_rect.x += cell_area->x + xpad;
toggle_rect.y += cell_area->y + ypad;
toggle_rect.width -= xpad * 2;
toggle_rect.height -= ypad * 2;
if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
return;
active =
gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
if (gtk_widget_has_focus (widget))
state = GTK_STATE_SELECTED;
else
state = GTK_STATE_ACTIVE;
}
else
{
if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell)))
state = GTK_STATE_NORMAL;
else
state = GTK_STATE_INSENSITIVE;
}
if (gdk_rectangle_intersect (expose_area, cell_area, &draw_rect) &&
(flags & GTK_CELL_RENDERER_PRELIT))
gtk_paint_shadow (style,
window,
state,
active ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
&draw_rect,
widget, NULL,
toggle_rect.x, toggle_rect.y,
toggle_rect.width, toggle_rect.height);
if (active)
{
toggle_rect.x += style->xthickness;
toggle_rect.y += style->ythickness;
toggle_rect.width -= style->xthickness * 2;
toggle_rect.height -= style->ythickness * 2;
if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
{
cairo_t *cr = gdk_cairo_create (window);
gboolean inconsistent;
gdk_cairo_rectangle (cr, &draw_rect);
cairo_clip (cr);
gdk_cairo_set_source_pixbuf (cr, toggle->pixbuf,
toggle_rect.x, toggle_rect.y);
cairo_paint (cr);
g_object_get (toggle,
"inconsistent", &inconsistent,
NULL);
if (inconsistent)
{
gdk_cairo_set_source_color (cr, &style->fg[state]);
cairo_set_line_width (cr, 1.5);
cairo_move_to (cr,
toggle_rect.x + toggle_rect.width - 1,
toggle_rect.y + 1);
cairo_line_to (cr,
toggle_rect.x + 1,
toggle_rect.y + toggle_rect.height - 1);
cairo_stroke (cr);
}
cairo_destroy (cr);
}
}
}
static gboolean expose_event(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
#endif
{
#ifdef __WXGTK3__
if (!gtk_cairo_should_draw_window(cr, gtk_widget_get_window(widget)))
return false;
GtkStyleContext* sc = gtk_widget_get_style_context(widget);
gtk_style_context_save(sc);
gtk_style_context_add_class(sc, GTK_STYLE_CLASS_BUTTON);
gtk_render_frame(sc, cr, 0, 0, win->m_width, win->m_height);
gtk_style_context_restore(sc);
wxGTKCairoDC dc(cr);
#else
if (gdk_event->count > 0 ||
gdk_event->window != gtk_widget_get_window(widget))
{
return false;
}
gtk_paint_shadow (gtk_widget_get_style(widget),
gtk_widget_get_window(widget),
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, NULL, NULL, // FIXME: No clipping?
0, 0,
win->m_width, win->m_height);
wxClientDC dc(win);
wxDCImpl *impl = dc.GetImpl();
wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl );
gtk_impl->m_gdkwindow = gtk_widget_get_window(widget); // Hack alert
#endif
int style = win->GetWindowStyle();
if (style & wxRESIZE_BORDER)
{
dc.SetBrush( *wxGREY_BRUSH );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );
}
if (win->m_miniTitle && !win->GetTitle().empty())
{
dc.SetFont( *wxSMALL_FONT );
wxBrush brush(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
dc.SetBrush( brush );
dc.SetPen( *wxTRANSPARENT_PEN );
dc.DrawRectangle( win->m_miniEdge-1,
win->m_miniEdge-1,
win->m_width - (2*(win->m_miniEdge-1)),
15 );
const wxColour textColor = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
dc.SetTextForeground(textColor);
dc.DrawText( win->GetTitle(), 6, 4 );
if (style & wxCLOSE_BOX)
{
dc.SetTextBackground(textColor);
dc.DrawBitmap( win->m_closeButton, win->m_width-18, 3, true );
}
}
return false;
}
static void
color_area_draw ()
{
Color col;
GdkColor *win_bg;
GdkColor fg, bg, bd;
gint rect_w, rect_h;
gint width, height;
gint def_width, def_height;
gint swap_width, swap_height;
GdkColor mask_pattern;
/* Check we haven't gotten initial expose yet,
* no point in drawing anything
*/
if (!color_area_pixmap || !color_area_gc)
return;
gdk_drawable_get_size (color_area_pixmap, &width, &height);
win_bg = &(color_area->style->bg[GTK_STATE_NORMAL]);
col = attributes_get_foreground();
color_convert(&col, &fg);
col = attributes_get_background();
color_convert(&col, &bg);
bd = color_gdk_black;
rect_w = width * 0.65;
rect_h = height * 0.65;
/* initialize the mask to transparent */
mask_pattern.pixel = 0;
gdk_gc_set_foreground (mask_gc, &mask_pattern);
gdk_draw_rectangle (color_area_mask, mask_gc, TRUE, 0, 0, -1, -1);
/* set the mask's gc to opaque */
mask_pattern.pixel = 1;
gdk_gc_set_foreground (mask_gc, &mask_pattern);
gdk_gc_set_foreground (color_area_gc, win_bg);
gdk_draw_rectangle (color_area_pixmap, color_area_gc, 1,
0, 0, width, height);
gdk_gc_set_foreground (color_area_gc, &bg);
gdk_draw_rectangle (color_area_pixmap, color_area_gc, 1,
(width - rect_w), (height - rect_h), rect_w, rect_h);
gdk_draw_rectangle (color_area_mask, mask_gc, TRUE,
(width - rect_w), (height - rect_h), rect_w, rect_h);
if (active_color == FOREGROUND)
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, color_area, NULL,
(width - rect_w), (height - rect_h),
rect_w, rect_h);
else
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_IN,
NULL, color_area, NULL,
(width - rect_w), (height - rect_h),
rect_w, rect_h);
gdk_gc_set_foreground (color_area_gc, &fg);
gdk_draw_rectangle (color_area_pixmap, color_area_gc, 1,
0, 0, rect_w, rect_h);
gdk_draw_rectangle (color_area_mask, mask_gc, TRUE,
0, 0, rect_w, rect_h);
if (active_color == FOREGROUND)
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_IN,
NULL, color_area, NULL,
0, 0,
rect_w, rect_h);
else
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, color_area, NULL,
0, 0,
rect_w, rect_h);
/* draw the default pixmap */
gdk_drawable_get_size (default_pixmap, &def_width, &def_height);
gdk_draw_drawable (color_area_pixmap, color_area_gc, default_pixmap,
0, 0, 0, height - def_height, def_width, def_height);
gdk_draw_drawable (color_area_mask, mask_gc, default_mask,
0, 0, 0, height - def_height, def_width, def_height);
/* draw the swap pixmap */
gdk_drawable_get_size (swap_pixmap, &swap_width, &swap_height);
gdk_draw_drawable (color_area_pixmap, color_area_gc, swap_pixmap,
0, 0, width - swap_width, 0, swap_width, swap_height);
gdk_draw_drawable (color_area_mask, mask_gc, swap_mask,
0, 0, width - swap_width, 0, swap_width, swap_height);
/* draw the widget */
gdk_gc_set_clip_mask (color_area_gc, color_area_mask);
gdk_gc_set_clip_origin (color_area_gc, 0, 0);
gdk_draw_drawable (color_area->window, color_area_gc, color_area_pixmap,
0, 0, 0, 0, width, height);
/* reset the clip mask */
gdk_gc_set_clip_mask (color_area_gc, NULL);
}
static gboolean
gimp_fg_bg_view_expose (GtkWidget *widget,
GdkEventExpose *eevent)
{
GimpFgBgView *view = GIMP_FG_BG_VIEW (widget);
GtkStyle *style = gtk_widget_get_style (widget);
GdkWindow *window = gtk_widget_get_window (widget);
cairo_t *cr;
GtkAllocation allocation;
gint rect_w, rect_h;
GimpRGB color;
if (! gtk_widget_is_drawable (widget))
return FALSE;
cr = gdk_cairo_create (eevent->window);
gdk_cairo_region (cr, eevent->region);
cairo_clip (cr);
gtk_widget_get_allocation (widget, &allocation);
cairo_translate (cr, allocation.x, allocation.y);
rect_w = allocation.width * 3 / 4;
rect_h = allocation.height * 3 / 4;
if (! view->transform)
gimp_fg_bg_view_create_transform (view);
/* draw the background area */
if (view->context)
{
gimp_context_get_background (view->context, &color);
if (view->transform)
gimp_color_transform_process_pixels (view->transform,
babl_format ("R'G'B'A double"),
&color,
babl_format ("R'G'B'A double"),
&color,
1);
gimp_cairo_set_source_rgb (cr, &color);
cairo_rectangle (cr,
allocation.width - rect_w + 1,
allocation.height - rect_h + 1,
rect_w - 2,
rect_h - 2);
cairo_fill (cr);
}
gtk_paint_shadow (style, window, GTK_STATE_NORMAL,
GTK_SHADOW_IN,
NULL, widget, NULL,
allocation.x + allocation.width - rect_w,
allocation.y + allocation.height - rect_h,
rect_w, rect_h);
/* draw the foreground area */
if (view->context)
{
gimp_context_get_foreground (view->context, &color);
if (view->transform)
gimp_color_transform_process_pixels (view->transform,
babl_format ("R'G'B'A double"),
&color,
babl_format ("R'G'B'A double"),
&color,
1);
gimp_cairo_set_source_rgb (cr, &color);
cairo_rectangle (cr, 1, 1, rect_w - 2, rect_h - 2);
cairo_fill (cr);
}
gtk_paint_shadow (style, window, GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, widget, NULL,
allocation.x, allocation.y, rect_w, rect_h);
cairo_destroy (cr);
return TRUE;
}
/**
* Callback when canvas recieves an expose event. The icon is entirely
* redrawn for every expose event instead of checking and redrawing
* just the dirty regions. Since the icon is so small, the gain
* probably isn't worth the extra overhead.
*/
gboolean
on_canvas_expose_event(GtkWidget *widget, GdkEventExpose *event,
gpointer unused_udata)
{
GdkRectangle panel, rect, bar;
(void) unused_udata;
/* just draw once for all expose events */
if (event->count)
return FALSE;
/* setup image column */
panel.x = ICON_INSET;
panel.y = ICON_INSET;
panel.height = (widget->allocation.height - ICON_INSET2) / 3;
panel.width = XPM_WIDTH;
/* draw connection icon */
center_image(&rect, &panel, con_pixbuf);
gdk_draw_pixbuf(canvas->window, NULL, con_pixbuf, 0, 0,
rect.x, rect.y, rect.width, rect.height, GDK_RGB_DITHER_NONE, 0, 0);
panel.y += panel.height;
/* paint download icon */
center_image(&rect, &panel, down_pixbuf);
gdk_draw_pixbuf(canvas->window, NULL, down_pixbuf, 0, 0,
rect.x, rect.y, rect.width, rect.height, GDK_RGB_DITHER_NONE, 0, 0);
panel.y += panel.height;
/* paint upload icon */
center_image(&rect, &panel, up_pixbuf);
gdk_draw_pixbuf(canvas->window, NULL, up_pixbuf, 0, 0,
rect.x, rect.y, rect.width, rect.height, GDK_RGB_DITHER_NONE, 0, 0);
/* setup bar column */
panel.x = XPM_WIDTH + ICON_INSET;
panel.y = ICON_INSET;
panel.width = (ICON_WIDTH - ICON_INSET2) - XPM_WIDTH;
panel.height = (widget->allocation.height - ICON_INSET2);
/* draw bar panel */
gtk_paint_box(widget->style, widget->window,
GTK_STATE_INSENSITIVE, GTK_SHADOW_OUT,
NULL, widget, NULL,
panel.x, panel.y, panel.width, panel.height);
panel.height /= 3;
rect.x = panel.x + ICON_INSET2;
rect.y = panel.y + ICON_INSET2;
rect.width = panel.width - ICON_INSET4;
rect.height = panel.height - ICON_INSET4;
bar.x = rect.x + ICON_INSET;
bar.y = rect.y + ICON_INSET;
bar.width = rect.width - ICON_INSET2;
bar.height = rect.height - ICON_INSET2;
/* paint connection bar */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, NULL,
rect.x, rect.y, rect.width, rect.height);
gdk_draw_rectangle(widget->window, widget->style->black_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
bar.width = get_width(&bar, leaf_cnt + norm_cnt + ultra_cnt, con_max);
gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
panel.y += panel.height;
rect.y += panel.height;
bar.y += panel.height;
bar.width = rect.width - ICON_INSET2;
/* paint download bar */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, NULL,
rect.x, rect.y, rect.width, rect.height);
gdk_draw_rectangle(widget->window, widget->style->black_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
bar.width = get_width(&bar, down_cnt, down_max);
gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
panel.y += panel.height;
rect.y += panel.height;
bar.y += panel.height;
bar.width = rect.width - ICON_INSET2;
/* paint upload bar */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, NULL,
rect.x, rect.y, rect.width, rect.height);
gdk_draw_rectangle(widget->window, widget->style->black_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
bar.width = get_width(&bar, up_cnt, up_max);
gdk_draw_rectangle(widget->window, widget->style->white_gc, TRUE,
bar.x, bar.y, bar.width, bar.height);
/* paint border */
gtk_paint_shadow(widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, NULL, 0, 0, -1, -1);
return FALSE;
}
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;
}
static gboolean
selector_expose_event (GtkWidget * widget,
GdkEventExpose* event)
{
GdkRectangle rectangles[] = {
/* above the eye */
{ widget->allocation.x, widget->allocation.y,
widget->allocation.width, HORIZONTAL_BAR_HEIGHT
},
/* below the eye */
{ widget->allocation.x,
widget->allocation.y + widget->allocation.height - HORIZONTAL_BAR_HEIGHT,
widget->allocation.width, HORIZONTAL_BAR_HEIGHT
},
/* left of the eye */
{ widget->allocation.x, widget->allocation.y + HORIZONTAL_BAR_HEIGHT,
VERTICAL_BAR_WIDTH, widget->allocation.height - 2 * HORIZONTAL_BAR_HEIGHT
},
/* right of the eye */
{ widget->allocation.x + widget->allocation.width - VERTICAL_BAR_WIDTH,
widget->allocation.y + HORIZONTAL_BAR_HEIGHT,
VERTICAL_BAR_WIDTH, widget->allocation.height - 2 * HORIZONTAL_BAR_HEIGHT
}
};
gsize i;
for (i = 0; i < G_N_ELEMENTS (rectangles); i++) {
gtk_paint_box (widget->style,
widget->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
&rectangles[i],
widget,
NULL,
widget->allocation.x,
widget->allocation.y,
widget->allocation.width,
widget->allocation.height);
}
/* inner shadow */
gtk_paint_shadow (widget->style,
widget->window,
GTK_STATE_NORMAL,
GTK_SHADOW_IN,
&widget->allocation,
widget,
NULL,
widget->allocation.x + VERTICAL_BAR_WIDTH,
widget->allocation.y + HORIZONTAL_BAR_HEIGHT,
widget->allocation.width - 2 * VERTICAL_BAR_WIDTH,
widget->allocation.height - 2 * HORIZONTAL_BAR_HEIGHT);
if (GTK_WIDGET_HAS_FOCUS (widget)) {
gtk_paint_focus (widget->style,
widget->window,
GTK_STATE_NORMAL,
&widget->allocation,
widget,
NULL,
widget->allocation.x + FOCUS_OFFSET,
widget->allocation.y + FOCUS_OFFSET,
widget->allocation.width - 2 * FOCUS_OFFSET,
widget->allocation.height - 2 * FOCUS_OFFSET);
}
return FALSE;
}
void WidgetRenderingContext::gtkPaintShadow(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_shadow(gtk_widget_get_style(widget), m_target, stateType, shadowType, &paintRect, widget,
detail, paintRect.x, paintRect.y, paintRect.width, paintRect.height);
}
