static gboolean
preview_draw (GtkWidget *widget,
cairo_t *cr,
SoliPrintPreview *preview)
{
GdkWindow *bin_window;
gint tile_width;
gint page_num;
gint n_pages;
gint col;
bin_window = gtk_layout_get_bin_window (preview->layout);
if (!gtk_cairo_should_draw_window (cr, bin_window))
{
return GDK_EVENT_STOP;
}
cairo_save (cr);
gtk_cairo_transform_to_window (cr, widget, bin_window);
get_tile_size (preview, &tile_width, NULL);
n_pages = get_n_pages (preview);
col = 0;
page_num = get_first_page_displayed (preview);
while (col < preview->n_columns && page_num < n_pages)
{
if (!gtk_print_operation_preview_is_selected (preview->gtk_preview, page_num))
{
page_num++;
continue;
}
draw_page (cr,
col * tile_width,
0,
page_num,
preview);
col++;
page_num++;
}
cairo_restore (cr);
return GDK_EVENT_STOP;
}
/* Returns %TRUE if @clip is set. @clip contains the area that should be drawn. */
static gboolean
get_clip_rectangle (GtkSourceGutter *gutter,
GtkSourceView *view,
cairo_t *cr,
GdkRectangle *clip)
{
GdkWindow *window = get_window (gutter);
if (window == NULL || !gtk_cairo_should_draw_window (cr, window))
{
return FALSE;
}
gtk_cairo_transform_to_window (cr, GTK_WIDGET (view), window);
return gdk_cairo_get_clip_rectangle (cr, clip);
}
static gboolean sc_shape_draw(GtkWidget*widget, cairo_t*cr)
{
SCShape*shape=SC_SHAPE(widget);
int width=gtk_widget_get_allocated_width(widget);
int height =gtk_widget_get_allocated_height(widget);
gdk_cairo_set_source_rgba(cr,&shape->color);
cairo_set_line_width(cr,shape->line_width);
cairo_save(cr);
gtk_cairo_transform_to_window(cr, widget,shape->event_window);
cairo_translate(cr,(double)shape->rectangle.x,(double)shape->rectangle.y);
if((shape->rectangle.width!=0 && shape->rectangle.height!=0))
cairo_scale(cr,(shape->rectangle.width),(shape->rectangle.height));
gdk_cairo_set_source_rgba(cr,&shape->color);
if(shape->shape_type==SHAPE_RECT){
cairo_rectangle(cr,0,0,1,1);
}else if(shape->shape_type==SHAPE_CIRCLE){
cairo_arc(cr,0.5,0.5,0.5,0,2*M_PI);
}
cairo_restore(cr);
cairo_stroke(cr);
return FALSE;
}
static void
gd_tagged_entry_tag_draw (GdTaggedEntryTag *tag,
cairo_t *cr,
GdTaggedEntry *entry)
{
GtkStyleContext *context;
GtkStateFlags state;
GtkAllocation background_allocation, layout_allocation, button_allocation;
context = gd_tagged_entry_tag_get_context (tag, entry);
gd_tagged_entry_tag_get_relative_allocations (tag, entry, context,
&background_allocation,
&layout_allocation,
&button_allocation);
cairo_save (cr);
gtk_cairo_transform_to_window (cr, GTK_WIDGET (entry), tag->window);
gtk_style_context_save (context);
state = gd_tagged_entry_tag_get_state (tag, entry);
gtk_style_context_set_state (context, state);
gtk_render_background (context, cr,
background_allocation.x, background_allocation.y,
background_allocation.width, background_allocation.height);
gtk_render_frame (context, cr,
background_allocation.x, background_allocation.y,
background_allocation.width, background_allocation.height);
gtk_render_layout (context, cr,
layout_allocation.x, layout_allocation.y,
tag->layout);
gtk_style_context_restore (context);
if (!entry->button_visible || !tag->has_close_button)
goto done;
gtk_style_context_add_class (context, GTK_STYLE_CLASS_BUTTON);
state = gd_tagged_entry_tag_get_button_state (tag, entry);
gtk_style_context_set_state (context, state);
/* if the state changed since last time we draw the pixbuf,
* clear and redraw it.
*/
if (state != tag->last_button_state)
{
g_clear_pointer (&tag->close_surface, cairo_surface_destroy);
gd_tagged_entry_tag_ensure_close_surface (tag, context);
tag->last_button_state = state;
}
gtk_render_background (context, cr,
button_allocation.x, button_allocation.y,
button_allocation.width, button_allocation.height);
gtk_render_frame (context, cr,
button_allocation.x, button_allocation.y,
button_allocation.width, button_allocation.height);
gtk_render_icon_surface (context, cr,
tag->close_surface,
button_allocation.x, button_allocation.y);
done:
cairo_restore (cr);
g_object_unref (context);
}
static gboolean
on_view_draw (GtkSourceView *view,
cairo_t *cr,
GtkSourceGutter *gutter)
{
GdkWindow *window;
GtkTextView *text_view;
GArray *sizes;
GdkRectangle clip;
gint x, y;
gint y1, y2;
GArray *numbers;
GArray *pixels;
GArray *heights;
GtkTextIter cur;
gint cur_line;
gint count;
gint i;
GList *item;
GtkTextIter start;
GtkTextIter end;
GtkTextBuffer *buffer;
GdkRectangle background_area;
GdkRectangle cell_area;
GtkTextIter selection_start;
GtkTextIter selection_end;
gboolean has_selection;
gint idx;
GtkStyleContext *style_context;
GdkRGBA fg_color;
window = gtk_source_gutter_get_window (gutter);
if (window == NULL || !gtk_cairo_should_draw_window (cr, window))
{
return FALSE;
}
gtk_cairo_transform_to_window (cr, GTK_WIDGET (view), window);
text_view = GTK_TEXT_VIEW (view);
if (!gdk_cairo_get_clip_rectangle (cr, &clip))
{
return FALSE;
}
gutter->priv->is_drawing = TRUE;
buffer = gtk_text_view_get_buffer (text_view);
gdk_window_get_pointer (window, &x, &y, NULL);
y1 = clip.y;
y2 = y1 + clip.height;
/* get the extents of the line printing */
gtk_text_view_window_to_buffer_coords (text_view,
gutter->priv->window_type,
0,
y1,
NULL,
&y1);
gtk_text_view_window_to_buffer_coords (text_view,
gutter->priv->window_type,
0,
y2,
NULL,
&y2);
numbers = g_array_new (FALSE, FALSE, sizeof (gint));
pixels = g_array_new (FALSE, FALSE, sizeof (gint));
heights = g_array_new (FALSE, FALSE, sizeof (gint));
sizes = g_array_new (FALSE, FALSE, sizeof (gint));
calculate_gutter_size (gutter, sizes);
i = 0;
x = 0;
background_area.x = 0;
background_area.height = get_lines (text_view,
y1,
y2,
pixels,
heights,
numbers,
&count,
&start,
&end);
cell_area.x = gutter->priv->xpad;
cell_area.height = background_area.height;
gtk_text_view_buffer_to_window_coords (text_view,
gutter->priv->window_type,
0,
g_array_index (pixels, gint, 0),
NULL,
&background_area.y);
cell_area.y = background_area.y;
item = gutter->priv->renderers;
idx = 0;
style_context = gtk_widget_get_style_context (GTK_WIDGET (view));
gtk_style_context_get_color (style_context,
gtk_widget_get_state (GTK_WIDGET (view)),
&fg_color);
gdk_cairo_set_source_rgba (cr, &fg_color);
while (item)
{
Renderer *renderer = item->data;
gint xpad;
gint width;
width = g_array_index (sizes, gint, idx++);
if (gtk_source_gutter_renderer_get_visible (renderer->renderer))
{
gtk_source_gutter_renderer_get_padding (renderer->renderer,
&xpad,
NULL);
background_area.width = width;
cell_area.width = width - 2 * xpad;
cell_area.x = background_area.x + xpad;
cairo_save (cr);
gdk_cairo_rectangle (cr, &background_area);
cairo_clip (cr);
gtk_source_gutter_renderer_begin (renderer->renderer,
cr,
&background_area,
&cell_area,
&start,
&end);
cairo_restore (cr);
background_area.x += background_area.width;
}
item = g_list_next (item);
}
gtk_text_buffer_get_iter_at_mark (buffer,
&cur,
gtk_text_buffer_get_insert (buffer));
cur_line = gtk_text_iter_get_line (&cur);
gtk_text_buffer_get_selection_bounds (buffer,
&selection_start,
&selection_end);
has_selection = !gtk_text_iter_equal (&selection_start, &selection_end);
if (has_selection)
{
if (!gtk_text_iter_starts_line (&selection_start))
{
gtk_text_iter_set_line_offset (&selection_start, 0);
}
if (!gtk_text_iter_ends_line (&selection_end))
{
gtk_text_iter_forward_to_line_end (&selection_end);
}
}
for (i = 0; i < count; ++i)
{
gint pos;
gint line_to_paint;
end = start;
if (!gtk_text_iter_ends_line (&end))
{
gtk_text_iter_forward_to_line_end (&end);
}
gtk_text_view_buffer_to_window_coords (text_view,
gutter->priv->window_type,
0,
g_array_index (pixels, gint, i),
NULL,
&pos);
line_to_paint = g_array_index (numbers, gint, i);
background_area.y = pos;
background_area.height = g_array_index (heights, gint, i);
background_area.x = 0;
idx = 0;
for (item = gutter->priv->renderers; item; item = g_list_next (item))
{
Renderer *renderer;
gint width;
GtkSourceGutterRendererState state;
gint xpad;
gint ypad;
renderer = item->data;
width = g_array_index (sizes, gint, idx++);
if (!gtk_source_gutter_renderer_get_visible (renderer->renderer))
{
continue;
}
gtk_source_gutter_renderer_get_padding (renderer->renderer,
&xpad,
&ypad);
background_area.width = width;
cell_area.y = background_area.y + ypad;
cell_area.height = background_area.height - 2 * ypad;
cell_area.x = background_area.x + xpad;
cell_area.width = background_area.width - 2 * xpad;
state = GTK_SOURCE_GUTTER_RENDERER_STATE_NORMAL;
if (line_to_paint == cur_line)
{
state |= GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR;
}
if (has_selection &&
gtk_text_iter_in_range (&start,
&selection_start,
&selection_end))
{
state |= GTK_SOURCE_GUTTER_RENDERER_STATE_SELECTED;
}
if (renderer->prelit >= 0 && cell_area.y <= renderer->prelit && cell_area.y + cell_area.height >= renderer->prelit)
{
state |= GTK_SOURCE_GUTTER_RENDERER_STATE_PRELIT;
}
gtk_source_gutter_renderer_query_data (renderer->renderer,
&start,
&end,
state);
cairo_save (cr);
gdk_cairo_rectangle (cr, &background_area);
cairo_clip (cr);
/* Call render with correct area */
gtk_source_gutter_renderer_draw (renderer->renderer,
cr,
&background_area,
&cell_area,
&start,
&end,
state);
cairo_restore (cr);
background_area.x += background_area.width;
}
gtk_text_iter_forward_line (&start);
}
for (item = gutter->priv->renderers; item; item = g_list_next (item))
{
Renderer *renderer = item->data;
if (gtk_source_gutter_renderer_get_visible (renderer->renderer))
{
gtk_source_gutter_renderer_end (renderer->renderer);
}
}
g_array_free (numbers, TRUE);
g_array_free (pixels, TRUE);
g_array_free (heights, TRUE);
g_array_free (sizes, TRUE);
gutter->priv->is_drawing = FALSE;
return FALSE;
}
inf_text_gtk_viewport_scrollbar_expose_event_cb(GtkWidget* scrollbar,
GdkEventExpose* event,
gpointer user_data)
#endif
{
InfTextGtkViewport* viewport;
InfTextGtkViewportPrivate* priv;
InfTextGtkViewportUser* viewport_user;
GdkRectangle* rectangle;
GdkColor* color;
double h,s,v;
double r,g,b;
GSList* item;
double line_width;
#if GTK_CHECK_VERSION(2, 91, 0)
GdkRectangle clip_area;
#else
cairo_t* cr;
#endif
viewport = INF_TEXT_GTK_VIEWPORT(user_data);
priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(viewport);
/* Can this happen? */
#if GTK_CHECK_VERSION(2, 91, 0)
if(!gtk_cairo_should_draw_window(cr, gtk_widget_get_window(scrollbar)))
#elif GTK_CHECK_VERSION(2,14,0)
if(event->window != gtk_widget_get_window(scrollbar))
#else
if(event->window != GTK_WIDGET(scrollbar)->window)
#endif
return FALSE;
if(priv->show_user_markers)
{
color = >k_widget_get_style(scrollbar)->bg[GTK_STATE_NORMAL];
h = color->red / 65535.0;
s = color->green / 65535.0;
v = color->blue / 65535.0;
rgb_to_hsv(&h, &s, &v);
s = MIN(MAX(s, 0.5), 0.8);
v = MAX(v, 0.5);
#if GTK_CHECK_VERSION(2, 91, 0)
gtk_cairo_transform_to_window(
cr,
GTK_WIDGET(scrollbar),
gtk_widget_get_window(scrollbar)
);
gdk_cairo_get_clip_rectangle(cr, &clip_area);
#else
cr = gdk_cairo_create(event->window);
#endif
line_width = cairo_get_line_width(cr);
for(item = priv->users; item != NULL; item = item->next)
{
viewport_user = (InfTextGtkViewportUser*)item->data;
rectangle = &viewport_user->rectangle;
#if GTK_CHECK_VERSION(2, 91, 0)
if(gdk_rectangle_intersect(&clip_area, rectangle, NULL))
#elif GTK_CHECK_VERSION(2,90,5)
if(cairo_region_contains_rectangle(event->region, rectangle) !=
CAIRO_REGION_OVERLAP_OUT)
#else
if(gdk_region_rect_in(event->region, rectangle) !=
GDK_OVERLAP_RECTANGLE_OUT)
#endif
{
h = inf_text_user_get_hue(viewport_user->user);
cairo_rectangle(
cr,
rectangle->x + line_width/2,
rectangle->y + line_width/2,
rectangle->width - line_width,
rectangle->height - line_width
);
r = h; g = s; b = v/2.0;
hsv_to_rgb(&r, &g, &b);
cairo_set_source_rgba(cr, r, g, b, 0.6);
cairo_stroke_preserve(cr);
r = h; g = s; b = v;
hsv_to_rgb(&r, &g, &b);
cairo_set_source_rgba(cr, r, g, b, 0.6);
cairo_fill(cr);
}
}
#if ! GTK_CHECK_VERSION(2, 91, 0)
cairo_destroy(cr);
#endif
}
return FALSE;
}
