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 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
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 int doPrint(GtkPrintOperation *prt, GtkPrintContext *context,cairo_t *cr,gint page)
{
gdouble maxHeight = gtk_print_context_get_height(context);
PangoFontDescription *desc;
gint pg = 0;
gdouble row = 0;
gchar **text;
gdouble text_height;
desc = pango_font_description_from_string(g_object_get_data(G_OBJECT(prt),"3270FontName"));
for(text = g_object_get_data(G_OBJECT(prt),"3270Text");*text;text++)
{
gint layout_height;
PangoLayout *layout = gtk_print_context_create_pango_layout(context);
pango_layout_set_font_description(layout, desc);
pango_layout_set_text(layout, *text, -1);
pango_layout_get_size(layout, NULL, &layout_height);
text_height = ((gdouble)layout_height) / PANGO_SCALE;
if((row+text_height) >= maxHeight)
{
row = 0;
pg++;
}
row += text_height;
if(cr && page == pg)
{
cairo_move_to(cr,0,row);
pango_cairo_show_layout(cr, layout);
}
g_object_unref(layout);
}
pango_font_description_free(desc);
return pg+1;
}
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;
}
/**
* 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;
}
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 VALUE
rg_height(VALUE self)
{
return rb_float_new(gtk_print_context_get_height(_SELF(self)));
}
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);
}
/**
* 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);
}
}