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);
}
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 struct font_engine_font_t *do_font_load(const char *name)
{
struct font_engine_font_t *fef = NULL;
PangoFontDescription *desc;
if( (name) && (desc = pango_font_description_from_string(name)) )
{
fef = calloc_2(1, sizeof(struct font_engine_font_t));
fef->desc = desc;
fef->font = pango_font_map_load_font( pango_cairo_font_map_get_default(), GLOBALS->fonts_context, fef->desc);
fef->metrics=pango_font_get_metrics(fef->font, NULL /*pango_language_get_default()*/ );
fef->ascent = pango_font_metrics_get_ascent(fef->metrics) / 1000;
fef->descent = pango_font_metrics_get_descent(fef->metrics) / 1000;
fef->is_pango = 1;
if(!strncmp(name, "Monospace", 9))
{
int i_width = font_engine_string_measure(fef, "i");
fef->mono_width = font_engine_string_measure(fef, "O");
fef->is_mono = (i_width == fef->mono_width);
}
}
return(fef);
}
gboolean
gtkutil_find_font (const char *fontname)
{
int i;
int n_families;
const char *family_name;
PangoFontMap *fontmap;
PangoFontFamily *family;
PangoFontFamily **families;
fontmap = pango_cairo_font_map_get_default ();
pango_font_map_list_families (fontmap, &families, &n_families);
for (i = 0; i < n_families; i++)
{
family = families[i];
family_name = pango_font_family_get_name (family);
if (!g_ascii_strcasecmp (family_name, fontname))
{
g_free (families);
return TRUE;
}
}
g_free (families);
return FALSE;
}
static void ListFontFamilies(PangoFontFamily*** families,
int* n_families) {
InitFontconfig();
PangoFontMap* font_map = pango_cairo_font_map_get_default();
DISABLE_HEAP_LEAK_CHECK;
pango_font_map_list_families(font_map, families, n_families);
}
int main(int argc, char **argv) {
PangoFontMap* map;
PangoFontFamily **families;
int n_families;
int i;
PangoFontFace **faces;
int n_faces;
int j;
gtk_init(&argc, &argv);
map = pango_cairo_font_map_get_default();
pango_font_map_list_families(map, &families, &n_families);
for (i = 0; i < n_families; i++) {
g_print("%s\n", pango_font_family_get_name(families[i]));
pango_font_family_list_faces(families[i], &faces, &n_faces);
for (j = 0; j < n_faces; j++) {
g_print(" %s\n", pango_font_face_get_face_name(faces[j]));
}
}
return 0;
}
void textbox_setup ( Display *display )
{
if ( config.color_enabled ) {
textbox_parse_string ( display, config.color_normal, &( colors[NORMAL] ) );
textbox_parse_string ( display, config.color_urgent, &( colors[URGENT] ) );
textbox_parse_string ( display, config.color_active, &( colors[ACTIVE] ) );
}
else {
parse_color ( display, config.menu_bg, &( colors[NORMAL].bg ) );
parse_color ( display, config.menu_fg, &( colors[NORMAL].fg ) );
parse_color ( display, config.menu_bg_alt, &( colors[NORMAL].bgalt ) );
parse_color ( display, config.menu_hlfg, &( colors[NORMAL].hlfg ) );
parse_color ( display, config.menu_hlbg, &( colors[NORMAL].hlbg ) );
parse_color ( display, config.menu_bg_urgent, &( colors[URGENT].bg ) );
parse_color ( display, config.menu_fg_urgent, &( colors[URGENT].fg ) );
parse_color ( display, config.menu_bg_alt, &( colors[URGENT].bgalt ) );
parse_color ( display, config.menu_hlfg_urgent, &( colors[URGENT].hlfg ) );
parse_color ( display, config.menu_hlbg_urgent, &( colors[URGENT].hlbg ) );
parse_color ( display, config.menu_bg_active, &( colors[ACTIVE].bg ) );
parse_color ( display, config.menu_fg_active, &( colors[ACTIVE].fg ) );
parse_color ( display, config.menu_bg_alt, &( colors[ACTIVE].bgalt ) );
parse_color ( display, config.menu_hlfg_active, &( colors[ACTIVE].hlfg ) );
parse_color ( display, config.menu_hlbg_active, &( colors[ACTIVE].hlbg ) );
}
PangoFontMap *font_map = pango_cairo_font_map_get_default ();
if ( config.dpi > 0 ) {
pango_cairo_font_map_set_resolution ( (PangoCairoFontMap *) font_map, (double) config.dpi );
}
p_context = pango_font_map_create_context ( font_map );
}
PangoFontMap* pangoFontMap()
{
if (!g_fontMap)
g_fontMap = pango_cairo_font_map_get_default();
return g_fontMap;
}
bool FontPlatformData::init()
{
static bool initialized = false;
if (initialized)
return true;
initialized = true;
if (!m_fontMap)
m_fontMap = pango_cairo_font_map_get_default();
if (!m_hashTable) {
PangoFontFamily** families = 0;
int n_families = 0;
m_hashTable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref);
pango_font_map_list_families(m_fontMap, &families, &n_families);
for (int family = 0; family < n_families; family++)
g_hash_table_insert(m_hashTable,
g_strdup(pango_font_family_get_name(families[family])),
g_object_ref(families[family]));
g_free(families);
}
return true;
}
/*----------------------------------------------------------------------------------------------
Get Font Ascent and Descent in one go more efficent that making two calls.
----------------------------------------------------------------------------------------------*/
bool VwGraphicsCairo::FontAscentAndDescent(int * ascent, int * descent)
{
// cache the PangoFont and PangoFontMetricsfont to the m_pangoFontDescription
if (m_ascent == -1 && m_descent == -1)
{
if (m_fontMapForFontContext == NULL)
m_fontMapForFontContext = pango_cairo_font_map_get_default();
if (m_fontContext == NULL)
m_fontContext = pango_font_map_create_context (m_fontMapForFontContext);
PangoFont * font = pango_context_load_font(m_fontContext, m_pangoFontDescription);
// TODO-Linux: should we specify a language - for the font?
PangoFontMetrics * metrics = pango_font_get_metrics (font, NULL);
m_ascent = pango_font_metrics_get_ascent (metrics) / PANGO_SCALE;
m_descent = pango_font_metrics_get_descent (metrics) / PANGO_SCALE;
pango_font_metrics_unref(metrics);
g_object_unref(font);
}
if (ascent != NULL)
*ascent = m_ascent;
if (descent != NULL)
*descent = m_descent;
return true;
}
PangoLayout * VwGraphicsCairo::GetPangoLayoutHelper()
{
if (m_fontMap == NULL)
m_fontMap = pango_cairo_font_map_get_default();
if (m_context == NULL)
{ m_context = pango_context_new();
pango_context_set_font_map(m_context, m_fontMap);
}
if (m_layout == NULL)
{
m_layout = pango_layout_new(m_context);
PangoAttrList* list = pango_attr_list_new();
PangoAttribute * fallbackAttrib = pango_attr_fallback_new(true);
pango_attr_list_insert(list, fallbackAttrib);
pango_layout_set_attributes(m_layout, list);
pango_attr_list_unref(list);
pango_layout_set_single_paragraph_mode(m_layout, true);
}
return m_layout;
}
PangoFontMap* GetFontMap()
{
static PangoFontMap* map = NULL;
if (map == NULL)
map = pango_cairo_font_map_get_default();
return map;
}
// We should create the layout with our actual context but we can't access it from here.
static PangoLayout* getDefaultPangoLayout(const TextRun& run)
{
static PangoFontMap* map = pango_cairo_font_map_get_default();
static PangoContext* pangoContext = pango_cairo_font_map_create_context(PANGO_CAIRO_FONT_MAP(map));
PangoLayout* layout = pango_layout_new(pangoContext);
return layout;
}
/**
* _init:
* @fo_doc_cairo: #FoDocCairo object to initialise.
*
* Implements #GInstanceInitFunc for #FoDocCairo.
**/
static void
_init (FoDocCairo *fo_doc_cairo)
{
PangoFontMap *font_map = pango_cairo_font_map_get_default ();
pango_cairo_font_map_set_resolution ((PangoCairoFontMap*) font_map, 72);
FO_DOC (fo_doc_cairo)->pango_context =
pango_cairo_font_map_create_context ((PangoCairoFontMap*) font_map);
}
/* subfunction of gtk_plot_cairo_draw_string(). */
static gint
drawstring(GtkPlotPC *pc,
gint angle,
gint dx, gint dy,
GtkPSFont *psfont, gint height,
const gchar *text)
{
cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
PangoLayout *layout = GTK_PLOT_CAIRO(pc)->layout;
PangoFontDescription *font;
PangoRectangle rect;
PangoFontMap *map;
gint ret_value;
gint dpi_cairo, dpi_screen;
GdkScreen *screen = gdk_screen_get_default();
if(!text || strlen(text) == 0) return 0;
cairo_save(cairo);
map = pango_cairo_font_map_get_default();
dpi_cairo = pango_cairo_font_map_get_resolution(PANGO_CAIRO_FONT_MAP(map));
dpi_screen = gdk_screen_get_resolution(screen);
height *= (double)dpi_screen/(double)dpi_cairo;
font = gtk_psfont_get_font_description(psfont, height);
pango_layout_set_font_description(GTK_PLOT_CAIRO(pc)->layout, font);
pango_layout_set_text(GTK_PLOT_CAIRO(pc)->layout, text, strlen(text));
pango_layout_get_extents(GTK_PLOT_CAIRO(pc)->layout, NULL, &rect);
if (psfont->i18n_latinfamily && psfont->vertical) {
/* vertical-writing CJK postscript fonts. */
return rect.height;
}
else
{
/* horizontal writing */
if(angle == 90)
// cairo_translate(cairo, dx, dy-PANGO_PIXELS(rect.width));
cairo_translate(cairo, dx, dy);
else if(angle == 270)
cairo_translate(cairo, dx+PANGO_PIXELS(rect.height), dy);
else if(angle == 180)
cairo_translate(cairo, dx-PANGO_PIXELS(rect.width), dy);
else
cairo_translate(cairo, dx, dy);
}
cairo_rotate(cairo, -angle * G_PI / 180);
pango_cairo_update_layout(cairo, layout);
pango_cairo_show_layout(cairo, layout);
cairo_restore(cairo);
pango_font_description_free(font);
ret_value = (angle == 0 || angle == 180) ? rect.width : rect.height;
return PANGO_PIXELS(rect.width);
}
static PyObject *
pango_GetFontMap(PyObject *self, PyObject *args) {
PangoFontMap *fm;
PangoContext *ctx;
PangoFontFamily **families;
PangoFontFace **faces;
PyObject *family;
int n_families, n_faces, i, j;
int *sizes, n_sizes;
PyObject *faces_tuple;
PyObject *ret;
fm = pango_cairo_font_map_get_default();
ctx = pango_font_map_create_context(fm);
pango_context_list_families(ctx, &families, &n_families);
ret = PyTuple_New(n_families);
for (i = 0; i < n_families; i++) {
family = PyTuple_New(2);
PyTuple_SetItem(family, 0,
Py_BuildValue("s", pango_font_family_get_name(families[i])));
pango_font_family_list_faces(families[i], &faces, &n_faces);
pango_font_face_list_sizes(faces[0], &sizes, &n_sizes);
if (!sizes) {
faces_tuple = PyTuple_New(n_faces);
for (j = 0; j < n_faces; j++) {
PyTuple_SetItem(faces_tuple, j,
Py_BuildValue("s",
pango_font_face_get_face_name(faces[j])));
}
PyTuple_SetItem(family, 1, faces_tuple);
} else {
Py_INCREF(Py_None);
PyTuple_SetItem(family, 1, Py_None);
}
PyTuple_SetItem(ret, i, family);
g_free(sizes);
g_free(faces);
}
g_free(families);
g_object_unref(ctx);
return ret;
}
static void
joy_theme_init(JoyTheme *self)
{
self->priv = ASSIGN_PRIVATE(self);
struct Private *priv = GET_PRIVATE(self);
priv->styles = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, destroy);
PangoFontMap *map = pango_cairo_font_map_get_default();
if (G_LIKELY(map)) {
priv->context = pango_font_map_create_context(map);
}
}
// We should create the layout with our actual context but we can't access it from here.
static PangoLayout* getDefaultPangoLayout(const TextRun& run)
{
static PangoFontMap* map = pango_cairo_font_map_get_default();
#if PANGO_VERSION_CHECK(1, 21, 5)
static PangoContext* pangoContext = pango_font_map_create_context(map);
#else
// Deprecated in Pango 1.21.
static PangoContext* pangoContext = pango_cairo_font_map_create_context(PANGO_CAIRO_FONT_MAP(map));
#endif
PangoLayout* layout = pango_layout_new(pangoContext);
return layout;
}
// Returns the PangoFont structure corresponding to the closest available font
// in the font map. Note that if the font is wholly missing, this could
// correspond to a completely different font family and face.
PangoFont* PangoFontInfo::ToPangoFont() const {
InitFontconfig();
PangoFontMap* font_map = pango_cairo_font_map_get_default();
PangoContext* context = pango_context_new();
pango_cairo_context_set_resolution(context, resolution_);
pango_context_set_font_map(context, font_map);
PangoFont* font = NULL;
{
DISABLE_HEAP_LEAK_CHECK;
font = pango_font_map_load_font(font_map, context, desc_);
}
g_object_unref(context);
return font;
}
/* Create/get a pango context
*
* On windows we use the win32 context creator, on everything else we
* use the cairo one.
*/
PangoContext *
splitter_create_pango_context(void) {
#ifdef _WIN32
return pango_win32_get_context();
#else
PangoContext *context = NULL;
PangoFontMap *fontmap = pango_cairo_font_map_get_default();
context =
pango_cairo_font_map_create_context(PANGO_CAIRO_FONT_MAP(fontmap));
g_object_unref(G_OBJECT(fontmap));
return context;
#endif
}
static void
gtk_font_button_font_chooser_set_font_map (GtkFontChooser *chooser,
PangoFontMap *font_map)
{
GtkFontButton *font_button = GTK_FONT_BUTTON (chooser);
if (g_set_object (&font_button->priv->font_map, font_map))
{
PangoContext *context;
if (!font_map)
font_map = pango_cairo_font_map_get_default ();
context = gtk_widget_get_pango_context (font_button->priv->font_label);
pango_context_set_font_map (context, font_map);
}
}
StringList Font::familiesAvailable()
{
PangoFontMap* map = pango_cairo_font_map_get_default();
PangoFontFamily** families;
int count;
pango_font_map_list_families(map, &families, &count);
StringList result;
for(int i = 0; i < count; ++i) {
PangoFontFamily* family = families[i];
result.push_back(pango_font_family_get_name(family));
}
free(families);
return result;
}
int
main (int argc, char *argv[])
{
GDir *dir;
GError *error = NULL;
const gchar *name;
gchar *path;
g_setenv ("LC_ALL", "C", TRUE);
setlocale (LC_ALL, "");
g_test_init (&argc, &argv, NULL);
context = pango_font_map_create_context (pango_cairo_font_map_get_default ());
/* allow to easily generate expected output for new test cases */
if (argc > 1)
{
GString *string;
string = g_string_sized_new (0);
test_file (argv[1], string);
g_print ("%s", string->str);
return 0;
}
path = g_test_build_filename (G_TEST_DIST, "layouts", NULL);
dir = g_dir_open (path, 0, &error);
g_free (path);
g_assert_no_error (error);
while ((name = g_dir_read_name (dir)) != NULL)
{
if (!strstr (name, "markup"))
continue;
path = g_strdup_printf ("/layout/%s", name);
g_test_add_data_func_full (path, g_test_build_filename (G_TEST_DIST, "layouts", name, NULL),
test_layout, g_free);
g_free (path);
}
g_dir_close (dir);
return g_test_run ();
}
/* static */
bool FontUtils::IsAvailableFont(const char* input_query_desc) {
string query_desc(input_query_desc);
if (PANGO_VERSION <= 12005) {
// Strip commas and any ' Medium' substring in the name.
query_desc.erase(std::remove(query_desc.begin(), query_desc.end(), ','),
query_desc.end());
const string kMediumStr = " Medium";
std::size_t found = query_desc.find(kMediumStr);
if (found != std::string::npos) {
query_desc.erase(found, kMediumStr.length());
}
}
PangoFontDescription *desc = pango_font_description_from_string(
query_desc.c_str());
PangoFont* selected_font = NULL;
{
InitFontconfig();
PangoFontMap* font_map = pango_cairo_font_map_get_default();
PangoContext* context = pango_context_new();
pango_context_set_font_map(context, font_map);
{
DISABLE_HEAP_LEAK_CHECK;
selected_font = pango_font_map_load_font(font_map, context, desc);
}
g_object_unref(context);
}
PangoFontDescription* selected_desc = pango_font_describe(selected_font);
bool equal = pango_font_description_equal(desc, selected_desc);
tlog(3, "query weight = %d \t selected weight =%d\n",
pango_font_description_get_weight(desc),
pango_font_description_get_weight(selected_desc));
char* selected_desc_str = pango_font_description_to_string(selected_desc);
tlog(2, "query_desc: '%s' Selected: 's'\n", query_desc.c_str(),
selected_desc_str);
g_free(selected_desc_str);
pango_font_description_free(selected_desc);
pango_font_description_free(desc);
return equal;
}
static void
lsm_dom_view_init (LsmDomView *view)
{
PangoFontMap *font_map;
PangoContext *pango_context;
cairo_font_options_t *font_options;
view->resolution_ppi = LSM_DOM_VIEW_DEFAULT_RESOLUTION;
view->viewport_pt.x = 0;
view->viewport_pt.y = 0;
view->viewport_pt.width = LSM_DOM_VIEW_DEFAULT_VIEWBOX_WIDTH;
view->viewport_pt.height = LSM_DOM_VIEW_DEFAULT_VIEWBOX_HEIGHT;
view->font_description = pango_font_description_new ();
font_map = pango_cairo_font_map_get_default ();
#if PANGO_VERSION_CHECK(1,22,0)
pango_context = pango_font_map_create_context (font_map);
#else
pango_context = pango_cairo_font_map_create_context (PANGO_CAIRO_FONT_MAP (font_map));
#endif
pango_cairo_context_set_resolution (pango_context, 72.0);
view->measure_pango_layout = pango_layout_new (pango_context);
font_options = cairo_font_options_create ();
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE);
pango_cairo_context_set_font_options (pango_context, font_options);
cairo_font_options_destroy (font_options);
g_object_unref (pango_context);
view->pango_layout = NULL;
view->cairo = NULL;
view->is_vector = FALSE;
}
/**
* gdk_pango_context_get_for_screen:
* @screen: the #GdkScreen for which the context is to be created.
*
* Creates a #PangoContext for @screen.
*
* The context must be freed when you're finished with it.
*
* When using GTK+, normally you should use gtk_widget_get_pango_context()
* instead of this function, to get the appropriate context for
* the widget you intend to render text onto.
*
* The newly created context will have the default font options
* (see #cairo_font_options_t) for the screen; if these options
* change it will not be updated. Using gtk_widget_get_pango_context()
* is more convenient if you want to keep a context around and track
* changes to the screen's font rendering settings.
*
* Return value: (transfer full): a new #PangoContext for @screen
*
* Since: 2.2
**/
PangoContext *
gdk_pango_context_get_for_screen (GdkScreen *screen)
{
PangoFontMap *fontmap;
PangoContext *context;
const cairo_font_options_t *options;
double dpi;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
fontmap = pango_cairo_font_map_get_default ();
context = pango_font_map_create_context (fontmap);
options = gdk_screen_get_font_options (screen);
pango_cairo_context_set_font_options (context, options);
dpi = gdk_screen_get_resolution (screen);
pango_cairo_context_set_resolution (context, dpi);
return context;
}
static void
hippo_canvas_context_win_init(HippoCanvasContextWin *canvas_win)
{
PangoFontDescription *desc;
canvas_win->pointer = HIPPO_CANVAS_POINTER_UNSET;
/* canvas_win->pango = pango_win32_get_context(); */
PangoCairoFontMap *font_map = (PangoCairoFontMap*) pango_cairo_font_map_get_default();
canvas_win->pango = pango_cairo_font_map_create_context(font_map);
g_object_unref((void*) font_map);
desc = pango_font_description_new();
// Sans is resolved in the pango.aliases we install; since the first element
// is already "Arial", we specify just Sans here, rather than the "Arial,sans-serif"
// we use in site.css.
pango_font_description_set_family_static(desc, "Sans");
pango_font_description_set_absolute_size(desc, 12 * PANGO_SCALE);
// FIXME on my laptop (Visual Studio 2005) this has crashed Pango with a g_error(),
// but it seems to have mysteriously gone away.
pango_context_set_font_description(canvas_win->pango, desc);
pango_font_description_free(desc);
}
static void
hippo_canvas_context_win_init(HippoCanvasContextWin *canvas_win)
{
PangoFontDescription *desc;
canvas_win->pointer = HIPPO_CANVAS_POINTER_UNSET;
/* canvas_win->pango = pango_win32_get_context(); */
PangoCairoFontMap *font_map = (PangoCairoFontMap*) pango_cairo_font_map_get_default();
canvas_win->pango = pango_cairo_font_map_create_context(font_map);
g_object_unref((void*) font_map);
desc = pango_font_description_new();
// Note that this matches the web font in our site.css
// We only set Arial instead of Arial, sans-serif because
// pango cairo doesn't like a font list here.
pango_font_description_set_family_static(desc, "Arial");
pango_font_description_set_absolute_size(desc, 12 * PANGO_SCALE);
// FIXME on my laptop (Visual Studio 2005) this has crashed Pango with a g_error(),
// but it seems to have mysteriously gone away.
pango_context_set_font_description(canvas_win->pango, desc);
pango_font_description_free(desc);
}
int main(int argc, const char* argv[])
{
size_t tex_side =(argc>1)? std::atoi(argv[1]) : 512;
const char* font_desc_str = (argc>2)? argv[2] : "Sans 18";
unsigned plane = (argc>3)? std::atoi(argv[3]) : 0;
cairo_surface_t *surface = cairo_image_surface_create(
CAIRO_FORMAT_A8,
tex_side,
tex_side
);
cairo_t *cr = cairo_create(surface);
PangoFontDescription *font_desc = pango_font_description_from_string(
font_desc_str
);
PangoFontMap* font_map = pango_cairo_font_map_get_default();
PangoContext* context = pango_font_map_create_context(font_map);
PangoFont* font = pango_font_map_load_font(
font_map,
context,
font_desc
);
PangoFontMetrics* font_metrics = pango_font_get_metrics(font, nullptr);
// The Bitmap Glyph Metrics file
std::ofstream bgm((argc>5) ? argv[5] : "out.bgm");
unsigned step = tex_side / 16;
for(unsigned y=0; y!=16; ++y)
{
for(unsigned x=0; x!=16; ++x)
{
render_glyph(
cr,
font_desc,
font,
256*plane + y*16 + x,
x, y,
step,
tex_side,
pango_font_metrics_get_ascent(font_metrics),
pango_font_metrics_get_descent(font_metrics),
bgm
);
}
}
bgm.close();
pango_font_metrics_unref(font_metrics);
pango_font_description_free(font_desc);
g_object_unref(context);
cairo_destroy(cr);
cairo_status_t status = cairo_surface_write_to_png(
surface,
(argc>4) ? argv[4] : "out.png"
);
cairo_surface_destroy(surface);
return 0;
}
GtkWidget *setupLCD(GtkWidget *parent, int rows, int cols, char *font){
int i;
int width;
int wid, hgt;
#ifdef GTK_VER_1_1
static GtkTargetEntry targetlist[] = {
/* Target Flags Info */
{ "STRING", 0, TARGET_STRING },
{ "TEXT", 0, TARGET_TEXT },
{ "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
#endif
/* store arguments */
lcdWidth = cols;
lcdHeight = rows;
#ifdef USE_PANGO
lcdDA = gtk_drawing_area_new();
pango_layout = gtk_widget_create_pango_layout(lcdDA, NULL);
pango_desc = pango_font_description_from_string(font?font:"Liberation Mono 16");
pango_fontmap = pango_cairo_font_map_get_default();
pango_context = pango_cairo_font_map_create_context( (PangoCairoFontMap *)pango_fontmap );
pango_font = pango_context_load_font(pango_context, pango_desc);
pango_metrics =
pango_context_get_metrics(pango_context, pango_desc, pango_language_get_default());
fontW = (pango_font_metrics_get_approximate_digit_width(pango_metrics))/PANGO_SCALE;
fontH = (pango_font_metrics_get_ascent(pango_metrics) + pango_font_metrics_get_descent(pango_metrics))/PANGO_SCALE;
fontD = pango_font_metrics_get_descent(pango_metrics)/PANGO_SCALE;
gtk_widget_modify_font(lcdDA, pango_desc);
#else
fontW = 0;
fontH = 0;
fontD = 0;
/* get a font for the main window */
if(font != NULL){
if(NULL == (lcdFont = gdk_font_load(font))){
fprintf(stderr, "Unable to load font %s.\n", font);
exit(0);
}
} else if(NULL == (lcdFont = gdk_font_load(FONT1)) &&
NULL == (lcdFont = gdk_font_load(FONT2)) &&
NULL == (lcdFont = gdk_font_load(FONT3)) &&
NULL == (lcdFont = gdk_font_load(FONT4)) &&
NULL == (lcdFont = gdk_font_load(FONT5)) &&
NULL == (lcdFont = gdk_font_load(FONT6))){
fprintf(stderr, "Unable to load a font.\n");
exit(0);
}
/* find max font width */
for(i=0; i<256; i++){
width = gdk_char_width(lcdFont, (gchar)i);
if(width < 50 && width > fontW) fontW = width;
}
/* globals we use all over the place */
fontH = lcdFont->ascent + lcdFont->descent;
fontD = lcdFont->descent;
#endif
if(fontW == 0 || fontH == 0){
fprintf(stderr, "Error: can not determine font dimentions.\n");
exit(0);
}
wid = (2 * BORDER) + (lcdWidth * fontW);
hgt = (2 * BORDER) + (lcdHeight * fontH);
#ifndef USE_PANGO
lcdDA = gtk_drawing_area_new();
#endif
gtk_drawing_area_size(GTK_DRAWING_AREA(lcdDA), wid, hgt);
gtk_box_pack_start(GTK_BOX(parent), lcdDA, TRUE, TRUE, 0);
/* Signals used to handle window ops */
gtk_signal_connect(GTK_OBJECT(lcdDA), "expose_event",
(GtkSignalFunc)lcdExposeCB, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA),"configure_event",
(GtkSignalFunc)lcdResizeCB, NULL);
/* Event signals (Selection) */
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_received",
(GtkSignalFunc)lcdPasteCB, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_clear_event",
(GtkSignalFunc)loseSelection, NULL);
/*
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_request_event",
(GtkSignalFunc)convertSelection, NULL);
*/
#ifdef GTK_VER_1_1
gtk_selection_add_targets(lcdDA,
GDK_SELECTION_PRIMARY, targetlist, ntargets);
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_get",
(GtkSignalFunc)convertSelection, NULL);
#else
gtk_selection_add_handler(lcdDA, GDK_SELECTION_PRIMARY,
GDK_SELECTION_TYPE_STRING, convertSelection, NULL);
#endif
/* Event signals (Input) */
gtk_signal_connect(GTK_OBJECT(lcdDA), "motion_notify_event",
(GtkSignalFunc)lcdMotionEvnt, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA), "button_press_event",
(GtkSignalFunc)lcdButtonPressEvnt, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA), "button_release_event",
(GtkSignalFunc)lcdButtonReleaseEvnt, NULL);
gtk_signal_connect_after(GTK_OBJECT(lcdDA), "key_press_event",
(GtkSignalFunc)lcdKeyPressEvnt, NULL);
gtk_signal_connect_after(GTK_OBJECT(lcdDA), "key_release_event",
(GtkSignalFunc)lcdKeyReleaseEvnt, NULL);
gtk_widget_set_events(lcdDA,
GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
GTK_WIDGET_SET_FLAGS(lcdDA, GTK_CAN_FOCUS);
gtk_widget_show(lcdDA);
gtk_widget_grab_focus(lcdDA);
return lcdDA;
}
