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 (cairo_t *cr, PangoLayout *layout, unsigned int i)
{
cairo_set_source_rgba (cr, 1, 1, 1, 1);
cairo_paint (cr);
cairo_set_source_rgba (cr, 1, 1, 1, 0);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_identity_matrix (cr);
cairo_scale (cr, (100 + i) / 100., (100 + i) / 100.);
pango_cairo_update_layout (cr, layout);
pango_cairo_show_layout (cr, layout);
}
void ly_3lrc_widget_draw_text (cairo_t *cr, gchar *text, gchar *font)
{
PangoLayout *layout;
PangoFontDescription *desc;
layout = pango_cairo_create_layout (cr);
pango_layout_set_text (layout, text, -1);
desc = pango_font_description_from_string (font);
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
pango_cairo_update_layout (cr, layout);
pango_cairo_show_layout (cr, layout);
g_object_unref (layout);
}
void
TextAsset::drawText(cairo_t* cairoContext,
const std::string& textString,
const Rect& rect,
PangoFontDescription* inFontDescription,
bool outlineEnabled)
{
cairo_move_to(cairoContext, rect.x, rect.y);
PangoLayout* layout = pango_cairo_create_layout(cairoContext);
// Kerning
PangoAttrList* attr_list = pango_attr_list_new();
PangoAttribute* spacing_attr = pango_attr_letter_spacing_new(pango_units_from_double(_kern));
pango_attr_list_insert(attr_list, spacing_attr);
pango_layout_set_attributes(layout, attr_list);
pango_cairo_context_set_resolution(pango_layout_get_context(layout), DISPLAY_RESOLUTION);
pango_layout_set_text(layout, textString.c_str(), textString.length());
pango_layout_set_font_description(layout, inFontDescription);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_width(layout, pango_units_from_double(rect.size.width + WIDTH_PADDING));
pango_layout_set_height(layout, pango_units_from_double(rect.size.height + HEIGHT_PADDING));
pango_layout_set_alignment(layout, _alignment);
applyLeading(cairoContext, layout, inFontDescription);
pango_cairo_show_layout(cairoContext, layout);
// Core Text defines positive outline width values as stroke only
if (_outlineThickness <= 0.0f) {
cairo_fill_preserve(cairoContext);
}
// Outline
if (outlineEnabled && _outlineThickness != 0.0f) {
const float outlineThickness = (fabsf(_outlineThickness) / 100.0f) * _fontSize * CLIENT_TO_SERVER_SCALE;
cairo_set_source_rgba(cairoContext,
_outlineColor.red,
_outlineColor.green,
_outlineColor.blue,
_outlineColor.alpha);
pango_cairo_layout_path(cairoContext, layout);
cairo_set_line_width(cairoContext, outlineThickness);
cairo_stroke(cairoContext);
} else {
cairo_new_path(cairoContext);
}
g_object_unref(layout);
}
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);
}
void TextView::drawText(cairo_t * cr, Text * t) {
cairo_save(cr);
cairo_translate(cr, t->getX(), t->getY());
PangoLayout * layout = initPango(cr, t);
String str = t->getText();
pango_layout_set_text(layout, str.c_str(), str.size());
pango_cairo_show_layout(cr, layout);
g_object_unref(layout);
cairo_restore(cr);
}
void wnobj::draw_text(cairo_t *cr, double x, double y, double w, double h, PangoLayout * layout, gdouble alpha, bool highlight)
{
cairo_save(cr);
cairo_set_source_rgba(cr, 1, 1, 1, alpha);
cairo_rectangle(cr, x, y, w, h);
cairo_fill(cr);
cairo_move_to(cr, x, y);
if (highlight) {
cairo_set_source_rgb(cr, 0, 0, 1);
} else {
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
}
pango_cairo_show_layout(cr, layout);
cairo_restore(cr);
}
static gboolean
about_dialog_anim_expose (GtkWidget *widget,
GdkEventExpose *event,
GimpAboutDialog *dialog)
{
GtkStyle *style = gtk_widget_get_style (widget);
cairo_t *cr;
GtkAllocation allocation;
gint x, y;
gint width, height;
if (! dialog->visible)
return FALSE;
cr = gdk_cairo_create (event->window);
gdk_cairo_set_source_color (cr, &style->text[GTK_STATE_NORMAL]);
gtk_widget_get_allocation (widget, &allocation);
pango_layout_get_pixel_size (dialog->layout, &width, &height);
x = (allocation.width - width) / 2;
y = (allocation.height - height) / 2;
if (dialog->textrange[1] > 0)
{
GdkRegion *covered_region;
covered_region = gdk_pango_layout_get_clip_region (dialog->layout,
x, y,
dialog->textrange, 1);
gdk_region_intersect (covered_region, event->region);
gdk_cairo_region (cr, covered_region);
cairo_clip (cr);
gdk_region_destroy (covered_region);
}
cairo_move_to (cr, x, y);
pango_cairo_show_layout (cr, dialog->layout);
cairo_destroy (cr);
return FALSE;
}
static gboolean ygtk_steps_draw (GtkWidget *widget, cairo_t *cr)
{
GTK_WIDGET_CLASS (ygtk_steps_parent_class)->draw(widget, cr);
YGtkSteps *steps = YGTK_STEPS (widget);
gboolean reverse = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
GList *children = gtk_container_get_children (GTK_CONTAINER (widget)), *i;
cairo_set_source_rgb (cr, 0, 0, 0);
int n = 0;
for (i = children; i; i = i->next, n++) {
GtkWidget *label = i->data;
GtkAllocation alloc;
gtk_widget_get_allocation(label, &alloc);
if (g_object_get_data (G_OBJECT (label), "is-header"))
continue;
PangoLayout *layout;
if (n < steps->current_step)
layout = steps->check_mark_layout;
else if (n == steps->current_step)
layout = steps->current_mark_layout;
else //if (n > steps->current_step)
layout = steps->todo_mark_layout;
int x = alloc.x, y = alloc.y;
if (reverse) {
PangoRectangle rect;
pango_layout_get_pixel_extents (layout, NULL, &rect);
x += alloc.width - rect.width - 4;
}
else
x += 4;
if (n == steps->current_step) {
int offset;
if (steps->current_mark_frame < CURRENT_MARK_FRAMES_NB/2)
offset = steps->current_mark_frame * CURRENT_MARK_ANIMATION_OFFSET;
else
offset = (CURRENT_MARK_FRAMES_NB - steps->current_mark_frame) *
CURRENT_MARK_ANIMATION_OFFSET;
x += offset * (reverse ? 1 : -1);
}
cairo_move_to (cr, x, y);
pango_cairo_show_layout (cr, layout);
}
g_list_free (children);
return FALSE;
}
void iupDrawText(IdrawCanvas* dc, const char* text, int len, int x, int y, unsigned char r, unsigned char g, unsigned char b, const char* font)
{
PangoLayout* fontlayout = (PangoLayout*)iupgtkGetPangoLayout(font);
pango_layout_set_text(fontlayout, iupgtkStrConvertToUTF8(text), len);
cairo_set_source_rgba(dc->image_cr, iupCOLOR8ToDouble(r),
iupCOLOR8ToDouble(g),
iupCOLOR8ToDouble(b),
1.0);
pango_cairo_update_layout(dc->image_cr, fontlayout);
cairo_move_to(dc->image_cr, x, y);
pango_cairo_show_layout(dc->image_cr, fontlayout);
}
/* this function is copied from the mist gtk engine */
static void
moblin_netbook_draw_layout (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
gboolean use_text,
GdkRectangle *area,
GtkWidget *widget,
const char *detail,
int x,
int y,
PangoLayout *layout)
{
GdkGC *gc;
gc = use_text ? style->text_gc[state_type] : style->fg_gc[state_type];
if (area)
{
gdk_gc_set_clip_rectangle (gc, area);
}
if (DETAIL ("accellabel") && state_type == GTK_STATE_NORMAL)
{
cairo_t *cr;
cr = moblin_netbook_cairo_create (window, area);
cairo_set_source_rgba (cr,
style->fg[state_type].red / 65535.0,
style->fg[state_type].green / 65535.0,
style->fg[state_type].blue / 65535.0,
0.5);
cairo_move_to (cr, x, y);
pango_cairo_show_layout (cr, layout);
cairo_stroke (cr);
cairo_destroy (cr);
}
else
gdk_draw_layout (window, gc, x, y, layout);
if (area)
{
gdk_gc_set_clip_rectangle (gc, NULL);
}
}
/**
* fo_doc_cairo_render_layout:
* @fo_doc:
* @area_layout:
* @x:
* @y:
*
*
**/
void
fo_doc_cairo_render_layout (FoDoc *fo_doc,
FoArea *area_layout,
gdouble x,
gdouble y)
{
g_return_if_fail (FO_IS_DOC_CAIRO (fo_doc));
g_return_if_fail (FO_DOC_CAIRO (fo_doc)->cr != NULL);
g_return_if_fail (FO_IS_AREA_LAYOUT (area_layout));
cairo_move_to (FO_DOC_CAIRO (fo_doc)->cr,
x,
FO_DOC_CAIRO (fo_doc)->page_height - y);
pango_cairo_show_layout (FO_DOC_CAIRO (fo_doc)->cr,
fo_layout_get_pango_layout (fo_area_layout_get_layout (area_layout)));
}
void ttext::rerender(const bool force) const
{
if(surface_dirty_ || force) {
assert(layout_);
recalculate(force);
surface_dirty_ = false;
int width = rect_.x + rect_.width;
int height = rect_.y + rect_.height;
if(maximum_width_ > 0) { width = std::min(width, maximum_width_); }
if(maximum_height_ > 0) { height = std::min(height, maximum_height_); }
cairo_format_t format = CAIRO_FORMAT_ARGB32;
const unsigned stride = cairo_format_stride_for_width(format, width);
create_surface_buffer(stride * height);
cairo_surface_t* cairo_surface =
cairo_image_surface_create_for_data(surface_buffer_, format, width, height, stride);
cairo_t* cr = cairo_create(cairo_surface);
/* set color (used for foreground). */
cairo_set_source_rgba(cr,
(foreground_color_ >> 24) / 256.0,
((foreground_color_ >> 16) & 0xFF) / 256.0,
((foreground_color_ >> 8) & 0xFF) / 256.0,
(foreground_color_ & 0xFF) / 256.0);
pango_cairo_show_layout(cr, layout_);
// The cairo surface is in CAIRO_FORMAT_ARGB32 which uses
// pre-multiplied alpha. SDL doesn't use that so the pixels need to be
// decoded again.
for(int y = 0; y < height; ++y) {
for(int x = 0; x < width; ++x) {
unsigned char* pixel = &surface_buffer_[(y * width + x) * 4];
decode_pixel(pixel);
}
}
surface_.assign(SDL_CreateRGBSurfaceFrom(
surface_buffer_, width, height, 32, stride, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000));
cairo_destroy(cr);
cairo_surface_destroy(cairo_surface);
}
void gt_graphics_cairo_draw_text_right(GtGraphics *gg, double x, double y,
const char *text)
{
PangoRectangle ink;
GtGraphicsCairo *g = gt_graphics_cairo_cast(gg);
gt_assert(g && text && g->layout);
pango_layout_set_text(g->layout, text, -1);
/* get text extents */
pango_layout_get_pixel_extents(g->layout, &ink, NULL);
cairo_set_source_rgb(g->cr, 0, 0, 0);
/* draw text w/ its right end at the given coords */
cairo_move_to(g->cr, x-(ink.width)-1, y-g->font_height);
pango_cairo_show_layout(g->cr, g->layout);
}
/**
* draw a line of a transaction
*
* \param
*
* \return the new line_position
* */
static gint print_transactions_list_draw_row ( GtkPrintContext *context,
CustomRecord *record,
gint line_position )
{
gint column;
gfloat alignment[] = {
PANGO_ALIGN_CENTER, PANGO_ALIGN_CENTER, PANGO_ALIGN_LEFT,
PANGO_ALIGN_CENTER, PANGO_ALIGN_RIGHT, PANGO_ALIGN_RIGHT, PANGO_ALIGN_RIGHT
};
for (column=0 ; column<CUSTOM_MODEL_VISIBLE_COLUMNS ; column++)
{
PangoLayout *layout;
gchar *text;
gint column_position;
column_position = columns_position[column];
/* draw first the column */
column_position = print_transactions_list_draw_column (column_position, line_position);
/* get the text */
text = record -> visible_col[column];
if (!text)
continue;
cairo_move_to (cr, column_position, line_position);
/* create the new layout */
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_text (layout, text, -1);
pango_layout_set_font_description (layout, gsb_data_print_config_get_font_transactions ());
pango_layout_set_width (layout,columns_width[column]);
pango_layout_set_alignment (layout, alignment[column]);
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
pango_cairo_show_layout (cr, layout);
g_object_unref (layout);
}
/* go to the next row */
line_position = line_position + size_row;
return line_position;
}
/* contact_page_draw_footer inserts the
* page number at the end of each page
* while printing*/
void
contact_page_draw_footer (GtkPrintOperation *operation,
GtkPrintContext *context,
gint page_nr)
{
PangoFontDescription *desc;
PangoLayout *layout;
gdouble x, y, page_height, page_width, page_margin;
/*gint n_pages;*/
gchar *text;
cairo_t *cr;
GtkPageSetup *setup;
/*Uncomment next if it is successful to get total number if pages in list view
* g_object_get (operation, "n-pages", &n_pages, NULL)*/
text = g_strdup_printf (_("Page %d"), page_nr + 1);
setup = gtk_print_context_get_page_setup ( context);
page_height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS);
page_width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
page_margin = gtk_page_setup_get_bottom_margin (setup, GTK_UNIT_POINTS);
desc = pango_font_description_from_string ("Sans Regular 8");
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, -1);
x = page_width / 2.0 - page_margin;
y = page_height - page_margin / 2.0;
cr = gtk_print_context_get_cairo_context (context);
cairo_save (cr);
cairo_set_source_rgb (cr, .0, .0, .0);
cairo_move_to (cr, x, y);
pango_cairo_show_layout (cr, layout);
cairo_restore (cr);
g_object_unref (layout);
pango_font_description_free (desc);
g_free (text);
}
void
gitg_label_renderer_draw(GtkWidget *widget, PangoFontDescription *font, cairo_t *context, GSList *labels, GdkRectangle *area)
{
GSList *item;
double pos = MARGIN + 0.5;
cairo_save(context);
cairo_set_line_width(context, 1.0);
PangoContext *ctx = gtk_widget_get_pango_context(widget);
PangoLayout *layout = pango_layout_new(ctx);
pango_layout_set_font_description(layout, font);
for (item = labels; item; item = item->next)
{
GitgRef *ref = (GitgRef *)item->data;
gint w;
gint h;
gchar *smaller = g_strdup_printf("<span size='smaller'>%s</span>", ref->shortname);
pango_layout_set_markup(layout, smaller, -1);
pango_layout_get_pixel_size(layout, &w, &h);
// draw rounded rectangle
rounded_rectangle(context, pos + 0.5, area->y + MARGIN + 0.5, w + PADDING * 2, area->height - MARGIN * 2, 5);
set_source_for_ref_type(context, ref->type);
cairo_fill_preserve(context);
cairo_set_source_rgb(context, 0, 0, 0);
cairo_stroke(context);
cairo_save(context);
cairo_translate(context, pos + PADDING, area->y + (area->height - h) / 2.0 + 0.5);
pango_cairo_show_layout(context, layout);
cairo_restore(context);
pos += w + PADDING * 2 + MARGIN;
g_free(smaller);
}
g_object_unref(layout);
cairo_restore(context);
}
static gboolean
cairo_menu_item_expose (GtkWidget *widget,GdkEventExpose *event)
{
CairoMenuItemPrivate * priv = GET_PRIVATE(widget);
if (priv->cairo_style)
{
PangoLayout *layout;
double x,y,width,height;
gchar * label;
g_object_get (widget,
"label",&label,
NULL);
cairo_t * cr = gdk_cairo_create (widget->window);
g_debug ("%s: bit depth = %d",__func__,gdk_drawable_get_depth (widget->window));
// g_debug ("Region %d,%d: %dx%d",event->area.x, event->area.y,event->area.width, event->area.height);
x = event->area.x;
y = event->area.y;
width = event->area.width;
height = event->area.height;
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba (cr,0.0,1.0,0.0,0.1);
cairo_rectangle (cr, x,y,width,height);
cairo_fill (cr);
layout = pango_cairo_create_layout (cr);
pango_font_description_set_absolute_size (priv->font_description, height * 0.8 * PANGO_SCALE);
pango_layout_set_font_description (layout, priv->font_description);
pango_layout_set_text (layout, label, -1);
cairo_set_source_rgba (cr,1.0,1.0,1.0,0.3);
cairo_move_to (cr,x+height * 1.1,y+height*0.1);
pango_cairo_show_layout (cr, layout);
cairo_destroy (cr);
g_object_unref (layout);
g_free (label);
return TRUE;
}
else
{
return FALSE;
}
}
static void setup_font_sample(GtkWidget* darea, Antialiasing antialiasing, Hinting hinting)
{
const char *str = "<span font=\"18\" style=\"normal\">abcfgop AO </span>"
"<span font=\"20\" style=\"italic\">abcfgop</span>";
PangoContext *context;
PangoLayout *layout;
PangoFontDescription *fd;
PangoRectangle extents;
cairo_surface_t *surface;
cairo_t *cr;
int width, height;
context = gtk_widget_get_pango_context (darea);
set_fontoptions (context, antialiasing, hinting);
layout = pango_layout_new (context);
fd = pango_font_description_from_string ("Serif");
pango_layout_set_font_description (layout, fd);
pango_font_description_free (fd);
pango_layout_set_markup (layout, str, -1);
pango_layout_get_extents (layout, NULL, &extents);
width = PANGO_PIXELS(extents.width) + 4;
height = PANGO_PIXELS(extents.height) + 2;
surface = cairo_image_surface_create (CAIRO_FORMAT_A8, width, height);
cr = cairo_create (surface);
cairo_move_to (cr, 2, 1);
pango_cairo_show_layout (cr, layout);
g_object_unref (layout);
cairo_destroy (cr);
g_object_set_data_full(G_OBJECT(darea), "sample-surface", surface, (GDestroyNotify) cairo_surface_destroy);
gtk_widget_set_size_request (GTK_WIDGET(darea), width + 2, height + 2);
#if GTK_CHECK_VERSION (3, 0, 0)
g_signal_connect(darea, "draw", G_CALLBACK(sample_draw), NULL);
#else
g_signal_connect(darea, "expose_event", G_CALLBACK(sample_expose), NULL);
#endif
}
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;
}
void shoes_plot_draw_caption(cairo_t *cr, shoes_plot *plot)
{
char *str = RSTRING_PTR(plot->caption);
int x, y;
PangoLayout *layout = pango_cairo_create_layout (cr);
pango_layout_set_font_description (layout, plot->caption_pfd);
pango_layout_set_text (layout, str, -1);
PangoRectangle logical;
pango_layout_get_pixel_extents (layout, NULL, &logical);
int xoffset = (plot->place.w / 2) - (logical.width / 2);
x = xoffset - (plot->place.dx);
int yhalf = (plot->caption_h / 2 );
int yoffset = yhalf + logical.height;
y = plot->place.ih;
y -= yoffset;
cairo_move_to(cr, x, y);
pango_cairo_show_layout (cr, layout);
}
void shoes_plot_draw_title(cairo_t *cr, shoes_plot *plot)
{
char *str = RSTRING_PTR(plot->title);
int x, y;
PangoLayout *layout = pango_cairo_create_layout (cr);
pango_layout_set_font_description (layout, plot->title_pfd);
pango_layout_set_text (layout, str, -1);
PangoRectangle logical;
pango_layout_get_pixel_extents (layout, NULL, &logical);
int xoffset = (plot->place.w / 2) - (logical.width / 2);
x = xoffset - (plot->place.dx);
int yhalf = (plot->title_h / 2 );
int yoffset = yhalf;
y = yoffset;
if (plot->chart_type == PIE_CHART)
y -= 8;
cairo_move_to(cr, x, y);
pango_cairo_show_layout (cr, layout);
}
void pango_printf(cairo_t *cairo, const char *font, int32_t scale, bool markup, const char *fmt, ...) {
char *buf = malloc(2048);
va_list args;
va_start(args, fmt);
if (vsnprintf(buf, 2048, fmt, args) >= 2048) {
strcpy(buf, "[buffer overflow]");
}
va_end(args);
PangoLayout *layout = get_pango_layout(cairo, font, buf, scale, markup);
pango_cairo_update_layout(cairo, layout);
pango_cairo_show_layout(cairo, layout);
g_object_unref(layout);
free(buf);
}
void gt_graphics_cairo_draw_text(GtGraphics *gg, double x, double y,
const char *text)
{
PangoRectangle ink;
GtGraphicsCairo *g = gt_graphics_cairo_cast(gg);
gt_assert(g && text && g->layout);
pango_layout_set_text(g->layout, text, -1);
/* get text extents */
pango_layout_get_pixel_extents(g->layout, &ink, NULL);
if (gt_double_smaller_double(g->width, x+ink.width))
return;
cairo_set_source_rgb(g->cr, 0, 0, 0);
cairo_move_to(g->cr, x, y-g->font_height);
pango_cairo_show_layout(g->cr, g->layout);
}
static void
balsa_print_object_default_draw(BalsaPrintObject * self,
GtkPrintContext * context,
cairo_t * cairo_ctx)
{
BalsaPrintObjectDefault *pod;
gdouble c_max_height;
gdouble c_offset;
PangoLayout *layout;
PangoFontDescription *font;
PangoTabArray *tabs;
/* set up */
pod = BALSA_PRINT_OBJECT_DEFAULT(self);
g_assert(pod != NULL);
c_max_height = MAX(pod->c_text_height, pod->c_image_height);
c_offset = pod->c_image_width + 4 * C_LABEL_SEP;
/* print the icon */
if (pod->pixbuf)
cairo_print_pixbuf(cairo_ctx, pod->pixbuf, self->c_at_x,
self->c_at_y, 1.0);
/* print the description */
font = pango_font_description_from_string(balsa_app.print_header_font);
layout = gtk_print_context_create_pango_layout(context);
pango_layout_set_font_description(layout, font);
pango_font_description_free(font);
pango_layout_set_indent(layout, -pod->p_label_width);
tabs =
pango_tab_array_new_with_positions(1, FALSE, PANGO_TAB_LEFT,
pod->p_label_width);
pango_layout_set_tabs(layout, tabs);
pango_tab_array_free(tabs);
pango_layout_set_width(layout, C_TO_P(self->c_width - c_offset));
pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
pango_layout_set_text(layout, pod->description, -1);
cairo_move_to(cairo_ctx, self->c_at_x + c_offset,
self->c_at_y + (c_max_height -
pod->c_text_height) * 0.5);
pango_cairo_show_layout(cairo_ctx, layout);
g_object_unref(G_OBJECT(layout));
}
static void draw_text (GtkWidget * widget, cairo_t * cr, int x, int y, int
width, float r, float g, float b, float a, const char * font,
const char * text)
{
cairo_move_to(cr, x, y);
cairo_set_operator(cr, CAIRO_OPERATOR_ATOP);
cairo_set_source_rgba(cr, r, g, b, a);
PangoFontDescription * desc = pango_font_description_from_string (font);
PangoLayout * pl = gtk_widget_create_pango_layout (widget, NULL);
pango_layout_set_text (pl, text, -1);
pango_layout_set_font_description(pl, desc);
pango_font_description_free(desc);
pango_layout_set_width (pl, width * PANGO_SCALE);
pango_layout_set_ellipsize (pl, PANGO_ELLIPSIZE_END);
pango_cairo_show_layout(cr, pl);
g_object_unref(pl);
}
//------------------------------------------------------------------
void ofxPangoCairo::rendertext(cairo_t *cr) {
PangoLayout *layout;
PangoFontDescription *desc;
cairo_translate(cr, 10, 20);
layout = pango_cairo_create_layout(cr);
pango_layout_set_text(layout, "Hello World!", -1);
desc = pango_font_description_from_string("Sans Bold 100");
pango_layout_set_font_description(layout, desc);
pango_font_description_free(desc);
cairo_set_source_rgb(cr, 0.0, 0.0, 1.0);
pango_cairo_update_layout(cr, layout);
pango_cairo_show_layout(cr, layout);
/*
g_object_unref(layout);
*/
}
void gt_graphics_cairo_draw_text_clip(GtGraphics *gg, double x, double y,
const char *text)
{
GtGraphicsCairo *g = gt_graphics_cairo_cast(gg);
gt_assert(g && text && g->layout);
pango_layout_set_text(g->layout, text, -1);
cairo_save(g->cr);
cairo_rectangle(g->cr,
g->margin_x,
g->margin_y,
g->width-2*g->margin_x,
g->height-2*g->margin_y);
cairo_clip(g->cr);
cairo_set_source_rgb(g->cr, 0, 0, 0);
cairo_move_to(g->cr, x, y-g->font_height);
pango_cairo_show_layout(g->cr, g->layout);
cairo_restore(g->cr);
}
void RegionChooser::draw_digit(const Cairo::RefPtr<Cairo::Context>& cr,
int key) {
const int h = KEYBOARD_HEIGHT;
const int w = get_width() - 1;
Glib::RefPtr<Pango::Layout> layout =
Pango::Layout::create(get_pango_context());
char buf[30];
sprintf(buf, "<span size=\"8000\">%d</span>", key / 12 - 1);
layout->set_markup(buf);
Pango::Rectangle rectangle = layout->get_logical_extents();
double text_w = double(rectangle.get_width()) / Pango::SCALE;
double text_h = double(rectangle.get_height()) / Pango::SCALE;
double x = w * (key + 0.75) / 128.0;
Gdk::Cairo::set_source_rgba(cr, black);
cr->move_to(int(x - text_w / 2 + 1), int(h1 + h - text_h + 0.5));
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2
pango_cairo_show_layout(cr->cobj(), layout->gobj());
#else
layout->show_in_cairo_context(cr);
#endif
}
void
OutputStringWithContextReal(cairo_t * c, PangoFontDescription* desc, int dpi, const char *str, int x, int y)
{
if (!str || str[0] == 0)
return;
if (!fcitx_utf8_check_string(str))
return;
cairo_save(c);
PangoContext *pc = pango_cairo_create_context(c);
pango_cairo_context_set_resolution(pc, dpi);
PangoLayout *layout = pango_layout_new(pc);
pango_layout_set_text(layout, str, -1);
pango_layout_set_font_description(layout, desc);
cairo_move_to(c, x, y);
pango_cairo_show_layout(c, layout);
cairo_restore(c);
g_object_unref(layout);
g_object_unref(pc);
}