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; }