void WidgetRenderingContext::gtkPaintVLine(const IntRect& rect, GtkWidget* widget, GtkStateType stateType, const gchar* detail)
{
GdkRectangle paintRect = { m_paintRect.x + rect.x(), m_paintRect.y + rect.y(), rect.width(), rect.height() };
gtk_paint_vline(gtk_widget_get_style(widget), m_target, stateType, &paintRect, widget, detail,
paintRect.y, paintRect.y + paintRect.height, paintRect.x);
}
static gboolean cb_expose(GtkWidget *wid, GdkEventExpose *e, gSeparator *data)
{
gint x, y, w, h;
gColor color;
x = wid->allocation.x;
y = wid->allocation.y;
w = data->width();
h = data->height();
if (w == 1 || h == 1)
{
cairo_t *cr;
cr = gdk_cairo_create(wid->window);
color = data->foreground();
if (color == COLOR_DEFAULT)
color = gDesktop::lightfgColor();
gt_cairo_set_source_color(cr, color);
cairo_rectangle(cr, e->area.x, e->area.y, e->area.width, e->area.height);
cairo_fill(cr);
cairo_destroy(cr);
}
else if (w>=h)
gtk_paint_hline(wid->style, wid->window, GTK_STATE_NORMAL, &e->area, wid, NULL, x, x + w, y + h / 2);
else
gtk_paint_vline(wid->style, wid->window, GTK_STATE_NORMAL, &e->area, wid, NULL, y, y + h, x + w / 2);
return false;
}
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_vline(VALUE self, VALUE gdkwindow, VALUE state_type, VALUE area, VALUE widget, VALUE detail, VALUE y1, VALUE y2, VALUE x)
{
gtk_paint_vline(_SELF(self), GDK_WINDOW(RVAL2GOBJ(gdkwindow)),
RVAL2STATE(state_type), RVAL2REC(area),
GTK_WIDGET(RVAL2GOBJ(widget)),
NIL_P(detail) ? NULL : RVAL2CSTR(detail),
NUM2INT(y1), NUM2INT(y2), NUM2INT(x));
return self;
}
static gint
moz_gtk_combo_box_paint(GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state,
gboolean ishtml, GtkTextDirection direction)
{
GdkRectangle arrow_rect, real_arrow_rect;
gint /* arrow_size, */ separator_width;
gboolean wide_separators;
GtkStateType state_type = ConvertGtkState(state);
GtkShadowType shadow_type = state->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
GtkStyle* style;
GtkRequisition arrow_req;
ensure_combo_box_widgets();
/* Also sets the direction on gParts->comboBoxButtonWidget, which is then
* inherited by the separator and arrow */
moz_gtk_button_paint(drawable, rect, cliprect, state, GTK_RELIEF_NORMAL,
gParts->comboBoxButtonWidget, direction);
calculate_button_inner_rect(gParts->comboBoxButtonWidget,
rect, &arrow_rect, direction, ishtml);
/* Now arrow_rect contains the inner rect ; we want to correct the width
* to what the arrow needs (see gtk_combo_box_size_allocate) */
gtk_widget_size_request(gParts->comboBoxArrowWidget, &arrow_req);
if (direction == GTK_TEXT_DIR_LTR)
arrow_rect.x += arrow_rect.width - arrow_req.width;
arrow_rect.width = arrow_req.width;
calculate_arrow_rect(gParts->comboBoxArrowWidget,
&arrow_rect, &real_arrow_rect, direction);
style = gtk_widget_get_style(gParts->comboBoxArrowWidget);
TSOffsetStyleGCs(style, rect->x, rect->y);
gtk_widget_size_allocate(gParts->comboBoxWidget, rect);
gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
gParts->comboBoxArrowWidget, "arrow", GTK_ARROW_DOWN, TRUE,
real_arrow_rect.x, real_arrow_rect.y,
real_arrow_rect.width, real_arrow_rect.height);
/* If there is no separator in the theme, there's nothing left to do. */
if (!gParts->comboBoxSeparatorWidget)
return MOZ_GTK_SUCCESS;
style = gtk_widget_get_style(gParts->comboBoxSeparatorWidget);
TSOffsetStyleGCs(style, rect->x, rect->y);
gtk_widget_style_get(gParts->comboBoxSeparatorWidget,
"wide-separators", &wide_separators,
"separator-width", &separator_width,
NULL);
if (wide_separators) {
if (direction == GTK_TEXT_DIR_LTR)
arrow_rect.x -= separator_width;
else
arrow_rect.x += arrow_rect.width;
gtk_paint_box(style, drawable,
GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_OUT,
cliprect, gParts->comboBoxSeparatorWidget, "vseparator",
arrow_rect.x, arrow_rect.y,
separator_width, arrow_rect.height);
} else {
if (direction == GTK_TEXT_DIR_LTR)
arrow_rect.x -= XTHICKNESS(style);
else
arrow_rect.x += arrow_rect.width;
gtk_paint_vline(style, drawable, GTK_STATE_NORMAL, cliprect,
gParts->comboBoxSeparatorWidget, "vseparator",
arrow_rect.y, arrow_rect.y + arrow_rect.height,
arrow_rect.x);
}
return MOZ_GTK_SUCCESS;
}
static void
clearlooks_style_draw_box (DRAW_ARGS)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
const ClearlooksColors *colors;
cairo_t *cr;
cr = ge_gdk_drawable_to_cairo (window, area);
colors = &clearlooks_style->colors;
CHECK_ARGS
SANITIZE_SIZE
if (DETAIL ("menubar") && !ge_is_panel_widget_item(widget))
{
WidgetParameters params;
MenuBarParameters menubar;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
menubar.style = clearlooks_style->menubarstyle;
STYLE_FUNCTION(draw_menubar) (cr, colors, ¶ms, &menubar,
x, y, width, height);
}
else if (DETAIL ("button") && widget && widget->parent &&
(GE_IS_TREE_VIEW(widget->parent) ||
GE_IS_CLIST (widget->parent) ||
ge_object_is_a (G_OBJECT(widget->parent), "ETree"))) /* ECanvas inside ETree */
{
WidgetParameters params;
ListViewHeaderParameters header;
gint columns, column_index;
gboolean resizable = TRUE;
/* XXX: This makes unknown treeview header CL_ORDER_MIDDLE, in need for something nicer */
columns = 3;
column_index = 1;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
if (GE_IS_TREE_VIEW (widget->parent))
{
clearlooks_treeview_get_header_index (GTK_TREE_VIEW(widget->parent),
widget, &column_index, &columns,
&resizable);
}
else if (GE_IS_CLIST (widget->parent))
{
clearlooks_clist_get_header_index (GTK_CLIST(widget->parent),
widget, &column_index, &columns);
}
header.resizable = resizable;
if (column_index == 0)
header.order = params.ltr ? CL_ORDER_FIRST : CL_ORDER_LAST;
else if (column_index == columns-1)
header.order = params.ltr ? CL_ORDER_LAST : CL_ORDER_FIRST;
else
header.order = CL_ORDER_MIDDLE;
gtk_style_apply_default_background (style, window, FALSE, state_type, area, x, y, width, height);
STYLE_FUNCTION(draw_list_view_header) (cr, colors, ¶ms, &header,
x, y, width, height);
}
else if (DETAIL ("button") || DETAIL ("buttondefault"))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
if (ge_is_in_combo_box(widget))
{
if (params.ltr)
params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
else
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
if (params.xthickness > 2)
{
if (params.ltr)
x--;
width++;
}
}
else
{
params.corners = CR_CORNER_ALL;
/* if (!(ge_is_combo_box (widget, FALSE))) */
params.enable_glow = TRUE;
}
if (GE_IS_TOGGLE_BUTTON (widget) &&
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
params.active = TRUE;
STYLE_FUNCTION(draw_button) (cr, &clearlooks_style->colors, ¶ms,
x, y, width, height);
}
else if (DETAIL ("spinbutton_up") || DETAIL ("spinbutton_down"))
{
if (state_type == GTK_STATE_ACTIVE)
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
if (style->xthickness == 3)
{
width++;
if (params.ltr)
x--;
}
if (DETAIL ("spinbutton_up"))
{
height+=2;
if (params.ltr)
params.corners = CR_CORNER_TOPRIGHT;
else
params.corners = CR_CORNER_TOPLEFT;
}
else
{
if (params.ltr)
params.corners = CR_CORNER_BOTTOMRIGHT;
else
params.corners = CR_CORNER_BOTTOMLEFT;
}
STYLE_FUNCTION(draw_spinbutton_down) (cr, &clearlooks_style->colors, ¶ms, x, y, width, height);
}
}
else if (DETAIL ("spinbutton"))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
if (params.ltr)
params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
else
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
if (style->xthickness == 3)
{
if (params.ltr)
x--;
width++;
}
STYLE_FUNCTION(draw_spinbutton) (cr, &clearlooks_style->colors, ¶ms,
x, y, width, height);
}
else if (detail && g_str_has_prefix (detail, "trough") && GE_IS_SCALE (widget))
{
WidgetParameters params;
SliderParameters slider;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
slider.lower = DETAIL ("trough-lower");
slider.fill_level = DETAIL ("trough-fill-level") || DETAIL ("trough-fill-level-full");
slider.horizontal = (GTK_RANGE (widget)->orientation == GTK_ORIENTATION_HORIZONTAL);
STYLE_FUNCTION(draw_scale_trough) (cr, &clearlooks_style->colors,
¶ms, &slider,
x, y, width, height);
}
else if (DETAIL ("trough") && widget && GE_IS_PROGRESS_BAR (widget))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
STYLE_FUNCTION(draw_progressbar_trough) (cr, colors, ¶ms,
x, y, width, height);
}
else if (DETAIL ("trough") && widget && (GE_IS_VSCROLLBAR (widget) || GE_IS_HSCROLLBAR (widget)))
{
WidgetParameters params;
ScrollBarParameters scrollbar;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
scrollbar.horizontal = TRUE;
scrollbar.junction = clearlooks_scrollbar_get_junction (widget);
if (GE_IS_RANGE (widget))
scrollbar.horizontal = GTK_RANGE (widget)->orientation == GTK_ORIENTATION_HORIZONTAL;
if (scrollbar.horizontal)
{
x += 2;
width -= 4;
}
else
{
y += 2;
height -= 4;
}
STYLE_FUNCTION(draw_scrollbar_trough) (cr, colors, ¶ms, &scrollbar,
x, y, width, height);
}
else if (DETAIL ("bar"))
{
WidgetParameters params;
ProgressBarParameters progressbar;
gdouble elapsed = 0.0;
#ifdef HAVE_ANIMATION
if(clearlooks_style->animation && CL_IS_PROGRESS_BAR (widget))
{
gboolean activity_mode = GTK_PROGRESS (widget)->activity_mode;
if (!activity_mode)
clearlooks_animation_progressbar_add ((gpointer)widget);
}
elapsed = clearlooks_animation_elapsed (widget);
#endif
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
if (widget && GE_IS_PROGRESS_BAR (widget))
{
progressbar.orientation = gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget));
progressbar.value = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(widget));
progressbar.pulsing = GTK_PROGRESS (widget)->activity_mode;
}
else
{
progressbar.orientation = CL_ORIENTATION_LEFT_TO_RIGHT;
progressbar.value = 0;
progressbar.pulsing = FALSE;
}
if (!params.ltr)
{
if (progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_LEFT_TO_RIGHT)
progressbar.orientation = GTK_PROGRESS_RIGHT_TO_LEFT;
else if (progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_RIGHT_TO_LEFT)
progressbar.orientation = GTK_PROGRESS_LEFT_TO_RIGHT;
}
/* Following is a hack to have a larger clip area, the one passed in
* does not allow for the shadow. */
if (area)
{
GdkRectangle tmp = *area;
if (!progressbar.pulsing)
{
switch (progressbar.orientation)
{
case GTK_PROGRESS_RIGHT_TO_LEFT:
tmp.x -= 1;
case GTK_PROGRESS_LEFT_TO_RIGHT:
tmp.width += 1;
break;
case GTK_PROGRESS_BOTTOM_TO_TOP:
tmp.y -= 1;
case GTK_PROGRESS_TOP_TO_BOTTOM:
tmp.height += 1;
break;
}
}
else
{
if (progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_RIGHT_TO_LEFT ||
progressbar.orientation == (ClearlooksOrientation)GTK_PROGRESS_LEFT_TO_RIGHT)
{
tmp.x -= 1;
tmp.width += 2;
}
else
{
tmp.y -= 1;
tmp.height += 2;
}
}
cairo_reset_clip (cr);
gdk_cairo_rectangle (cr, &tmp);
cairo_clip (cr);
}
STYLE_FUNCTION(draw_progressbar_fill) (cr, colors, ¶ms, &progressbar,
x, y, width, height,
10 - (int)(elapsed * 10.0) % 10);
}
else if (DETAIL ("optionmenu"))
{
WidgetParameters params;
OptionMenuParameters optionmenu;
GtkRequisition indicator_size;
GtkBorder indicator_spacing;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.enable_glow = TRUE;
ge_option_menu_get_props (widget, &indicator_size, &indicator_spacing);
if (ge_widget_is_ltr (widget))
optionmenu.linepos = width - (indicator_size.width + indicator_spacing.left + indicator_spacing.right) - 1;
else
optionmenu.linepos = (indicator_size.width + indicator_spacing.left + indicator_spacing.right) + 1;
STYLE_FUNCTION(draw_optionmenu) (cr, colors, ¶ms, &optionmenu,
x, y, width, height);
}
else if (DETAIL ("menuitem"))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
if (widget && GE_IS_MENU_BAR (widget->parent))
{
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
height += 1;
STYLE_FUNCTION(draw_menubaritem) (cr, colors, ¶ms, x, y, width, height);
}
else
{
params.corners = CR_CORNER_ALL;
STYLE_FUNCTION(draw_menuitem) (cr, colors, ¶ms, x, y, width, height);
}
}
else if (DETAIL ("hscrollbar") || DETAIL ("vscrollbar")) /* This can't be "stepper" for scrollbars ... */
{
WidgetParameters params;
ScrollBarParameters scrollbar;
ScrollBarStepperParameters stepper;
GdkRectangle this_rectangle;
this_rectangle.x = x;
this_rectangle.y = y;
this_rectangle.width = width;
this_rectangle.height = height;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
scrollbar.has_color = FALSE;
scrollbar.horizontal = TRUE;
scrollbar.junction = clearlooks_scrollbar_get_junction (widget);
if (clearlooks_style->colorize_scrollbar || clearlooks_style->has_scrollbar_color) {
scrollbar.has_color = TRUE;
}
scrollbar.horizontal = DETAIL ("hscrollbar");
stepper.stepper = clearlooks_scrollbar_get_stepper (widget, &this_rectangle);
STYLE_FUNCTION(draw_scrollbar_stepper) (cr, colors, ¶ms, &scrollbar, &stepper,
x, y, width, height);
}
else if (DETAIL ("toolbar") || DETAIL ("handlebox_bin") || DETAIL ("dockitem_bin"))
{
WidgetParameters params;
ToolbarParameters toolbar;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
clearlooks_set_toolbar_parameters (&toolbar, widget, window, x, y);
toolbar.style = clearlooks_style->toolbarstyle;
/* Only draw the shadows on horizontal toolbars */
if (shadow_type != GTK_SHADOW_NONE && height < 2*width )
STYLE_FUNCTION(draw_toolbar) (cr, colors, ¶ms, &toolbar, x, y, width, height);
}
else if (DETAIL ("trough"))
{
}
else if (DETAIL ("menu"))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
STYLE_FUNCTION(draw_menu_frame) (cr, colors, ¶ms, x, y, width, height);
}
else if (DETAIL ("hseparator") || DETAIL ("vseparator"))
{
const gchar *new_detail = detail;
/* Draw a normal separator, we just use this because it gives more control
* over sizing (currently). */
/* This isn't nice ... but it seems like the best cleanest way to me right now.
* It will get slightly nicer in the future hopefully. */
if (GE_IS_MENU_ITEM (widget))
new_detail = "menuitem";
if (DETAIL ("hseparator")) {
gtk_paint_hline (style, window, state_type, area, widget, new_detail,
x, x + width - 1, y + height/2);
} else
gtk_paint_vline (style, window, state_type, area, widget, new_detail,
y, y + height - 1, x + width/2);
}
else
{
clearlooks_parent_class->draw_box (style, window, state_type, shadow_type, area,
widget, detail, x, y, width, height);
}
cairo_destroy (cr);
}
static void
moblin_netbook_draw_box (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
GtkShadowType shadow_type,
GdkRectangle *area,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height)
{
cairo_t *cr;
MoblinNetbookStyle *mb_style = MOBLIN_NETBOOK_STYLE (style);
gint radius = mb_style->radius;
DEBUG;
if (DETAIL ("paned") || DETAIL ("buttondefault"))
return;
/* we want hover and focused widgets to look the same */
if (widget && GTK_WIDGET_HAS_FOCUS (widget))
state_type = GTK_STATE_PRELIGHT;
/* scrollbar troughs are a plain rectangle */
if (widget && GTK_IS_SCROLLBAR (widget) && DETAIL ("trough"))
{
cr = moblin_netbook_cairo_create (window, area);
cairo_rectangle (cr, x, y, width, height);
gdk_cairo_set_source_color (cr, &style->base[state_type]);
cairo_fill (cr);
cairo_destroy (cr);
return;
}
SANITIZE_SIZE;
/*** treeview headers ***/
if (widget && GTK_IS_TREE_VIEW (widget->parent))
{
cr = moblin_netbook_cairo_create (window, area);
cairo_rectangle (cr, x, y, width, height);
gdk_cairo_set_source_color (cr, &style->bg[state_type]);
cairo_fill (cr);
cairo_destroy (cr);
gtk_paint_vline (style, window, state_type, area, widget, detail,
y + 5, y + height - 5, x + width - 1);
return;
}
/*** spin buttons ***/
if (DETAIL ("spinbutton_down") || DETAIL ("spinbutton_up"))
return;
if (DETAIL ("spinbutton"))
{
/* FIXME: for RTL */
width += 10;
x -= 10;
/* always draw button as shadow out to match the entry */
shadow_type = GTK_SHADOW_OUT;
/* draw the buttons with the same state type as the entry */
state_type = widget->state;
}
/*** combo boxes ***/
if (DETAIL ("button") && widget && GTK_IS_COMBO_BOX_ENTRY (widget->parent))
{
GtkWidget *entry;
entry = g_object_get_data (G_OBJECT (widget->parent),
"moblin-netbook-combo-entry");
g_object_set_data (G_OBJECT (widget->parent),
"moblin-netbook-combo-button", widget);
/* always draw combo box entry buttons as shadow out to match the entry */
shadow_type = GTK_SHADOW_OUT;
if (GTK_IS_ENTRY (entry))
{
gtk_widget_queue_draw (entry);
}
/* FIXME: RTL */
width += 10;
x -= 10;
}
if (widget
&& (DETAIL ("trough")
|| DETAIL ("trough-fill-level")
|| DETAIL ("trough-fill-level-full"))
&& GTK_IS_SCALE (widget))
{
if (mb_style->shadow)
{
width--;
height--;
}
if (width > height)
{
y = y + (height / 2.0 - 2);
height = 4;
}
else
{
x = x + (width / 2.0 - 2);
width = 4;
}
}
/* scrollbar buttons */
if (DETAIL ("hscrollbar") || DETAIL ("vscrollbar"))
{
x += 2;
y += 2;
width -= 4;
height -= 4;
}
/* scrollbar slider */
if (DETAIL ("slider"))
{
if (widget && GTK_IS_HSCROLLBAR (widget))
{
y += 2;
height -= 4;
}
else
{
x += 2;
width -= 4;
}
}
cr = moblin_netbook_cairo_create (window, area);
cairo_set_line_width (cr, LINE_WIDTH);
/* special "fill" indicator */
if (DETAIL ("trough-fill-level-full")
|| DETAIL ("trough-fill-level"))
{
gdk_cairo_set_source_color (cr, &style->base[GTK_STATE_SELECTED]);
if (width > height)
cairo_rectangle (cr, x, y + 1, width, height - 2);
else
cairo_rectangle (cr, x + 1, y, width - 2, height);
cairo_fill (cr);
cairo_destroy (cr);
return;
}
if (mb_style->shadow)
{
if (shadow_type == GTK_SHADOW_OUT)
{
/* outer shadow */
moblin_netbook_rounded_rectangle (cr, x, y, width, height,
radius + 1);
cairo_set_source_rgba (cr, 0, 0, 0, mb_style->shadow);
cairo_fill (cr);
/* reduce size for outer shadow */
height--;
width--;
}
else if (shadow_type == GTK_SHADOW_IN)
{
x++;
y++;
width--;
height--;
}
}
/* fill */
moblin_netbook_rounded_rectangle (cr, x, y, width, height, radius);
if (DETAIL ("light-switch-trough"))
{
cairo_pattern_t *crp;
crp = cairo_pattern_create_linear (x, y, x, height);
/* FIXME: these colours really should not be defined here */
if (state_type == GTK_STATE_SELECTED)
{
cairo_pattern_add_color_stop_rgb (crp, 0, 0.365, 0.820, 0.953);
cairo_pattern_add_color_stop_rgb (crp, 1, 0.627, 0.894, 0.973);
}
else
{
cairo_pattern_add_color_stop_rgb (crp, 0, 0.937, 0.941, 0.929);
cairo_pattern_add_color_stop_rgb (crp, 1, 1.0, 1.0, 1.0);
}
cairo_set_source (cr, crp);
}
else
gdk_cairo_set_source_color (cr, &style->bg[state_type]);
cairo_fill (cr);
/* extra hilight for "button" widgets, also used as focus rectangle since
* state_type is set to prelight for focused widgets (see above) */
if (state_type == GTK_STATE_PRELIGHT && DETAIL ("button")
&& !(widget && GTK_IS_COMBO_BOX_ENTRY (widget->parent)))
{
cairo_set_line_width (cr, 2.0);
moblin_netbook_rounded_rectangle (cr, x + 2, y + 2, width - 4,
height - 4, radius - 1);
gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_SELECTED]);
cairo_stroke (cr);
cairo_set_line_width (cr, 1.0);
}
if (shadow_type != GTK_SHADOW_NONE)
{
/* border */
moblin_netbook_rounded_rectangle (cr, x + 0.5, y + 0.5,
width - 1, height - 1, radius);
moblin_netbook_set_border_color (cr, style, state_type);
cairo_stroke (cr);
}
/* add a grip to handles */
if (DETAIL ("light-switch-handle") || DETAIL ("hscale"))
{
gdk_cairo_set_source_color (cr, &style->mid[state_type]);
moblin_netbook_draw_grip (cr, FALSE, x, y, width, height);
}
else if (DETAIL ("vscale"))
{
gdk_cairo_set_source_color (cr, &style->mid[state_type]);
moblin_netbook_draw_grip (cr, TRUE, x, y, width, height);
}
cairo_destroy (cr);
}
/* TODO remove redundant code */
static void
i7_cell_renderer_transcript_render(GtkCellRenderer *self, GdkWindow *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags)
{
I7_CELL_RENDERER_TRANSCRIPT_USE_PRIVATE;
int x, y, width, height;
unsigned xpad, ypad, transcript_width;
GtkStateType state;
cairo_t *cr;
PangoRectangle command_rect;
PangoLayout *layout;
GtkStyle *style = gtk_widget_get_style(widget);
/* Get the size we calculated earlier and then take the padding into account */
g_object_get(self, "xpad", &xpad, "ypad", &ypad, NULL);
gtk_cell_renderer_get_size(self, widget, cell_area, &x, &y, &width, &height);
x += cell_area->x + (int)xpad;
y += cell_area->y + (int)ypad;
width -= (int)xpad * 2;
height -= (int)ypad * 2;
/* Decide what state to draw the widget components in */
switch(flags) {
case GTK_CELL_RENDERER_PRELIT:
state = GTK_STATE_PRELIGHT;
break;
case GTK_CELL_RENDERER_INSENSITIVE:
state = GTK_STATE_INSENSITIVE;
break;
default:
state = GTK_STATE_NORMAL;
}
/* Get a cairo context to draw the rectangles on directly; use GTK themed
drawing to draw everything else */
cr = gdk_cairo_create(GDK_DRAWABLE(window));
/* Draw the command */
layout = gtk_widget_create_pango_layout(widget, priv->command);
pango_layout_get_pixel_extents(layout, NULL, &command_rect);
set_rgb_style(cr, STYLE_COMMAND);
cairo_rectangle(cr, (double)x, (double)y,
(double)width, (double)(command_rect.height + priv->text_padding * 2));
cairo_fill(cr);
gtk_paint_layout(style, window, state, TRUE, cell_area, widget, NULL,
x + priv->text_padding, y + priv->text_padding,
layout);
g_object_unref(layout);
/* Draw the transcript text */
transcript_width = priv->default_width / 2 - xpad;
if(priv->changed)
set_rgb_style(cr, STYLE_CHANGED);
else
set_rgb_style(cr, STYLE_UNCHANGED);
cairo_rectangle(cr,
(double)x,
(double)(y + command_rect.height + priv->text_padding * 2),
(double)(width / 2),
(double)(height - command_rect.height - priv->text_padding * 2));
cairo_fill(cr);
layout = gtk_widget_create_pango_layout(widget, NULL);
pango_layout_set_markup(layout, priv->transcript_text, -1);
pango_layout_set_width(layout, (int)(transcript_width - priv->text_padding * 2) * PANGO_SCALE);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
gtk_paint_layout(style, window, state, TRUE, cell_area, widget, NULL,
x + (int)priv->text_padding,
y + command_rect.height + (int)priv->text_padding * 3,
layout);
g_object_unref(layout);
/* Draw the expected text */
switch(priv->match_type) {
case CANT_COMPARE:
set_rgb_style(cr, STYLE_NO_EXPECTED);
break;
case NO_MATCH:
set_rgb_style(cr, STYLE_NO_MATCH);
break;
case NEAR_MATCH:
set_rgb_style(cr, STYLE_NEAR_MATCH);
break;
case EXACT_MATCH:
default:
set_rgb_style(cr, STYLE_EXACT_MATCH);
break;
}
cairo_rectangle(cr,
(double)(x + width / 2),
(double)(y + command_rect.height + priv->text_padding * 2),
(double)(width / 2),
(double)(height - command_rect.height - priv->text_padding * 2));
cairo_fill(cr);
layout = gtk_widget_create_pango_layout(widget, NULL);
pango_layout_set_markup(layout, priv->expected_text, -1);
pango_layout_set_width(layout, (int)(transcript_width - priv->text_padding * 2) * PANGO_SCALE);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
gtk_paint_layout(style, window, state, TRUE, cell_area, widget, NULL,
x + width / 2 + (int)priv->text_padding,
y + command_rect.height + (int)priv->text_padding * 3,
layout);
g_object_unref(layout);
/* Draw some lines */
gtk_paint_hline(style, window, state, cell_area, widget, NULL,
x, x + width,
y + command_rect.height + priv->text_padding * 2);
gtk_paint_vline(style, window, state, cell_area, widget, NULL,
y + command_rect.height + priv->text_padding * 2, y + height,
x + width / 2);
/* Draw a border around the highlighted node */
if(priv->current) {
cairo_set_line_width(cr, 4.0);
set_rgb_style(cr, STYLE_HIGHLIGHT);
cairo_rectangle(cr, (double)x + 2.0, (double)y + 2.0,
(double)width - 4.0, (double)height - 4.0);
cairo_stroke(cr);
}
/* Draw a border around the active node */
if(priv->played) {
cairo_set_line_width(cr, 2.0);
set_rgb_style(cr, STYLE_ACTIVE);
cairo_rectangle(cr, (double)x + 1.0, (double)y + 1.0,
(double)width - 2.0, (double)height - 2.0);
cairo_stroke(cr);
}
cairo_destroy(cr);
}
