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);
};
