static gboolean
mx_gtk_light_switch_expose (GtkWidget *lightswitch,
GdkEventExpose *event)
{
MxGtkLightSwitchPrivate *priv;
GtkStyle *style;
GtkStateType state_type;
cairo_t *cr;
cr = gdk_cairo_create (gtk_widget_get_window (lightswitch));
cairo_rectangle (cr,
event->area.x,
event->area.y,
event->area.width,
event->area.height);
cairo_clip (cr);
priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);
style = gtk_widget_get_style (lightswitch);
state_type = gtk_widget_get_state (lightswitch);
/* draw the trough */
gtk_paint_box (style,
gtk_widget_get_window (lightswitch),
(state_type != GTK_STATE_INSENSITIVE && priv->active)
? GTK_STATE_SELECTED : state_type,
GTK_SHADOW_IN,
NULL,
NULL,
"light-switch-trough",
0,
0,
(priv->trough_width),
priv->switch_height);
/* draw the switch itself */
if (state_type != GTK_STATE_INSENSITIVE)
{
gtk_paint_box (style,
gtk_widget_get_window (lightswitch),
gtk_widget_get_state (lightswitch),
GTK_SHADOW_OUT,
NULL,
NULL,
"light-switch-handle",
priv->x + style->xthickness,
style->ythickness,
priv->switch_width - style->xthickness * 2,
priv->switch_height - style->ythickness * 2);
}
cairo_destroy (cr);
return FALSE;
}
wxRect DrawCloseButton(wxDC& dc,
GtkWidget *widget,
int button_state,
wxRect const &in_rect,
int orientation,
GdkRectangle* clipRect)
{
GtkStyle *style_button = gtk_widget_get_style(wxGTKPrivate::GetButtonWidget());
int xthickness = style_button->xthickness;
int ythickness = style_button->ythickness;
wxBitmap bmp(gtk_widget_render_icon(widget, GTK_STOCK_CLOSE, GTK_ICON_SIZE_SMALL_TOOLBAR, "tab"));
if(bmp.GetWidth() != s_CloseIconSize || bmp.GetHeight() != s_CloseIconSize)
{
wxImage img = bmp.ConvertToImage();
img.Rescale(s_CloseIconSize, s_CloseIconSize);
bmp = img;
}
int button_size = s_CloseIconSize + 2 * xthickness;
wxRect out_rect;
if (orientation == wxLEFT)
out_rect.x = in_rect.x - ythickness;
else
out_rect.x = in_rect.x + in_rect.width - button_size - ythickness;
out_rect.y = in_rect.y + (in_rect.height - button_size) / 2;
out_rect.width = button_size;
out_rect.height = button_size;
wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
GdkWindow* window = impldc->GetGDKWindow();
if (button_state == wxAUI_BUTTON_STATE_HOVER)
{
gtk_paint_box(style_button, window,
GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, clipRect, widget, "button",
out_rect.x, out_rect.y, out_rect.width, out_rect.height);
}
else if (button_state == wxAUI_BUTTON_STATE_PRESSED)
{
gtk_paint_box(style_button, window,
GTK_STATE_ACTIVE, GTK_SHADOW_IN, clipRect, widget, "button",
out_rect.x, out_rect.y, out_rect.width, out_rect.height);
}
dc.DrawBitmap(bmp, out_rect.x + xthickness, out_rect.y + ythickness, true);
return out_rect;
}
static gint
moz_gtk_scrollbar_trough_paint(GtkThemeWidgetType widget,
GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStyle* style;
GtkScrollbar *scrollbar;
ensure_scrollbar_widget();
if (widget == MOZ_GTK_SCROLLBAR_TRACK_HORIZONTAL)
scrollbar = GTK_SCROLLBAR(gParts->horizScrollbarWidget);
else
scrollbar = GTK_SCROLLBAR(gParts->vertScrollbarWidget);
gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
style = gtk_widget_get_style(GTK_WIDGET(scrollbar));
TSOffsetStyleGCs(style, rect->x, rect->y);
gtk_paint_box(style, drawable, GTK_STATE_ACTIVE, GTK_SHADOW_IN, cliprect,
GTK_WIDGET(scrollbar), "trough", rect->x, rect->y,
rect->width, rect->height);
if (state->focused) {
gtk_paint_focus(style, drawable, GTK_STATE_ACTIVE, cliprect,
GTK_WIDGET(scrollbar), "trough",
rect->x, rect->y, rect->width, rect->height);
}
return MOZ_GTK_SUCCESS;
}
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;
}
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_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_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 void
custom_cell_renderer_progress_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
guint flags)
{
CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (cell);
GtkStateType state;
gint width, height;
gint x_offset, y_offset;
custom_cell_renderer_progress_get_size (cell, widget, cell_area,
&x_offset, &y_offset,
&width, &height);
if (GTK_WIDGET_HAS_FOCUS (widget))
state = GTK_STATE_ACTIVE;
else
state = GTK_STATE_NORMAL;
width -= cell->xpad*2;
height -= cell->ypad*2;
gtk_paint_box (widget->style,
window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, "trough",
cell_area->x + x_offset + cell->xpad,
cell_area->y + y_offset + cell->ypad,
width - 1, height - 1);
gtk_paint_box (widget->style,
window,
state, GTK_SHADOW_OUT,
NULL, widget, "bar",
cell_area->x + x_offset + cell->xpad,
cell_area->y + y_offset + cell->ypad,
width * cellprogress->progress,
height - 1);
}
static gboolean
on_widget_expose (GtkWidget *widget,
GdkEventExpose *event,
char *item_id)
{
g_print ("%s received 'expose' signal\n", item_id);
gtk_paint_box (widget->style, widget->window, GTK_STATE_NORMAL,
GTK_SHADOW_IN, &event->area, widget, NULL, 0, 0,
widget->allocation.width, widget->allocation.height);
return FALSE;
}
void WidgetRenderingContext::gtkPaintBox(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() };
// Some widgets also need their allocation adjusted to account for extra space.
// Right now only scrollbar buttons have significant allocations.
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
allocation.x += m_paintRect.x;
allocation.y += m_paintRect.y;
gtk_widget_set_allocation(widget, &allocation);
gtk_paint_box(gtk_widget_get_style(widget), m_target, stateType, shadowType, &paintRect,
widget, detail, paintRect.x, paintRect.y, paintRect.width, paintRect.height);
}
void wxAuiGtkTabArt::DrawBorder(wxDC& WXUNUSED(dc), wxWindow* wnd, const wxRect& rect)
{
int generic_border_width = wxAuiGenericTabArt::GetBorderWidth(wnd);
if (!wnd) return;
if (!wnd->m_wxwindow) return;
if (!gtk_widget_is_drawable(wnd->m_wxwindow)) return;
GtkStyle *style_notebook = gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget());
gtk_paint_box(style_notebook, wnd->GTKGetDrawingWindow(), GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, wnd->m_wxwindow,
const_cast<char*>("notebook"),
rect.x + generic_border_width + 1, rect.y + generic_border_width + 1,
rect.width - (generic_border_width + 1), rect.height - (generic_border_width + 1));
}
virtual void Paint2(Draw& w) {
Size sz = GetSize();
w.DrawRect(GetSize(), White());
static GdkColormap* cm = gdk_x11_colormap_foreign_new(
gdkx_visual_get(XVisualIDFromVisual(Xvisual)), Xcolormap);
GdkWindow *gw = gdk_window_foreign_new(w.GetDrawable());
GtkStyle *style = gtk_widget_get_style((GtkWidget *)gtk__parent());
GdkRectangle r;
r.x = r.y = 0;
r.width = r.height = 64;
gtk_paint_box(style, gw,
(GtkStateType)0, (GtkShadowType)0, &r,
(GtkWidget*)GTK().gtk_button_new(), "button",
0, 0, 64, 64);
}
static gint
moz_gtk_progress_chunk_paint(GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkTextDirection direction)
{
GtkStyle* style;
ensure_progress_widget();
gtk_widget_set_direction(gParts->progresWidget, direction);
style = gtk_widget_get_style(gParts->progresWidget);
TSOffsetStyleGCs(style, rect->x, rect->y);
gtk_paint_box(style, drawable, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
cliprect, gParts->progresWidget, "bar", rect->x, rect->y,
rect->width, rect->height);
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;
}
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;
}
void wxAuiGtkTabArt::DrawTab(wxDC& dc, wxWindow* wnd, const wxAuiNotebookPage& page,
const wxRect& in_rect, int close_button_state, wxRect* out_tab_rect,
wxRect* out_button_rect, int* x_extent)
{
GtkWidget *widget = wnd->GetHandle();
GtkStyle *style_notebook = gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget());
wxRect const &window_rect = wnd->GetRect();
int focus_width = 0;
gtk_widget_style_get(wxGTKPrivate::GetNotebookWidget(),
"focus-line-width", &focus_width,
NULL);
int tab_pos;
if (m_flags &wxAUI_NB_BOTTOM)
tab_pos = wxAUI_NB_BOTTOM;
else //if (m_flags & wxAUI_NB_TOP) {}
tab_pos = wxAUI_NB_TOP;
// TODO: else if (m_flags &wxAUI_NB_LEFT) {}
// TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
// figure out the size of the tab
wxSize tab_size = GetTabSize(dc, wnd, page.caption, page.bitmap,
page.active, close_button_state, x_extent);
wxRect tab_rect = in_rect;
tab_rect.width = tab_size.x;
tab_rect.height = tab_size.y;
tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
if (page.active)
tab_rect.height += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
int gap_rect_height = 10 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
int gap_rect_x = 1, gap_start = 0, gap_width = 0;
int gap_rect_y = tab_rect.y - gap_rect_height;
int gap_rect_width = window_rect.width;
switch (tab_pos)
{
case wxAUI_NB_TOP:
tab_rect.y -= 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
if (!page.active)
tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
gap_rect_y = tab_rect.y + tab_rect.height - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
// fall through
case wxAUI_NB_BOTTOM:
gap_start = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder / 2;
gap_width = tab_rect.width;
break;
// TODO: case wxAUI_NB_LEFT: break;
// TODO: case wxAUI_NB_RIGHT: break;
}
tab_rect.y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
gap_rect_y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
int padding = focus_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
int clip_width = tab_rect.width;
if (tab_rect.x + tab_rect.width > in_rect.x + in_rect.width)
clip_width = (in_rect.x + in_rect.width) - tab_rect.x;
dc.SetClippingRegion(tab_rect.x, tab_rect.y - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder, clip_width, tab_rect.height + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder);
GdkRectangle area;
area.x = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
area.y = tab_rect.y - 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
area.width = clip_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
area.height = tab_rect.height + 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
GdkWindow* window = impldc->GetGDKWindow();
// Before drawing the active tab itself, draw a box without border, because some themes
// have transparent gaps and a line would be visible at the bottom of the tab
if (page.active)
gtk_paint_box(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
NULL, widget,
const_cast<char*>("notebook"),
gap_rect_x, gap_rect_y,
gap_rect_width, gap_rect_height);
if (tab_pos == wxAUI_NB_BOTTOM)
{
if (page.active)
{
gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget,
const_cast<char*>("notebook"),
gap_rect_x, gap_rect_y,
gap_rect_width, gap_rect_height,
GTK_POS_BOTTOM, gap_start , gap_width);
}
gtk_paint_extension(style_notebook, window,
page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
&area, widget,
const_cast<char*>("tab"),
tab_rect.x, tab_rect.y,
tab_rect.width, tab_rect.height,
GTK_POS_TOP);
}
else
{
if (page.active)
{
gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget,
const_cast<char*>("notebook"),
gap_rect_x, gap_rect_y,
gap_rect_width, gap_rect_height,
GTK_POS_TOP, gap_start , gap_width);
}
gtk_paint_extension(style_notebook, window,
page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
&area, widget,
const_cast<char*>("tab"),
tab_rect.x, tab_rect.y,
tab_rect.width, tab_rect.height,
GTK_POS_BOTTOM);
}
// After drawing the inactive tab itself, draw a box with the same dimensions as the gap-box,
// otherwise we don't get a gap-box, if the active tab is invisible
if (!page.active)
gtk_paint_box(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget,
const_cast<char*>("notebook"),
gap_rect_x, gap_rect_y,
gap_rect_width, gap_rect_height);
wxCoord textX = tab_rect.x + padding + style_notebook->xthickness;
int bitmap_offset = 0;
if (page.bitmap.IsOk())
{
bitmap_offset = textX;
// draw bitmap
int bitmapY = tab_rect.y +(tab_rect.height - page.bitmap.GetHeight()) / 2;
if(!page.active)
{
if (tab_pos == wxAUI_NB_TOP)
bitmapY += style_notebook->ythickness / 2;
else
bitmapY -= style_notebook->ythickness / 2;
}
dc.DrawBitmap(page.bitmap,
bitmap_offset,
bitmapY,
true);
textX += page.bitmap.GetWidth() + padding;
}
wxCoord textW, textH, textY;
dc.SetFont(m_normalFont);
dc.GetTextExtent(page.caption, &textW, &textH);
textY = tab_rect.y + (tab_rect.height - textH) / 2;
if(!page.active)
{
if (tab_pos == wxAUI_NB_TOP)
textY += style_notebook->ythickness / 2;
else
textY -= style_notebook->ythickness / 2;
}
// draw tab text
GdkColor text_colour = page.active ? style_notebook->fg[GTK_STATE_NORMAL] : style_notebook->fg[GTK_STATE_ACTIVE];
dc.SetTextForeground(wxColor(text_colour));
GdkRectangle focus_area;
int padding_focus = padding - focus_width;
focus_area.x = tab_rect.x + padding_focus;
focus_area.y = textY - focus_width;
focus_area.width = tab_rect.width - 2 * padding_focus;
focus_area.height = textH + 2 * focus_width;
if(page.active && (wnd->FindFocus() == wnd) && focus_area.x <= (area.x + area.width))
{
// clipping seems not to work here, so we we have to recalc the focus-area manually
if((focus_area.x + focus_area.width) > (area.x + area.width))
focus_area.width = area.x + area.width - focus_area.x + focus_width - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
gtk_paint_focus (style_notebook, window,
GTK_STATE_ACTIVE, NULL, widget, "tab",
focus_area.x, focus_area.y, focus_area.width, focus_area.height);
}
dc.DrawText(page.caption, textX, textY);
// draw close-button on tab (if enabled)
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
{
wxRect rect(tab_rect.x, tab_rect.y, tab_rect.width - style_notebook->xthickness, tab_rect.height);
if(!page.active)
{
if (tab_pos == wxAUI_NB_TOP)
rect.y += style_notebook->ythickness / 2;
else
rect.y -= style_notebook->ythickness / 2;
}
*out_button_rect = DrawCloseButton(dc, widget, close_button_state, rect, wxRIGHT, &area);
}
if ( clip_width < tab_rect.width )
tab_rect.width = clip_width;
*out_tab_rect = tab_rect;
dc.DestroyClippingRegion();
}
static void
gtk_hruler_draw_ticks (GtkRuler *ruler)
{
GtkWidget *widget;
GdkGC *gc, *bg_gc;
GdkFont *font;
gint i;
gint width, height;
gint xthickness;
gint ythickness;
gint length, ideal_length;
gfloat lower, upper; /* Upper and lower limits, in ruler units */
gfloat increment; /* Number of pixels per unit */
gint scale; /* Number of units per major unit */
gfloat subd_incr;
gfloat start, end, cur;
gchar unit_str[32];
gint digit_height;
gint text_width;
gint pos;
g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_HRULER (ruler));
if (!GTK_WIDGET_DRAWABLE (ruler))
return;
widget = GTK_WIDGET (ruler);
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
font = widget->style->font;
xthickness = widget->style->klass->xthickness;
ythickness = widget->style->klass->ythickness;
digit_height = font->ascent; /* assume descent == 0 ? */
width = widget->allocation.width;
height = widget->allocation.height - ythickness * 2;
gtk_paint_box (widget->style, ruler->backing_store,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, "hruler",
0, 0,
widget->allocation.width, widget->allocation.height);
gdk_draw_line (ruler->backing_store, gc,
xthickness,
height + ythickness,
widget->allocation.width - xthickness,
height + ythickness);
upper = ruler->upper / ruler->metric->pixels_per_unit;
lower = ruler->lower / ruler->metric->pixels_per_unit;
if ((upper - lower) == 0)
return;
increment = (gfloat) width / (upper - lower);
/* determine the scale
* We calculate the text size as for the vruler instead of using
* text_width = gdk_string_width(font, unit_str), so that the result
* for the scale looks consistent with an accompanying vruler
*/
scale = ceil (ruler->max_size / ruler->metric->pixels_per_unit);
sprintf (unit_str, "%d", scale);
text_width = strlen (unit_str) * digit_height + 1;
for (scale = 0; scale < MAXIMUM_SCALES; scale++)
if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
break;
if (scale == MAXIMUM_SCALES)
scale = MAXIMUM_SCALES - 1;
/* drawing starts here */
length = 0;
for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
{
subd_incr = (gfloat) ruler->metric->ruler_scale[scale] /
(gfloat) ruler->metric->subdivide[i];
if (subd_incr * fabs(increment) <= MINIMUM_INCR)
continue;
/* Calculate the length of the tickmarks. Make sure that
* this length increases for each set of ticks
*/
ideal_length = height / (i + 1) - 1;
if (ideal_length > ++length)
length = ideal_length;
if (lower < upper)
{
start = floor (lower / subd_incr) * subd_incr;
end = ceil (upper / subd_incr) * subd_incr;
}
else
{
start = floor (upper / subd_incr) * subd_incr;
end = ceil (lower / subd_incr) * subd_incr;
}
for (cur = start; cur <= end; cur += subd_incr)
{
pos = ROUND ((cur - lower) * increment);
gdk_draw_line (ruler->backing_store, gc,
pos, height + ythickness,
pos, height - length + ythickness);
/* draw label */
if (i == 0)
{
sprintf (unit_str, "%d", (int) cur);
gdk_draw_string (ruler->backing_store, font, gc,
pos + 2, ythickness + font->ascent - 1,
unit_str);
}
}
}
}
static gint
moz_gtk_scrollbar_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state,
GtkScrollbarButtonFlags flags,
GtkTextDirection direction)
{
GtkStateType state_type = ConvertGtkState(state);
GtkShadowType shadow_type = (state->active) ?
GTK_SHADOW_IN : GTK_SHADOW_OUT;
GdkRectangle arrow_rect;
GtkStyle* style;
GtkWidget *scrollbar;
GtkAllocation allocation;
GtkArrowType arrow_type;
gint arrow_displacement_x, arrow_displacement_y;
const char* detail = (flags & MOZ_GTK_STEPPER_VERTICAL) ?
"vscrollbar" : "hscrollbar";
ensure_scrollbar_widget();
if (flags & MOZ_GTK_STEPPER_VERTICAL)
scrollbar = gParts->vertScrollbarWidget;
else
scrollbar = gParts->horizScrollbarWidget;
gtk_widget_set_direction(scrollbar, direction);
/* Some theme engines (i.e., ClearLooks) check the scrollbar's allocation
to determine where it should paint rounded corners on the buttons.
We need to trick them into drawing the buttons the way we want them. */
gtk_widget_get_allocation(scrollbar, &allocation);
allocation.x = rect->x;
allocation.y = rect->y;
allocation.width = rect->width;
allocation.height = rect->height;
if (flags & MOZ_GTK_STEPPER_VERTICAL) {
allocation.height *= 5;
if (flags & MOZ_GTK_STEPPER_DOWN) {
arrow_type = GTK_ARROW_DOWN;
if (flags & MOZ_GTK_STEPPER_BOTTOM)
allocation.y -= 4 * rect->height;
else
allocation.y -= rect->height;
} else {
arrow_type = GTK_ARROW_UP;
if (flags & MOZ_GTK_STEPPER_BOTTOM)
allocation.y -= 3 * rect->height;
}
} else {
allocation.width *= 5;
if (flags & MOZ_GTK_STEPPER_DOWN) {
arrow_type = GTK_ARROW_RIGHT;
if (flags & MOZ_GTK_STEPPER_BOTTOM)
allocation.x -= 4 * rect->width;
else
allocation.x -= rect->width;
} else {
arrow_type = GTK_ARROW_LEFT;
if (flags & MOZ_GTK_STEPPER_BOTTOM)
allocation.x -= 3 * rect->width;
}
}
gtk_widget_set_allocation(scrollbar, &allocation);
style = gtk_widget_get_style(scrollbar);
TSOffsetStyleGCs(style, rect->x, rect->y);
gtk_paint_box(style, drawable, state_type, shadow_type, cliprect,
scrollbar, detail, rect->x, rect->y,
rect->width, rect->height);
arrow_rect.width = rect->width / 2;
arrow_rect.height = rect->height / 2;
arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
if (state_type == GTK_STATE_ACTIVE) {
gtk_widget_style_get(scrollbar,
"arrow-displacement-x", &arrow_displacement_x,
"arrow-displacement-y", &arrow_displacement_y,
NULL);
arrow_rect.x += arrow_displacement_x;
arrow_rect.y += arrow_displacement_y;
}
gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
scrollbar, detail, arrow_type, TRUE, arrow_rect.x,
arrow_rect.y, arrow_rect.width, arrow_rect.height);
return MOZ_GTK_SUCCESS;
}
static gboolean _togglebutton_expose(GtkWidget *widget, GdkEventExpose *event)
{
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (DTGTK_IS_TOGGLEBUTTON(widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
GtkStyle *style=gtk_widget_get_style(widget);
int state = gtk_widget_get_state(widget);
/* fix text style */
for(int i=0; i<5; i++)
style->text[i]=style->fg[i];
/* fetch flags */
int flags = DTGTK_TOGGLEBUTTON (widget)->icon_flags;
/* set inner border */
int border = (flags&CPF_DO_NOT_USE_BORDER)?2:6;
/* update active state paint flag */
gboolean active = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (widget));
if (active)
flags |= CPF_ACTIVE;
else
flags &=~(CPF_ACTIVE);
/* prelight */
if (state == GTK_STATE_PRELIGHT)
flags |= CPF_PRELIGHT;
else
flags &=~CPF_PRELIGHT;
/* begin cairo drawing */
cairo_t *cr;
cr = gdk_cairo_create (gtk_widget_get_window(widget));
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int x = allocation.x;
int y = allocation.y;
int width = allocation.width;
int height = allocation.height;
/* draw standard button background if not transparent nor flat styled */
if( (flags & CPF_STYLE_FLAT ))
{
if( state != GTK_STATE_NORMAL )
{
cairo_rectangle (cr,x,y,width,height);
cairo_set_source_rgba (cr,
style->bg[state].red/65535.0,
style->bg[state].green/65535.0,
style->bg[state].blue/65535.0,
0.5);
cairo_fill (cr);
}
}
else if( !(flags & CPF_BG_TRANSPARENT) )
{
/* draw default boxed button */
gtk_paint_box (gtk_widget_get_style(widget), gtk_widget_get_window(widget),
gtk_widget_get_state(widget),
GTK_SHADOW_OUT, NULL, widget, "button",
x, y, width, height);
}
/* create pango text settings if label exists */
PangoLayout *layout=NULL;
int pw=0,ph=0;
const gchar *text=gtk_button_get_label (GTK_BUTTON (widget));
if (text)
{
layout = pango_cairo_create_layout (cr);
pango_layout_set_font_description (layout,style->font_desc);
pango_layout_set_text (layout,text,-1);
pango_layout_get_pixel_size (layout,&pw,&ph);
}
cairo_set_source_rgb (cr,
style->fg[state].red/65535.0,
style->fg[state].green/65535.0,
style->fg[state].blue/65535.0);
/* draw icon */
if (DTGTK_TOGGLEBUTTON (widget)->icon)
{
// if (flags & CPF_IGNORE_FG_STATE)
// state = GTK_STATE_NORMAL;
if (text)
DTGTK_TOGGLEBUTTON (widget)->icon (cr,x+border,y+border,height-(border*2),height-(border*2),flags);
else
DTGTK_TOGGLEBUTTON (widget)->icon (cr,x+border,y+border,width-(border*2),height-(border*2),flags);
}
/* draw label */
if (text)
{
int lx=x+2, ly=y+((height/2.0)-(ph/2.0));
//if (DTGTK_TOGGLEBUTTON (widget)->icon) lx += width;
//GdkRectangle t={x,y,x+width,y+height};
//gtk_paint_layout(style,gtk_widget_get_window(widget), state,TRUE,&t,widget,"togglebutton",lx,ly,layout);
cairo_translate(cr, lx, ly);
pango_cairo_show_layout (cr,layout);
}
cairo_destroy (cr);
return FALSE;
}
static void
gtk_tearoff_menu_item_paint (GtkWidget *widget,
GdkRectangle *area)
{
GtkMenuItem *menu_item;
GtkShadowType shadow_type;
gint width, height;
gint x, y;
gint right_max;
GtkArrowType arrow_type;
GtkTextDirection direction;
if (GTK_WIDGET_DRAWABLE (widget))
{
menu_item = GTK_MENU_ITEM (widget);
direction = gtk_widget_get_direction (widget);
x = widget->allocation.x + GTK_CONTAINER (menu_item)->border_width;
y = widget->allocation.y + GTK_CONTAINER (menu_item)->border_width;
width = widget->allocation.width - GTK_CONTAINER (menu_item)->border_width * 2;
height = widget->allocation.height - GTK_CONTAINER (menu_item)->border_width * 2;
right_max = x + width;
if (widget->state == GTK_STATE_PRELIGHT)
{
gint selected_shadow_type;
gtk_widget_style_get (widget,
"selected-shadow-type", &selected_shadow_type,
NULL);
gtk_paint_box (widget->style,
widget->window,
GTK_STATE_PRELIGHT,
selected_shadow_type,
area, widget, "menuitem",
x, y, width, height);
}
else
gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
if (GTK_IS_MENU (widget->parent) && GTK_MENU (widget->parent)->torn_off)
{
gint arrow_x;
if (widget->state == GTK_STATE_PRELIGHT)
shadow_type = GTK_SHADOW_IN;
else
shadow_type = GTK_SHADOW_OUT;
if (menu_item->toggle_size > ARROW_SIZE)
{
if (direction == GTK_TEXT_DIR_LTR) {
arrow_x = x + (menu_item->toggle_size - ARROW_SIZE)/2;
arrow_type = GTK_ARROW_LEFT;
}
else {
arrow_x = x + width - menu_item->toggle_size + (menu_item->toggle_size - ARROW_SIZE)/2;
arrow_type = GTK_ARROW_RIGHT;
}
x += menu_item->toggle_size + BORDER_SPACING;
}
else
{
if (direction == GTK_TEXT_DIR_LTR) {
arrow_x = ARROW_SIZE / 2;
arrow_type = GTK_ARROW_LEFT;
}
else {
arrow_x = x + width - 2 * ARROW_SIZE + ARROW_SIZE / 2;
arrow_type = GTK_ARROW_RIGHT;
}
x += 2 * ARROW_SIZE;
}
gtk_paint_arrow (widget->style, widget->window,
widget->state, shadow_type,
NULL, widget, "tearoffmenuitem",
arrow_type, FALSE,
arrow_x, y + height / 2 - 5,
ARROW_SIZE, ARROW_SIZE);
}
while (x < right_max)
{
gint x1, x2;
if (direction == GTK_TEXT_DIR_LTR) {
x1 = x;
x2 = MIN (x + TEAR_LENGTH, right_max);
}
else {
x1 = right_max - x;
x2 = MAX (right_max - x - TEAR_LENGTH, 0);
}
gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
NULL, widget, "tearoffmenuitem",
x1, x2, y + (height - widget->style->ythickness) / 2);
x += 2 * TEAR_LENGTH;
}
}
}
static gint
moz_gtk_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state,
GtkReliefStyle relief, GtkWidget* widget,
GtkTextDirection direction)
{
GtkShadowType shadow_type;
GtkStyle* style = gtk_widget_get_style(widget);
GtkStateType button_state = ConvertGtkState(state);
gint x = rect->x, y=rect->y, width=rect->width, height=rect->height;
gboolean interior_focus;
gint focus_width, focus_pad;
moz_gtk_widget_get_focus(widget, &interior_focus, &focus_width, &focus_pad);
gtk_widget_set_state(widget, button_state);
gtk_widget_set_direction(widget, direction);
if (state->isDefault)
GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_DEFAULT);
gtk_button_set_relief(GTK_BUTTON(widget), relief);
/* Some theme engines love to cause us pain in that gtk_paint_focus is a
no-op on buttons and button-like widgets. They only listen to this flag. */
if (state->focused && !state->disabled)
GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
if (!interior_focus && state->focused) {
x += focus_width + focus_pad;
y += focus_width + focus_pad;
width -= 2 * (focus_width + focus_pad);
height -= 2 * (focus_width + focus_pad);
}
shadow_type = button_state == GTK_STATE_ACTIVE ||
state->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
if (state->isDefault && relief == GTK_RELIEF_NORMAL) {
gtk_paint_box(style, drawable, button_state, shadow_type, cliprect,
widget, "buttondefault", x, y, width, height);
}
if (relief != GTK_RELIEF_NONE || state->depressed ||
(button_state != GTK_STATE_NORMAL &&
button_state != GTK_STATE_INSENSITIVE)) {
TSOffsetStyleGCs(style, x, y);
/* the following line can trigger an assertion (Crux theme)
file ../../gdk/gdkwindow.c: line 1846 (gdk_window_clear_area):
assertion `GDK_IS_WINDOW (window)' failed */
gtk_paint_box(style, drawable, button_state, shadow_type, cliprect,
widget, "button", x, y, width, height);
}
if (state->focused) {
if (interior_focus) {
GtkStyle* style = gtk_widget_get_style(widget);
x += style->xthickness + focus_pad;
y += style->ythickness + focus_pad;
width -= 2 * (style->xthickness + focus_pad);
height -= 2 * (style->ythickness + focus_pad);
} else {
x -= focus_width + focus_pad;
y -= focus_width + focus_pad;
width += 2 * (focus_width + focus_pad);
height += 2 * (focus_width + focus_pad);
}
TSOffsetStyleGCs(style, x, y);
gtk_paint_focus(style, drawable, button_state, cliprect,
widget, "button", x, y, width, height);
}
GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_DEFAULT);
GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
return MOZ_GTK_SUCCESS;
}
static void
gtk_vruler_draw_ticks (GtkRuler *ruler)
{
GtkWidget *widget;
GdkGC *gc, *bg_gc;
GdkFont *font;
gint i, j;
gint width, height;
gint xthickness;
gint ythickness;
gint length, ideal_length;
gfloat lower, upper; /* Upper and lower limits, in ruler units */
gfloat increment; /* Number of pixels per unit */
gint scale; /* Number of units per major unit */
gfloat subd_incr;
gfloat start, end, cur;
gchar unit_str[32];
gchar digit_str[2] = { '\0', '\0' };
gint digit_height;
gint text_height;
gint pos;
g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_VRULER (ruler));
if (!GTK_WIDGET_DRAWABLE (ruler))
return;
widget = GTK_WIDGET (ruler);
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
font = widget->style->font;
xthickness = widget->style->klass->xthickness;
ythickness = widget->style->klass->ythickness;
digit_height = font->ascent; /* assume descent == 0 ? */
width = widget->allocation.height;
height = widget->allocation.width - ythickness * 2;
gtk_paint_box (widget->style, ruler->backing_store,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, "vruler",
0, 0,
widget->allocation.width, widget->allocation.height);
gdk_draw_line (ruler->backing_store, gc,
height + xthickness,
ythickness,
height + xthickness,
widget->allocation.height - ythickness);
upper = ruler->upper / ruler->metric->pixels_per_unit;
lower = ruler->lower / ruler->metric->pixels_per_unit;
if ((upper - lower) == 0)
return;
increment = (gfloat) width / (upper - lower);
/* determine the scale
* use the maximum extents of the ruler to determine the largest
* possible number to be displayed. Calculate the height in pixels
* of this displayed text. Use this height to find a scale which
* leaves sufficient room for drawing the ruler.
*/
scale = ceil (ruler->max_size / ruler->metric->pixels_per_unit);
sprintf (unit_str, "%d", scale);
text_height = strlen (unit_str) * digit_height + 1;
for (scale = 0; scale < MAXIMUM_SCALES; scale++)
if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_height)
break;
if (scale == MAXIMUM_SCALES)
scale = MAXIMUM_SCALES - 1;
/* drawing starts here */
length = 0;
for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
{
subd_incr = (gfloat) ruler->metric->ruler_scale[scale] /
(gfloat) ruler->metric->subdivide[i];
if (subd_incr * fabs(increment) <= MINIMUM_INCR)
continue;
/* Calculate the length of the tickmarks. Make sure that
* this length increases for each set of ticks
*/
ideal_length = height / (i + 1) - 1;
if (ideal_length > ++length)
length = ideal_length;
if (lower < upper)
{
start = floor (lower / subd_incr) * subd_incr;
end = ceil (upper / subd_incr) * subd_incr;
}
else
{
start = floor (upper / subd_incr) * subd_incr;
end = ceil (lower / subd_incr) * subd_incr;
}
for (cur = start; cur <= end; cur += subd_incr)
{
pos = ROUND ((cur - lower) * increment);
gdk_draw_line (ruler->backing_store, gc,
height + xthickness - length, pos,
height + xthickness, pos);
/* draw label */
if (i == 0)
{
sprintf (unit_str, "%d", (int) cur);
for (j = 0; j < (int) strlen (unit_str); j++)
{
digit_str[0] = unit_str[j];
gdk_draw_string (ruler->backing_store, font, gc,
xthickness + 1,
pos + digit_height * (j + 1) + 1,
digit_str);
}
}
}
}
}
/**
* 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 void
gtk_hruler_draw_ticks (GtkRuler *ruler)
{
GtkWidget *widget;
GdkGC *gc, *bg_gc;
gint i;
gint width, height;
gint xthickness;
gint ythickness;
gint length, ideal_length;
gdouble lower, upper; /* Upper and lower limits, in ruler units */
gdouble increment; /* Number of pixels per unit */
gint scale; /* Number of units per major unit */
gdouble subd_incr;
gdouble start, end, cur;
gchar unit_str[32];
gint digit_height;
gint digit_offset;
gint text_width;
gint pos;
PangoLayout *layout;
PangoRectangle logical_rect, ink_rect;
if (!GTK_WIDGET_DRAWABLE (ruler))
return;
widget = GTK_WIDGET (ruler);
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
xthickness = widget->style->xthickness;
ythickness = widget->style->ythickness;
digit_height = PANGO_PIXELS (ink_rect.height) + 2;
digit_offset = ink_rect.y;
layout = gtk_widget_create_pango_layout (widget, "012456789");
pango_layout_get_extents (layout, &ink_rect, &logical_rect);
digit_height = PANGO_PIXELS (ink_rect.height) + 1;
digit_offset = ink_rect.y;
width = widget->allocation.width;
height = widget->allocation.height - ythickness * 2;
gtk_paint_box (widget->style, ruler->backing_store,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, "hruler",
0, 0,
widget->allocation.width, widget->allocation.height);
gdk_draw_line (ruler->backing_store, gc,
xthickness,
height + ythickness,
widget->allocation.width - xthickness,
height + ythickness);
upper = ruler->upper / ruler->metric->pixels_per_unit;
lower = ruler->lower / ruler->metric->pixels_per_unit;
if ((upper - lower) == 0)
return;
increment = (gdouble) width / (upper - lower);
/* determine the scale
* We calculate the text size as for the vruler instead of using
* text_width = gdk_string_width(font, unit_str), so that the result
* for the scale looks consistent with an accompanying vruler
*/
scale = ceil (ruler->max_size / ruler->metric->pixels_per_unit);
g_snprintf (unit_str, sizeof (unit_str), "%d", scale);
text_width = strlen (unit_str) * digit_height + 1;
for (scale = 0; scale < MAXIMUM_SCALES; scale++)
if (ruler->metric->ruler_scale[scale] * fabs(increment) > 2 * text_width)
break;
if (scale == MAXIMUM_SCALES)
scale = MAXIMUM_SCALES - 1;
/* drawing starts here */
length = 0;
for (i = MAXIMUM_SUBDIVIDE - 1; i >= 0; i--)
{
subd_incr = (gdouble) ruler->metric->ruler_scale[scale] /
(gdouble) ruler->metric->subdivide[i];
if (subd_incr * fabs(increment) <= MINIMUM_INCR)
continue;
/* Calculate the length of the tickmarks. Make sure that
* this length increases for each set of ticks
*/
ideal_length = height / (i + 1) - 1;
if (ideal_length > ++length)
length = ideal_length;
if (lower < upper)
{
start = floor (lower / subd_incr) * subd_incr;
end = ceil (upper / subd_incr) * subd_incr;
}
else
{
start = floor (upper / subd_incr) * subd_incr;
end = ceil (lower / subd_incr) * subd_incr;
}
for (cur = start; cur <= end; cur += subd_incr)
{
pos = ROUND ((cur - lower) * increment);
gdk_draw_line (ruler->backing_store, gc,
pos, height + ythickness,
pos, height - length + ythickness);
/* draw label */
if (i == 0)
{
g_snprintf (unit_str, sizeof (unit_str), "%d", (int) cur);
pango_layout_set_text (layout, unit_str, -1);
pango_layout_get_extents (layout, &logical_rect, NULL);
gtk_paint_layout (widget->style,
ruler->backing_store,
GTK_WIDGET_STATE (widget),
FALSE,
NULL,
widget,
"hruler",
pos + 2, ythickness + PANGO_PIXELS (logical_rect.y - digit_offset),
layout);
}
}
}
g_object_unref (layout);
}
static gboolean
gimp_tag_popup_border_expose (GtkWidget *widget,
GdkEventExpose *event,
GimpTagPopup *popup)
{
GdkWindow *window = gtk_widget_get_window (widget);
GtkStyle *style = gtk_widget_get_style (widget);
GdkRectangle border;
GdkRectangle upper;
GdkRectangle lower;
gint arrow_space;
gint arrow_size;
if (event->window != gtk_widget_get_window (widget))
return FALSE;
get_arrows_visible_area (popup, &border, &upper, &lower, &arrow_space);
arrow_size = 0.7 * arrow_space;
gtk_paint_box (style, window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
&event->area, widget, "menu",
0, 0, -1, -1);
if (popup->arrows_visible)
{
/* upper arrow */
gtk_paint_box (style, window,
popup->upper_arrow_state,
GTK_SHADOW_OUT,
&event->area, widget, "menu",
upper.x,
upper.y,
upper.width,
upper.height);
gtk_paint_arrow (style, window,
popup->upper_arrow_state,
GTK_SHADOW_OUT,
&event->area, widget, "menu_scroll_arrow_up",
GTK_ARROW_UP,
TRUE,
upper.x + (upper.width - arrow_size) / 2,
upper.y + style->ythickness + (arrow_space - arrow_size) / 2,
arrow_size, arrow_size);
/* lower arrow */
gtk_paint_box (style, window,
popup->lower_arrow_state,
GTK_SHADOW_OUT,
&event->area, widget, "menu",
lower.x,
lower.y,
lower.width,
lower.height);
gtk_paint_arrow (style, window,
popup->lower_arrow_state,
GTK_SHADOW_OUT,
&event->area, widget, "menu_scroll_arrow_down",
GTK_ARROW_DOWN,
TRUE,
lower.x + (lower.width - arrow_size) / 2,
lower.y + style->ythickness + (arrow_space - arrow_size) / 2,
arrow_size, arrow_size);
}
return FALSE;
}
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);
}
gboolean mgtk_range_slider_expose_handler(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
GdkGC* gc = widget->style->fg_gc[GTK_WIDGET_STATE(widget)];
const unsigned int width = widget->allocation.width;
const unsigned int height = widget->allocation.height;
/* Slider background trough. */
gtk_paint_slider( widget->style,
widget->window,
GTK_STATE_ACTIVE,
GTK_SHADOW_IN,
NULL,
widget,
NULL, // const gchar *detail,
0, (height>>2)+(height>>3),
width, height>>2,
GTK_ORIENTATION_HORIZONTAL);
/* Range slider's state based widget componets. */
mgtk_range_slider_state_t* state =
(mgtk_range_slider_state_t*)gtk_object_get_data(GTK_OBJECT(widget), "mgtk_range_slider_state");
if ( state )
{
//state->width = width;
const float end_v = 1.0f / ( state->max - state->min );
/* Render a slider with a handle grip at current_key. */
int x = ( state->start - state->min ) * end_v * width;
int x2 = ( state->end - state->min ) * end_v * width;
gtk_paint_box( widget->style,
widget->window,
true ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
GTK_SHADOW_OUT,
NULL, GTK_WIDGET(widget),
"buttondefault",
x, 2, x2 - x, height - 4 );
/* Ranged slider handles. */
gtk_paint_handle( widget->style,
widget->window,
GTK_STATE_ACTIVE,
GTK_SHADOW_OUT,
NULL,
widget,
"stepper",
x+1, 4,
8, height - 8,
GTK_ORIENTATION_HORIZONTAL );
gtk_paint_handle( widget->style,
widget->window,
GTK_STATE_ACTIVE,
GTK_SHADOW_OUT,
NULL,
widget,
"stepper",
x2-9, 4,
8, height - 8,
GTK_ORIENTATION_HORIZONTAL );
/* Ranged slider start/end numeric strings. */
char s[16];
snprintf( s, 16, "%i", state->start );
gtk_paint_string( widget->style,
widget->window,
GTK_STATE_ACTIVE,
NULL,
widget,
NULL, //const gchar *detail,
x+10, (height>>1)+(height>>2),
s);
snprintf( s, 16, "%i", state->end );
gtk_paint_string( widget->style,
widget->window,
GTK_STATE_ACTIVE,
NULL,
widget,
NULL, //const gchar *detail,
x2-26, (height>>1)+(height>>2),
s);
}
return TRUE;
}
static void
gtk_shruler_draw_ticks(GtkRuler *ruler)
{
GtkWidget *widget;
GdkGC *gc, *bg_gc;
gint i;
gint width, height;
gint xthickness;
gint ythickness;
gint pos;
g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_HRULER (ruler));
if (!GTK_WIDGET_DRAWABLE (ruler))
return;
widget = GTK_WIDGET (ruler);
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
xthickness = widget->style->xthickness;
ythickness = widget->style->ythickness;
width = widget->allocation.width;
height = widget->allocation.height - ythickness * 2;
gtk_paint_box (widget->style, ruler->backing_store,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget, "hruler",
0, 0,
widget->allocation.width, widget->allocation.height);
#if 0
gdk_draw_line (ruler->backing_store, gc,
xthickness,
height + ythickness,
widget->allocation.width - xthickness,
height + ythickness);
#endif
/* assume ruler->max_size has the char width */
/* i is increment of char_width, pos is label number
* y position is based on height of widget itself */
for ( pos = GTK_SHRULER(ruler)->start_pos, i = 0; pos < widget->allocation.width - xthickness; pos += ruler->max_size, i++ ) {
gint length = height / 8;
if ( i % 10 == 0 ) length = ( 2 * height / 3 );
else if ( i % 5 == 0 ) length = ( height / 3 );
gdk_draw_line(ruler->backing_store, gc,
pos, height + ythickness,
pos, height - length);
if ( i % 10 == 0 ) {
gchar buf[8];
PangoLayout *layout;
/* draw label */
g_snprintf(buf, sizeof buf, "%d", i);
layout = gtk_widget_create_pango_layout
(GTK_WIDGET(ruler), buf);
gdk_draw_layout(ruler->backing_store, gc, pos + 2,
0, layout);
g_object_unref(layout);
}
}
}
void
_gtk_button_paint (GtkButton *button,
GdkRectangle *area,
GtkStateType state_type,
GtkShadowType shadow_type,
const gchar *main_detail,
const gchar *default_detail)
{
GtkWidget *widget;
gint width, height;
gint x, y;
gint border_width;
GtkBorder default_border;
GtkBorder default_outside_border;
gboolean interior_focus;
gint focus_width;
gint focus_pad;
if (GTK_WIDGET_DRAWABLE (button))
{
widget = GTK_WIDGET (button);
border_width = GTK_CONTAINER (widget)->border_width;
gtk_button_get_props (button, &default_border, &default_outside_border, &interior_focus);
gtk_widget_style_get (GTK_WIDGET (widget),
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
x = widget->allocation.x + border_width;
y = widget->allocation.y + border_width;
width = widget->allocation.width - border_width * 2;
height = widget->allocation.height - border_width * 2;
if (GTK_WIDGET_HAS_DEFAULT (widget) &&
GTK_BUTTON (widget)->relief == GTK_RELIEF_NORMAL)
{
if(!uxtheme_dll)
gtk_paint_box (widget->style, widget->window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
area, widget, "buttondefault",
x, y, width, height);
x += default_border.left;
y += default_border.top;
width -= default_border.left + default_border.right;
height -= default_border.top + default_border.bottom;
}
else if (GTK_WIDGET_CAN_DEFAULT (widget))
{
x += default_outside_border.left;
y += default_outside_border.top;
width -= default_outside_border.left + default_outside_border.right;
height -= default_outside_border.top + default_outside_border.bottom;
}
if (!interior_focus && GTK_WIDGET_HAS_FOCUS (widget))
{
x += focus_width + focus_pad;
y += focus_width + focus_pad;
width -= 2 * (focus_width + focus_pad);
height -= 2 * (focus_width + focus_pad);
}
if ((button->relief != GTK_RELIEF_NONE) ||
((GTK_WIDGET_STATE(widget) != GTK_STATE_NORMAL) &&
(GTK_WIDGET_STATE(widget) != GTK_STATE_INSENSITIVE)))
gtk_paint_box (widget->style, widget->window,
state_type,
shadow_type, area, widget, "button",
x, y, width, height);
if (GTK_WIDGET_HAS_FOCUS (widget))
{
if (uxtheme_dll)
gtk_paint_box (widget->style, widget->window,
state_type,
shadow_type, area, widget, "buttondefault",
x, y, width, height);
if (interior_focus)
{
x += widget->style->xthickness + focus_pad;
y += widget->style->ythickness + focus_pad;
width -= 2 * (widget->style->xthickness + focus_pad);
height -= 2 * (widget->style->xthickness + focus_pad);
}
else
{
x -= focus_width + focus_pad;
y -= focus_width + focus_pad;
width += 2 * (focus_width + focus_pad);
height += 2 * (focus_width + focus_pad);
}
if(!uxtheme_dll)
gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
area, widget, "button",
x, y, width, height);
}
}
}
static void
gimp_ruler_draw_ticks (GimpRuler *ruler)
{
GtkWidget *widget = GTK_WIDGET (ruler);
GtkStyle *style = gtk_widget_get_style (widget);
GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler);
GtkStateType state = gtk_widget_get_state (widget);
GtkAllocation allocation;
cairo_t *cr;
gint i;
gint width, height;
gint xthickness;
gint ythickness;
gint length, ideal_length;
gdouble lower, upper; /* Upper and lower limits, in ruler units */
gdouble increment; /* Number of pixels per unit */
gint scale; /* Number of units per major unit */
gdouble start, end, cur;
gchar unit_str[32];
gint digit_height;
gint digit_offset;
gint text_size;
gint pos;
gdouble max_size;
GimpUnit unit;
PangoLayout *layout;
PangoRectangle logical_rect, ink_rect;
if (! gtk_widget_is_drawable (widget))
return;
gtk_widget_get_allocation (widget, &allocation);
xthickness = style->xthickness;
ythickness = style->ythickness;
layout = gimp_ruler_get_layout (widget, "0123456789");
pango_layout_get_extents (layout, &ink_rect, &logical_rect);
digit_height = PANGO_PIXELS (ink_rect.height) + 2;
digit_offset = ink_rect.y;
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
width = allocation.width;
height = allocation.height - ythickness * 2;
}
else
{
width = allocation.height;
height = allocation.width - ythickness * 2;
}
cr = cairo_create (priv->backing_store);
gdk_cairo_set_source_color (cr, &style->bg[state]);
#if 0
gtk_paint_box (style, priv->backing_store,
GTK_STATE_NORMAL, GTK_SHADOW_OUT,
NULL, widget,
priv->orientation == GTK_ORIENTATION_HORIZONTAL ?
"hruler" : "vruler",
0, 0,
allocation.width, allocation.height);
#else
cairo_paint (cr);
#endif
gdk_cairo_set_source_color (cr, &style->fg[state]);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
cairo_rectangle (cr,
xthickness,
height + ythickness,
allocation.width - 2 * xthickness,
1);
}
else
{
cairo_rectangle (cr,
height + xthickness,
ythickness,
1,
allocation.height - 2 * ythickness);
}
gimp_ruler_get_range (ruler, &lower, &upper, &max_size);
if ((upper - lower) == 0)
goto out;
increment = (gdouble) width / (upper - lower);
/* determine the scale
* use the maximum extents of the ruler to determine the largest
* possible number to be displayed. Calculate the height in pixels
* of this displayed text. Use this height to find a scale which
* leaves sufficient room for drawing the ruler.
*
* We calculate the text size as for the vruler instead of
* actually measuring the text width, so that the result for the
* scale looks consistent with an accompanying vruler.
*/
scale = ceil (max_size);
g_snprintf (unit_str, sizeof (unit_str), "%d", scale);
text_size = strlen (unit_str) * digit_height + 1;
for (scale = 0; scale < G_N_ELEMENTS (ruler_metric.ruler_scale); scale++)
if (ruler_metric.ruler_scale[scale] * fabs (increment) > 2 * text_size)
break;
if (scale == G_N_ELEMENTS (ruler_metric.ruler_scale))
scale = G_N_ELEMENTS (ruler_metric.ruler_scale) - 1;
unit = gimp_ruler_get_unit (ruler);
/* drawing starts here */
length = 0;
for (i = G_N_ELEMENTS (ruler_metric.subdivide) - 1; i >= 0; i--)
{
gdouble subd_incr;
/* hack to get proper subdivisions at full pixels */
if (unit == GIMP_UNIT_PIXEL && scale == 1 && i == 1)
subd_incr = 1.0;
else
subd_incr = ((gdouble) ruler_metric.ruler_scale[scale] /
(gdouble) ruler_metric.subdivide[i]);
if (subd_incr * fabs (increment) <= MINIMUM_INCR)
continue;
/* don't subdivide pixels */
if (unit == GIMP_UNIT_PIXEL && subd_incr < 1.0)
continue;
/* Calculate the length of the tickmarks. Make sure that
* this length increases for each set of ticks
*/
ideal_length = height / (i + 1) - 1;
if (ideal_length > ++length)
length = ideal_length;
if (lower < upper)
{
start = floor (lower / subd_incr) * subd_incr;
end = ceil (upper / subd_incr) * subd_incr;
}
else
{
start = floor (upper / subd_incr) * subd_incr;
end = ceil (lower / subd_incr) * subd_incr;
}
for (cur = start; cur <= end; cur += subd_incr)
{
pos = ROUND ((cur - lower) * increment);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
cairo_rectangle (cr,
pos, height + ythickness - length,
1, length);
}
else
{
cairo_rectangle (cr,
height + xthickness - length, pos,
length, 1);
}
/* draw label */
if (i == 0)
{
g_snprintf (unit_str, sizeof (unit_str), "%d", (int) cur);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
pango_layout_set_text (layout, unit_str, -1);
pango_layout_get_extents (layout, &logical_rect, NULL);
#if 0
gtk_paint_layout (style,
priv->backing_store,
state,
FALSE,
NULL,
widget,
"hruler",
pos + 2,
ythickness + PANGO_PIXELS (logical_rect.y - digit_offset),
layout);
#else
cairo_move_to (cr,
pos + 2,
ythickness + PANGO_PIXELS (logical_rect.y - digit_offset));
pango_cairo_show_layout (cr, layout);
#endif
}
else
{
gint j;
for (j = 0; j < (int) strlen (unit_str); j++)
{
pango_layout_set_text (layout, unit_str + j, 1);
pango_layout_get_extents (layout, NULL, &logical_rect);
#if 0
gtk_paint_layout (style,
priv->backing_store,
state,
FALSE,
NULL,
widget,
"vruler",
xthickness + 1,
pos + digit_height * j + 2 + PANGO_PIXELS (logical_rect.y - digit_offset),
layout);
#else
cairo_move_to (cr,
xthickness + 1,
pos + digit_height * j + 2 + PANGO_PIXELS (logical_rect.y - digit_offset));
pango_cairo_show_layout (cr, layout);
#endif
}
}
}
}
}
cairo_fill (cr);
out:
cairo_destroy (cr);
}
