FontPlatformData::FontPlatformData(cairo_font_face_t* fontFace, float size, bool bold, bool oblique) : m_font(0) , m_size(size) , m_fontFace(fontFace) , m_scaledFont(0) , m_syntheticBold(bold) , m_syntheticOblique(oblique) , m_useGDI(false) { cairo_matrix_t fontMatrix; cairo_matrix_init_scale(&fontMatrix, size, size); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); cairo_font_options_t* options = cairo_font_options_create(); // We force antialiasing and disable hinting to provide consistent // typographic qualities for custom fonts on all platforms. #if PLATFORM(APOLLO) // In Apollo use the anti-aliasing mode selected by the user. See bug 2404418. cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_DEFAULT); #else cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); #endif m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options); cairo_font_options_destroy(options); }
void setCairoFontOptionsFromFontConfigPattern(cairo_font_options_t* options, FcPattern* pattern) { FcBool booleanResult; int integerResult; if (FcPatternGetInteger(pattern, FC_RGBA, 0, &integerResult) == FcResultMatch) { cairo_font_options_set_subpixel_order(options, convertFontConfigSubpixelOrder(integerResult)); // Based on the logic in cairo-ft-font.c in the cairo source, a font with // a subpixel order implies that is uses subpixel antialiasing. if (integerResult != FC_RGBA_NONE) cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_SUBPIXEL); } if (FcPatternGetBool(pattern, FC_ANTIALIAS, 0, &booleanResult) == FcResultMatch) { // Only override the anti-aliasing setting if was previously turned off. Otherwise // we'll override the preference which decides between gray anti-aliasing and // subpixel anti-aliasing. if (!booleanResult) cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_NONE); else if (cairo_font_options_get_antialias(options) == CAIRO_ANTIALIAS_NONE) cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); } if (FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &integerResult) == FcResultMatch) cairo_font_options_set_hint_style(options, convertFontConfigHintStyle(integerResult)); if (FcPatternGetBool(pattern, FC_HINTING, 0, &booleanResult) == FcResultMatch && !booleanResult) cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); }
FontPlatformData::FontPlatformData(GDIObject<HFONT> font, cairo_font_face_t* fontFace, float size, bool bold, bool oblique) : m_font(SharedGDIObject<HFONT>::create(WTFMove(font))) , m_size(size) , m_syntheticOblique(oblique) { cairo_matrix_t fontMatrix; cairo_matrix_init_scale(&fontMatrix, size, size); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); cairo_font_options_t* options = cairo_font_options_create(); // We force antialiasing and disable hinting to provide consistent // typographic qualities for custom fonts on all platforms. cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_BEST); if (syntheticOblique()) { static const float syntheticObliqueSkew = -tanf(14 * acosf(0) / 90); cairo_matrix_t skew = {1, 0, syntheticObliqueSkew, 1, 0, 0}; cairo_matrix_multiply(&fontMatrix, &skew, &fontMatrix); } m_scaledFont = adoptRef(cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options)); cairo_font_options_destroy(options); }
/** * clutter_backend_get_font_options: * @backend: a #ClutterBackend * * Retrieves the font options for @backend. * * Return value: (transfer none): the font options of the #ClutterBackend. * The returned #cairo_font_options_t is owned by the backend and should * not be modified or freed * * Since: 0.8 */ const cairo_font_options_t * clutter_backend_get_font_options (ClutterBackend *backend) { ClutterBackendPrivate *priv; g_return_val_if_fail (CLUTTER_IS_BACKEND (backend), NULL); priv = backend->priv; if (G_LIKELY (priv->font_options)) return priv->font_options; priv->font_options = cairo_font_options_create (); cairo_font_options_set_hint_style (priv->font_options, CAIRO_HINT_STYLE_NONE); cairo_font_options_set_subpixel_order (priv->font_options, CAIRO_SUBPIXEL_ORDER_DEFAULT); cairo_font_options_set_antialias (priv->font_options, CAIRO_ANTIALIAS_DEFAULT); g_signal_emit (backend, backend_signals[FONT_CHANGED], 0); return priv->font_options; }
ttext::ttext() : #if PANGO_VERSION_CHECK(1,22,0) context_(pango_font_map_create_context(pango_cairo_font_map_get_default())), #else context_(pango_cairo_font_map_create_context(( reinterpret_cast<PangoCairoFontMap*>(pango_cairo_font_map_get_default())))), #endif layout_(pango_layout_new(context_)), rect_(), surface_(), #ifdef SDL_GPU texture_(), #endif text_(), markedup_text_(false), link_aware_(false), link_color_(), font_class_(font::FONT_SANS_SERIF), font_size_(14), font_style_(STYLE_NORMAL), foreground_color_(0xFFFFFFFF), // solid white maximum_width_(-1), characters_per_line_(0), maximum_height_(-1), ellipse_mode_(PANGO_ELLIPSIZE_END), alignment_(PANGO_ALIGN_LEFT), maximum_length_(std::string::npos), calculation_dirty_(true), length_(0), surface_dirty_(true), surface_buffer_(nullptr) { // With 72 dpi the sizes are the same as with SDL_TTF so hardcoded. pango_cairo_context_set_resolution(context_, 72.0); pango_layout_set_ellipsize(layout_, ellipse_mode_); pango_layout_set_alignment(layout_, alignment_); pango_layout_set_wrap(layout_, PANGO_WRAP_WORD_CHAR); /* * Set the pango spacing a bit bigger since the default is deemed to small * http://www.wesnoth.org/forum/viewtopic.php?p=358832#p358832 */ pango_layout_set_spacing(layout_, 2 * PANGO_SCALE); cairo_font_options_t *fo = cairo_font_options_create(); cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL); cairo_font_options_set_hint_metrics(fo, CAIRO_HINT_METRICS_ON); #ifdef _WIN32 // Cairo on Windows (at least the latest available version from gtk.org // as of 2014-02-22, version 1.10.2) has issues with ClearType resulting // in glitchy anti-aliasing with CAIRO_ANTIALIAS_SUBPIXEL or // CAIRO_ANTIALIAS_DEFAULT, but not CAIRO_ANTIALIAS_GRAY, so we use that // as a workaround until the Windows package is updated to use a newer // version of Cairo (see Wesnoth bug #21648). cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_GRAY); #endif pango_cairo_context_set_font_options(context_, fo); cairo_font_options_destroy(fo); }
FontPlatformData::FontPlatformData(cairo_font_face_t* fontFace, float size, bool bold, bool oblique) : m_font(0) , m_size(size) , m_orientation(Horizontal) , m_textOrientation(TextOrientationVerticalRight) , m_widthVariant(RegularWidth) , m_scaledFont(0) , m_isColorBitmapFont(false) , m_syntheticBold(bold) , m_syntheticOblique(oblique) , m_useGDI(false) { cairo_matrix_t fontMatrix; cairo_matrix_init_scale(&fontMatrix, size, size); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); cairo_font_options_t* options = cairo_font_options_create(); // We force antialiasing and disable hinting to provide consistent // typographic qualities for custom fonts on all platforms. cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options); cairo_font_options_destroy(options); }
TextPainter::TextPainter(string text) : _text(text), _textSize(20.0), _cairoTextSize(0), _cairoWidth(1), _cairoHeight(1), _padding(_textSize/2), _textColor(4, 1.0), _context(0), _surface(0), _lastResolution(1, 1), _lastRoi(0, 0, 0, 0) { // ensure a valid opengl context OpenGl::Guard guard; // create a pixel buffer object glCheck(glGenBuffersARB(1, &_buf)); // create cairo font options _fontOptions = cairo_font_options_create(); // override system default antialiasing method cairo_font_options_set_antialias(_fontOptions, CAIRO_ANTIALIAS_DEFAULT); }
void unicodeSetFont(char *fontName, int fontSize, int boldFlag, int italicFlag, int antiAliasFlag) { char description[200]; g_sprintf(description, "%s, %s %s %dpx", fontName, (boldFlag ? "bold" : ""), (italicFlag ? "italic" : ""), fontSize); if (fontDescr != NULL) pango_font_description_free(fontDescr); fontDescr = pango_font_description_from_string(description); if (fontOptions == NULL) { fontOptions = cairo_font_options_create(); // Note: On Mac OS, the default hint style and metrics looked the best. Also, using // the default allows the user to control the look via the OS settings. /* styles: CAIRO_HINT_STYLE_DEFAULT Use the default hint style for for font backend and target device CAIRO_HINT_STYLE_NONE Do not hint outlines CAIRO_HINT_STYLE_SLIGHT Hint outlines slightly to improve contrast while retaining good fidelity to the original shapes. CAIRO_HINT_STYLE_MEDIUM Hint outlines with medium strength giving a compromise between fidelity to the original shapes and contrast CAIRO_HINT_STYLE_FULL Hint outlines to maximize contrast metrics: CAIRO_HINT_METRICS_DEFAULT Hint metrics in the default manner for the font backend and target device CAIRO_HINT_METRICS_OFF Do not hint font metrics CAIRO_HINT_METRICS_ON Hint font metrics */ cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_DEFAULT); cairo_font_options_set_hint_metrics(fontOptions, CAIRO_HINT_METRICS_DEFAULT); } cairo_font_options_set_antialias(fontOptions, antiAliasFlag ? CAIRO_ANTIALIAS_GRAY : CAIRO_ANTIALIAS_NONE); }
// Den Text zeichnen static void draw_text (Lcd *lcd, cairo_t *cr) { LcdPrivate *priv; GtkWidget *widget; cairo_text_extents_t extents; cairo_font_options_t *options; gdouble x, y; gchar *text; priv = LCD_GET_PRIVATE (lcd); widget = GTK_WIDGET (lcd); // Text erstellen text = construct_text (LCD (lcd)); // Farbe setzen cairo_set_source_rgb (cr, 0, 0, 0); // Font setzen //cairo_select_font_face (cr, "Mono", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); //cairo_select_font_face (cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); //cairo_select_font_face (cr, "Ubuntu-Title", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_select_font_face (cr, "Purisa", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, 24); cairo_text_extents (cr, text, &extents); // Font-Antialiasing ausschalten options = cairo_font_options_create (); //cairo_get_font_options (cr, options); if (!options) { g_message ("Font-Antialiasing ausschalten"); cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_NONE); cairo_set_font_options (cr, options); } // Nur sliden wenn Text grösser als Platz ist if (extents.width < widget->allocation.width - FRAME_ABSTAND) { // Text horizontal zentrieren priv->current_x = (widget->allocation.width / 2) - (extents.width / 2); } else if ((priv->current_x + extents.width) <= 0) { // falls Text zu Ende -> wieder hinten anfangen priv->current_x = widget->allocation.width; } x = priv->current_x; y = (widget->allocation.height / 2) + (extents.height / 2) - (extents.height + extents.y_bearing); //g_debug ("text position: x=%.1f y=%.1f", x, y); cairo_move_to (cr, x, y); cairo_show_text (cr, text); // Debug Rechteck zeichnen //cairo_set_line_width (cr, 1); //cairo_set_source_rgb (cr, 1, 0, 0); //cairo_rectangle (cr, x, y-extents.height, extents.width, extents.height); //cairo_stroke (cr); }
static PyObject * font_options_set_antialias (PycairoFontOptions *o, PyObject *args) { cairo_antialias_t aa = CAIRO_ANTIALIAS_DEFAULT; if (!PyArg_ParseTuple(args, "|i:FontOptions.set_antialias", &aa)) return NULL; cairo_font_options_set_antialias (o->font_options, aa); RETURN_NULL_IF_CAIRO_FONT_OPTIONS_ERROR(o->font_options); Py_RETURN_NONE; }
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; }
void setCairoFontOptionsFromFontConfigPattern(cairo_font_options_t* options, FcPattern* pattern) { FcBool booleanResult; int integerResult; // We will determine if subpixel anti-aliasing is enabled via the FC_RGBA setting. if (FcPatternGetBool(pattern, FC_ANTIALIAS, 0, &booleanResult) == FcResultMatch && booleanResult) cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); if (FcPatternGetInteger(pattern, FC_RGBA, 0, &integerResult) == FcResultMatch) { if (integerResult != FC_RGBA_NONE) cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_SUBPIXEL); cairo_font_options_set_subpixel_order(options, convertFontConfigSubpixelOrder(integerResult)); } if (FcPatternGetInteger(pattern, FC_HINT_STYLE, 0, &integerResult) == FcResultMatch) cairo_font_options_set_hint_style(options, convertFontConfigHintStyle(integerResult)); if (FcPatternGetBool(pattern, FC_HINTING, 0, &booleanResult) == FcResultMatch && !booleanResult) cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); }
void FontPlatformData::platformDataInit(HFONT font, float size, HDC hdc, WCHAR* faceName) { m_fontFace = cairo_win32_font_face_create_for_hfont(font); cairo_matrix_t sizeMatrix, ctm; cairo_matrix_init_identity(&ctm); cairo_matrix_init_scale(&sizeMatrix, size, size); static cairo_font_options_t* fontOptions = 0; if (!fontOptions) { fontOptions = cairo_font_options_create(); #if PLATFORM(APOLLO) // In Apollo use the anti-aliasing mode selected by the user. See bug 2404418. cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_DEFAULT); #else cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_SUBPIXEL); #endif } m_scaledFont = cairo_scaled_font_create(m_fontFace, &sizeMatrix, &ctm, fontOptions); }
/*! \brief handles configure events when the chart gets created or resized. Takes care of creating/destroying graphics contexts, backing pixmaps (two levels are used to split the rendering for speed reasons) colormaps are also created here as well \param widget (GtkWidget *) pointer to the chart object \param event (GdkEventConfigure *) pointer to GDK event datastructure that encodes important info like window dimensions and depth. */ gboolean mtx_stripchart_configure (GtkWidget *widget, GdkEventConfigure *event) { MtxStripChart * chart = MTX_STRIPCHART(widget); MtxStripChartPrivate *priv = MTX_STRIPCHART_GET_PRIVATE(chart); cairo_t *cr = NULL; priv->w = widget->allocation.width; priv->h = widget->allocation.height; /* Backing pixmap (copy of window) */ if (priv->bg_pixmap) g_object_unref(priv->bg_pixmap); priv->bg_pixmap=gdk_pixmap_new(widget->window, priv->w,priv->h, gtk_widget_get_visual(widget)->depth); cr = gdk_cairo_create(priv->bg_pixmap); cairo_set_operator(cr,CAIRO_OPERATOR_DEST_OUT); cairo_paint(cr); cairo_destroy(cr); /* Trace pixmap */ if (priv->trace_pixmap) g_object_unref(priv->trace_pixmap); priv->trace_pixmap=gdk_pixmap_new(widget->window, priv->w,priv->h, gtk_widget_get_visual(widget)->depth); cr = gdk_cairo_create(priv->trace_pixmap); cairo_set_operator(cr,CAIRO_OPERATOR_DEST_OUT); cairo_paint(cr); cairo_destroy(cr); /* Grat pixmap */ if (priv->grat_pixmap) g_object_unref(priv->grat_pixmap); priv->grat_pixmap=gdk_pixmap_new(widget->window, priv->w,priv->h, gtk_widget_get_visual(widget)->depth); cr = gdk_cairo_create(priv->grat_pixmap); cairo_set_operator(cr,CAIRO_OPERATOR_DEST_OUT); cairo_paint(cr); cairo_destroy(cr); gdk_window_set_back_pixmap(widget->window,priv->bg_pixmap,0); if (priv->font_options) cairo_font_options_destroy(priv->font_options); priv->font_options = cairo_font_options_create(); cairo_font_options_set_antialias(priv->font_options, CAIRO_ANTIALIAS_GRAY); generate_stripchart_static_traces(chart); render_marker (chart); return TRUE; }
drawContextFltkCairo::drawContextFltkCairo() { _surface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1); _queue = new queueString; _cr = cairo_create(_surface); cairo_font_options_t *fontOptions = cairo_font_options_create(); cairo_get_font_options(_cr, fontOptions); cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_FULL); cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_GRAY); cairo_set_font_options(_cr, fontOptions); cairo_font_options_destroy(fontOptions); _currentFontId = -1; }
static PyObject * font_options_set_antialias (PycairoFontOptions *o, PyObject *args) { cairo_antialias_t aa = CAIRO_ANTIALIAS_DEFAULT; if (!PyArg_ParseTuple(args, "|i:FontOptions.set_antialias", &aa)) return NULL; cairo_font_options_set_antialias (o->font_options, aa); if (Pycairo_Check_Status (cairo_font_options_status (o->font_options))) return NULL; Py_RETURN_NONE; }
ttext::ttext() : #if PANGO_VERSION_CHECK(1,22,0) context_(pango_font_map_create_context(pango_cairo_font_map_get_default())), #else context_(pango_cairo_font_map_create_context(( reinterpret_cast<PangoCairoFontMap*>(pango_cairo_font_map_get_default())))), #endif layout_(pango_layout_new(context_)), rect_(), surface_(), text_(), markedup_text_(false), link_aware_(false), link_color_(), font_class_(font::FONT_SANS_SERIF), font_size_(14), font_style_(STYLE_NORMAL), foreground_color_(0xFFFFFFFF), // solid white maximum_width_(-1), characters_per_line_(0), maximum_height_(-1), ellipse_mode_(PANGO_ELLIPSIZE_END), alignment_(PANGO_ALIGN_LEFT), maximum_length_(std::string::npos), calculation_dirty_(true), length_(0), surface_dirty_(true), surface_buffer_(nullptr) { // With 72 dpi the sizes are the same as with SDL_TTF so hardcoded. pango_cairo_context_set_resolution(context_, 72.0); pango_layout_set_ellipsize(layout_, ellipse_mode_); pango_layout_set_alignment(layout_, alignment_); pango_layout_set_wrap(layout_, PANGO_WRAP_WORD_CHAR); /* * Set the pango spacing a bit bigger since the default is deemed to small * http://www.wesnoth.org/forum/viewtopic.php?p=358832#p358832 */ pango_layout_set_spacing(layout_, 4 * PANGO_SCALE); cairo_font_options_t *fo = cairo_font_options_create(); cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL); cairo_font_options_set_hint_metrics(fo, CAIRO_HINT_METRICS_ON); cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_DEFAULT); pango_cairo_context_set_font_options(context_, fo); cairo_font_options_destroy(fo); }
static inline void _SetUpDrawingTools(const CNFORenderer* r, cairo_surface_t* a_surface, cairo_t** pcr, cairo_font_options_t** pcfo) { cairo_t* cr = cairo_create(a_surface); cairo_font_options_t *cfo = cairo_font_options_create(); cairo_font_options_set_antialias(cfo, (r->GetFontAntiAlias() ? CAIRO_ANTIALIAS_SUBPIXEL : CAIRO_ANTIALIAS_NONE)); cairo_font_options_set_hint_style(cfo, (r->IsClassicMode() ? CAIRO_HINT_STYLE_DEFAULT : CAIRO_HINT_STYLE_NONE)); cairo_font_options_set_hint_metrics(cfo, (r->IsClassicMode() ? CAIRO_HINT_METRICS_ON : CAIRO_HINT_METRICS_OFF)); const std::string l_font #ifdef _UNICODE = CUtil::FromWideStr(r->GetFontFace(), CP_UTF8); #else = r->GetFontFace();
void FontPlatformData::platformDataInit(HFONT font, float size, HDC hdc, WCHAR* faceName) { m_fontFace = cairo_win32_font_face_create_for_hfont(font); cairo_matrix_t sizeMatrix, ctm; cairo_matrix_init_identity(&ctm); cairo_matrix_init_scale(&sizeMatrix, size, size); static cairo_font_options_t* fontOptions = 0; if (!fontOptions) { fontOptions = cairo_font_options_create(); cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_SUBPIXEL); } m_scaledFont = cairo_scaled_font_create(m_fontFace, &sizeMatrix, &ctm, fontOptions); }
/*! \brief handles configure events whe nthe gauge gets created or resized. Takes care of creating/destroying graphics contexts, backing pixmaps (two levels are used to split the rendering for speed reasons) colormaps are also created here as well \param widget (GtkWidget *) pointer to the gauge object \param event (GdkEventConfigure *) pointer to GDK event datastructure that encodes important info like window dimensions and depth. */ gboolean mtx_pie_gauge_configure (GtkWidget *widget, GdkEventConfigure *event) { MtxPieGauge * gauge = MTX_PIE_GAUGE(widget); MtxPieGaugePrivate *priv = MTX_PIE_GAUGE_GET_PRIVATE(gauge); priv->w = widget->allocation.width; priv->h = widget->allocation.height; if (priv->gc) g_object_unref(priv->gc); /* Backing pixmap (copy of window) */ if (priv->pixmap) g_object_unref(priv->pixmap); priv->pixmap=gdk_pixmap_new(widget->window, priv->w,priv->h, gtk_widget_get_visual(widget)->depth); gdk_draw_rectangle(priv->pixmap, widget->style->black_gc, TRUE, 0,0, priv->w,priv->h); /* Static Background pixmap */ if (priv->bg_pixmap) g_object_unref(priv->bg_pixmap); priv->bg_pixmap=gdk_pixmap_new(widget->window, priv->w,priv->h, gtk_widget_get_visual(widget)->depth); gdk_draw_rectangle(priv->bg_pixmap, widget->style->black_gc, TRUE, 0,0, priv->w,priv->h); gdk_window_set_back_pixmap(widget->window,priv->pixmap,0); priv->gc = gdk_gc_new(priv->bg_pixmap); gdk_gc_set_colormap(priv->gc,priv->colormap); if (priv->font_options) cairo_font_options_destroy(priv->font_options); priv->font_options = cairo_font_options_create(); cairo_font_options_set_antialias(priv->font_options, CAIRO_ANTIALIAS_GRAY); generate_pie_gauge_background(gauge); update_pie_gauge_position(gauge); return TRUE; }
static int ui_set_antialias(lua_State *L) { struct context *c = lua_touserdata(L, 1); int enable = lua_toboolean(L, 2); cairo_antialias_t antialias = (enable) ? CAIRO_ANTIALIAS_DEFAULT : CAIRO_ANTIALIAS_NONE; cairo_set_antialias(c->cr, antialias); cairo_font_options_t *options; options = cairo_font_options_create(); cairo_font_options_set_antialias(options, antialias); cairo_set_font_options(c->cr, options); return 0; }
static void set_fontoptions(PangoContext *context, Antialiasing antialiasing, Hinting hinting) { cairo_font_options_t *opt; cairo_antialias_t aa; cairo_hint_style_t hs; switch (antialiasing) { case ANTIALIAS_NONE: aa = CAIRO_ANTIALIAS_NONE; break; case ANTIALIAS_GRAYSCALE: aa = CAIRO_ANTIALIAS_GRAY; break; case ANTIALIAS_RGBA: aa = CAIRO_ANTIALIAS_SUBPIXEL; break; default: aa = CAIRO_ANTIALIAS_DEFAULT; break; } switch (hinting) { case HINT_NONE: hs = CAIRO_HINT_STYLE_NONE; break; case HINT_SLIGHT: hs = CAIRO_HINT_STYLE_SLIGHT; break; case HINT_MEDIUM: hs = CAIRO_HINT_STYLE_MEDIUM; break; case HINT_FULL: hs = CAIRO_HINT_STYLE_FULL; break; default: hs = CAIRO_HINT_STYLE_DEFAULT; break; } opt = cairo_font_options_create (); cairo_font_options_set_antialias (opt, aa); cairo_font_options_set_hint_style (opt, hs); pango_cairo_context_set_font_options (context, opt); cairo_font_options_destroy (opt); }
cairo_scaled_font_t * gfxDWriteFont::CairoScaledFont() { if (!mCairoScaledFont) { cairo_matrix_t sizeMatrix; cairo_matrix_t identityMatrix; cairo_matrix_init_scale(&sizeMatrix, mAdjustedSize, mAdjustedSize); cairo_matrix_init_identity(&identityMatrix); cairo_font_options_t *fontOptions = cairo_font_options_create(); if (mNeedsOblique) { double skewfactor = OBLIQUE_SKEW_FACTOR; cairo_matrix_t style; cairo_matrix_init(&style, 1, //xx 0, //yx -1 * skewfactor, //xy 1, //yy 0, //x0 0); //y0 cairo_matrix_multiply(&sizeMatrix, &sizeMatrix, &style); } if (mAntialiasOption != kAntialiasDefault) { cairo_font_options_set_antialias(fontOptions, GetCairoAntialiasOption(mAntialiasOption)); } mCairoScaledFont = cairo_scaled_font_create(CairoFontFace(), &sizeMatrix, &identityMatrix, fontOptions); cairo_font_options_destroy(fontOptions); } NS_ASSERTION(mAdjustedSize == 0.0 || cairo_scaled_font_status(mCairoScaledFont) == CAIRO_STATUS_SUCCESS, "Failed to make scaled font"); return mCairoScaledFont; }
static double count_glyphs (double font_size, cairo_antialias_t antialias, cairo_t *cr, int width, int height) { const char text[] = "the jay, pig, fox, zebra and my wolves quack"; cairo_scaled_font_t *scaled_font; cairo_glyph_t *glyphs = NULL; cairo_text_extents_t extents; cairo_font_options_t *options; cairo_status_t status; int num_glyphs; int glyphs_per_line, lines_per_loop; options = cairo_font_options_create (); cairo_font_options_set_antialias (options, antialias); cairo_set_font_options (cr, options); cairo_font_options_destroy (options); cairo_select_font_face (cr, "@cairo:", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, font_size); scaled_font = cairo_get_scaled_font (cr); status = cairo_scaled_font_text_to_glyphs (scaled_font, 0., 0., text, -1, &glyphs, &num_glyphs, NULL, NULL, NULL); if (status) return 0; cairo_scaled_font_glyph_extents (scaled_font, glyphs, num_glyphs, &extents); cairo_glyph_free (glyphs); glyphs_per_line = num_glyphs * width / extents.width + 1; lines_per_loop = height / extents.height + 1; return glyphs_per_line * lines_per_loop / 1000.; /* kiloglyphs */ }
void FontPlatformData::platformDataInit(HFONT font, float size, HDC hdc, WCHAR* faceName) { cairo_font_face_t* fontFace = cairo_win32_font_face_create_for_hfont(font); cairo_matrix_t sizeMatrix, ctm; cairo_matrix_init_identity(&ctm); cairo_matrix_init_scale(&sizeMatrix, size, size); static cairo_font_options_t* fontOptions = nullptr; if (!fontOptions) { fontOptions = cairo_font_options_create(); cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_SUBPIXEL); } m_scaledFont = adoptRef(cairo_scaled_font_create(fontFace, &sizeMatrix, &ctm, fontOptions)); cairo_font_face_destroy(fontFace); if (!m_useGDI && m_size) m_isSystemFont = !wcscmp(faceName, L"Lucida Grande"); }
FontPlatformData::FontPlatformData(cairo_font_face_t* fontFace, float size, bool bold, bool italic) : m_context(0) , m_font(0) , m_size(size) , m_syntheticBold(bold) , m_syntheticOblique(italic) , m_scaledFont(0) { cairo_matrix_t fontMatrix; cairo_matrix_init_scale(&fontMatrix, size, size); cairo_matrix_t ctm; cairo_matrix_init_identity(&ctm); cairo_font_options_t* options = cairo_font_options_create(); // We force antialiasing and disable hinting to provide consistent // typographic qualities for custom fonts on all platforms. cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE); cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY); m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctm, options); cairo_font_options_destroy(options); }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_text_extents_t extents; cairo_font_options_t *font_options; const char black[] = "black", blue[] = "blue"; /* We draw in the default black, so paint white first. */ cairo_save (cr); cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */ cairo_paint (cr); cairo_restore (cr); cairo_select_font_face (cr, CAIRO_TEST_FONT_FAMILY " Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, TEXT_SIZE); font_options = cairo_font_options_create (); cairo_get_font_options (cr, font_options); cairo_font_options_set_antialias (font_options, CAIRO_ANTIALIAS_GRAY); cairo_set_font_options (cr, font_options); cairo_font_options_destroy (font_options); cairo_set_source_rgb (cr, 0, 0, 0); /* black */ cairo_text_extents (cr, black, &extents); cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing); cairo_show_text (cr, black); cairo_translate (cr, 0, -extents.y_bearing + 1); cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ cairo_text_extents (cr, blue, &extents); cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing); cairo_show_text (cr, blue); return CAIRO_TEST_SUCCESS; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_font_options_t *options; cairo_set_source_rgb (cr, 1, 1, 1); cairo_paint (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_set_antialias (cr, CAIRO_ANTIALIAS_NONE); cairo_select_font_face (cr, "@cairo:", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); options = cairo_font_options_create (); cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_NONE); cairo_set_font_options (cr, options); cairo_font_options_destroy (options); cairo_set_font_size (cr, 16); cairo_move_to (cr, 4, 14); cairo_show_text (cr, "Is cairo's twin giza?"); cairo_move_to (cr, 4, 34); cairo_text_path (cr, "Is cairo's twin giza?"); cairo_fill (cr); cairo_move_to (cr, 4, 54); cairo_text_path (cr, "Is cairo's twin giza?"); cairo_set_line_width (cr, 2/16.); cairo_stroke (cr); return CAIRO_TEST_SUCCESS; }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { cairo_text_extents_t extents; cairo_font_options_t *font_options; static char black[] = "black", blue[] = "blue"; cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); cairo_paint (cr); cairo_select_font_face (cr, "Bitstream Vera Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size (cr, TEXT_SIZE); font_options = cairo_font_options_create (); cairo_get_font_options (cr, font_options); cairo_font_options_set_antialias (font_options, CAIRO_ANTIALIAS_SUBPIXEL); cairo_font_options_set_subpixel_order (font_options, CAIRO_SUBPIXEL_ORDER_RGB); cairo_set_font_options (cr, font_options); cairo_font_options_destroy (font_options); cairo_set_source_rgb (cr, 0, 0, 0); /* black */ cairo_text_extents (cr, black, &extents); cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing); cairo_show_text (cr, black); cairo_translate (cr, 0, -extents.y_bearing + 1); cairo_set_source_rgb (cr, 0, 0, 1); /* blue */ cairo_text_extents (cr, blue, &extents); cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing); cairo_show_text (cr, blue); return CAIRO_TEST_SUCCESS; }
void GUIFont_GetGreaterSize(const char *AFontName, float AHeight, unsigned int *ACharWidth, unsigned int *ACharHeight) { cairo_text_extents_t *BExtents = (cairo_text_extents_t *)malloc(sizeof(cairo_text_extents_t)); unsigned char *BText = (unsigned char *)malloc(sizeof(unsigned char) * 2); BText[0] = 0; BText[1] = '\0'; cairo_surface_t *BSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1); cairo_t *BContext = cairo_create(BSurface); cairo_font_options_t *cfo = cairo_font_options_create(); cairo_font_options_set_antialias(cfo, CAIRO_ANTIALIAS_SUBPIXEL); cairo_set_font_options(BContext, cfo); cairo_select_font_face(BContext, AFontName, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_font_size(BContext, AHeight); for (BText[0] = 0; BText[0] < 255; BText[0]++) { cairo_text_extents(BContext, BText, BExtents); if (BExtents) { if (*ACharHeight < BExtents->height) { *ACharHeight = BExtents->height; }; if (*ACharWidth < BExtents->width) { *ACharWidth = BExtents->width; }; }; }; cairo_destroy(BContext); cairo_surface_destroy(BSurface); };