FontPlatformData& FontPlatformData::operator=(const FontPlatformData& other)
{
// Check for self-assignment.
if (this == &other)
return *this;
m_size = other.m_size;
m_syntheticBold = other.m_syntheticBold;
m_syntheticOblique = other.m_syntheticOblique;
m_fixedWidth = other.m_fixedWidth;
m_pattern = other.m_pattern;
m_orientation = other.m_orientation;
m_horizontalOrientationMatrix = other.m_horizontalOrientationMatrix;
if (m_fallbacks) {
FcFontSetDestroy(m_fallbacks);
// This will be re-created on demand.
m_fallbacks = 0;
}
if (m_scaledFont && m_scaledFont != hashTableDeletedFontValue())
cairo_scaled_font_destroy(m_scaledFont);
m_scaledFont = cairo_scaled_font_reference(other.m_scaledFont);
m_harfBuzzFace = other.m_harfBuzzFace;
return *this;
}
static int l_font_new(lua_State * L)
{
const char * family = luaL_checkstring(L, 1);
struct lfont_t * font = lua_newuserdata(L, sizeof(struct lfont_t));
if(FT_Init_FreeType(&font->library))
return 0;
if(FT_New_Xfs_Face(font->library, family, 0, &font->fface))
{
FT_Done_FreeType(font->library);
return 0;
}
font->face = cairo_ft_font_face_create_for_ft_face(font->fface, 0);
if(font->face->status != CAIRO_STATUS_SUCCESS)
{
FT_Done_Face(font->fface);
FT_Done_FreeType(font->library);
cairo_font_face_destroy(font->face);
return 0;
}
cairo_font_options_t * options = cairo_font_options_create();
cairo_matrix_t identity;
cairo_matrix_init_identity(&identity);
font->sfont = cairo_scaled_font_create(font->face, &identity, &identity, options);
cairo_font_options_destroy(options);
if(cairo_scaled_font_status(font->sfont) != CAIRO_STATUS_SUCCESS)
{
FT_Done_Face(font->fface);
FT_Done_FreeType(font->library);
cairo_font_face_destroy(font->face);
cairo_scaled_font_destroy(font->sfont);
return 0;
}
luaL_setmetatable(L, MT_FONT);
return 1;
}
void FontPlatformData::setOrientation(FontOrientation orientation)
{
ASSERT(m_scaledFont);
if (!m_scaledFont || (m_orientation == orientation))
return;
cairo_matrix_t transformationMatrix;
cairo_matrix_init_identity(&transformationMatrix);
cairo_matrix_t fontMatrix;
cairo_scaled_font_get_font_matrix(m_scaledFont, &fontMatrix);
cairo_font_options_t* options = getDefaultFontOptions();
// In case of vertical orientation, rotate the transformation matrix.
// Otherwise restore the horizontal orientation matrix.
if (orientation == Vertical)
rotateCairoMatrixForVerticalOrientation(&fontMatrix);
else
fontMatrix = m_horizontalOrientationMatrix;
cairo_font_face_t* fontFace = cairo_scaled_font_get_font_face(m_scaledFont);
cairo_scaled_font_destroy(m_scaledFont);
m_scaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &transformationMatrix, options);
cairo_font_options_destroy(options);
m_orientation = orientation;
}
static PyObject *
scaled_font_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PycairoFontFace *ff;
PycairoFontOptions *fo;
PycairoMatrix *mx1, *mx2;
if (!PyArg_ParseTuple(args, "O!O!O!O!:ScaledFont.__new__",
&PycairoFontFace_Type, &ff,
&PycairoMatrix_Type, &mx1,
&PycairoMatrix_Type, &mx2,
&PycairoFontOptions_Type, &fo))
return NULL;
PyObject *o = type->tp_alloc(type, 0);
if (o != NULL) {
cairo_scaled_font_t *scaled_font = cairo_scaled_font_create
(ff->font_face, &mx1->matrix, &mx2->matrix, fo->font_options);
if (Pycairo_Check_Status (cairo_scaled_font_status (scaled_font))) {
cairo_scaled_font_destroy (scaled_font);
Py_DECREF(o);
return NULL;
}
((PycairoScaledFont *)o)->scaled_font = scaled_font;
}
return o;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_font_face_t *font_face;
cairo_font_options_t *font_options;
cairo_scaled_font_t *scaled_font;
cairo_matrix_t identity;
cairo_matrix_t zero;
cairo_matrix_init_identity(&identity);
zero = identity;
cairo_matrix_scale(&zero, 0, 0);
font_face = cairo_get_font_face (cr);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
scaled_font = cairo_scaled_font_create (font_face,
&identity,
&zero,
font_options);
cairo_set_scaled_font (cr, scaled_font);
cairo_show_text (cr, "Hello");
cairo_scaled_font_destroy (scaled_font);
cairo_font_options_destroy (font_options);
return cairo_test_status_from_status (cairo_test_get_context (cr),
cairo_status(cr));
}
FontPlatformData& FontPlatformData::operator=(const FontPlatformData& other)
{
// Check for self-assignment.
if (this == &other)
return *this;
m_font = other.m_font;
m_size = other.m_size;
m_syntheticBold = other.m_syntheticBold;
m_syntheticOblique = other.m_syntheticOblique;
m_useGDI = other.m_useGDI;
if (other.m_fontFace)
cairo_font_face_reference(other.m_fontFace);
if (m_fontFace)
cairo_font_face_destroy(m_fontFace);
m_fontFace = other.m_fontFace;
if (other.m_scaledFont)
cairo_scaled_font_reference(other.m_scaledFont);
if (m_scaledFont)
cairo_scaled_font_destroy(m_scaledFont);
m_scaledFont = other.m_scaledFont;
return *this;
}
FontPlatformData& FontPlatformData::operator=(const FontPlatformData& other)
{
// Check for self-assignment.
if (this == &other)
return *this;
m_size = other.m_size;
m_syntheticBold = other.m_syntheticBold;
m_syntheticOblique = other.m_syntheticOblique;
if (other.m_scaledFont)
cairo_scaled_font_reference(other.m_scaledFont);
if (m_scaledFont)
cairo_scaled_font_destroy(m_scaledFont);
m_scaledFont = other.m_scaledFont;
if (other.m_font)
g_object_ref(other.m_font);
if (m_font)
g_object_unref(m_font);
m_font = other.m_font;
if (other.m_context)
g_object_ref(other.m_context);
if (m_context)
g_object_unref(m_context);
m_context = other.m_context;
return *this;
}
static cairo_status_t
_cairo_meta_surface_finish (void *abstract_surface)
{
cairo_meta_surface_t *meta = abstract_surface;
cairo_command_t *command;
cairo_command_t **elements;
int i, num_elements;
num_elements = meta->commands.num_elements;
elements = (cairo_command_t **) meta->commands.elements;
for (i = 0; i < num_elements; i++) {
command = elements[i];
switch (command->type) {
case CAIRO_COMMAND_COMPOSITE:
_cairo_pattern_fini (&command->composite.src_pattern.base);
if (command->composite.mask_pattern_pointer)
_cairo_pattern_fini (command->composite.mask_pattern_pointer);
free (command);
break;
case CAIRO_COMMAND_FILL_RECTANGLES:
free (command->fill_rectangles.rects);
free (command);
break;
case CAIRO_COMMAND_COMPOSITE_TRAPEZOIDS:
_cairo_pattern_fini (&command->composite_trapezoids.pattern.base);
free (command->composite_trapezoids.traps);
free (command);
break;
case CAIRO_COMMAND_INTERSECT_CLIP_PATH:
if (command->intersect_clip_path.path_pointer)
_cairo_path_fixed_fini (&command->intersect_clip_path.path);
free (command);
break;
case CAIRO_COMMAND_SHOW_GLYPHS:
cairo_scaled_font_destroy (command->show_glyphs.scaled_font);
_cairo_pattern_fini (&command->show_glyphs.pattern.base);
free (command->show_glyphs.glyphs);
free (command);
break;
case CAIRO_COMMAND_FILL_PATH:
_cairo_pattern_fini (&command->fill_path.pattern.base);
_cairo_path_fixed_fini (&command->fill_path.path);
free (command);
break;
default:
ASSERT_NOT_REACHED;
}
}
_cairo_array_fini (&meta->commands);
return CAIRO_STATUS_SUCCESS;
}
~font_fc() override {
if (m_scaled != nullptr) {
cairo_scaled_font_destroy(m_scaled);
}
if (m_pattern != nullptr) {
FcPatternDestroy(m_pattern);
}
}
static void
scaled_font_dealloc(PycairoScaledFont *o) {
if (o->scaled_font) {
cairo_scaled_font_destroy (o->scaled_font);
o->scaled_font = NULL;
}
o->ob_type->tp_free((PyObject *) o);
}
static int m_font_gc(lua_State * L)
{
struct lfont_t * font = luaL_checkudata(L, 1, MT_FONT);
FT_Done_Face(font->fface);
FT_Done_FreeType(font->library);
cairo_font_face_destroy(font->face);
cairo_scaled_font_destroy(font->sfont);
return 0;
}
ScaledFontBase::~ScaledFontBase()
{
#ifdef USE_SKIA
SkSafeUnref(mTypeface);
#endif
#ifdef USE_CAIRO_SCALED_FONT
cairo_scaled_font_destroy(mScaledFont);
#endif
}
gfxDWriteFont::~gfxDWriteFont()
{
if (mCairoFontFace) {
cairo_font_face_destroy(mCairoFontFace);
}
if (mCairoScaledFont) {
cairo_scaled_font_destroy(mCairoScaledFont);
}
}
/* PycairoScaledFont_FromScaledFont
* Create a new PycairoScaledFont from a cairo_scaled_font_t
* scaled_font - a cairo_scaled_font_t to 'wrap' into a Python object.
* it is unreferenced if the PycairoScaledFont creation fails
* Return value: New reference or NULL on failure
*/
PyObject *
PycairoScaledFont_FromScaledFont (cairo_scaled_font_t *scaled_font) {
PyObject *o;
assert (scaled_font != NULL);
if (Pycairo_Check_Status (cairo_scaled_font_status (scaled_font))) {
cairo_scaled_font_destroy (scaled_font);
return NULL;
}
o = PycairoScaledFont_Type.tp_alloc (&PycairoScaledFont_Type, 0);
if (o == NULL)
cairo_scaled_font_destroy (scaled_font);
else
((PycairoScaledFont *)o)->scaled_font = scaled_font;
return o;
}
void SimpleFontData::platformDestroy()
{
cairo_font_face_destroy(m_font.fontFace());
cairo_scaled_font_destroy(m_font.scaledFont());
DeleteObject(m_font.hfont());
platformCommonDestroy();
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_text_extents_t extents;
cairo_scaled_font_t *scaled_font;
cairo_status_t status;
const char text[] = "i-W";
double line_width, x, y;
line_width = cairo_get_line_width (cr);
/* 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);
status = create_scaled_font (cr, &scaled_font);
if (status) {
return cairo_test_status_from_status (cairo_test_get_context (cr),
status);
}
cairo_set_scaled_font (cr, scaled_font);
cairo_scaled_font_destroy (scaled_font);
cairo_set_line_width (cr, 1.0);
cairo_set_source_rgb (cr, 0, 0, 0); /* black */
cairo_text_extents (cr, text, &extents);
x = width - (extents.width + extents.x_bearing) - 5;
y = height - (extents.height + extents.y_bearing) - 5;
cairo_move_to (cr, x, y);
cairo_show_text (cr, text);
cairo_rectangle (cr,
x + extents.x_bearing - line_width / 2,
y + extents.y_bearing - line_width / 2,
extents.width + line_width,
extents.height + line_width);
cairo_stroke (cr);
cairo_set_source_rgb (cr, 0, 0, 1); /* blue */
cairo_text_extents (cr, text, &extents);
x = -extents.x_bearing + 5;
y = -extents.y_bearing + 5;
cairo_move_to (cr, x, y);
cairo_text_path (cr, text);
cairo_fill (cr);
cairo_rectangle (cr,
x + extents.x_bearing - line_width / 2,
y + extents.y_bearing - line_width / 2,
extents.width + line_width,
extents.height + line_width);
cairo_stroke (cr);
return CAIRO_TEST_SUCCESS;
}
FontPlatformData::~FontPlatformData()
{
if (m_fallbacks) {
FcFontSetDestroy(m_fallbacks);
m_fallbacks = 0;
}
if (m_scaledFont && m_scaledFont != hashTableDeletedFontValue())
cairo_scaled_font_destroy(m_scaledFont);
}
static void
_cairo_sub_font_destroy (cairo_sub_font_t *sub_font)
{
_cairo_hash_table_foreach (sub_font->sub_font_glyphs,
_cairo_sub_font_glyph_pluck,
sub_font->sub_font_glyphs);
_cairo_hash_table_destroy (sub_font->sub_font_glyphs);
cairo_scaled_font_destroy (sub_font->scaled_font);
free (sub_font);
}
static cairo_status_t
_cairo_recording_surface_finish (void *abstract_surface)
{
cairo_recording_surface_t *recording_surface = abstract_surface;
cairo_command_t **elements;
int i, num_elements;
num_elements = recording_surface->commands.num_elements;
elements = _cairo_array_index (&recording_surface->commands, 0);
for (i = 0; i < num_elements; i++) {
cairo_command_t *command = elements[i];
switch (command->header.type) {
case CAIRO_COMMAND_PAINT:
_cairo_pattern_fini (&command->paint.source.base);
break;
case CAIRO_COMMAND_MASK:
_cairo_pattern_fini (&command->mask.source.base);
_cairo_pattern_fini (&command->mask.mask.base);
break;
case CAIRO_COMMAND_STROKE:
_cairo_pattern_fini (&command->stroke.source.base);
_cairo_path_fixed_fini (&command->stroke.path);
_cairo_stroke_style_fini (&command->stroke.style);
break;
case CAIRO_COMMAND_FILL:
_cairo_pattern_fini (&command->fill.source.base);
_cairo_path_fixed_fini (&command->fill.path);
break;
case CAIRO_COMMAND_SHOW_TEXT_GLYPHS:
_cairo_pattern_fini (&command->show_text_glyphs.source.base);
free (command->show_text_glyphs.utf8);
free (command->show_text_glyphs.glyphs);
free (command->show_text_glyphs.clusters);
cairo_scaled_font_destroy (command->show_text_glyphs.scaled_font);
break;
default:
ASSERT_NOT_REACHED;
}
_cairo_clip_fini (&command->header.clip);
free (command);
}
_cairo_array_fini (&recording_surface->commands);
_cairo_clip_fini (&recording_surface->clip);
return CAIRO_STATUS_SUCCESS;
}
FontPlatformData::~FontPlatformData()
{
#if !PLATFORM(JS)
if (m_fallbacks) {
FcFontSetDestroy(m_fallbacks);
m_fallbacks = 0;
}
#endif
if (m_scaledFont && m_scaledFont != hashTableDeletedFontValue())
cairo_scaled_font_destroy(m_scaledFont);
}
const FontPlatformData& FontPlatformData::platformDataAssign(const FontPlatformData& other)
{
m_font = other.m_font;
m_useGDI = other.m_useGDI;
if (m_scaledFont && m_scaledFont != hashTableDeletedFontValue())
cairo_scaled_font_destroy(m_scaledFont);
m_scaledFont = cairo_scaled_font_reference(other.m_scaledFont);
return *this;
}
gfxGDIFont::~gfxGDIFont()
{
if (mScaledFont) {
cairo_scaled_font_destroy(mScaledFont);
}
if (mFontFace) {
cairo_font_face_destroy(mFontFace);
}
if (mFont) {
::DeleteObject(mFont);
}
delete mMetrics;
}
static void
text_layout_destroy(struct text_layout *layout)
{
if (layout->glyphs)
cairo_glyph_free(layout->glyphs);
if (layout->clusters)
cairo_text_cluster_free(layout->clusters);
cairo_scaled_font_destroy(layout->font);
free(layout);
}
void
ScaledFontBase::SetCairoScaledFont(cairo_scaled_font_t* font)
{
MOZ_ASSERT(!mScaledFont);
if (font == mScaledFont)
return;
if (mScaledFont)
cairo_scaled_font_destroy(mScaledFont);
mScaledFont = font;
cairo_scaled_font_reference(mScaledFont);
}
static void
scaled_font_dealloc(PycairoScaledFont *o)
{
#ifdef DEBUG
printf("scaled_font_dealloc start\n");
#endif
if (o->scaled_font) {
cairo_scaled_font_destroy (o->scaled_font);
o->scaled_font = NULL;
}
o->ob_type->tp_free((PyObject *) o);
#ifdef DEBUG
printf("scaled_font_dealloc end\n");
#endif
}
FontPlatformData::~FontPlatformData()
{
if (m_font && m_font != reinterpret_cast<PangoFont*>(-1)) {
g_object_unref(m_font);
m_font = 0;
}
if (m_context) {
g_object_unref(m_context);
m_context = 0;
}
if (m_scaledFont) {
cairo_scaled_font_destroy(m_scaledFont);
m_scaledFont = 0;
}
}
static void
pango_cairo_win32_font_finalize (GObject *object)
{
PangoCairoWin32Font *cwfont = PANGO_CAIRO_WIN32_FONT (object);
g_hash_table_destroy (cwfont->glyph_info);
g_slist_foreach (cwfont->metrics_by_lang, (GFunc)free_metrics_info, NULL);
g_slist_free (cwfont->metrics_by_lang);
if (cwfont->scaled_font)
cairo_scaled_font_destroy (cwfont->scaled_font);
if (cwfont->options)
cairo_font_options_destroy (cwfont->options);
G_OBJECT_CLASS (pango_cairo_win32_font_parent_class)->finalize (object);
}
gfxOS2Font::~gfxOS2Font()
{
#ifdef DEBUG_thebes_2
printf("gfxOS2Font[%#x]::~gfxOS2Font()\n", (unsigned)this);
#endif
if (mFontFace) {
cairo_font_face_destroy(mFontFace);
}
if (mScaledFont) {
cairo_scaled_font_destroy(mScaledFont);
}
if (mMetrics) {
delete mMetrics;
}
mFontFace = nsnull;
mScaledFont = nsnull;
mMetrics = nsnull;
}
static cairo_status_t
_cairo_toy_font_face_scaled_font_create (void *abstract_font_face,
const cairo_matrix_t *font_matrix,
const cairo_matrix_t *ctm,
const cairo_font_options_t *options,
cairo_scaled_font_t **scaled_font)
{
cairo_toy_font_face_t *font_face = abstract_font_face;
cairo_status_t status;
if (font_face->base.status)
return font_face->base.status;
status = cairo_font_options_status ((cairo_font_options_t *) options);
if (status)
return status;
if (CAIRO_SCALED_FONT_BACKEND_DEFAULT != &_cairo_user_scaled_font_backend)
{
const cairo_scaled_font_backend_t * backend = CAIRO_SCALED_FONT_BACKEND_DEFAULT;
*scaled_font = NULL;
status = backend->create_toy (font_face,
font_matrix,
ctm,
options,
scaled_font);
if (status != CAIRO_INT_STATUS_UNSUPPORTED)
return _cairo_font_face_set_error (&font_face->base, status);
if (*scaled_font)
cairo_scaled_font_destroy (*scaled_font);
}
status = _cairo_user_scaled_font_backend.create_toy (font_face,
font_matrix,
ctm,
options,
scaled_font);
return _cairo_font_face_set_error (&font_face->base, status);
}
void
_pango_cairo_font_private_finalize (PangoCairoFontPrivate *cf_priv)
{
_pango_cairo_font_private_scaled_font_data_destroy (cf_priv->data);
if (cf_priv->scaled_font)
cairo_scaled_font_destroy (cf_priv->scaled_font);
cf_priv->scaled_font = NULL;
_pango_cairo_font_hex_box_info_destroy (cf_priv->hbi);
cf_priv->hbi = NULL;
if (cf_priv->glyph_extents_cache)
g_free (cf_priv->glyph_extents_cache);
cf_priv->glyph_extents_cache = NULL;
g_slist_foreach (cf_priv->metrics_by_lang, (GFunc)free_metrics_info, NULL);
g_slist_free (cf_priv->metrics_by_lang);
cf_priv->metrics_by_lang = NULL;
}
