void export_image(const Array<T>& x, std::string filename, double winMin, double winMax, colormap cm) { auto y = colorize<T>(x, winMin, winMax, cm); cairo_surface_t *surface; cairo_t *cr; bool png = false; if(filename.substr(filename.find_last_of(".") + 1) == "png") png = true; if(png) surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, y.shape(1), y.shape(0)); else surface = cairo_pdf_surface_create(filename.c_str(), y.shape(1), y.shape(0)); cr = cairo_create(surface); cairo_surface_t *image; image = cairo_image_surface_create_for_data((unsigned char*) y.data(), CAIRO_FORMAT_ARGB32, shape(y,1), shape(y,0), shape(y,1) * sizeof(int32_t)); //cairo_scale (cr, 256.0/w, 256.0/h); cairo_set_source_surface (cr, image, 0, 0); cairo_paint (cr); cairo_surface_destroy (image); if(png) { cairo_surface_flush(surface); cairo_surface_write_to_png(surface, filename.c_str()); } else { cairo_show_page(cr); } cairo_surface_destroy(surface); cairo_destroy(cr); }
void T2PPage::print() // Prints the page. { // White background. cairo_set_source_rgb(cairo, 1.0, 1.0, 1.0); cairo_paint(cairo); // Headers. if (text_reference_area->has_content()) { header_reference_area->print(number, print_date, text_reference_area->left_running_header(), text_reference_area->right_running_header(), text_reference_area->suppress_headers(), text_reference_area->left_running_first_chapter(), text_reference_area->left_running_last_chapter(), text_reference_area->right_running_first_chapter(), text_reference_area->right_running_last_chapter()); } // Print the reference areas. header_reference_area->print(); text_reference_area->print(); footer_reference_area->print(); // Output this page. cairo_show_page(cairo); }
cairo_status_t _cairo_boilerplate_svg_finish_surface (cairo_surface_t *surface) { svg_target_closure_t *ptc = cairo_surface_get_user_data (surface, &svg_closure_key); cairo_status_t status; /* Both surface and ptc->target were originally created at the * same dimensions. We want a 1:1 copy here, so we first clear any * device offset on surface. * * In a more realistic use case of device offsets, the target of * this copying would be of a different size than the source, and * the offset would be desirable during the copy operation. */ cairo_surface_set_device_offset (surface, 0, 0); if (ptc->target) { cairo_t *cr; cr = cairo_create (ptc->target); cairo_set_source_surface (cr, surface, 0, 0); cairo_paint (cr); cairo_show_page (cr); status = cairo_status (cr); cairo_destroy (cr); if (status) return status; cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status) return status; surface = ptc->target; } cairo_surface_finish (surface); status = cairo_surface_status (surface); if (status) return status; return CAIRO_STATUS_SUCCESS; }
int main (void) { cairo_test_context_t ctx; cairo_t *cr; const char *filename = "svg-surface.svg"; cairo_surface_t *surface; cairo_test_init (&ctx, "svg-surface"); if (! (cairo_test_is_target_enabled (&ctx, "svg11") || cairo_test_is_target_enabled (&ctx, "svg12"))) { cairo_test_fini (&ctx); return CAIRO_TEST_UNTESTED; } surface = cairo_svg_surface_create (filename, WIDTH_IN_POINTS, HEIGHT_IN_POINTS); if (cairo_surface_status (surface)) { cairo_test_log (&ctx, "Failed to create svg surface for file %s: %s\n", filename, cairo_status_to_string (cairo_surface_status (surface))); cairo_test_fini (&ctx); return CAIRO_TEST_FAILURE; } cr = cairo_create (surface); draw (cr, WIDTH_IN_POINTS, HEIGHT_IN_POINTS); cairo_show_page (cr); cairo_destroy (cr); cairo_surface_destroy (surface); printf ("svg-surface: Please check svg-surface.svg to make sure it looks happy.\n"); cairo_test_fini (&ctx); return CAIRO_TEST_SUCCESS; }
static void cairogen_end_page(GVJ_t * job) { cairo_t *cr = (cairo_t *) job->context; cairo_surface_t *surface; cairo_status_t status; switch (job->render.id) { #ifdef CAIRO_HAS_PNG_FUNCTIONS case FORMAT_PNG: surface = cairo_get_target(cr); cairo_surface_write_to_png_stream(surface, writer, job); break; #endif case FORMAT_PS: case FORMAT_PDF: case FORMAT_SVG: cairo_show_page(cr); surface = cairo_surface_reference(cairo_get_target(cr)); cairo_surface_finish(surface); status = cairo_surface_status(surface); cairo_surface_destroy(surface); if (status != CAIRO_STATUS_SUCCESS) fprintf(stderr, "cairo: %s\n", cairo_status_to_string(status)); break; case FORMAT_CAIRO: default: surface = cairo_get_target(cr); if (cairo_image_surface_get_width(surface) == 0 || cairo_image_surface_get_height(surface) == 0) { /* apparently cairo never allocates a surface if nothing was ever written to it */ /* but suppress this error message since a zero area surface seems to happen during normal operations, particular in -Tx11 fprintf(stderr, "ERROR: cairo surface has zero area, this may indicate some problem during rendering shapes.\n"); - jce */ } job->imagedata = (char *)(cairo_image_surface_get_data(surface)); break; /* formatting will be done by gvdevice_format() */ } }
int main (void) { cairo_surface_t *surface; cairo_t *cr; surface = cairo_svg_surface_create ("image.svg", 504, 648); cr = cairo_create (surface); cairo_set_source_rgb (cr, 0, 0, 0); cairo_select_font_face (cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, 40.0); cairo_move_to (cr, 10.0, 50.0); cairo_show_text (cr, "Hello world!"); cairo_show_page (cr); cairo_surface_destroy (surface); cairo_destroy (cr); return 0; }
void Shape::Render(const char *path){ if(geom_ == NULL) return; cairo_surface_t *surface = cairo_ps_surface_create(path, width_, height_); if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { std::cout << cairo_status_to_string(cairo_surface_status(surface)) << std::endl; exit(1); return; } ctx_ = cairo_create(surface); OGREnvelope env; geom_->getEnvelope(&env); cairo_matrix_t mat; matrix_init(&mat, width_, height_, &env); cairo_set_matrix(ctx_, &mat); Dispatch(geom_); cairo_show_page(ctx_); cairo_destroy(ctx_); cairo_surface_destroy(surface); }
void gt_graphics_cairo_save_to_stream(const GtGraphics *gg, GtStr *stream) { const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg; GT_UNUSED cairo_status_t rval; cairo_surface_t *bgsurf = NULL; cairo_t *bgc = NULL; gt_assert(g && stream); /* do nothing if no surface was created */ if (g->from_context) return; switch (g->type) { case GT_GRAPHICS_PNG: /* blend rendered image with background color */ bgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, g->width, g->height); bgc = cairo_create(bgsurf); cairo_set_source_rgba(bgc, g->bg_color.red, g->bg_color.green, g->bg_color.blue, g->bg_color.alpha); cairo_paint(bgc); cairo_set_source_surface(bgc, g->surf, 0, 0); cairo_paint(bgc); rval = cairo_surface_write_to_png_stream(bgsurf, str_write_func, stream); gt_assert(rval == CAIRO_STATUS_SUCCESS); /* str_write_func() is sane */ cairo_destroy(bgc); cairo_surface_destroy(bgsurf); break; default: cairo_show_page(g->cr); cairo_surface_flush(g->surf); cairo_surface_finish(g->surf); gt_str_reset(stream); gt_str_append_str(stream, g->outbuf); gt_assert(gt_str_length(stream) > 0); } }
/* The only reason we go through all these machinations to write a PNG * image is to _really ensure_ that the data actually landed in our * buffer through the paginated surface to the test_paginated_surface. * * If we didn't implement this function then the default * cairo_surface_write_to_png would result in the paginated_surface's * acquire_source_image function replaying the meta-surface to an * intermediate image surface. And in that case the * test_paginated_surface would not be involved and wouldn't be * tested. */ cairo_status_t _cairo_boilerplate_test_paginated_surface_write_to_png (cairo_surface_t *surface, const char *filename) { cairo_surface_t *image; cairo_format_t format; test_paginated_closure_t *tpc; cairo_status_t status; /* show page first. the automatic show_page is too late for us */ /* XXX use cairo_surface_show_page() when that's added */ cairo_t *cr = cairo_create (surface); cairo_show_page (cr); cairo_destroy (cr); tpc = cairo_surface_get_user_data (surface, &test_paginated_closure_key); format = cairo_boilerplate_format_from_content (tpc->content); image = cairo_image_surface_create_for_data (tpc->data, format, tpc->width, tpc->height, tpc->stride); status = cairo_surface_write_to_png (image, filename); if (status) { CAIRO_BOILERPLATE_LOG ("Error writing %s: %s. Exiting\n", filename, cairo_status_to_string (status)); exit (1); } cairo_surface_destroy (image); return CAIRO_STATUS_SUCCESS; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; /* Plug-in variables */ gboolean single_image; gboolean defaults_proc; /* Plug-In variables */ cairo_surface_t *pdf_file; cairo_t *cr; GimpExportCapabilities capabilities; guint32 i = 0; gint32 j = 0; gdouble x_res, y_res; gdouble x_scale, y_scale; gint32 image_id; gboolean exported; GimpImageBaseType type; gint32 temp; gint *layers; gint32 num_of_layers; GimpDrawable *layer; cairo_surface_t *layer_image; gdouble opacity; gint x, y; GimpRGB layer_color; gboolean single_color; gint32 mask_id = -1; GimpDrawable *mask = NULL; cairo_surface_t *mask_image = NULL; FILE *fp; INIT_I18N (); /* Setting mandatory output values */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Initializing all the settings */ multi_page.image_count = 0; if (! init_vals (name, nparams, param, &single_image, &defaults_proc, &run_mode)) { values[0].data.d_status = GIMP_PDB_CALLING_ERROR; return; } /* Starting the executions */ if (run_mode == GIMP_RUN_INTERACTIVE) { if (single_image) { if (! gui_single ()) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } } else if (! gui_multi ()) { values[0].data.d_status = GIMP_PDB_CANCEL; return; } if (file_name == NULL) { values[0].data.d_status = GIMP_PDB_CALLING_ERROR; gimp_message (_("You must select a file to save!")); return; } } fp = g_fopen (file_name, "wb"); pdf_file = cairo_pdf_surface_create_for_stream (write_func, fp, 1, 1); if (cairo_surface_status (pdf_file) != CAIRO_STATUS_SUCCESS) { char *str = g_strdup_printf (_("An error occured while creating the PDF file:\n" "%s\n" "Make sure you entered a valid filename and that the selected location isn't read only!"), cairo_status_to_string (cairo_surface_status (pdf_file))); gimp_message (str); g_free (str); values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; return; } cr = cairo_create (pdf_file); capabilities = GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_ALPHA | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_LAYERS | GIMP_EXPORT_CAN_HANDLE_INDEXED; if (optimize.apply_masks) capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS; for (i = 0; i < multi_page.image_count; i++) { /* Save the state of the surface before any changes, so that settings * from one page won't affect all the others */ cairo_save (cr); image_id = multi_page.images[i]; /* We need the active layer in order to use gimp_image_export */ temp = gimp_image_get_active_drawable (image_id); if (temp == -1) exported = gimp_export_image (&image_id, &temp, NULL, capabilities) == GIMP_EXPORT_EXPORT; else exported = FALSE; type = gimp_image_base_type (image_id); gimp_image_get_resolution (image_id, &x_res, &y_res); x_scale = 72.0 / x_res; y_scale = 72.0 / y_res; cairo_pdf_surface_set_size (pdf_file, gimp_image_width (image_id) * x_scale, gimp_image_height (image_id) * y_scale); /* This way we set how many pixels are there in every inch. * It's very important for PangoCairo */ cairo_surface_set_fallback_resolution (pdf_file, x_res, y_res); /* PDF is usually 72 points per inch. If we have a different resolution, * we will need this to fit our drawings */ cairo_scale (cr, x_scale, y_scale); /* Now, we should loop over the layers of each image */ layers = gimp_image_get_layers (image_id, &num_of_layers); for (j = 0; j < num_of_layers; j++) { layer = gimp_drawable_get (layers [num_of_layers-j-1]); opacity = gimp_layer_get_opacity (layer->drawable_id)/100.0; /* Gimp doesn't display indexed layers with opacity below 50% * And if it's above 50%, it will be rounded to 100% */ if (type == GIMP_INDEXED) { if (opacity <= 0.5) opacity = 0.0; else opacity = 1.0; } if (gimp_item_get_visible (layer->drawable_id) && (! optimize.ignore_hidden || (optimize.ignore_hidden && opacity > 0.0))) { mask_id = gimp_layer_get_mask (layer->drawable_id); if (mask_id != -1) { mask = gimp_drawable_get (mask_id); mask_image = get_drawable_image (mask); } gimp_drawable_offsets (layer->drawable_id, &x, &y); /* For raster layers */ if (!gimp_item_is_text_layer (layer->drawable_id)) { layer_color = get_layer_color (layer, &single_color); cairo_rectangle (cr, x, y, layer->width, layer->height); if (optimize.vectorize && single_color) { cairo_set_source_rgba (cr, layer_color.r, layer_color.g, layer_color.b, layer_color.a * opacity); if (mask_id != -1) cairo_mask_surface (cr, mask_image, x, y); else cairo_fill (cr); } else { cairo_clip (cr); layer_image = get_drawable_image (layer); cairo_set_source_surface (cr, layer_image, x, y); cairo_push_group (cr); cairo_paint_with_alpha (cr, opacity); cairo_pop_group_to_source (cr); if (mask_id != -1) cairo_mask_surface (cr, mask_image, x, y); else cairo_paint (cr); cairo_reset_clip (cr); cairo_surface_destroy (layer_image); } } /* For text layers */ else { drawText (layer, opacity, cr, x_res, y_res); } } /* We are done with the layer - time to free some resources */ gimp_drawable_detach (layer); if (mask_id != -1) { gimp_drawable_detach (mask); cairo_surface_destroy (mask_image); } } /* We are done with this image - Show it! */ cairo_show_page (cr); cairo_restore (cr); if (exported) gimp_image_delete (image_id); } /* We are done with all the images - time to free the resources */ cairo_surface_destroy (pdf_file); cairo_destroy (cr); fclose (fp); /* Finally done, let's save the parameters */ gimp_set_data (DATA_OPTIMIZE, &optimize, sizeof (optimize)); if (!single_image) { g_strlcpy (multi_page.file_name, file_name, MAX_FILE_NAME_LENGTH); gimp_set_data (DATA_IMAGE_LIST, &multi_page, sizeof (multi_page)); } }
void SaveSummary(const std::string &fname, Result &result, Config &config) { const float fnorm = 2.f / sqrtf(result.npoints); const float rnorm = 1.f / sqrtf(2.f / (SQRT3 * result.npoints)); const int csize = 512; // Composition cell size const double dashes[] = { 6.0, 3.0 }; cairo_surface_t *surface = cairo_pdf_surface_create(fname.c_str(), 2*csize, 1.5*csize); cairo_pdf_surface_restrict_to_version(surface, CAIRO_PDF_VERSION_1_4); cairo_t *cr = cairo_create(surface); unsigned char *imgdata = NULL; cairo_surface_t *image = NULL; // Draw points const float radius = 2.0; cairo_identity_matrix(cr); cairo_set_source_rgba(cr, 0, 0, 0, 1); for (int i = 0; i < result.points.size(); ++i) { float x = result.points[i].x * csize; float y = (1.f - result.points[i].y) * csize; cairo_arc(cr, x, y, radius, 0, TWOPI); cairo_fill(cr); } // Draw radial power reference level cairo_identity_matrix(cr); cairo_set_source_rgba(cr, 0.6, 0.6, 0.6, 1); cairo_set_line_width(cr, 1.0); cairo_set_dash(cr, dashes, 2, 0); const float rpref = 1.f - (1.f - config.fymin) / (config.fymax - config.fymin); cairo_move_to(cr, csize, csize + rpref*csize/2); cairo_line_to(cr, 2*csize, csize + rpref*csize/2); cairo_stroke(cr); // Draw radial power cairo_identity_matrix(cr); cairo_set_source_rgba(cr, 0, 0, 0, 1); cairo_set_line_width(cr, 1.0); cairo_set_dash(cr, NULL, 0, 0); for (int i = 0; i < result.rp.size(); ++i) { float x = i / (float) result.rp.size(); float y = 1.f - (result.rp[i] - config.fymin) / (config.fymax - config.fymin); Clamp01(y); if (i == 0) cairo_move_to(cr, csize + x*csize, csize + y*csize/2); else cairo_line_to(cr, csize + x*csize, csize + y*csize/2); } cairo_stroke(cr); // Draw spectrum int stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, result.spectrum.width); result.spectrum.GetRGBA(imgdata); image = cairo_image_surface_create_for_data(imgdata, CAIRO_FORMAT_RGB24, result.spectrum.width, result.spectrum.height, stride); cairo_identity_matrix(cr); cairo_translate(cr, csize, 0); cairo_scale(cr, csize / (float) result.spectrum.width, csize / (float) result.spectrum.height); cairo_set_source_surface(cr, image, 0, 0); cairo_paint(cr); // Draw RDF reference level cairo_identity_matrix(cr); cairo_set_source_rgba(cr, 0.6, 0.6, 0.6, 1); cairo_set_line_width(cr, 1.0); cairo_set_dash(cr, dashes, 2, 0); const float rdfref = 1.f - (1.f - config.rymin) / (config.rymax - config.rymin); cairo_move_to(cr, 0, csize + rdfref*csize/2); cairo_line_to(cr, csize, csize + rdfref*csize/2); cairo_stroke(cr); // Draw RDF cairo_identity_matrix(cr); cairo_set_source_rgba(cr, 0, 0, 0, 1); cairo_set_line_width(cr, 1.0); cairo_set_dash(cr, NULL, 0, 0); for (int i = 0; i < result.rdf.size(); ++i) { float x = i / (float) result.rdf.size(); float y = 1.f - (result.rdf[i] - config.rymin) / (config.rymax - config.rymin); Clamp01(y); if (i == 0) cairo_move_to(cr, x*csize, csize + y*csize/2); else cairo_line_to(cr, x*csize, csize + y*csize/2); } cairo_stroke(cr); // Draw separators cairo_identity_matrix(cr); cairo_set_line_width(cr, 1.0); cairo_set_source_rgba(cr, 0, 0, 0, 1); cairo_move_to(cr, 0, csize); cairo_line_to(cr, 2*csize, csize); cairo_stroke(cr); cairo_move_to(cr, csize, 0); cairo_line_to(cr, csize, 1.5*csize); cairo_stroke(cr); // Draw labels cairo_identity_matrix(cr); cairo_set_font_size(cr, 12.0); cairo_select_font_face(cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_source_rgba(cr, 0, 0, 0, 1); cairo_move_to(cr, 0.0125 * csize, 1.025 * csize); cairo_show_text(cr, "RDF"); cairo_stroke(cr); cairo_move_to(cr, 1.0125 * csize, 1.025 * csize); cairo_show_text(cr, "Power Spectrum"); cairo_stroke(cr); // Draw stats box #ifdef PSA_HAS_CGAL int nlines = 5; #else int nlines = 4; #endif nlines += (result.nsets > 1); double offset = 0.03; double bsize[] = { 0.33 * csize, (nlines * offset + 0.01) * csize }; double banchor = 0.0125 * csize; cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.7); cairo_rectangle(cr, banchor, banchor, bsize[0], bsize[1]); cairo_fill(cr); // Draw stats and corresponding labels cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0); cairo_set_font_size(cr, 12.0); cairo_select_font_face(cr, "monospace", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); const int len = 128; char label[len]; double tanchor[2] = { 1.75 * banchor, 0.9 * banchor }; int i = 1; if (result.nsets > 1) { snprintf(label, len, "Averaged over %d sets", result.nsets); cairo_move_to(cr, tanchor[0], tanchor[1] + i * offset * csize); cairo_show_text(cr, label); ++i; } snprintf(label, len, "Gbl. Mindist %.5f", result.stats.mindist * rnorm); cairo_move_to(cr, tanchor[0], tanchor[1] + i * offset * csize); ++i; cairo_show_text(cr, label); snprintf(label, len, "Avg. Mindist %.5f", result.stats.avgmindist * rnorm); cairo_move_to(cr, tanchor[0], tanchor[1] + i * offset * csize); ++i; cairo_show_text(cr, label); #ifdef PSA_HAS_CGAL snprintf(label, len, "Orient. order %.5f", result.stats.orientorder); cairo_move_to(cr, tanchor[0], tanchor[1] + i * offset * csize); ++i; cairo_show_text(cr, label); #endif snprintf(label, len, "Eff. Nyquist %.5f", result.stats.effnyquist * fnorm); cairo_move_to(cr, tanchor[0], tanchor[1] + i * offset * csize); ++i; cairo_show_text(cr, label); snprintf(label, len, "Oscillations %.5f", result.stats.oscillations); cairo_move_to(cr, tanchor[0], tanchor[1] + i * offset * csize); ++i; cairo_show_text(cr, label); cairo_stroke(cr); // Save and clean up cairo_show_page(cr); cairo_surface_destroy(image); if (imgdata) delete[] imgdata; cairo_destroy(cr); cairo_surface_destroy(surface); }
static cairo_status_t _cairo_boilerplate_win32_printing_surface_write_to_png (cairo_surface_t *surface, const char *filename) { win32_target_closure_t *ptc = cairo_surface_get_user_data (surface, &win32_closure_key); char command[4096]; cairo_surface_t *src_image, *dst_image; cairo_t *cr; cairo_status_t status; /* Both surface and ptc->target were originally created at the * same dimensions. We want a 1:1 copy here, so we first clear any * device offset on surface. * * In a more realistic use case of device offsets, the target of * this copying would be of a different size than the source, and * the offset would be desirable during the copy operation. */ cairo_surface_set_device_offset (surface, 0, 0); if (ptc->target) { cairo_t *cr; cr = cairo_create (ptc->target); cairo_set_source_surface (cr, surface, 0, 0); cairo_paint (cr); cairo_show_page (cr); cairo_destroy (cr); cairo_surface_finish (surface); surface = ptc->target; } cairo_surface_finish (surface); EndPage (ptc->dc); EndDoc (ptc->dc); sprintf (command, "gs -q -r72 -g%dx%d -dSAFER -dBATCH -dNOPAUSE -sDEVICE=pngalpha -sOutputFile=%s %s", ptc->width + ptc->left_margin, ptc->height + ptc->bottom_margin, filename, ptc->filename); if (system (command) != 0) return CAIRO_STATUS_WRITE_ERROR; /* Create a new image from the ghostscript image that has the * left and bottom margins removed */ src_image = cairo_image_surface_create_from_png (filename); status = cairo_surface_status (src_image); if (status) return status; dst_image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, ptc->width, ptc->height); cr = cairo_create (dst_image); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_set_source_surface (cr, src_image, -ptc->left_margin, 0); cairo_paint (cr); cairo_destroy (cr); cairo_surface_write_to_png (dst_image, filename); status = cairo_surface_status (dst_image); if (status) return status; cairo_surface_destroy (src_image); cairo_surface_destroy (dst_image); return CAIRO_STATUS_SUCCESS; }
void lime_cairo_show_page (double handle) { cairo_show_page ((cairo_t*)(intptr_t)handle); }
void cairo_context::show_page() { cairo_show_page(cairo_.get()); check_object_status_and_throw_exception(*this); }
void Context::showPage() { cairo_show_page( mCairo ); }
int log2pdf(log2pdf_params *p) { /** First of all, we read the entire map into memory */ FILE *input_file = open_file_for_reading(p->input_filename); if(!input_file) return 0; LDP*scans; int nscans; if(!ld_read_some_scans_distance(input_file, &scans, &nscans, p->use_reference, p->distance_xy, deg2rad(p->distance_th_deg) ) ){ sm_error("Could not read map from file '%s'.\n", p->input_filename); return 0; } if(nscans == 0) { sm_error("I could not read any scan from file '%s'.\n", p->input_filename); return 0; } sm_debug("Read map: %d scans in total.\n", nscans); /** Let's find the bounding box for the map */ double bb_min[2], bb_max[2]; double offset[3] = {0,0,0}; lda_get_bounding_box(scans, nscans, bb_min, bb_max, offset, p->use_reference, p->laser.horizon); bb_min[0] -= p->padding; bb_min[1] -= p->padding; bb_max[0] += p->padding; bb_max[1] += p->padding; sm_debug("Bounding box: %f %f -- %f %f.\n", bb_min[0], bb_min[1], bb_max[0], bb_max[1]); /* Create PDF surface and setup paper size and transformations */ int max_width_points = p->dimension; int max_height_points = p->dimension; cairo_surface_t *surface; cairo_t *cr; if(!create_pdf_surface(p->output_filename, max_width_points, max_height_points, bb_min, bb_max, &surface, &cr)) return 0; /* Draw pose path */ if(p->pose_path.draw) { cairo_save(cr); cr_set_style(cr, &(p->pose_path)); cr_lda_draw_pose_path(cr, scans, nscans, p->use_reference); if(nscans > 0 && p->laser.pose.draw) { cairo_set_source_rgb(cr, 0.3, 0.0, 1.0); double *pose0 = ld_get_reference_pose(scans[0], p->use_reference); cairo_arc(cr, pose0[0], pose0[1], p->start_pose_width, 0.0, 2*M_PI); cairo_fill(cr); } cairo_restore(cr); } /* Draw map */ int k; for(k=0;k<nscans;k++) { LDP ld = scans[k]; double *pose = ld_get_reference_pose(ld, p->use_reference); if(!pose) continue; double offset[3] = {0,0, deg2rad(p->offset_theta_deg) }; double world_pose[3]; oplus_d(offset, pose, world_pose); cairo_save(cr); cr_set_reference(cr, world_pose); cr_ld_draw(cr, ld, &(p->laser)); cairo_restore(cr); } cairo_show_page (cr); cairo_destroy (cr); cairo_surface_destroy (surface); return 1; }
int main() { json_t *root; json_error_t error; root = json_load_file("../test.json", 0, &error); if(root == 0){ printf("ERRO AO LER ARQUIVO, linha %d!\n", error.line); return error.line; } const char * fileName = JSON_getString(root, "fileName"); printf("O nome do arquivo é: %s\n", fileName); const char * format = JSON_getString(root, "format"); if(strcmp(format, "png") != 0 && strcmp(format, "pdf") != 0 ){ printf("Formato: o formato %s não é suportado!\n", format); return 0; } printf("O formato é: %s\n", JSON_getString(root, "format")); const char * name = JSON_getString(root, "name"); printf("O titulo do grafico é: %s\n", name); int width = JSON_getInt(root, "width"); if(width < 200 || width > 1000){ printf("Width: medida não suportada!\n"); return 0; } printf("Width: %d\n", width); int height = JSON_getInt(root, "height"); if(height < 200 || height > 1000){ printf("Height: medida não suportada!\n"); return 0; } printf("Height: %d\n", height); int type = JSON_getInt(root, "type"); printf("Type: %d\n", type); double aux; //aux = height/width; if(height>width) aux = (width/200); else aux = (height/200); cairo_surface_t *surface; if(strcmp(format, "png") == 0){ surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); } else{ surface = cairo_pdf_surface_create(fileName, width, height); } cairo_t *context = cairo_create(surface); cairo_set_source_rgba(context, 1, 1, 1, 1); cairo_rectangle(context, 0, 0, width, height); cairo_fill(context); Color pointColor = JSON_getColor(root); Point *points = JSON_getPoints(root); if(type == 0 || type == 1) create_point(context, points, width, height, type, aux, pointColor); if (type==2) { draw_area(context, points, width, height, aux, pointColor); create_point(context, points, width, height, type, aux, pointColor); } draw_line(context, points, width, height, type, aux, pointColor); write_text(context, name, width, height, aux, pointColor); if(strcmp(JSON_getString(root, "format"), "png") == 0) cairo_surface_write_to_png(surface, fileName); else cairo_show_page(context); cairo_destroy(context); cairo_surface_destroy(surface); return 0; }
EXPORT void slate_cairo_paint(cairo_t* c) { cairo_show_page(c); }
int main (void) { cairo_test_context_t ctx; cairo_surface_t *surface; cairo_t *cr; cairo_status_t status; const char *filename; size_t i; char dsc[255]; cairo_test_init (&ctx, "ps-features"); if (! cairo_test_is_target_enabled (&ctx, "ps")) { cairo_test_fini (&ctx); return CAIRO_TEST_UNTESTED; } filename = "ps-features.ps"; /* We demonstrate that the initial size doesn't matter (we're * passing 0,0), if we use cairo_ps_surface_set_size on the first * page. */ surface = cairo_ps_surface_create (filename, 0, 0); cairo_ps_surface_dsc_comment (surface, "%%Title: ps-features"); cairo_ps_surface_dsc_comment (surface, "%%Copyright: Copyright (C) 2006 Red Hat, Inc."); cairo_ps_surface_dsc_begin_setup (surface); cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *PageSize letter"); cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaColor White"); cr = cairo_create (surface); cairo_select_font_face (cr, "Bitstream Vera Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, TEXT_SIZE); for (i=0; i < ARRAY_SIZE(pages); i++) { cairo_ps_surface_set_size (surface, pages[i].width_in_points, pages[i].height_in_points); cairo_ps_surface_dsc_begin_page_setup (surface); snprintf (dsc, 255, "%%IncludeFeature: *PageSize %s", pages[i].page_size_alias); cairo_ps_surface_dsc_comment (surface, dsc); if (i % 2) { snprintf (dsc, 255, "%%IncludeFeature: *MediaType Glossy"); cairo_ps_surface_dsc_comment (surface, dsc); } cairo_move_to (cr, TEXT_SIZE, TEXT_SIZE); cairo_show_text (cr, pages[i].page_size); cairo_show_text (cr, " - "); cairo_show_text (cr, pages[i].orientation); cairo_show_page (cr); } status = cairo_status (cr); cairo_destroy (cr); cairo_surface_destroy (surface); if (status) { cairo_test_log (&ctx, "Failed to create ps surface for file %s: %s\n", filename, cairo_status_to_string (status)); return CAIRO_TEST_FAILURE; } printf ("ps-features: Please check %s to ensure it looks/prints correctly.\n", filename); cairo_test_fini (&ctx); return CAIRO_TEST_SUCCESS; }
void implf() { int lf,yv,xv; double wep; //char zt[17] = " \0"; char zn[20],zn2[20]; yv = ydeb; for ( lf=0; lf < derlig; ++lf) { if ( yv >= yfin || ligfac[lf].typlig == SPAG) { // saut de page cairo_show_page(cr); sfac_spag(); yv = ydeb; } if (ligfac[lf].typlig == DETAIL ) { if ( parlf[CSFlibprod].y != 0) { cairotextlf(CSFlibprod); cairo_move_to(cr, parlf[CSFlibprod].x, yv); cairo_show_text(cr, ligfac[lf].libprod); } if ( parlf[CSFquant].y != 0) { cairotextlf(CSFquant); cairo_move_to(cr, parlf[CSFquant].x, yv); formfloat(zn2,ligfac[lf].quant); sprintf(zn,"%10s",zn2); cairo_show_text(cr, zn); } if ( parlf[CSFunit].y != 0) { cairotextlf(CSFunit); cairo_move_to(cr, parlf[CSFunit].x, yv); cairo_show_text(cr, ligfac[lf].unit); } if ( parlf[CSFctax].y != 0) { cairotextlf(CSFctax); cairo_move_to(cr, parlf[CSFctax].x, yv); cairo_show_text(cr, ligfac[lf].codtax); } if ( parlf[CSFpu].y != 0) { cairotextlf(CSFpu); cairo_move_to(cr, parlf[CSFpu].x, yv); cairo_show_text(cr, ligfac[lf].spriunit); } if ( parlf[CSFval].y != 0) { cairotextlf(CSFval); cairo_move_to(cr, parlf[CSFval].x, yv); cairo_show_text(cr, ligfac[lf].svalor); // ltof(ligfac[lf].valor,zt,13); // cairo_show_text(cr, zt); } if ( parlf[CSFcodprod].y != 0) { cairotextlf(CSFcodprod); cairo_move_to(cr, parlf[CSFcodprod].x, yv); cairo_show_text(cr, ligfac[lf].codprod); } } else if (ligfac[lf].typlig == DETLIB ) { if ( parlf[CSFlibprod].y != 0) { cairotextlf(CSFlibprod); cairo_move_to(cr, parlf[CSFlibprod].x, yv); cairo_show_text(cr, ligfac[lf].libprod); } } else if (ligfac[lf].typlig == LQQ ) { if ( parlf[CSFlibvar].y != 0) { cairotextlf(CSFlibvar); cairo_move_to(cr, parlf[CSFlibvar].x, yv); cairo_show_text(cr, ligfac[lf].libprod); } } else if (ligfac[lf].typlig == TAX || ligfac[lf].typlig == TIX) { // on se base sur DETAIL if ( parlf[CSFlibprod].y != 0) { cairotextlf(CSFlibprod); cairo_move_to(cr, parlf[CSFlibprod].x, yv); cairo_show_text(cr, ligfac[lf].libprod); } if ( parlf[CSFpu].y != 0) { cairotextlf(CSFpu); cairo_move_to(cr, parlf[CSFpu].x, yv); cairo_show_text(cr, ligfac[lf].spriunit); } if ( parlf[CSFval].y != 0) { cairotextlf(CSFval); cairo_move_to(cr, parlf[CSFval].x, yv); cairo_show_text(cr, ligfac[lf].svalor); // ltof(ligfac[lf].valor,zt,13); // cairo_show_text(cr, zt); } } else if (ligfac[lf].typlig == CALTOT ) { if ( parlf[CSFlibtot].y != 0) { cairotextlf(CSFlibtot); cairo_move_to(cr, parlf[CSFlibtot].x, yv); cairo_show_text(cr, ligfac[lf].libprod); } if ( parlf[CSFvaltot].y != 0) { cairotextlf(CSFvaltot); cairo_move_to(cr, parlf[CSFvaltot].x, yv); cairo_show_text(cr, ligfac[lf].svalor); // ltof(ligfac[lf].valor,zt,13); // cairo_show_text(cr, zt); } } else if (ligfac[lf].typlig == GENCAL ) { // traits if ( parlf[CSFvaltot].y != 0) { // on se base sur valtot cairotextlf(CSFvaltot); if ( strcmp(ligfac[lf].codprod,".ttt") == 0) wep = 0.7; else wep = 1.4; xv = parlf[CSFvaltot].x + 5; cairo_set_line_width (cr, wep); cairo_move_to(cr, xv, yv); cairo_line_to(cr, xv + 80, yv); // 6 x 16 cairo_stroke(cr); } } else if (ligfac[lf].typlig == TPP ) { if ( parlf[CSFlibtot].y != 0) { cairotextlf(CSFlibtot); cairo_move_to(cr, parlf[CSFlibtot].x, yv); cairo_show_text(cr, ligfac[lf].libprod); } if ( parlf[CSFstot].y != 0) { cairotextlf(CSFstot); cairo_move_to(cr, parlf[CSFstot].x, yv); cairo_show_text(cr, ligfac[lf].spriunit); // ltof(ligfac[lf].valor,zt,13); // cairo_show_text(cr, zt); } } yv += dy; } // fin lecture lignes fac }
static int gt_sketch_page_runner(GT_UNUSED int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { SketchPageArguments *arguments = tool_arguments; int had_err = 0; GtFeatureIndex *features = NULL; GtRange qry_range, sequence_region_range; GtStyle *sty = NULL; GtStr *prog, *gt_style_file; GtDiagram *d = NULL; GtLayout *l = NULL; GtBioseq *bioseq = NULL; GtCanvas *canvas = NULL; const char *seqid = NULL, *outfile; unsigned long start, height, num_pages = 0; double offsetpos, usable_height; cairo_surface_t *surf = NULL; cairo_t *cr = NULL; GtTextWidthCalculator *twc; gt_error_check(err); features = gt_feature_index_memory_new(); if (cairo_version() < CAIRO_VERSION_ENCODE(1, 8, 6)) gt_warning("Your cairo library (version %s) is older than version 1.8.6! " "These versions contain a bug which may result in " "corrupted PDF output!", cairo_version_string()); /* get style */ sty = gt_style_new(err); if (gt_str_length(arguments->stylefile) == 0) { prog = gt_str_new(); gt_str_append_cstr_nt(prog, argv[0], gt_cstr_length_up_to_char(argv[0], ' ')); gt_style_file = gt_get_gtdata_path(gt_str_get(prog), err); gt_str_delete(prog); gt_str_append_cstr(gt_style_file, "/sketch/default.style"); } else { gt_style_file = gt_str_ref(arguments->stylefile); } had_err = gt_style_load_file(sty, gt_str_get(gt_style_file), err); outfile = argv[parsed_args]; if (!had_err) { /* get features */ had_err = gt_feature_index_add_gff3file(features, argv[parsed_args+1], err); if (!had_err && gt_str_length(arguments->seqid) == 0) { seqid = gt_feature_index_get_first_seqid(features); if (seqid == NULL) { gt_error_set(err, "GFF input file must contain a sequence region!"); had_err = -1; } } else if (!had_err && !gt_feature_index_has_seqid(features, gt_str_get(arguments->seqid))) { gt_error_set(err, "sequence region '%s' does not exist in GFF input file", gt_str_get(arguments->seqid)); had_err = -1; } else if (!had_err) seqid = gt_str_get(arguments->seqid); } /* set text */ if (gt_str_length(arguments->text) == 0) { gt_str_delete(arguments->text); arguments->text = gt_str_new_cstr(argv[parsed_args+1]); } if (!had_err) { /* set display range */ gt_feature_index_get_range_for_seqid(features, &sequence_region_range, seqid); qry_range.start = (arguments->range.start == GT_UNDEF_ULONG ? sequence_region_range.start : arguments->range.start); qry_range.end = (arguments->range.end == GT_UNDEF_ULONG ? sequence_region_range.end : arguments->range.end); /* set output format */ if (strcmp(gt_str_get(arguments->format), "pdf") == 0) { surf = cairo_pdf_surface_create(outfile, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight)); } else if (strcmp(gt_str_get(arguments->format), "ps") == 0) { surf = cairo_ps_surface_create(outfile, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight)); } gt_log_log("created page with %.2f:%.2f dimensions\n", mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight)); offsetpos = TEXT_SPACER + arguments->theight + TEXT_SPACER; usable_height = mm_to_pt(arguments->pheight) - arguments->theight - arguments->theight - 4*TEXT_SPACER; if (gt_str_length(arguments->seqfile) > 0) { bioseq = gt_bioseq_new(gt_str_get(arguments->seqfile), err); } cr = cairo_create(surf); cairo_set_font_size(cr, 8); twc = gt_text_width_calculator_cairo_new(cr, sty); for (start = qry_range.start; start <= qry_range.end; start += arguments->width) { GtRange single_range; GtCustomTrack *ct = NULL; const char *seq; single_range.start = start; single_range.end = start + arguments->width; if (had_err) break; d = gt_diagram_new(features, seqid, &single_range, sty, err); if (!d) { had_err = -1; break; } if (bioseq) { seq = gt_bioseq_get_sequence(bioseq, 0); ct = gt_custom_track_gc_content_new(seq, gt_bioseq_get_sequence_length(bioseq, 0), 800, 70, 0.4, true); gt_diagram_add_custom_track(d, ct); } l = gt_layout_new_with_twc(d, mm_to_pt(arguments->width), sty, twc, err); had_err = gt_layout_get_height(l, &height, err); if (!had_err) { if (gt_double_smaller_double(usable_height - 10 - 2*TEXT_SPACER - arguments->theight, offsetpos + height)) { draw_header(cr, gt_str_get(arguments->text), argv[parsed_args+1], seqid, num_pages, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight), arguments->theight); cairo_show_page(cr); offsetpos = TEXT_SPACER + arguments->theight + TEXT_SPACER; num_pages++; } canvas = gt_canvas_cairo_context_new(sty, cr, offsetpos, mm_to_pt(arguments->pwidth), height, NULL, err); if (!canvas) had_err = -1; offsetpos += height; if (!had_err) had_err = gt_layout_sketch(l, canvas, err); } gt_canvas_delete(canvas); gt_layout_delete(l); gt_diagram_delete(d); if (ct) gt_custom_track_delete(ct); } draw_header(cr, gt_str_get(arguments->text), argv[parsed_args+1], seqid, num_pages, mm_to_pt(arguments->pwidth), mm_to_pt(arguments->pheight), arguments->theight); cairo_show_page(cr); num_pages++; gt_log_log("finished, should be %lu pages\n", num_pages); gt_text_width_calculator_delete(twc); cairo_destroy(cr); cairo_surface_flush(surf); cairo_surface_finish(surf); cairo_surface_destroy(surf); cairo_debug_reset_static_data(); if (bioseq) gt_bioseq_delete(bioseq); gt_style_delete(sty); gt_str_delete(gt_style_file); gt_feature_index_delete(features); } return had_err; }
static void BM_NewPage(const pGEcontext gc, pDevDesc dd) { pX11Desc xd = (pX11Desc) dd->deviceSpecific; char buf[PATH_MAX]; cairo_status_t res; xd->npages++; if (xd->type == PNG || xd->type == JPEG || xd->type == BMP) { if (xd->npages > 1) { /* try to preserve the page we do have */ BM_Close_bitmap(xd); if (xd->fp) fclose(xd->fp); } snprintf(buf, PATH_MAX, xd->filename, xd->npages); xd->fp = R_fopen(R_ExpandFileName(buf), "wb"); if (!xd->fp) error(_("could not open file '%s'"), buf); } else if(xd->type == PNGdirect || xd->type == TIFF) { if (xd->npages > 1) { xd->npages--; BM_Close_bitmap(xd); xd->npages++; } } #ifdef HAVE_CAIRO_SVG else if(xd->type == SVG) { if (xd->npages > 1 && xd->cs) { cairo_show_page(xd->cc); if(!xd->onefile) { cairo_surface_destroy(xd->cs); cairo_destroy(xd->cc); } } if(xd->npages == 1 || !xd->onefile) { snprintf(buf, PATH_MAX, xd->filename, xd->npages); xd->cs = cairo_svg_surface_create(R_ExpandFileName(buf), (double)xd->windowWidth, (double)xd->windowHeight); res = cairo_surface_status(xd->cs); if (res != CAIRO_STATUS_SUCCESS) { xd->cs = NULL; error("cairo error '%s'", cairo_status_to_string(res)); } if(xd->onefile) cairo_svg_surface_restrict_to_version(xd->cs, CAIRO_SVG_VERSION_1_2); xd->cc = cairo_create(xd->cs); res = cairo_status(xd->cc); if (res != CAIRO_STATUS_SUCCESS) { error("cairo error '%s'", cairo_status_to_string(res)); } cairo_set_antialias(xd->cc, xd->antialias); } } #endif #ifdef HAVE_CAIRO_PDF else if(xd->type == PDF) { if (xd->npages > 1) { cairo_show_page(xd->cc); if(!xd->onefile) { cairo_surface_destroy(xd->cs); cairo_destroy(xd->cc); } } if(xd->npages == 1 || !xd->onefile) { snprintf(buf, PATH_MAX, xd->filename, xd->npages); xd->cs = cairo_pdf_surface_create(R_ExpandFileName(buf), (double)xd->windowWidth, (double)xd->windowHeight); res = cairo_surface_status(xd->cs); if (res != CAIRO_STATUS_SUCCESS) { error("cairo error '%s'", cairo_status_to_string(res)); } xd->cc = cairo_create(xd->cs); res = cairo_status(xd->cc); if (res != CAIRO_STATUS_SUCCESS) { error("cairo error '%s'", cairo_status_to_string(res)); } cairo_set_antialias(xd->cc, xd->antialias); } } #endif #ifdef HAVE_CAIRO_PS else if(xd->type == PS) { if (xd->npages > 1 && !xd->onefile) { cairo_show_page(xd->cc); cairo_surface_destroy(xd->cs); cairo_destroy(xd->cc); } if(xd->npages == 1 || !xd->onefile) { snprintf(buf, PATH_MAX, xd->filename, xd->npages); xd->cs = cairo_ps_surface_create(R_ExpandFileName(buf), (double)xd->windowWidth, (double)xd->windowHeight); res = cairo_surface_status(xd->cs); if (res != CAIRO_STATUS_SUCCESS) { error("cairo error '%s'", cairo_status_to_string(res)); } // We already require >= 1.2 #if CAIRO_VERSION_MAJOR > 2 || CAIRO_VERSION_MINOR >= 6 if(!xd->onefile) cairo_ps_surface_set_eps(xd->cs, TRUE); #endif xd->cc = cairo_create(xd->cs); res = cairo_status(xd->cc); if (res != CAIRO_STATUS_SUCCESS) { error("cairo error '%s'", cairo_status_to_string(res)); } cairo_set_antialias(xd->cc, xd->antialias); } } #endif else error(_("unimplemented cairo-based device")); cairo_reset_clip(xd->cc); if (xd->type == PNG || xd->type == TIFF|| xd->type == PNGdirect) { /* First clear it */ cairo_set_operator (xd->cc, CAIRO_OPERATOR_CLEAR); cairo_paint (xd->cc); cairo_set_operator (xd->cc, CAIRO_OPERATOR_OVER); xd->fill = gc->fill; } else xd->fill = R_OPAQUE(gc->fill) ? gc->fill: xd->canvas; CairoColor(xd->fill, xd); cairo_new_path(xd->cc); cairo_paint(xd->cc); }
/* * gera relatorio ... * * ret: -1 => algum erro encontrado ... * ret: 0 => ok! */ int impressao_geral (cairo_t *cr, char *sql) { FILE *fp; char *sheader; char *sbuffer; char *cstr; long int len = 1; /* + */ char car; GList *columns; double x = MARGEM_ESQUERDA, y = MARGEM_SUPERIOR; cairo_text_extents_t extents; const char *utf8 = "+"; /* Controle de impressao de pagina */ static long int actual_page = 0; static double start_field = 0.0; static double end_field = 0.0; double redundancy = 0.7; printf ("impressao_geral\n"); /* * Listagem */ char *command = g_strdup_printf ("/usr/share/xmoney/sh/print %s", sql); fp = popen (command, "r"); g_free (command); if ((car = fgetc (fp)) != '+') { cairo_set_source_rgb (cr, 250, 250, 250); cairo_paint (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_select_font_face (cr, "Monospace", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, 20.0); cairo_move_to (cr, 20.0, 40.0); cairo_show_text (cr, "Ops! Sem dados disponiveis para listagem aqui!"); return -1; } /* * Prop. fonte */ cairo_set_source_rgb (cr, 0, 0, 0); cairo_select_font_face (cr, "Monospace", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, TamanhoFonte); cairo_text_extents (cr, utf8, &extents); /* * Cabecalho */ columns = NULL; // g_list_alloc (); /* ---+ */ while ((car = getc (fp)) != '\n') { ++ len; if (car == '+') { columns = g_list_append (columns, g_strdup_printf ("%ld", len)); if ((extents.width * len) > LarguraPagina) { ++ actual_page; } else { end_field = len; } } printf ("%c", car); } printf ("\n"); printf ("Largura Pagina: %f\n" "Largura Campos: %f\n", LarguraPagina, extents.width * len); GList *list = g_list_first (columns); printf ("list->length = %d\n", g_list_length (list)); while (list) { printf ("coluna : %d\n", atoi ((char *) list->data)); list = list->next; } printf ("string width : %f\n" " height: %f\n" " x_bearing: %f\n" " y_bearing: %f\n" " x_advance: %f\n" " y_advance: %f\n", extents.width, extents.height, extents.x_bearing, extents.y_bearing, extents.x_advance, extents.y_advance); /* * Fundo branco pagina */ cairo_set_source_rgb (cr, 255, 255, 255); cairo_rectangle (cr, 0.0, 0.0, LarguraPagina, AlturaPagina); cairo_fill (cr); /* * Fundo verde cabelho */ cairo_set_source_rgb (cr, 0, 100, 0); cairo_rectangle (cr, x, y, (extents.width + redundancy) * len, extents.height * 3); cairo_fill (cr); // linha topo ... cairo_set_source_rgb (cr, 0, 0, 0); // preto cairo_move_to (cr, x, y); cairo_line_to (cr, x + ((extents.width + redundancy) * len), y); cairo_stroke (cr); // cabecalho sql sheader = (char *) malloc (len); sbuffer = (char *) malloc (len); fread (sheader, len, 1, fp); cstr = strndup (sbuffer, len); while ((car = getc (fp)) != '\n'); y += extents.height * 2; cairo_move_to (cr, x, y); cairo_show_text (cr, cstr = strndup (sheader, len)); free (cstr); /* +---+ */ while ((car = getc (fp)) != '\n'); // linha debaixo do cabecalho ... y += extents.height; cairo_move_to (cr, x, y); cairo_line_to (cr, x + ((extents.width + redundancy) * len), y); cairo_stroke (cr); /* * Linhas */ char n_linhas = 0; int bottom_y; y += extents.height * 2; while (fread (sbuffer, len, 1, fp)) { cstr = strndup (sbuffer, len); if (cstr [0] == '+') { cairo_move_to (cr, x, bottom_y); cairo_line_to (cr, x + ((extents.width + redundancy) * len), bottom_y); cairo_stroke (cr); free (cstr); break; } // Listagem cairo_move_to (cr, x, y); cairo_show_text (cr, cstr); free (cstr); bottom_y = y + extents.height; //cairo_move_to (cr, x, y - 10.0); //cairo_line_to (cr, WIDTH_POINTS, y - 10.0); //cairo_stroke (cr); /* Espera nova linha ... */ while ((car = getc (fp)) != '\n'); ++ n_linhas; if (n_linhas > 40) { // linha debaixo da listatem y += extents.height; cairo_move_to (cr, x, y); cairo_line_to (cr, x + ((extents.width + redundancy) * len), y); cairo_stroke (cr); cairo_show_page (cr); y = MARGEM_ESQUERDA; x = MARGEM_SUPERIOR; n_linhas = 0; // linha topo da listagem cairo_move_to (cr, x, y); cairo_line_to (cr, x + ((extents.width + redundancy) * len), y); cairo_stroke (cr); } y += extents.height * 2; } free (sheader); free (sbuffer); g_list_free (columns); fclose (fp); return 0; }
static void create_pages (Pqueue * queue) { gchar * msg; gdouble line_height; guint i, id; glong index; PangoLayoutLine * line; PangoRectangle ink_rect, logical_rect; g_return_if_fail (queue); g_return_if_fail (queue->pos < strlen(queue->text)); while (queue->pos < strlen (queue->text)) { while (gtk_events_pending ()) gtk_main_iteration (); for (i = 0; i < queue->lines_per_page; i++) { line = pango_layout_iter_get_line (queue->iter); pango_layout_iter_next_line (queue->iter); pango_layout_iter_get_line_extents (queue->iter, &ink_rect, &logical_rect); index = pango_layout_iter_get_index (queue->iter); if (index == 0) { i = queue->lines_per_page; queue->pos = strlen (queue->text); g_message ("%s", _("Error: Pango iter index is zero.")); continue; } line_height = logical_rect.height / PANGO_SCALE; if ((queue->page_height + line_height) > (queue->height - (EDGE_MARGIN/2))) { queue->pos += index; queue->page_height = EDGE_MARGIN; gtk_progress_bar_pulse (queue->progressbar); pango_cairo_update_layout (queue->cr, queue->layout); queue->layout = make_new_page (queue->context, queue->desc, queue->height, queue->width); i = queue->lines_per_page; queue->page_count++; pango_layout_set_text (queue->layout, (queue->text+queue->pos), -1); queue->iter = pango_layout_get_iter (queue->layout); pango_cairo_show_layout_line (queue->cr, line); pango_cairo_update_layout (queue->cr, queue->layout); cairo_show_page (queue->cr); } else pango_cairo_show_layout_line (queue->cr, line); queue->page_height += line_height; cairo_move_to (queue->cr, SIDE_MARGIN / 2, queue->page_height); } } pango_layout_iter_free (queue->iter); gtk_progress_bar_set_fraction (queue->progressbar, 0.0); cairo_surface_destroy(queue->surface); pango_font_description_free (queue->desc); g_object_unref (queue->context); g_object_unref (queue->layout); cairo_destroy (queue->cr); id = gtk_statusbar_get_context_id (queue->statusbar, PACKAGE); msg = g_strdup_printf (ngettext("Saved PDF file. (%ld page)", "Saved PDF file (%ld pages).", queue->page_count), queue->page_count); gtk_statusbar_push (queue->statusbar, id, msg); g_free (msg); }
void lime_cairo_show_page (value handle) { cairo_show_page ((cairo_t*)val_data (handle)); }
void hb_export_pdf_listview(GtkTreeView *treeview, gchar *filepath, gchar *accname) { cairo_surface_t *surf; cairo_t *cr; PdfPrintContext ppc; PangoFontDescription *desc; PangoLayout *layout; GtkTreeModel *model; GtkTreeIter iter; gboolean valid; gint i, col; DB( g_print("[gtk-chart] export to pdf\n") ); model = gtk_tree_view_get_model(treeview); papersize(&ppc); //gchar *filename = "/home/max/Desktop/hb-txn-export.pdf"; double width; //=210 * 2.83; double height; //=297 * 2.83; width = ppc.w; height = ppc.h; surf = cairo_pdf_surface_create (filepath, width, height); if( cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS ) //todo: manage error later on return; cr = cairo_create (surf); //cairo_pdf_surface_set_size(surf, width * 2.83, height * 2.83); //g_print("width=%d\n", cairo_image_surface_get_width( surf)); double x1, x2, y1, y2; cairo_clip_extents (cr, &x1, &y1, &x2, &y2); DB( g_print("surface w=%f, h=%f\n", x2 - x1, y2 - y1) ); double pwidth = x2 - x1; /* Create a PangoLayout, set the font and text */ layout = pango_cairo_create_layout (cr); /* get and copy the font from the treeview widget */ gtk_style_context_get(gtk_widget_get_style_context(GTK_WIDGET(treeview)), GTK_STATE_FLAG_NORMAL, "font", &desc, NULL); ppc.desc = pango_font_description_copy(desc); DB( g_print("family: %s\n", pango_font_description_get_family(desc)) ); DB( g_print("size: %d (%d)\n", pango_font_description_get_size (desc), pango_font_description_get_size (desc )/PANGO_SCALE) ); /* header is 1 line for date page number at top, then a title in bold, then 2 empty lines */ gint header_height = PDF_FONT_NORMAL * 2 + PDF_FONT_TITLE; gint nb_lines = gtk_tree_model_iter_n_children(model, NULL); /* should include here the headertitle line */ gint lpp = floor ((height-header_height-ppc.mt-ppc.mb) / (PDF_FONT_NORMAL + PDF_LINE_MARGIN)); gint page, num_pages = (nb_lines - 1) / lpp + 1; DB( g_print("\n - should pdf %d lines, lpp=%d, num_pages=%d\n", nb_lines, lpp, num_pages) ); gint tot_lines = 0; gint cur_page_line = 1; gchar dbuffer[255]; gchar amtbuf[G_ASCII_DTOSTR_BUF_SIZE]; gchar balbuf[G_ASCII_DTOSTR_BUF_SIZE]; GDate *date = g_date_new (); //cairo_set_font_size(cr, PDF_FONT_NORMAL); pango_font_description_set_absolute_size(ppc.desc, PDF_FONT_NORMAL * PANGO_SCALE); pango_layout_set_font_description (layout, ppc.desc); /* reset struct */ hb_pdf_set_col_title(&ppc); for(col=0;col<PDF_NUMCOL;col++) { int tw, th; ppc.column_width[col] = 0; pango_layout_set_text (layout, ppc.column_txt[col], -1); pango_layout_get_size (layout, &tw, &th); ppc.column_width[col] = MAX(ppc.column_width[col], tw / PANGO_SCALE); } DB( g_print(" - compute width\n") ); /* first pass to get max width */ valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter); while (valid) { Transaction *txn; int tw, th; gtk_tree_model_get (model, &iter, LST_DSPOPE_DATAS, &txn, -1); i = 0; g_date_set_julian (date, txn->date); g_date_strftime (dbuffer, 255-1, "%x", date); pango_layout_set_text (layout, dbuffer, -1); pango_layout_get_size (layout, &tw, &th); ppc.column_width[i] = MAX(ppc.column_width[i], tw / PANGO_SCALE); i = 1; if(txn->info != NULL && strlen(txn->info) > 0) { pango_layout_set_text (layout, txn->info, -1); pango_layout_get_size (layout, &tw, &th); ppc.column_width[i] = MAX(ppc.column_width[i], tw / PANGO_SCALE); } i = 4; hb_strfnum(amtbuf, G_ASCII_DTOSTR_BUF_SIZE-1, txn->amount, txn->kcur, GLOBALS->minor); pango_layout_set_text (layout, amtbuf, -1); pango_layout_get_size (layout, &tw, &th); ppc.column_width[i] = MAX(ppc.column_width[i], tw / PANGO_SCALE); i = 5; pango_layout_set_text (layout, "R", -1); pango_layout_get_size (layout, &tw, &th); ppc.column_width[i] = MAX(ppc.column_width[i], tw / PANGO_SCALE); i = 6; hb_strfnum(balbuf, G_ASCII_DTOSTR_BUF_SIZE-1, txn->balance, txn->kcur, GLOBALS->minor); pango_layout_set_text (layout, balbuf, -1); pango_layout_get_size (layout, &tw, &th); ppc.column_width[i] = MAX(ppc.column_width[i], tw / PANGO_SCALE); valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter); } /* distribute remaining size */ gdouble tmp = pwidth - ppc.ml - ppc.mr - (PDF_COL_MARGIN*PDF_NUMCOL); DB( g_print(" page width=%f, remain width=%f\n", pwidth, tmp) ); tmp -= ppc.column_width[0]; tmp -= ppc.column_width[4]; tmp -= ppc.column_width[5]; tmp -= ppc.column_width[6]; /* info=1/4 payee=1/4 memo=2/4 */ ppc.column_width[1] = tmp / 4;; ppc.column_width[2] = tmp / 4; ppc.column_width[3] = 2*tmp / 4; DB( g_print(" page width=%f, remain width=%f\n", width, tmp) ); #if MYDEBUG == 1 for(i=0;i<PDF_NUMCOL;i++) g_print(" col%d=%g ", i, ppc.column_width[i]); g_print("\n"); #endif DB( g_print("\n - start printing\n") ); gint y; page = 1; valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter); while (valid) { Transaction *txn; int tw, th; gtk_tree_model_get (model, &iter, LST_DSPOPE_DATAS, &txn, -1); //DB( g_print(" - %d, %d, %s\n", x, y, txn->memo) ); if(cur_page_line == 1) { //helpdraw #if HELPDRAW == 1 //page with margin hb_pdf_draw_help_rect(cr, 0xFF0000FF, ppc.ml+0.5, ppc.mt+0.5, width-(ppc.ml+ppc.mr), height - (ppc.mt+ppc.mb)); hb_pdf_draw_help_rect(cr, 0xFF00FFFF, ppc.ml+0.5, ppc.mt+0.5, width-(ppc.ml+ppc.mr), header_height); #endif cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); // draw account title pango_font_description_set_absolute_size(ppc.desc, PDF_FONT_TITLE * PANGO_SCALE); pango_layout_set_font_description (layout, ppc.desc); pango_layout_set_text (layout, accname, -1); pango_layout_get_pixel_size (layout, &tw, &th); cairo_move_to(cr, pwidth/2 - (tw/2), ppc.mt); pango_cairo_show_layout (cr, layout); // draw column titles pango_font_description_set_absolute_size(ppc.desc, PDF_FONT_NORMAL * PANGO_SCALE); pango_layout_set_font_description (layout, ppc.desc); g_sprintf(dbuffer, "Page %d/%d", page, num_pages); pango_layout_set_text (layout, dbuffer, -1); pango_layout_get_pixel_size (layout, &tw, &th); cairo_move_to(cr, pwidth - ppc.mr - tw, ppc.mt); pango_cairo_show_layout (cr, layout); //x = ppc.ml; y = ppc.mt + header_height - (PDF_FONT_NORMAL + PDF_LINE_MARGIN); hb_pdf_set_col_title(&ppc); hb_pdf_draw_line(&ppc, cr, y, TRUE, FALSE); } /* print a single line */ //x = ppc.ml; y = ppc.mt + header_height + (cur_page_line * (PDF_FONT_NORMAL + PDF_LINE_MARGIN)); /* reset struct */ for(i=0;i<PDF_NUMCOL;i++) { ppc.column_txt[i] = NULL; } i = 0; g_date_set_julian (date, txn->date); g_date_strftime (dbuffer, 255-1, "%x", date); ppc.column_txt[i] = dbuffer; i = 1; ppc.column_txt[i] = txn->info; i = 2; Payee *p = da_pay_get(txn->kpay); if(p) ppc.column_txt[i] = p->name; i = 3; /*Category *c = da_cat_get(txn->kcat); if(c) ppc.column_txt[i] = da_cat_get_fullname(c);*/ ppc.column_txt[i] = txn->memo; i = 4; hb_strfnum(amtbuf, G_ASCII_DTOSTR_BUF_SIZE-1, txn->amount, txn->kcur, GLOBALS->minor); ppc.column_txt[i] = amtbuf; i = 5; ppc.column_txt[i] = ""; if(txn->status == TXN_STATUS_CLEARED) ppc.column_txt[i] = "c"; else if(txn->status == TXN_STATUS_RECONCILED) ppc.column_txt[i] = "R"; i = 6; hb_strfnum(balbuf, G_ASCII_DTOSTR_BUF_SIZE-1, txn->balance, txn->kcur, GLOBALS->minor); ppc.column_txt[i] = balbuf; hb_pdf_draw_line(&ppc, cr, y, FALSE, (cur_page_line % 2)); /* free any fullcat name */ /*if(ppc.column_txt[3] != NULL) g_free(ppc.column_txt[3]);*/ /* export page */ if(cur_page_line >= lpp) { DB( g_print("\n - next page %d\n", page) ); cairo_show_page(cr); cur_page_line = 0; page++; } cur_page_line++; tot_lines++; valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter); } g_date_free(date); g_object_unref (layout); pango_font_description_free (ppc.desc); cairo_destroy (cr); cairo_surface_destroy (surf); }