static void draw_page (GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data) { ViewerCbInfo *info = (ViewerCbInfo *) user_data; cairo_t *cr; gdouble page_width, page_height; cr = gtk_print_context_get_cairo_context (context); page_width = gtk_print_context_get_width (context); page_height = gtk_print_context_get_height (context); { RsvgHandle *handle; RsvgDimensionData svg_dimensions; struct RsvgSizeCallbackData size_data; /* should not fail */ handle = rsvg_handle_new_from_data(info->svg_bytes->data, info->svg_bytes->len, NULL); rsvg_handle_set_base_uri (handle, info->base_uri); rsvg_handle_set_dpi_x_y (handle, gtk_print_context_get_dpi_x(context), gtk_print_context_get_dpi_y(context)); rsvg_handle_get_dimensions(handle, &svg_dimensions); if (svg_dimensions.width > page_width || svg_dimensions.height > page_height) { /* scale down the image to the page's size, while preserving the aspect ratio */ if ((double) svg_dimensions.height * (double) page_width > (double) svg_dimensions.width * (double) page_height) { svg_dimensions.width = 0.5 + (double) svg_dimensions.width *(double) page_height / (double) svg_dimensions.height; svg_dimensions.height = page_height; } else { svg_dimensions.height = 0.5 + (double) svg_dimensions.height *(double) page_width / (double) svg_dimensions.width; svg_dimensions.width = page_width; } } size_data.type = RSVG_SIZE_WH; size_data.width = svg_dimensions.width; size_data.height = svg_dimensions.height; size_data.keep_aspect_ratio = FALSE; rsvg_handle_set_size_callback (handle, _rsvg_size_callback, &size_data, NULL); rsvg_handle_render_cairo(handle, cr); g_object_unref (handle); } }
static void print_job_begin_print(GtkPrintOperation *operation, GtkPrintContext *context, gpointer user_data) { PlannerPrintJob *job; PlannerPrintJobPriv *priv; GList *l; PlannerView *view; int n_pages = 0; job = (PlannerPrintJob *)user_data; priv = job->priv; job->cr = gtk_print_context_get_cairo_context (context); job->pc = context; priv->paper_height = gtk_print_context_get_height (context); priv->paper_width = gtk_print_context_get_width (context); print_job_update_size (job); planner_print_job_set_font_regular (job); job->x_pad = planner_print_job_get_extents (job, "#") / 2; for (l = priv->views; l; l = l->next) { view = l->data; planner_view_print_init (view, job); n_pages += planner_view_print_get_n_pages (view); } gtk_print_operation_set_n_pages (operation, (n_pages > 0) ? n_pages : 1); }
static void _draw_page_number (GtkPrintContext *context, gint page_nr, GwPageInfo *page, GwPrintData *data) { //Declarations PangoLayout *layout; char *text; PangoFontDescription *desc; int width; int height; cairo_t *cr; gdouble drawable_width; //Initializations text = g_strdup_printf (gettext("Page %d/%d"), page_nr + 1, g_list_length (data->pages)); layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string ("sans 8"); cr = gtk_print_context_get_cairo_context (context); drawable_width = gtk_print_context_get_width (context); //Draw if (text != NULL && layout != NULL && desc != NULL) { pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD); pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT); pango_layout_set_font_description (layout, desc); pango_layout_set_markup (layout, text, -1); pango_layout_get_size (layout, &width, &height); cairo_move_to (cr, (int) drawable_width - PANGO_PIXELS (width), 0); pango_cairo_show_layout (cr, layout); } //Cleanup if (text != NULL) g_free (text); if (layout != NULL) g_object_unref (layout); if (desc != NULL) pango_font_description_free (desc); }
JNIEXPORT jdouble JNICALL Java_org_gnome_gtk_GtkPrintContext_gtk_1print_1context_1get_1width ( JNIEnv* env, jclass cls, jlong _self ) { gdouble result; jdouble _result; GtkPrintContext* self; // convert parameter self self = (GtkPrintContext*) _self; // call function result = gtk_print_context_get_width(self); // cleanup parameter self // translate return value to JNI type _result = (jdouble) result; // and finally return _result; }
static void setup_range(DocInfo *dinfo, GtkPrintContext *ctx) { dinfo->fr.hdc = dinfo->fr.hdcTarget = gtk_print_context_get_cairo_context(ctx); dinfo->fr.rcPage.left = 0; dinfo->fr.rcPage.top = 0; dinfo->fr.rcPage.right = gtk_print_context_get_width(ctx); dinfo->fr.rcPage.bottom = gtk_print_context_get_height(ctx); dinfo->fr.rc.left = dinfo->fr.rcPage.left; dinfo->fr.rc.top = dinfo->fr.rcPage.top; dinfo->fr.rc.right = dinfo->fr.rcPage.right; dinfo->fr.rc.bottom = dinfo->fr.rcPage.bottom; #if GTK_CHECK_VERSION(2, 20, 0) { gdouble m_top, m_left, m_right, m_bottom; if (gtk_print_context_get_hard_margins(ctx, &m_top, &m_bottom, &m_left, &m_right)) { dinfo->fr.rc.left += m_left; dinfo->fr.rc.top += m_top; dinfo->fr.rc.right -= m_right; dinfo->fr.rc.bottom -= m_bottom; } } #endif if (printing_prefs.print_page_header) dinfo->fr.rc.top += dinfo->line_height * 3; /* header height */ if (printing_prefs.print_page_numbers) dinfo->fr.rc.bottom -= dinfo->line_height * 1; /* footer height */ dinfo->fr.chrg.cpMin = 0; dinfo->fr.chrg.cpMax = sci_get_length(dinfo->sci); }
static bool draw_page_image(cairo_t* cairo, GtkPrintContext* context, zathura_t* zathura, zathura_page_t* page) { /* Try to render the page on a temporary image surface. */ const double width = gtk_print_context_get_width(context); const double height = gtk_print_context_get_height(context); const double scale_height = 5; const double scale_width = 5; /* Render to a surface that is 5 times larger to workaround quality issues. */ const double page_height = zathura_page_get_height(page) * scale_height; const double page_width = zathura_page_get_width(page) * scale_width; cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, page_width, page_height); if (surface == NULL) { return false; } if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy(surface); return false; } cairo_t* temp_cairo = cairo_create(surface); if (cairo == NULL) { cairo_surface_destroy(surface); return false; } /* Draw a white background. */ cairo_save(temp_cairo); cairo_set_source_rgb(temp_cairo, 1, 1, 1); cairo_rectangle(temp_cairo, 0, 0, page_width, page_height); cairo_fill(temp_cairo); cairo_restore(temp_cairo); /* Render the page to the temporary surface */ zathura_renderer_lock(zathura->sync.render_thread); const int err = zathura_page_render(page, temp_cairo, true); zathura_renderer_unlock(zathura->sync.render_thread); if (err != ZATHURA_ERROR_OK) { cairo_destroy(temp_cairo); cairo_surface_destroy(surface); return false; } /* Rescale the page and keep the aspect ratio */ const gdouble scale = MIN(width / page_width, height / page_height); cairo_scale(cairo, scale, scale); /* Blit temporary surface to original cairo object. */ cairo_set_source_surface(cairo, surface, 0.0, 0.0); cairo_paint(cairo); cairo_destroy(temp_cairo); cairo_surface_destroy(surface); return true; }
static void begin_print (GtkPrintOperation *operation, GtkPrintContext *context, PrintData *print_data) { PangoFontDescription *desc; PangoLayoutLine *layout_line; double width, height; double page_height; GList *page_breaks; int num_lines; int line; width = gtk_print_context_get_width (context); height = gtk_print_context_get_height (context); print_data->layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string (print_data->font); pango_layout_set_font_description (print_data->layout, desc); pango_font_description_free (desc); pango_layout_set_width (print_data->layout, width * PANGO_SCALE); pango_layout_set_text (print_data->layout, print_data->text, -1); num_lines = pango_layout_get_line_count (print_data->layout); page_breaks = NULL; page_height = 0; for (line = 0; line < num_lines; line++) { PangoRectangle ink_rect, logical_rect; double line_height; layout_line = pango_layout_get_line (print_data->layout, line); pango_layout_line_get_extents (layout_line, &ink_rect, &logical_rect); line_height = logical_rect.height / 1024.0; if (page_height + line_height > height) { page_breaks = g_list_prepend (page_breaks, GINT_TO_POINTER (line)); page_height = 0; } page_height += line_height; } page_breaks = g_list_reverse (page_breaks); gtk_print_operation_set_n_pages (operation, g_list_length (page_breaks) + 1); print_data->page_breaks = page_breaks; }
static void draw_page (GtkPrintOperation *operation, GtkPrintContext *context, int page_nr) { cairo_t *cr; PangoLayout *layout; PangoFontDescription *desc; cr = gtk_print_context_get_cairo_context (context); /* Draw a red rectangle, as wide as the paper (inside the margins) */ cairo_set_source_rgb (cr, 1.0, 0, 0); cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50); cairo_fill (cr); /* Draw some lines */ cairo_move_to (cr, 20, 10); cairo_line_to (cr, 40, 20); cairo_arc (cr, 60, 60, 20, 0, G_PI); cairo_line_to (cr, 80, 20); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_line_width (cr, 5); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_stroke (cr); /* Draw some text */ layout = gtk_print_context_create_pango_layout (context); pango_layout_set_text (layout, "Hello World! Printing is easy", -1); desc = pango_font_description_from_string ("sans 28"); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); cairo_move_to (cr, 30, 20); pango_cairo_layout_path (cr, layout); /* Font Outline */ cairo_set_source_rgb (cr, 0.93, 1.0, 0.47); cairo_set_line_width (cr, 0.5); cairo_stroke_preserve (cr); /* Font Fill */ cairo_set_source_rgb (cr, 0, 0.0, 1.0); cairo_fill (cr); g_object_unref (layout); }
static void draw_page(GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data) { cairo_t *cr; PangoLayout *layout; double w, h; struct graphics_context gc = { .printer = 1 }; cr = gtk_print_context_get_cairo_context(context); gc.cr = cr; layout=gtk_print_context_create_pango_layout(context); w = gtk_print_context_get_width(context); h = gtk_print_context_get_height(context); /* Do the profile on the top half of the page.. */ plot(&gc, w, h/2, current_dive); pango_cairo_show_layout(cr,layout); g_object_unref(layout); } static void begin_print(GtkPrintOperation *operation, gpointer user_data) { } static GtkPrintSettings *settings = NULL; void do_print(void) { GtkPrintOperation *print; GtkPrintOperationResult res; print = gtk_print_operation_new(); if (settings != NULL) gtk_print_operation_set_print_settings(print, settings); gtk_print_operation_set_n_pages(print, 1); g_signal_connect(print, "begin_print", G_CALLBACK(begin_print), NULL); g_signal_connect(print, "draw_page", G_CALLBACK(draw_page), NULL); res = gtk_print_operation_run(print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(main_window), NULL); if (res == GTK_PRINT_OPERATION_RESULT_APPLY) { if (settings != NULL) g_object_unref(settings); settings = g_object_ref(gtk_print_operation_get_print_settings(print)); } g_object_unref(print); }
static void _draw_page_results (GtkPrintContext *context, GwPageInfo *page, GwPrintData *data) { //Declarations GtkTextView *view; GtkTextBuffer *buffer; PangoLayout *layout; char *text; PangoFontDescription *desc; int width; int height; gdouble drawable_width, drawable_height; cairo_t *cr; gint line_start; gint line_end; //Initializations view = gw_searchwindow_get_current_textview (data->window); buffer = gtk_text_view_get_buffer (view); text = gtk_text_buffer_get_text (buffer, &(page->start), &(page->end), FALSE); layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string ("sans 10"); drawable_width = gtk_print_context_get_width (context); drawable_height = gtk_print_context_get_height (context); cr = gtk_print_context_get_cairo_context (context); line_start = 0; line_end = 0; //Draw if (text != NULL) { cairo_move_to (cr, 5, 10); pango_layout_set_font_description (layout, desc); pango_layout_set_markup (layout, text, -1); pango_layout_set_width (layout, drawable_width * PANGO_SCALE); pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT); pango_layout_set_height (layout, drawable_height * PANGO_SCALE); pango_layout_get_size (layout, &width, &height); pango_cairo_show_layout (cr, layout); //Adjust the end GtkTextIter to the cutoff in the visible cairo context line_start = gtk_text_iter_get_line (&page->start); line_end = line_start + pango_layout_get_line_count (layout) - 1; gtk_text_buffer_get_iter_at_line (buffer, &(page->end), line_end); } //Cleanup if (text != NULL) g_free (text); if (layout != NULL) g_object_unref (layout); if (desc != NULL) pango_font_description_free (desc); }
static void draw_header (GtkPrintContext * cnt, gint pn, gint pc) { cairo_t *cr; PangoFontDescription *desc; PangoLayout *layout; gint pw, tw, th; gchar *page; cr = gtk_print_context_get_cairo_context (cnt); pw = gtk_print_context_get_width (cnt); layout = gtk_print_context_create_pango_layout (cnt); desc = pango_font_description_from_string (HEADER_FONT); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); pango_layout_set_text (layout, options.common_data.uri, -1); pango_layout_get_pixel_size (layout, &tw, &th); if (tw > pw) { pango_layout_set_width (layout, pw); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_START); pango_layout_get_pixel_size (layout, &tw, &th); } cairo_move_to (cr, (pw - tw) / 2, (HEADER_HEIGHT - th) / 2); pango_cairo_show_layout (cr, layout); page = g_strdup_printf ("%d/%d", pn, pc); pango_layout_set_text (layout, page, -1); g_free (page); pango_layout_set_width (layout, -1); pango_layout_get_pixel_size (layout, &tw, &th); cairo_move_to (cr, pw - tw - 4, (HEADER_HEIGHT - th) / 2); pango_cairo_show_layout (cr, layout); g_object_unref (layout); cairo_move_to (cr, 0.0, HEADER_HEIGHT); cairo_line_to (cr, pw, HEADER_HEIGHT); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_line_width (cr, 1); cairo_stroke (cr); }
static void print_draw_crop_marks (GtkPrintContext *context, gdouble x, gdouble y, gdouble w, gdouble h) { cairo_t *cr = gtk_print_context_get_cairo_context (context); gdouble len = MIN (gtk_print_context_get_width (context), gtk_print_context_get_height (context)) / 20.0; /* upper left */ cairo_move_to (cr, x - len, y); cairo_line_to (cr, x - len / 5, y); cairo_move_to (cr, x, y - len); cairo_line_to (cr, x, y - len / 5); /* upper right */ cairo_move_to (cr, x + w + len / 5, y); cairo_line_to (cr, x + w + len, y); cairo_move_to (cr, x + w, y - len); cairo_line_to (cr, x + w, y - len / 5); /* lower left */ cairo_move_to (cr, x - len, y + h); cairo_line_to (cr, x - len / 5, y + h); cairo_move_to (cr, x, y + h + len); cairo_line_to (cr, x, y + h + len / 5); /* lower right */ cairo_move_to (cr, x + w + len / 5, y + h); cairo_line_to (cr, x + w + len, y + h); cairo_move_to (cr, x + w, y + h + len); cairo_line_to (cr, x + w, y + h + len / 5); cairo_set_source_rgb (cr, 0.5, 0.5, 0.5); cairo_set_line_width (cr, 2); cairo_stroke (cr); }
static void draw_page_image (GtkPrintOperation * op, GtkPrintContext * cnt, gint page, gpointer data) { cairo_t *cr; GdkPixbuf *pb, *spb; guint iw, ih; gdouble pw, ph; gdouble factor; cr = gtk_print_context_get_cairo_context (cnt); pw = gtk_print_context_get_width (cnt); ph = gtk_print_context_get_height (cnt); if (options.print_data.headers) ph -= HEADER_HEIGHT + HEADER_GAP; /* create header */ if (options.print_data.headers) draw_header (cnt, 1, 1); /* scale image to page size */ pb = gdk_pixbuf_new_from_file (options.common_data.uri, NULL); iw = gdk_pixbuf_get_width (pb); ih = gdk_pixbuf_get_height (pb); if (pw < iw || ph < ih) { factor = MIN (pw / iw, ph / ih); factor = (factor > 1.0) ? 1.0 : factor; spb = gdk_pixbuf_scale_simple (pb, iw * factor, ih * factor, GDK_INTERP_HYPER); } else spb = g_object_ref (pb); g_object_unref (pb); /* add image to surface */ gdk_cairo_set_source_pixbuf (cr, spb, 0.0, HEADER_HEIGHT + HEADER_GAP); cairo_paint (cr); g_object_unref (spb); }
/*! Drawing callback for use with GtkPrintOperation. */ static void draw_page__print_operation (GtkPrintOperation *print, GtkPrintContext *context, gint page_nr, gpointer user_data) { GschemToplevel *w_current = (GschemToplevel *) user_data; PAGE *page; cairo_t *cr; PangoContext *pc; double width, height; EdaConfig *cfg; gboolean is_color; /* Find the page data */ g_return_if_fail (page_nr != 1); page = w_current->toplevel->page_current; g_return_if_fail (page != NULL); /* Get cairo & pango contexts */ cr = gtk_print_context_get_cairo_context (context); pc = gtk_print_context_create_pango_context (context); width = gtk_print_context_get_width (context); height = gtk_print_context_get_height (context); /* Find out if colour printing is enabled */ cfg = eda_config_get_context_for_path (s_page_get_filename (page)); is_color = !eda_config_get_boolean (cfg, CFG_GROUP_PRINTING, CFG_KEY_PRINTING_MONOCHROME, NULL); x_print_draw_page (w_current->toplevel, page, cr, pc, width, height, is_color, FALSE); /* Clean up */ g_object_unref (pc); }
static void mail_printer_draw_footer_cb (GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr) { PangoFontDescription *desc; PangoLayout *layout; gint n_pages; gdouble width, height; gchar *text; cairo_t *cr; cr = gtk_print_context_get_cairo_context (context); width = gtk_print_context_get_width (context); height = gtk_print_context_get_height (context); g_object_get (operation, "n-pages", &n_pages, NULL); text = g_strdup_printf (_("Page %d of %d"), page_nr + 1, n_pages); cairo_set_source_rgb (cr, 0.1, 0.1, 0.1); cairo_fill (cr); desc = pango_font_description_from_string ("Sans Regular 10"); layout = gtk_print_context_create_pango_layout (context); pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER); pango_layout_set_font_description (layout, desc); pango_layout_set_text (layout, text, -1); pango_layout_set_width (layout, width * PANGO_SCALE); pango_font_description_free (desc); cairo_move_to (cr, 0, height + 5); pango_cairo_show_layout (cr, layout); g_object_unref (layout); g_free (text); }
static void cb_begin_print(GtkPrintOperation *op, GtkPrintContext *ctx, gpointer data) { gint layout_height; gchar *text; GtkTextIter start, end; GtkTextBuffer *buffer = gtk_text_view_get_buffer(data); PangoTabArray *tabs; gtk_text_buffer_get_bounds(buffer, &start, &end); text = g_strchomp(gtk_text_buffer_get_text(buffer, &start, &end, FALSE)); page_width = gtk_print_context_get_width(ctx); page_height = gtk_print_context_get_height(ctx); font_desc = gtk_widget_get_style(data)->font_desc; layout = gtk_print_context_create_pango_layout(ctx); pango_layout_set_width(layout, page_width * PANGO_SCALE); pango_layout_set_font_description(layout, font_desc); pango_layout_set_text(layout, text, -1); get_tab_array(&tabs, ctx, data); if (tabs) { pango_layout_set_tabs(layout, tabs); pango_tab_array_free(tabs); } pango_layout_get_size(layout, NULL, &layout_height); line_count = pango_layout_get_line_count(layout); text_height = pango_font_description_get_size(font_desc) / PANGO_SCALE; lines_per_page = page_height / text_height; n_pages = (line_count - 1) / lines_per_page + 1; gtk_print_operation_set_n_pages(op, n_pages); g_free(text); }
gboolean draw_page_cairo (GtkPrintContext *context, PrintData *data) { GimpDrawable *drawable = gimp_drawable_get (data->drawable_id); GimpPixelRgn region; cairo_t *cr; cairo_surface_t *surface; guchar *pixels; gdouble cr_width; gdouble cr_height; gdouble cr_dpi_x; gdouble cr_dpi_y; gint width; gint height; gint stride; gint y; gdouble scale_x; gdouble scale_y; width = drawable->width; height = drawable->height; gimp_tile_cache_ntiles (width / gimp_tile_width () + 1); cr = gtk_print_context_get_cairo_context (context); cr_width = gtk_print_context_get_width (context); cr_height = gtk_print_context_get_height (context); cr_dpi_x = gtk_print_context_get_dpi_x (context); cr_dpi_y = gtk_print_context_get_dpi_y (context); scale_x = cr_dpi_x / data->xres; scale_y = cr_dpi_y / data->yres; #if 0 /* print header if it is requested */ if (data->show_info_header) { draw_info_header (context, cr, data); /* In points */ #define HEADER_HEIGHT (20 * 72.0 / 25.4) cairo_translate (cr, 0, HEADER_HEIGHT); cr_height -= HEADER_HEIGHT; } #endif cairo_translate (cr, data->offset_x / cr_dpi_x * 72.0, data->offset_y / cr_dpi_y * 72.0); cairo_scale (cr, scale_x, scale_y); gimp_pixel_rgn_init (®ion, drawable, 0, 0, width, height, FALSE, FALSE); surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, height); pixels = cairo_image_surface_get_data (surface); stride = cairo_image_surface_get_stride (surface); for (y = 0; y < height; y++, pixels += stride) { gimp_pixel_rgn_get_row (®ion, pixels, 0, y, width); switch (drawable->bpp) { case 3: convert_from_rgb (pixels, width); break; case 4: convert_from_rgba (pixels, width); break; } if (y % 16 == 0) gimp_progress_update ((gdouble) y / (gdouble) height); } cairo_set_source_surface (cr, surface, 0, 0); cairo_rectangle (cr, 0, 0, width, height); cairo_fill (cr); cairo_surface_destroy (surface); gimp_progress_update (1.0); gimp_drawable_detach (drawable); return TRUE; }
static void draw_info_header (GtkPrintContext *context, cairo_t *cr, PrintData *data) { PangoLayout *layout; PangoFontDescription *desc; gdouble text_height; gdouble text_width; gdouble fname_text_width; gint layout_height; gint layout_width; gchar date_buffer[100]; GDate *date; const gchar *name_str; GimpParasite *parasite; const gchar *end_ptr; gchar *filename; gdouble cr_width; cairo_save (cr); cr_width = gtk_print_context_get_width (context); cairo_rectangle (cr, 0, 0, cr_width, HEADER_HEIGHT); cairo_set_source_rgb (cr, 0.8, 0.8, 0.8); cairo_fill_preserve (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_line_width (cr, 1); cairo_stroke (cr); layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string ("sans 14"); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); pango_layout_set_width (layout, -1); pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER); /* image name */ pango_layout_set_text (layout, gimp_image_get_name (data->image_id), -1); pango_layout_get_size (layout, &layout_width, &layout_height); text_height = (gdouble) layout_height / PANGO_SCALE; cairo_move_to (cr, 0.02 * cr_width, (HEADER_HEIGHT - text_height) / 5); pango_cairo_show_layout (cr, layout); /* user name */ name_str = g_get_real_name (); if (name_str && g_utf8_validate (name_str, -1, &end_ptr)) { pango_layout_set_text (layout, name_str, -1); pango_layout_get_size (layout, &layout_width, &layout_height); text_height = (gdouble) layout_height / PANGO_SCALE; text_width = (gdouble) layout_width / PANGO_SCALE; cairo_move_to (cr, 0.5 * cr_width - 0.5 * text_width, (HEADER_HEIGHT - text_height) / 5); pango_cairo_show_layout (cr, layout); } /* date */ date = g_date_new (); g_date_set_time_t (date, time (NULL)); g_date_strftime (date_buffer, 100, "%x", date); g_date_free (date); pango_layout_set_text (layout, date_buffer, -1); pango_layout_get_size (layout, &layout_width, &layout_height); text_height = (gdouble) layout_height / PANGO_SCALE; text_width = (gdouble) layout_width / PANGO_SCALE; cairo_move_to (cr, 0.98 * cr_width - text_width, (HEADER_HEIGHT - text_height) / 5); pango_cairo_show_layout (cr, layout); /* file name if any */ filename = gimp_image_get_filename (data->image_id); if (filename) { pango_layout_set_text (layout, gimp_filename_to_utf8 (filename), -1); g_free (filename); pango_layout_get_size (layout, &layout_width, &layout_height); text_height = (gdouble) layout_height / PANGO_SCALE; fname_text_width = (gdouble) layout_width / PANGO_SCALE; cairo_move_to (cr, 0.02 * cr_width, 4 * (HEADER_HEIGHT - text_height) / 5); pango_cairo_show_layout (cr, layout); } else { fname_text_width = 0; } /* image comment if it is short */ parasite = gimp_image_parasite_find (data->image_id, "gimp-comment"); if (parasite) { pango_layout_set_text (layout, gimp_parasite_data (parasite), -1); pango_layout_get_size (layout, &layout_width, &layout_height); text_height = (gdouble) layout_height / PANGO_SCALE; text_width = (gdouble) layout_width / PANGO_SCALE; if (fname_text_width + text_width < 0.8 * cr_width && text_height < 0.5 * HEADER_HEIGHT) { cairo_move_to (cr, 0.98 * cr_width - text_width, 4 * (HEADER_HEIGHT - text_height) / 5); pango_cairo_show_layout (cr, layout); } gimp_parasite_free (parasite); } g_object_unref (layout); cairo_restore (cr); }
static void cb_print_draw_page(GtkPrintOperation* print_operation, GtkPrintContext* context, gint page_number, zathura_t* zathura) { if (context == NULL || zathura == NULL || zathura->document == NULL || zathura->ui.session == NULL || zathura->ui.statusbar.file == NULL) { gtk_print_operation_cancel(print_operation); return; } /* Update statusbar. */ char* tmp = g_strdup_printf("Printing %d...", page_number); girara_statusbar_item_set_text(zathura->ui.session, zathura->ui.statusbar.file, tmp); g_free(tmp); /* Get the page and cairo handle. */ cairo_t* cairo = gtk_print_context_get_cairo_context(context); zathura_page_t* page = zathura_document_get_page(zathura->document, page_number); if (cairo == NULL || page == NULL) { gtk_print_operation_cancel(print_operation); return; } /* Try to render the page without a temporary surface. This only works with * plugins that support rendering to any surface. */ girara_debug("printing page %d ...", page_number); zathura_renderer_lock(zathura->sync.render_thread); int err = zathura_page_render(page, cairo, true); zathura_renderer_unlock(zathura->sync.render_thread); if (err == ZATHURA_ERROR_OK) { return; } /* Try to render the page on a temporary image surface. */ const gdouble width = gtk_print_context_get_width(context); const gdouble height = gtk_print_context_get_height(context); /* Render to a surface that is 5 times larger to workaround quality issues. */ const double page_height = zathura_page_get_height(page) * 5; const double page_width = zathura_page_get_width(page) * 5; cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, page_width, page_height); if (surface == NULL) { gtk_print_operation_cancel(print_operation); return; } cairo_t* temp_cairo = cairo_create(surface); if (cairo == NULL) { gtk_print_operation_cancel(print_operation); cairo_surface_destroy(surface); return; } /* Draw a white background. */ cairo_save(temp_cairo); cairo_set_source_rgb(temp_cairo, 1, 1, 1); cairo_rectangle(temp_cairo, 0, 0, page_width, page_height); cairo_fill(temp_cairo); cairo_restore(temp_cairo); /* Render the page to the temporary surface */ girara_debug("printing page %d (fallback) ...", page_number); zathura_renderer_lock(zathura->sync.render_thread); err = zathura_page_render(page, temp_cairo, true); zathura_renderer_unlock(zathura->sync.render_thread); if (err != ZATHURA_ERROR_OK) { cairo_destroy(temp_cairo); cairo_surface_destroy(surface); gtk_print_operation_cancel(print_operation); return; } /* Rescale the page and keep the aspect ratio */ const gdouble scale = MIN(width / page_width, height / page_height); cairo_scale(cairo, scale, scale); /* Blit temporary surface to original cairo object. */ cairo_set_source_surface(cairo, surface, 0.0, 0.0); cairo_paint(cairo); cairo_destroy(temp_cairo); cairo_surface_destroy(surface); }
static VALUE rg_width(VALUE self) { return rb_float_new(gtk_print_context_get_width(_SELF(self))); }
/** * Function called first when try to print the transaction list * initialize the variables and calculate the number of pages * * \param operation GtkPrintOperation * \param context GtkPrintContext * \param null * * \return FALSE * */ gboolean print_transactions_list_begin ( GtkPrintOperation *operation, GtkPrintContext *context, gpointer null ) { CustomList *custom_list; gint size_transaction; gint size_title = 0; gint size_archive = 0; gdouble transactions_per_page_double; gint nb_pages; gint number_of_archives = 0; devel_debug (NULL); /* we need to calculate the number of pages */ cr = gtk_print_context_get_cairo_context (context); custom_list = transaction_model_get_model (); /* get the size of the title */ if (gsb_data_print_config_get_draw_title () && title_string && strlen (title_string)) size_title = pango_font_description_get_size (gsb_data_print_config_get_font_title ())/PANGO_SCALE; /* we need the number of archives and of transactions to print * number_of_archives will be set to 0 if no draw archives */ print_transactions_list_get_visibles_lines (&number_of_archives, &total_transactions_to_print ); /* xxx mk_include 2 fois de suite modifie qd même des fichiers */ /* get the size of a complete transaction and an archive */ size_row = pango_font_description_get_size (gsb_data_print_config_get_font_transactions ())/PANGO_SCALE; size_transaction = size_row * custom_list -> nb_rows_by_transaction + 2*gsb_data_print_config_get_draw_lines (); size_archive = size_row + 2*gsb_data_print_config_get_draw_lines (); /* the heigh of a page decrease of 1 line if we use the columns titles */ page_height = gtk_print_context_get_height (context) - gsb_data_print_config_get_draw_columns_name ()*size_transaction; /* how much transactions we can show in a page : */ transactions_per_page_double = page_height / size_transaction; if (!size_title && !gsb_data_print_config_get_draw_archives ()) { /* simple way : no archives and no title */ nb_pages = ceil ( total_transactions_to_print / transactions_per_page_double ); transactions_in_first_page = floor (transactions_per_page_double); } else { /* there are title or archives, it's more complex because it will have less transactions * on the first page */ gint first_page_height = page_height - size_title - size_archive*number_of_archives; transactions_in_first_page = floor (first_page_height / size_transaction); nb_pages = 1 + ceil ( (total_transactions_to_print - transactions_in_first_page)/ transactions_per_page_double ); } /* set the number of page */ gtk_print_operation_set_n_pages ( GTK_PRINT_OPERATION (operation), nb_pages ); /* save the nb of transactions per page */ transactions_per_page = floor (transactions_per_page_double); /* calculate the size and position of the columns */ page_width = gtk_print_context_get_width (context); print_transactions_list_calculate_columns (page_width); total_transactions_printed = 0; current_row_to_print = 0; return FALSE; }
static void draw_page(GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data) { DocInfo *dinfo = user_data; GeanyEditor *editor; cairo_t *cr; gdouble width, height; gdouble x = 0.0, y = 0.0; /*gint layout_h;*/ gint count; GString *str; if (dinfo == NULL || page_nr >= dinfo->n_pages) return; editor = dinfo->doc->editor; if (dinfo->n_pages > 0) { gdouble fraction = (page_nr + 1) / (gdouble) dinfo->n_pages; gchar *text = g_strdup_printf(_("Page %d of %d"), page_nr, dinfo->n_pages); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(main_widgets.progressbar), fraction); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(main_widgets.progressbar), text); g_free(text); } #ifdef GEANY_PRINT_DEBUG geany_debug("draw_page = %d, pages = %d, (real) lines_per_page = %d", page_nr, dinfo->n_pages, dinfo->lines_per_page); #endif str = g_string_sized_new(256); cr = gtk_print_context_get_cairo_context(context); width = gtk_print_context_get_width(context); height = gtk_print_context_get_height(context); cairo_set_source_rgb(cr, 0, 0, 0); #ifdef GEANY_PRINT_DEBUG cairo_set_line_width(cr, 0.2); cairo_rectangle(cr, 0, 0, width, height); cairo_stroke(cr); #endif cairo_move_to(cr, 0, 0); pango_layout_set_width(dinfo->layout, width * PANGO_SCALE); pango_layout_set_alignment(dinfo->layout, PANGO_ALIGN_LEFT); pango_layout_set_ellipsize(dinfo->layout, FALSE); pango_layout_set_justify(dinfo->layout, FALSE); if (printing_prefs.print_page_header) add_page_header(dinfo, cr, width, page_nr); count = 0; /* the actual line counter for the current page, might be different from * dinfo->cur_line due to possible line breaks */ while (count < dinfo->lines_per_page) { gchar c = 'a'; gint style = -1; PangoAttrList *layout_attr; PangoAttribute *attr; gint colours[3] = { 0 }; gboolean add_linenumber = TRUE; gboolean at_eol; while (count < dinfo->lines_per_page && c != '\0') { at_eol = FALSE; g_string_erase(str, 0, str->len); /* clear the string */ /* line numbers */ if (printing_prefs.print_line_numbers && add_linenumber) { /* if we had a wrapped line on the last page which needs to be continued, don't * add a line number */ if (dinfo->long_line) { add_linenumber = FALSE; } else { gchar *line_number = NULL; gint cur_line_number_margin = get_line_numbers_arity(dinfo->cur_line + 1); gchar *fill = g_strnfill( dinfo->max_line_number_margin - cur_line_number_margin - 1, ' '); line_number = g_strdup_printf("%s%d ", fill, dinfo->cur_line + 1); g_string_append(str, line_number); dinfo->cur_line++; /* increase document line */ add_linenumber = FALSE; style = STYLE_LINENUMBER; c = 'a'; /* dummy value */ g_free(fill); g_free(line_number); } } /* data */ else { style = sci_get_style_at(dinfo->doc->editor->sci, dinfo->cur_pos); c = sci_get_char_at(dinfo->doc->editor->sci, dinfo->cur_pos); if (c == '\0' || style == -1) { /* if c gets 0, we are probably out of document boundaries, * so stop to break out of outer loop */ count = dinfo->lines_per_page; break; } dinfo->cur_pos++; /* convert tabs to spaces which seems to be better than using Pango tabs */ if (c == '\t') { gint tab_width = sci_get_tab_width(editor->sci); gchar *s = g_strnfill(tab_width, ' '); g_string_append(str, s); g_free(s); } /* don't add line breaks, they are handled manually below */ else if (c == '\r' || c == '\n') { gchar c_next = sci_get_char_at(dinfo->doc->editor->sci, dinfo->cur_pos); at_eol = TRUE; if (c == '\r' && c_next == '\n') dinfo->cur_pos++; /* skip LF part of CR/LF */ } else { g_string_append_c(str, c); /* finally add the character */ /* handle UTF-8: since we add char by char (better: byte by byte), we need to * keep UTF-8 characters together(e.g. two bytes for one character) * the input is always UTF-8 and c is signed, so all non-Ascii * characters are less than 0 and consist of all bytes less than 0. * style doesn't change since it is only one character with multiple bytes. */ while (c < 0) { c = sci_get_char_at(dinfo->doc->editor->sci, dinfo->cur_pos); if (c < 0) { /* only add the byte when it is part of the UTF-8 character * otherwise we could add e.g. a '\n' and it won't be visible in the * printed document */ g_string_append_c(str, c); dinfo->cur_pos++; } } } } if (! at_eol) { /* set text */ pango_layout_set_text(dinfo->layout, str->str, -1); /* attributes */ layout_attr = pango_attr_list_new(); /* foreground colour */ get_rgb_values(dinfo->styles[style][FORE], &colours[0], &colours[1], &colours[2]); attr = pango_attr_foreground_new(colours[0], colours[1], colours[2]); ADD_ATTR(layout_attr, attr); /* background colour */ get_rgb_values(dinfo->styles[style][BACK], &colours[0], &colours[1], &colours[2]); attr = pango_attr_background_new(colours[0], colours[1], colours[2]); ADD_ATTR(layout_attr, attr); /* bold text */ if (dinfo->styles[style][BOLD]) { attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD); ADD_ATTR(layout_attr, attr); } /* italic text */ if (dinfo->styles[style][ITALIC]) { attr = pango_attr_style_new(PANGO_STYLE_ITALIC); ADD_ATTR(layout_attr, attr); } pango_layout_set_attributes(dinfo->layout, layout_attr); pango_layout_context_changed(dinfo->layout); pango_attr_list_unref(layout_attr); } cairo_get_current_point(cr, &x, &y); /* normal line break at eol character in document */ if (at_eol) { /*pango_layout_get_size(dinfo->layout, NULL, &layout_h);*/ /*cairo_move_to(cr, 0, y + (gdouble)layout_h / PANGO_SCALE);*/ cairo_move_to(cr, 0, y + dinfo->line_height); count++; /* we added a new document line so request a new line number */ add_linenumber = TRUE; } else { gint x_offset = 0; /* maybe we need to force a line break because of too long line */ if (x >= (width - dinfo->font_width)) { /* don't start the line at horizontal origin because we need to skip the * line number margin */ if (printing_prefs.print_line_numbers) { x_offset = (dinfo->max_line_number_margin + 1) * dinfo->font_width; } /*pango_layout_get_size(dinfo->layout, NULL, &layout_h);*/ /*cairo_move_to(cr, x_offset, y + (gdouble)layout_h / PANGO_SCALE);*/ /* this is faster but not exactly the same as above */ cairo_move_to(cr, x_offset, y + dinfo->line_height); cairo_get_current_point(cr, &x, &y); count++; } if (count < dinfo->lines_per_page) { /* str->len is counted in bytes not characters, so use g_utf8_strlen() */ x_offset = (g_utf8_strlen(str->str, -1) * dinfo->font_width); if (dinfo->long_line && count == 0) { x_offset = (dinfo->max_line_number_margin + 1) * dinfo->font_width; dinfo->long_line = FALSE; } pango_cairo_show_layout(cr, dinfo->layout); cairo_move_to(cr, x + x_offset, y); } else /* we are on a wrapped line but we are out of lines on this page, so continue * the current line on the next page and remember to continue in current line */ dinfo->long_line = TRUE; } } } if (printing_prefs.print_line_numbers) { /* print a thin line between the line number margin and the data */ gint y_start = 0; if (printing_prefs.print_page_header) y_start = (dinfo->line_height * 3) - 2; /* "- 2": to connect the line number line to * the page header frame */ cairo_set_line_width(cr, 0.3); cairo_move_to(cr, (dinfo->max_line_number_margin * dinfo->font_width) + 1, y_start); cairo_line_to(cr, (dinfo->max_line_number_margin * dinfo->font_width) + 1, y + dinfo->line_height); /* y is last added line, we reuse it */ cairo_stroke(cr); } if (printing_prefs.print_page_numbers) { gchar *line = g_strdup_printf("<small>- %d -</small>", page_nr + 1); pango_layout_set_markup(dinfo->layout, line, -1); pango_layout_set_alignment(dinfo->layout, PANGO_ALIGN_CENTER); cairo_move_to(cr, 0, height - dinfo->line_height); pango_cairo_show_layout(cr, dinfo->layout); g_free(line); #ifdef GEANY_PRINT_DEBUG cairo_set_line_width(cr, 0.3); cairo_move_to(cr, 0, height - (1.25 * dinfo->line_height)); cairo_line_to(cr, width - 1, height - (1.25 * dinfo->line_height)); cairo_stroke(cr); #endif } g_string_free(str, TRUE); }
static gint get_page_count(GtkPrintContext *context, DocInfo *dinfo) { gdouble width, height; gint layout_h; gint i, j, lines_left; gchar *line_buf; if (dinfo == NULL) return -1; width = gtk_print_context_get_width(context); height = gtk_print_context_get_height(context); if (printing_prefs.print_line_numbers) /* remove line number margin space from overall width */ width -= dinfo->max_line_number_margin * dinfo->font_width; pango_layout_set_width(dinfo->layout, width * PANGO_SCALE); /* add test text to get line height */ pango_layout_set_text(dinfo->layout, "Test 1", -1); pango_layout_get_size(dinfo->layout, NULL, &layout_h); if (layout_h <= 0) { geany_debug("Invalid layout_h (%d). Falling back to default height (%d)", layout_h, 100 * PANGO_SCALE); layout_h = 100 * PANGO_SCALE; } dinfo->line_height = (gdouble)layout_h / PANGO_SCALE; dinfo->lines_per_page = ceil((height - dinfo->line_height) / dinfo->line_height); #ifdef GEANY_PRINT_DEBUG geany_debug("max lines_per_page: %d", dinfo->lines_per_page); #endif if (printing_prefs.print_page_numbers) dinfo->lines_per_page -= 2; if (printing_prefs.print_page_header) dinfo->lines_per_page -= 3; lines_left = dinfo->lines_per_page; i = 0; for (j = 0; j < dinfo->lines; j++) { gint lines = 1; gint line_width; line_buf = sci_get_line(dinfo->doc->editor->sci, j); line_width = (g_utf8_strlen(line_buf, -1) + 1) * dinfo->font_width; if (line_width > width) lines = ceil(line_width / width); #ifdef GEANY_PRINT_DEBUG if (lines != 1) geany_debug("%d %d", j+1, lines); #endif while (lines_left < lines) { lines -= lines_left; lines_left = dinfo->lines_per_page; i++; } lines_left -= lines; g_free(line_buf); } return i + 1; }
/** * Function called first when try to print the list * initialize the variables and calculate the number of pages * * \param operation GtkPrintOperation * \param context GtkPrintContext * \param null * * \return FALSE * */ gboolean print_tree_view_list_begin ( GtkPrintOperation *operation, GtkPrintContext *context, gpointer data ) { GtkTreeView *tree_view = ( GtkTreeView * ) data; gint size_line; gdouble lines_per_page_double; gint nbre_pages; devel_debug (NULL); /* we need to calculate the number of pages */ cr = gtk_print_context_get_cairo_context ( context ); /* get the size of the title */ if ( title_string && strlen ( title_string ) ) size_title = print_tree_view_list_get_title_size ( ); else size_title = 0; /* get the size of a row */ size_row = pango_font_description_get_size ( gsb_data_print_config_get_font_transactions () ) / PANGO_SCALE; size_line = size_row + gsb_data_print_config_get_draw_lines ( ); /* get the size of the titles of columns */ if ( gsb_data_print_config_get_draw_columns_name () ) { nbre_lines_col_title = print_tree_view_list_get_columns_title_nbre_lines ( tree_view ); size_columns_title = print_tree_view_list_get_columns_title_size ( nbre_lines_col_title ); } else size_columns_title = 0; /* the heigh of a page decrease size_columns_title */ page_height = gtk_print_context_get_height ( context ); /* get total lines to print */ total_lines_to_print = 0; total_lines_to_print = print_tree_view_list_set_rows_to_print ( tree_view ); /* how much transactions we can show in a page : */ lines_per_page_double = page_height / size_line; /* on enlève les lignes des titres des colonnes */ lines_per_page_double -= nbre_lines_col_title; if ( !size_title ) /* no title */ { nbre_pages = ceil ( total_lines_to_print / lines_per_page_double ); lines_in_first_page = floor ( lines_per_page_double ); } else { gint first_page_height; first_page_height = page_height - size_title; lines_in_first_page = floor ( first_page_height / size_line ) - nbre_lines_col_title; nbre_pages = 1 + ceil ( ( total_lines_to_print - lines_in_first_page ) / lines_per_page_double ); } /* set the number of page */ gtk_print_operation_set_n_pages ( GTK_PRINT_OPERATION ( operation ), nbre_pages ); /* save the nb of rows per page */ lines_per_page = floor ( lines_per_page_double ); /* calculate the size and position of the columns */ page_width = gtk_print_context_get_width ( context ); print_tree_view_list_calculate_columns_width ( tree_view, page_width ); if ( tree_path_to_print ) gtk_tree_path_free ( tree_path_to_print ); tree_path_to_print = gtk_tree_path_new_first ( ); total_lines_printed = 0; current_row_to_print = 0; return FALSE; }
static void draw_page(GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr, gpointer user_data) { DocInfo *dinfo = user_data; cairo_t *cr; gdouble width, height; g_return_if_fail(dinfo != NULL); g_return_if_fail((guint)page_nr < dinfo->pages->len); if (dinfo->pages->len > 0) { gdouble fraction = (page_nr + 1) / (gdouble) dinfo->pages->len; gchar *text = g_strdup_printf(_("Page %d of %d"), page_nr + 1, dinfo->pages->len); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(main_widgets.progressbar), fraction); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(main_widgets.progressbar), text); g_free(text); } cr = gtk_print_context_get_cairo_context(context); width = gtk_print_context_get_width(context); height = gtk_print_context_get_height(context); if (printing_prefs.print_page_header) add_page_header(dinfo, cr, width, page_nr); dinfo->fr.chrg.cpMin = g_array_index(dinfo->pages, gint, page_nr); if ((guint)page_nr + 1 < dinfo->pages->len) dinfo->fr.chrg.cpMax = g_array_index(dinfo->pages, gint, page_nr + 1) - 1; else /* it's the last page, print 'til the end */ dinfo->fr.chrg.cpMax = sci_get_length(dinfo->sci); scintilla_send_message(dinfo->sci, SCI_FORMATRANGE, TRUE, (sptr_t) &dinfo->fr); /* reset color */ cairo_set_source_rgb(cr, 0, 0, 0); if (printing_prefs.print_line_numbers) { /* print a thin line between the line number margin and the data */ gint y1 = 0, y2 = height; if (printing_prefs.print_page_header) y1 += (dinfo->line_height * 3) - 2; /* "- 2": to connect the line number line to * the page header frame */ if (printing_prefs.print_page_numbers) y2 -= (dinfo->line_height * 2) - 2; cairo_set_line_width(cr, 0.3); cairo_move_to(cr, dinfo->margin_width, y1); cairo_line_to(cr, dinfo->margin_width, y2); cairo_stroke(cr); } if (printing_prefs.print_page_numbers) { gchar *line = g_strdup_printf("<small>- %d -</small>", page_nr + 1); pango_layout_set_markup(dinfo->layout, line, -1); pango_layout_set_alignment(dinfo->layout, PANGO_ALIGN_CENTER); cairo_move_to(cr, 0, height - dinfo->line_height); pango_cairo_show_layout(cr, dinfo->layout); g_free(line); } }
void calendar_draw_page (GtkPrintOperation *operation, GtkPrintContext *context, gint npage, gpointer user_data) { PangoLayout *layout; PangoFontDescription *month_name_font, *day_name_font, *day_num_font, *event_font; cairo_t *cr; GDate *date; gdouble page_width, page_height, day_width, day_height; gint text_width, text_height, header_height, event_height, mnf_height, dnf_height, duf_height; gint day, month, i, j; guint32 julian; gboolean monday, actual; gchar buffer[BUFFER_SIZE]; gint padding = config.cal_print_padding; GUI *appGUI = (GUI *) user_data; date = g_date_new_julian (g_date_get_julian (appGUI->cal->date)); g_return_if_fail (date != NULL); cr = gtk_print_context_get_cairo_context (context); layout = gtk_print_context_create_pango_layout (context); month_name_font = pango_font_description_from_string (config.cal_print_month_name_font); day_name_font = pango_font_description_from_string (config.cal_print_day_name_font); day_num_font = pango_font_description_from_string (config.cal_print_day_num_font); event_font = pango_font_description_from_string (config.cal_print_event_font); pango_layout_set_text (layout, "Aj", -1); pango_layout_set_font_description (layout, month_name_font); pango_layout_get_pixel_size (layout, NULL, &mnf_height); mnf_height *= 1.2; pango_layout_set_font_description (layout, day_name_font); pango_layout_get_pixel_size (layout, NULL, &dnf_height); dnf_height *= 1.2; pango_layout_set_font_description (layout, day_num_font); pango_layout_get_pixel_size (layout, NULL, &duf_height); page_width = gtk_print_context_get_width (context); day_width = page_width / 7; page_height = gtk_print_context_get_height (context); header_height = mnf_height + dnf_height; day_height = (page_height - header_height) / 6; event_height = day_height - duf_height - padding * 3; cairo_set_line_width (cr, 1); monday = (config.display_options & GUI_CALENDAR_WEEK_START_MONDAY) ? TRUE : FALSE; /* Month and year */ pango_layout_set_font_description (layout, month_name_font); g_date_strftime (buffer, BUFFER_SIZE, "%B %Y", date); pango_layout_set_text (layout, buffer, -1); pango_layout_get_pixel_size (layout, &text_width, NULL); cairo_move_to (cr, (page_width - text_width) / 2, 0); pango_cairo_show_layout (cr, layout); /* Day names */ pango_layout_set_font_description (layout, day_name_font); for (i = 0; i < 7; i++) { g_snprintf (buffer, BUFFER_SIZE, "%s", utl_get_day_name (i + 7 + monday, FALSE)); pango_layout_set_text (layout, buffer, -1); pango_layout_get_pixel_size (layout, &text_width, NULL); cairo_move_to (cr, day_width * i + (day_width - text_width) / 2, mnf_height); pango_cairo_show_layout (cr, layout); } /* Day */ g_date_set_day (date, 1); day = g_date_get_weekday (date); month = g_date_get_month (date); day = monday ? day - 1 : day % 7; if (day > 0) g_date_subtract_days (date, day); day = g_date_get_day (date); julian = g_date_get_julian (date); pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR); pango_layout_set_width (layout, (day_width - padding * 2) * PANGO_SCALE); pango_layout_set_height (layout, event_height * PANGO_SCALE); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END); pango_layout_set_indent (layout, -4 * PANGO_SCALE); for (i = 0; i < 6; i++) { for (j = 0; j < 7; j++) { actual = (month == g_date_get_month (date)) ? TRUE : FALSE; day = g_date_get_day (date); cairo_rectangle (cr, day_width * j, header_height + day_height * i, day_width, day_height); if (actual) { cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); } else { cairo_set_source_rgb (cr, 0.8, 0.8, 0.8); } cairo_fill_preserve (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_stroke (cr); pango_layout_set_font_description (layout, day_num_font); if (actual) { cairo_move_to (cr, day_width * j + padding, header_height + day_height * i + padding); if ((j == 0 && !monday) || (j == 5 && monday) || j == 6) { g_snprintf (buffer, BUFFER_SIZE, "<span color=\"red\">%d</span>", day); } else { g_snprintf (buffer, BUFFER_SIZE, "%d", day); } pango_layout_set_markup (layout, buffer, -1); pango_cairo_show_layout (cr, layout); cal_print_get_events (buffer, julian, appGUI); pango_layout_set_markup (layout, "", -1); pango_layout_set_text (layout, buffer, -1); pango_layout_set_font_description (layout, event_font); pango_layout_get_pixel_size (layout, NULL, &text_height); cairo_move_to (cr, day_width * j + padding, header_height + day_height * (i + 1) - text_height - padding); pango_cairo_show_layout (cr, layout); } else { cairo_move_to (cr, day_width * j + padding, header_height + day_height * i + padding); g_snprintf (buffer, BUFFER_SIZE, "<span color=\"white\">%d</span>", day); pango_layout_set_markup (layout, buffer, -1); pango_cairo_show_layout (cr, layout); } g_date_add_days (date, 1); julian++; } } g_date_free (date); pango_font_description_free (month_name_font); pango_font_description_free (day_name_font); pango_font_description_free (day_num_font); pango_font_description_free (event_font); g_object_unref (layout); }
static void draw_page (GtkPrintOperation *operation, GtkPrintContext *context, gint page_number, gpointer user_data) { GdictPrintData *data = user_data; cairo_t *cr; PangoLayout *layout; gint text_width, text_height; gdouble width; gint line, i; PangoFontDescription *desc; gchar *page_str; cr = gtk_print_context_get_cairo_context (context); width = gtk_print_context_get_width (context); cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT (10)); cairo_set_source_rgb (cr, 0.8, 0.8, 0.8); cairo_fill_preserve (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_line_width (cr, 1); cairo_stroke (cr); /* header */ layout = gtk_print_context_create_pango_layout (context); desc = pango_font_description_from_string ("sans 14"); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); pango_layout_set_text (layout, data->word, -1); pango_layout_get_pixel_size (layout, &text_width, &text_height); if (text_width > width) { pango_layout_set_width (layout, width); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_START); pango_layout_get_pixel_size (layout, &text_width, &text_height); } cairo_move_to (cr, (width - text_width) / 2, (HEADER_HEIGHT (10) - text_height) / 2); pango_cairo_show_layout (cr, layout); page_str = g_strdup_printf ("%d/%d", page_number + 1, data->n_pages); pango_layout_set_text (layout, page_str, -1); g_free (page_str); pango_layout_set_width (layout, -1); pango_layout_get_pixel_size (layout, &text_width, &text_height); cairo_move_to (cr, width - text_width - 4, (HEADER_HEIGHT (10) - text_height) / 2); pango_cairo_show_layout (cr, layout); g_object_unref (layout); /* text */ layout = gtk_print_context_create_pango_layout (context); pango_font_description_set_size (data->font_desc, data->font_size * PANGO_SCALE); pango_layout_set_font_description (layout, data->font_desc); cairo_move_to (cr, 0, HEADER_HEIGHT (10) + HEADER_GAP (3)); line = page_number * data->lines_per_page; for (i = 0; i < data->lines_per_page && line < data->n_lines; i++) { pango_layout_set_text (layout, data->lines[line], -1); pango_cairo_show_layout (cr, layout); cairo_rel_move_to (cr, 0, data->font_size); line++; } g_object_unref (layout); }