PangoLayout* TextView::initPango(cairo_t* cr, Text* t)
{
PangoLayout* layout = pango_cairo_create_layout(cr);
// Additional Feature: add autowrap and text field size for
// the next xournal release (with new fileformat...)
// pango_layout_set_wrap
pango_cairo_context_set_resolution(pango_layout_get_context(layout), textDpi);
pango_cairo_update_layout(cr, layout);
pango_context_set_matrix(pango_layout_get_context(layout), NULL);
updatePangoFont(layout, t);
return layout;
}
static void setPangoAttributes(const Font* font, const TextRun& run, PangoLayout* layout, bool rtl)
{
PangoAttrList* list = pango_attr_list_new();
PangoAttribute* attr;
attr = pango_attr_size_new_absolute((int)(font->size() * PANGO_SCALE));
attr->end_index = G_MAXUINT;
pango_attr_list_insert_before(list, attr);
attr = pango_attr_letter_spacing_new(font->letterSpacing() * PANGO_SCALE);
attr->end_index = G_MAXUINT;
pango_attr_list_insert_before(list, attr);
// Pango does not yet support synthesising small caps
// See http://bugs.webkit.org/show_bug.cgi?id=15610
pango_layout_set_attributes(layout, list);
pango_attr_list_unref(list);
pango_layout_set_auto_dir(layout, FALSE);
PangoContext* pangoContext = pango_layout_get_context(layout);
PangoDirection direction = rtl ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
pango_context_set_base_dir(pangoContext, direction);
}
static gboolean
query_unlock_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tooltip,
GtkTooltip *tooltip,
gpointer user_data)
{
GtkWidget *label;
PangoLayout *layout;
PangoAttrList *attrs;
IconShapeData *data;
data = g_object_get_data (G_OBJECT (widget), "icon-shape-data");
label = g_object_get_data (G_OBJECT (widget), "tooltip-label");
if (label == NULL) {
label = gtk_label_new (data->text);
g_object_ref_sink (label);
g_object_set_data_full (G_OBJECT (widget),
"tooltip-label", label, g_object_unref);
}
layout = gtk_label_get_layout (GTK_LABEL (label));
pango_cairo_context_set_shape_renderer (pango_layout_get_context (layout),
icon_shape_renderer,
data, NULL);
attrs = create_shape_attr_list_for_layout (layout, data);
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
gtk_tooltip_set_custom (tooltip, label);
return TRUE;
}
static void
text_input_text_direction(void *data,
struct wl_text_input *text_input,
uint32_t serial,
uint32_t direction)
{
struct text_entry *entry = data;
PangoContext *context = pango_layout_get_context(entry->layout);
PangoDirection pango_direction;
switch (direction) {
case WL_TEXT_INPUT_TEXT_DIRECTION_LTR:
pango_direction = PANGO_DIRECTION_LTR;
break;
case WL_TEXT_INPUT_TEXT_DIRECTION_RTL:
pango_direction = PANGO_DIRECTION_RTL;
break;
case WL_TEXT_INPUT_TEXT_DIRECTION_AUTO:
default:
pango_direction = PANGO_DIRECTION_NEUTRAL;
}
pango_context_set_base_dir(context, pango_direction);
}
void pango_printf(cairo_t *cairo, const char *font,
double scale, bool markup, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
// Add one since vsnprintf excludes null terminator.
int length = vsnprintf(NULL, 0, fmt, args) + 1;
va_end(args);
char *buf = malloc(length);
if (buf == NULL) {
sway_log(SWAY_ERROR, "Failed to allocate memory");
return;
}
va_start(args, fmt);
vsnprintf(buf, length, fmt, args);
va_end(args);
PangoLayout *layout = get_pango_layout(cairo, font, buf, scale, markup);
cairo_font_options_t *fo = cairo_font_options_create();
cairo_get_font_options(cairo, fo);
pango_cairo_context_set_font_options(pango_layout_get_context(layout), fo);
cairo_font_options_destroy(fo);
pango_cairo_update_layout(cairo, layout);
pango_cairo_show_layout(cairo, layout);
g_object_unref(layout);
free(buf);
}
TextAsset::Size
TextAsset::computeSizeOfText(cairo_t* cairoContext,
const std::string textString,
int bounds,
PangoFontDescription* font,
Rect* tight,
float* lineHeightOut)
{
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(), (int)textString.length());
pango_layout_set_alignment(layout, _alignment);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
const Size maxTextureSize(bounds, 1024);
pango_layout_set_width(layout, pango_units_from_double(maxTextureSize.width));
pango_layout_set_height(layout, pango_units_from_double(maxTextureSize.height));
pango_layout_set_font_description(layout, font);
applyLeading(cairoContext, layout, font);
PangoRectangle estimateSize;
PangoRectangle ink;
pango_layout_get_pixel_extents(layout, &ink, &estimateSize);
// If the text is right or center aligned the offsets will contain all the
// leading space. We ignore that for the size because drawText will draw
// in the larger box. The tight box below will get the offsets so we know
// where to draw so the text lands in the same tight box.
Size res(estimateSize.width, estimateSize.height);
if (tight != NULL) {
float lineHeight;
float xHeight = charHeight(cairoContext, font, 'x', &lineHeight);
if (lineHeightOut != NULL) {
*lineHeightOut = lineHeight;
}
const float capHeight = charHeight(cairoContext, font, 'Y');
const float ascender = pango_units_to_double(pango_layout_get_baseline(layout));
const float topSpace = ascender - capHeight;
const float bottomSpace = MAX(lineHeight - ascender - (capHeight - xHeight), 0);
if (res.height > topSpace + bottomSpace) {
*tight = Rect(estimateSize.x,
estimateSize.y + topSpace,
res.width,
res.height - topSpace - bottomSpace);
} else {
*tight = Rect(0, 0, res.width, res.height);
}
}
g_object_unref(layout);
return res;
}
void
ge_cairo_transform_for_layout (cairo_t *cr,
PangoLayout *layout,
int x,
int y)
{
const PangoMatrix *matrix;
matrix = pango_context_get_matrix (pango_layout_get_context (layout));
if (matrix)
{
cairo_matrix_t cairo_matrix;
PangoRectangle rect;
cairo_matrix_init (&cairo_matrix,
matrix->xx, matrix->yx,
matrix->xy, matrix->yy,
matrix->x0, matrix->y0);
pango_layout_get_extents (layout, NULL, &rect);
pango_matrix_transform_rectangle (matrix, &rect);
pango_extents_to_pixels (&rect, NULL);
cairo_matrix.x0 += x - rect.x;
cairo_matrix.y0 += y - rect.y;
cairo_set_matrix (cr, &cairo_matrix);
}
else
cairo_translate (cr, x, y);
}
static gboolean
is_gnome_print_layout (PangoLayout *layout)
{
PangoContext *context = pango_layout_get_context (layout);
return is_gnome_print_object (G_OBJECT (context));
}
static void _tristatebutton_size_request(GtkWidget *widget, GtkRequisition *requisition)
{
g_return_if_fail(widget != NULL);
g_return_if_fail(DTGTK_IS_TRISTATEBUTTON(widget));
g_return_if_fail(requisition != NULL);
/* create pango text settings if label exists */
PangoLayout *layout = NULL;
int pw = 0, ph = 0;
const gchar *text = gtk_button_get_label(GTK_BUTTON(widget));
if(text)
{
layout = gtk_widget_create_pango_layout(widget, NULL);
pango_layout_set_font_description(layout, darktable.bauhaus->pango_font_desc);
pango_cairo_context_set_resolution(pango_layout_get_context(layout), darktable.gui->dpi);
pango_layout_set_text(layout, text, -1);
pango_layout_get_pixel_size(layout, &pw, &ph);
g_object_unref(layout);
requisition->width = pw + DT_PIXEL_APPLY_DPI(4);
requisition->height = ph + DT_PIXEL_APPLY_DPI(4);
}
else
{
requisition->width = requisition->height = DT_PIXEL_APPLY_DPI(24);
}
}
void pangox_layout_set_font_face(PangoLayout *layout, OutputFontFace face)
{
if (layout != NULL) {
const PangoFontDescription *old_font;
PangoFontDescription *new_font;
if ((old_font = pango_layout_get_font_description(layout)) == NULL) {
PangoContext *context = pango_layout_get_context(layout);
new_font = pango_font_description_copy(pango_context_get_font_description(context));
}
else {
new_font = pango_font_description_copy(old_font);
}
switch (face) {
case PS_FONT_SANS: {
pango_font_description_set_family(new_font, "Sans");
break;
}
case PS_FONT_SERIF: {
pango_font_description_set_family(new_font, "Serif");
break;
}
default: {
pango_font_description_set_family(new_font, "Fixed");
break;
}
}
pango_layout_set_font_description(layout, new_font);
pango_font_description_free(new_font);
}
}
GtkWidget *
do_rotated_text (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *box;
GtkWidget *drawing_area;
GtkWidget *label;
PangoLayout *layout;
PangoAttrList *attrs;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Rotated Text");
gtk_window_set_default_size (GTK_WINDOW (window), 4 * RADIUS, 2 * RADIUS);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
gtk_container_add (GTK_CONTAINER (window), box);
/* Add a drawing area */
drawing_area = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (box), drawing_area);
gtk_style_context_add_class (gtk_widget_get_style_context (drawing_area),
GTK_STYLE_CLASS_VIEW);
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area),
rotated_text_draw,
NULL, NULL);
/* And a label */
label = gtk_label_new (text);
gtk_container_add (GTK_CONTAINER (box), label);
gtk_label_set_angle (GTK_LABEL (label), 45);
/* Set up fancy stuff on the label */
layout = gtk_label_get_layout (GTK_LABEL (label));
pango_cairo_context_set_shape_renderer (pango_layout_get_context (layout),
fancy_shape_renderer,
NULL, NULL);
attrs = create_fancy_attr_list_for_layout (layout);
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
static void
e_contact_print_letter_heading (EContactPrintContext *ctxt,
gchar *letter)
{
PangoLayout *layout;
PangoFontDescription *desc;
PangoFontMetrics *metrics;
gint width, height;
cairo_t *cr;
desc = ctxt->letter_heading_font;
layout = gtk_print_context_create_pango_layout (ctxt->context);
/* Make the rectangle thrice the average character width.
* XXX Works well for English, what about other locales? */
metrics = pango_context_get_metrics (
pango_layout_get_context (layout),
desc, pango_language_get_default ());
width = pango_font_metrics_get_approximate_char_width (metrics) * 3;
pango_font_metrics_unref (metrics);
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
pango_layout_set_font_description (layout, desc);
pango_layout_set_text (layout, letter, -1);
pango_layout_set_width (layout, width);
pango_layout_get_size (layout, NULL, &height);
if (ctxt->page_nr == -1 || ctxt->pages != ctxt->page_nr) {
/* only calculating number of pages
* or on page we do not want to print */
ctxt->y += pango_units_to_double (height);
return;
}
/* Draw white text centered in a black rectangle. */
cr = gtk_print_context_get_cairo_context (ctxt->context);
cairo_save (cr);
cairo_set_source_rgb (cr, .0, .0, .0);
cairo_rectangle (
cr, ctxt->x, ctxt->y,
pango_units_to_double (width),
pango_units_to_double (height));
cairo_fill (cr);
cairo_restore (cr);
cairo_save (cr);
cairo_move_to (cr, ctxt->x, ctxt->y);
cairo_set_source_rgb (cr, 1., 1., 1.);
pango_cairo_show_layout (cr, layout);
cairo_restore (cr);
ctxt->y += pango_units_to_double (height);
}
static void set_item_text_gravity(GtkWidget* item)
{
GtkWidget* label;
PangoLayout* layout;
PangoContext* context;
label = gtk_bin_get_child(GTK_BIN(item));
layout = gtk_label_get_layout(GTK_LABEL(label));
context = pango_layout_get_context(layout);
pango_context_set_base_gravity(context, PANGO_GRAVITY_AUTO);
}
static PyObject *
_pango_cairo_layout_set_resolution(PyObject *self, PyObject *args)
{
PangoLayout *layout;
double res;
if (!PyArg_ParseTuple(args, "ld", &layout, &res))
return NULL;
pango_cairo_context_set_resolution(pango_layout_get_context(layout), res);
Py_RETURN_NONE;
}
void computeLayout(PangoLayout *layout, char *utf8, int utf8Length, int *wPtr, int *hPtr, int *xOffsetPtr, int *yOffsetPtr, int *layoutDetailsPtr) {
PangoRectangle inkRect, logicalRect;
int left, top, right, bottom, baseline;
PangoLayoutIter *iter;
if (fontDescr == NULL) unicodeSetFont("Verdana", 18, 0, 0, 1);
pango_cairo_context_set_font_options(pango_layout_get_context(layout), fontOptions);
pango_layout_set_font_description(layout, fontDescr);
pango_layout_set_text(layout, utf8, utf8Length);
pango_layout_get_pixel_extents(layout, &inkRect, &logicalRect);
left = (inkRect.x < logicalRect.x) ? inkRect.x : logicalRect.x;
top = (inkRect.y < logicalRect.y) ? inkRect.y : logicalRect.y;
right = inkRect.x + inkRect.width;
if ((logicalRect.x + logicalRect.width) > right) right = logicalRect.x + logicalRect.width;
bottom = inkRect.y + inkRect.height;
if ((logicalRect.y + logicalRect.height) > bottom) bottom = logicalRect.y + logicalRect.height;
iter = pango_layout_get_iter(layout);
baseline = PANGO_PIXELS(pango_layout_iter_get_baseline(iter));
pango_layout_iter_free(iter);
if (left < 0) {
inkRect.x = inkRect.x - left;
logicalRect.x = logicalRect.x - left;
}
if (top < 0) {
inkRect.y = inkRect.y - top;
logicalRect.y = logicalRect.y - top;
baseline = baseline - top;
}
if (layoutDetailsPtr != NULL) {
layoutDetailsPtr[0] = inkRect.x;
layoutDetailsPtr[1] = inkRect.y;
layoutDetailsPtr[2] = inkRect.width;
layoutDetailsPtr[3] = inkRect.height;
layoutDetailsPtr[4] = logicalRect.x;
layoutDetailsPtr[5] = logicalRect.y;
layoutDetailsPtr[6] = logicalRect.width;
layoutDetailsPtr[7] = logicalRect.height;
layoutDetailsPtr[8] = baseline;
}
*wPtr = right - left;
*hPtr = bottom - top;
*xOffsetPtr = left < 0 ? -left : 0;
*yOffsetPtr = top < 0 ? -top : 0;
}
static void
lsm_dom_view_set_cairo_context (LsmDomView *view, cairo_t *cairo)
{
PangoContext *context;
cairo_font_options_t *font_options;
const cairo_font_options_t *current_font_options;
cairo_surface_t *surface;
cairo_surface_type_t type;
g_return_if_fail (LSM_IS_DOM_VIEW (view));
if (view->cairo == cairo)
return;
if (view->cairo != NULL) {
cairo_destroy (view->cairo);
g_object_unref (view->pango_layout);
}
if (cairo == NULL) {
view->cairo = NULL;
view->pango_layout = NULL;
return;
}
cairo_reference (cairo);
view->cairo = cairo;
view->pango_layout = pango_cairo_create_layout (cairo);
surface = cairo_get_target (cairo);
type = cairo_surface_get_type (surface);
view->is_vector = (type == CAIRO_SURFACE_TYPE_SVG ||
type == CAIRO_SURFACE_TYPE_PDF ||
type == CAIRO_SURFACE_TYPE_PS);
context = pango_layout_get_context (view->pango_layout);
pango_cairo_context_set_resolution (context, 72);
current_font_options = pango_cairo_context_get_font_options (context);
if (current_font_options == NULL)
font_options = cairo_font_options_create ();
else
font_options = cairo_font_options_copy (current_font_options);
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
pango_cairo_context_set_font_options (context, font_options);
cairo_font_options_destroy (font_options);
}
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);
}
void
pango_clutter_ensure_glyph_cache_for_layout (PangoLayout *layout)
{
PangoContext *context;
PangoFontMap *fontmap;
PangoRenderer *renderer;
PangoLayoutIter *iter;
g_return_if_fail (PANGO_IS_LAYOUT (layout));
context = pango_layout_get_context (layout);
fontmap = pango_context_get_font_map (context);
g_return_if_fail (PANGO_CLUTTER_IS_FONT_MAP (fontmap));
renderer = _pango_clutter_font_map_get_renderer
(PANGO_CLUTTER_FONT_MAP (fontmap));
if ((iter = pango_layout_get_iter (layout)) == NULL)
return;
do
{
PangoLayoutLine *line;
GSList *l;
line = pango_layout_iter_get_line_readonly (iter);
for (l = line->runs; l; l = l->next)
{
PangoLayoutRun *run = l->data;
PangoGlyphString *glyphs = run->glyphs;
int i;
for (i = 0; i < glyphs->num_glyphs; i++)
{
PangoGlyphInfo *gi = &glyphs->glyphs[i];
if (!run->item->analysis.font)
/* Font not found */
continue;
pango_clutter_renderer_get_cached_glyph (renderer,
run->item->analysis.font,
gi->glyph);
}
}
}
while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
}
static PyObject *
_pango_cairo_create_layout(PyObject *self, PyObject *args)
{
cairo_t * cairo;
PangoLayout *layout;
if (!PyArg_ParseTuple(args, "l", &cairo))
return NULL;
layout = pango_cairo_create_layout(cairo);
printf("Resolution: %f\n", pango_cairo_context_get_resolution(pango_layout_get_context(layout)));
return Py_BuildValue("l", layout);
}
void pangox_layout_list_fonts(FILE *fp, PangoLayout *layout)
{
PangoContext *context;
PangoFontMap *fontmap;
PangoFontFamily **families;
int n, i;
context = pango_layout_get_context(layout);
fontmap = pango_context_get_font_map(context);
pango_font_map_list_families(fontmap, &families, &n);
fprintf(fp, "Found %d fonts\n", n);
for (i = 0; i < n; i++) {
fprintf(fp, " %s\n", pango_font_family_get_name(families[i]));
}
g_free(families);
}
/**
* pango_renderer_draw_layout:
* @renderer: a #PangoRenderer
* @layout: a #PangoLayout
* @x: X position of left edge of baseline, in user space coordinates
* in Pango units.
* @y: Y position of left edge of baseline, in user space coordinates
* in Pango units.
*
* Draws @layout with the specified #PangoRenderer.
*
* Since: 1.8
**/
void
pango_renderer_draw_layout (PangoRenderer *renderer,
PangoLayout *layout,
int x,
int y)
{
PangoLayoutIter *iter;
g_return_if_fail (PANGO_IS_RENDERER (renderer));
g_return_if_fail (PANGO_IS_LAYOUT (layout));
/* We only change the matrix if the renderer isn't already
* active.
*/
if (!renderer->active_count)
{
PangoContext *context = pango_layout_get_context (layout);
pango_renderer_set_matrix (renderer,
pango_context_get_matrix (context));
}
pango_renderer_activate (renderer);
iter = pango_layout_get_iter (layout);
do
{
PangoRectangle logical_rect;
PangoLayoutLine *line;
int baseline;
line = pango_layout_iter_get_line_readonly (iter);
pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
baseline = pango_layout_iter_get_baseline (iter);
pango_renderer_draw_layout_line (renderer,
line,
x + logical_rect.x,
y + baseline);
}
while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
pango_renderer_deactivate (renderer);
}
static PangoAttrList *
create_shape_attr_list_for_layout (PangoLayout *layout,
IconShapeData *data)
{
PangoAttrList *attrs;
PangoFontMetrics *metrics;
gint ascent, descent;
PangoRectangle ink_rect, logical_rect;
const gchar *p;
const gchar *text;
gint placeholder_len;
/* Get font metrics and prepare fancy shape size */
metrics = pango_context_get_metrics (pango_layout_get_context (layout),
pango_layout_get_font_description (layout),
NULL);
ascent = pango_font_metrics_get_ascent (metrics);
descent = pango_font_metrics_get_descent (metrics);
pango_font_metrics_unref (metrics);
logical_rect.x = 0;
logical_rect.y = - ascent;
logical_rect.width = ascent + descent;
logical_rect.height = ascent + descent;
ink_rect = logical_rect;
attrs = pango_attr_list_new ();
text = pango_layout_get_text (layout);
placeholder_len = strlen (data->placeholder_str);
for (p = text; (p = strstr (p, data->placeholder_str)); p += placeholder_len) {
PangoAttribute *attr;
attr = pango_attr_shape_new_with_data (&ink_rect,
&logical_rect,
GUINT_TO_POINTER (g_utf8_get_char (p)),
NULL, NULL);
attr->start_index = p - text;
attr->end_index = attr->start_index + placeholder_len;
pango_attr_list_insert (attrs, attr);
}
return attrs;
}
int pangox_layout_get_font_height(PangoLayout *layout)
{
if (layout != NULL) {
PangoFontMetrics *metric;
PangoContext *context;
int h;
context = pango_layout_get_context(layout);
metric = pango_context_get_metrics(context, pango_context_get_font_description(context), NULL);
h = pango_font_metrics_get_ascent(metric) + pango_font_metrics_get_descent(metric);
pango_font_metrics_unref(metric);
return(h / PANGO_SCALE);
}
else {
return(0);
}
}
void pangox_layout_set_font_style(PangoLayout *layout, PangoStyle style)
{
if (layout != NULL) {
const PangoFontDescription *old_font;
PangoFontDescription *new_font;
if ((old_font = pango_layout_get_font_description(layout)) == NULL) {
PangoContext *context = pango_layout_get_context(layout);
new_font = pango_font_description_copy(pango_context_get_font_description(context));
}
else {
new_font = pango_font_description_copy(old_font);
}
pango_font_description_set_style(new_font, style);
pango_layout_set_font_description(layout, new_font);
pango_font_description_free(new_font);
}
}
void pangox_layout_set_font_size(PangoLayout *layout, int size)
{
if (layout != NULL) {
const PangoFontDescription *old_font;
PangoFontDescription *new_font;
if ((old_font = pango_layout_get_font_description(layout)) == NULL) {
PangoContext *context = pango_layout_get_context(layout);
new_font = pango_font_description_copy(pango_context_get_font_description(context));
}
else {
new_font = pango_font_description_copy(old_font);
}
pango_font_description_set_size(new_font, size * PANGO_SCALE * 0.71);
pango_layout_set_font_description(layout, new_font);
pango_font_description_free(new_font);
}
}
static PangoLayout *
make_layout_like_label (ClutterText *label)
{
PangoLayout *label_layout, *new_layout;
PangoContext *context;
PangoFontDescription *fd;
/* Make another layout using the same context as the layout from the
label */
label_layout = clutter_text_get_layout (label);
context = pango_layout_get_context (label_layout);
new_layout = pango_layout_new (context);
fd = pango_font_description_from_string (TEST_FONT);
pango_layout_set_font_description (new_layout, fd);
pango_font_description_free (fd);
return new_layout;
}
static
PangoLayout *get_pangolayout(struct qp_graph *gr, cairo_t *cr)
{
if(!gr->pangolayout)
{
gr->pangolayout = pango_cairo_create_layout(cr);
qp_graph_set_grid_font(gr);
}
else
{
pango_cairo_update_layout(cr, gr->pangolayout);
}
if((gr->font_antialias_set && gr->qp->shape) ||
(!gr->font_antialias_set && !gr->qp->shape))
{
/* Doing a lot of crap just to set one bit */
cairo_font_options_t *fopt;
PangoContext *pc;
fopt = cairo_font_options_create();
if(gr->qp->shape)
{
cairo_font_options_set_antialias(fopt, CAIRO_ANTIALIAS_NONE);
gr->font_antialias_set = 0;
}
else
{
cairo_font_options_set_antialias(fopt, CAIRO_ANTIALIAS_DEFAULT);
gr->font_antialias_set = 1;
}
pc = pango_layout_get_context(gr->pangolayout);
pango_cairo_context_set_font_options(pc, fopt);
cairo_font_options_destroy(fopt);
}
return gr->pangolayout;
}
static void setPangoAttributes(const Font* font, const TextRun& run, PangoLayout* layout)
{
#if USE(FREETYPE)
if (font->primaryFont()->platformData().m_pattern) {
PangoFontDescription* desc = pango_fc_font_description_from_pattern(font->primaryFont()->platformData().m_pattern.get(), FALSE);
pango_layout_set_font_description(layout, desc);
pango_font_description_free(desc);
}
#elif USE(PANGO)
if (font->primaryFont()->platformData().m_font) {
PangoFontDescription* desc = pango_font_describe(font->primaryFont()->platformData().m_font);
pango_layout_set_font_description(layout, desc);
pango_font_description_free(desc);
}
#endif
pango_layout_set_auto_dir(layout, FALSE);
PangoContext* pangoContext = pango_layout_get_context(layout);
PangoDirection direction = run.rtl() ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
pango_context_set_base_dir(pangoContext, direction);
PangoAttrList* list = pango_attr_list_new();
PangoAttribute* attr;
attr = pango_attr_size_new_absolute(font->pixelSize() * PANGO_SCALE);
attr->end_index = G_MAXUINT;
pango_attr_list_insert_before(list, attr);
if (!run.spacingDisabled()) {
attr = pango_attr_letter_spacing_new(font->letterSpacing() * PANGO_SCALE);
attr->end_index = G_MAXUINT;
pango_attr_list_insert_before(list, attr);
}
// Pango does not yet support synthesising small caps
// See http://bugs.webkit.org/show_bug.cgi?id=15610
pango_layout_set_attributes(layout, list);
pango_attr_list_unref(list);
}
static PangoLayout *
get_layout (cairo_t *cr)
{
PangoLayout *layout;
PangoAttrList *attrs;
PangoRectangle ink_rect = {1 * PANGO_SCALE, -11 * PANGO_SCALE, 8 * PANGO_SCALE, 10 * PANGO_SCALE};
PangoRectangle logical_rect = {0 * PANGO_SCALE, -12 * PANGO_SCALE, 10 * PANGO_SCALE, 12 * PANGO_SCALE};
const char *p;
/* Create a PangoLayout, set the font and text */
layout = pango_cairo_create_layout (cr);
pango_cairo_context_set_shape_renderer (pango_layout_get_context (layout),
mini_svg_shape_renderer, NULL, NULL);
pango_layout_set_text (layout, text, -1);
attrs = pango_attr_list_new ();
/* Set gnome shape attributes for all bullets */
for (p = text; (p = strstr (p, BULLET)); p += strlen (BULLET))
{
PangoAttribute *attr;
attr = pango_attr_shape_new_with_data (&ink_rect,
&logical_rect,
&GnomeFootLogo,
NULL, NULL);
attr->start_index = p - text;
attr->end_index = attr->start_index + strlen (BULLET);
pango_attr_list_insert (attrs, attr);
}
pango_layout_set_attributes (layout, attrs);
pango_attr_list_unref (attrs);
return layout;
}
PangoAttrList *
create_fancy_attr_list_for_layout (PangoLayout *layout)
{
PangoAttrList *attrs;
PangoFontMetrics *metrics;
int ascent;
PangoRectangle ink_rect, logical_rect;
const char *p;
/* Get font metrics and prepare fancy shape size */
metrics = pango_context_get_metrics (pango_layout_get_context (layout),
pango_layout_get_font_description (layout),
NULL);
ascent = pango_font_metrics_get_ascent (metrics);
logical_rect.x = 0;
logical_rect.width = ascent;
logical_rect.y = -ascent;
logical_rect.height = ascent;
ink_rect = logical_rect;
pango_font_metrics_unref (metrics);
/* Set fancy shape attributes for all hearts */
attrs = pango_attr_list_new ();
for (p = text; (p = strstr (p, HEART)); p += strlen (HEART))
{
PangoAttribute *attr;
attr = pango_attr_shape_new_with_data (&ink_rect,
&logical_rect,
GUINT_TO_POINTER (g_utf8_get_char (p)),
NULL, NULL);
attr->start_index = p - text;
attr->end_index = attr->start_index + strlen (HEART);
pango_attr_list_insert (attrs, attr);
}
return attrs;
}
