static gint
matewnck_selector_get_width (GtkWidget *widget, const char *text)
{
GtkStyle *style;
PangoContext *context;
PangoFontMetrics *metrics;
gint char_width;
PangoLayout *layout;
PangoRectangle natural;
gint max_width;
gint screen_width;
gint width;
gtk_widget_ensure_style (widget);
style = gtk_widget_get_style (widget);
context = gtk_widget_get_pango_context (widget);
metrics = pango_context_get_metrics (context, style->font_desc,
pango_context_get_language (context));
char_width = pango_font_metrics_get_approximate_char_width (metrics);
pango_font_metrics_unref (metrics);
max_width = PANGO_PIXELS (SELECTOR_MAX_WIDTH * char_width);
layout = gtk_widget_create_pango_layout (widget, text);
pango_layout_get_pixel_extents (layout, NULL, &natural);
g_object_unref (G_OBJECT (layout));
screen_width = gdk_screen_get_width (gtk_widget_get_screen (widget));
width = MIN (natural.width, max_width);
width = MIN (width, 3 * (screen_width / 4));
return width;
}
double textbox_get_estimated_char_width ( void )
{
if ( char_width < 0 ) {
int width = pango_font_metrics_get_approximate_char_width ( p_metrics );
char_width = ( width ) / (double) PANGO_SCALE;
}
return char_width;
}
void
show_text(GtkWidget *window, const char *text)
{
GtkWidget *dialog, *content_area, *view, *sw;
GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
dialog = gtk_dialog_new_with_buttons(PACKAGE_NAME " Help",
GTK_WINDOW(window),
flags,
"_Close",
GTK_RESPONSE_CANCEL,
NULL);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add_with_properties(GTK_CONTAINER(content_area), sw,
"expand", TRUE,
"fill", TRUE,
NULL);
view = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD);
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)),
text, -1);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(view), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(view), FALSE);
/* Use font metrics to set the size of the text view. */
PangoContext *context = gtk_widget_get_pango_context(view);
PangoFontMetrics *metrics = pango_context_get_metrics(context, NULL, NULL);
gint char_width = pango_font_metrics_get_approximate_char_width(metrics);
gint ascent = pango_font_metrics_get_ascent(metrics);
gint descent = pango_font_metrics_get_descent(metrics);
gint height = PANGO_PIXELS(ascent + descent);
gint width = PANGO_PIXELS(char_width);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(view), 2 * width);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(view), 2 * width);
gtk_window_set_default_size(GTK_WINDOW(dialog), 70 * width, 20 * height);
gtk_container_add(GTK_CONTAINER(sw), view);
gtk_widget_show_all(dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static void
e_contact_print_letter_heading (EContactPrintContext *ctxt,
gchar *letter)
{
PangoLayout *layout;
PangoFontDescription *desc;
PangoFontMetrics *metrics;
gint width, height;
cairo_t *cr;
desc = ctxt->letter_heading_font;
layout = gtk_print_context_create_pango_layout (ctxt->context);
/* Make the rectangle thrice the average character width.
* XXX Works well for English, what about other locales? */
metrics = pango_context_get_metrics (
pango_layout_get_context (layout),
desc, pango_language_get_default ());
width = pango_font_metrics_get_approximate_char_width (metrics) * 3;
pango_font_metrics_unref (metrics);
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
pango_layout_set_font_description (layout, desc);
pango_layout_set_text (layout, letter, -1);
pango_layout_set_width (layout, width);
pango_layout_get_size (layout, NULL, &height);
if (ctxt->page_nr == -1 || ctxt->pages != ctxt->page_nr) {
/* only calculating number of pages
* or on page we do not want to print */
ctxt->y += pango_units_to_double (height);
return;
}
/* Draw white text centered in a black rectangle. */
cr = gtk_print_context_get_cairo_context (ctxt->context);
cairo_save (cr);
cairo_set_source_rgb (cr, .0, .0, .0);
cairo_rectangle (
cr, ctxt->x, ctxt->y,
pango_units_to_double (width),
pango_units_to_double (height));
cairo_fill (cr);
cairo_restore (cr);
cairo_save (cr);
cairo_move_to (cr, ctxt->x, ctxt->y);
cairo_set_source_rgb (cr, 1., 1., 1.);
pango_cairo_show_layout (cr, layout);
cairo_restore (cr);
ctxt->y += pango_units_to_double (height);
}
double textbox_get_estimated_char_width ( void )
{
PangoFontDescription *pfd = pango_font_description_from_string ( config.menu_font );
// Get width
PangoFontMetrics *metric = pango_context_get_metrics ( p_context, pfd, NULL );
int width = pango_font_metrics_get_approximate_char_width ( metric );
pango_font_metrics_unref ( metric );
pango_font_description_free ( pfd );
return ( width ) / (double) PANGO_SCALE;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkFontPeer_getFontMetrics
(JNIEnv *env, jobject java_font, jdoubleArray java_metrics)
{
struct peerfont *pfont = NULL;
jdouble *native_metrics = NULL;
PangoFontMetrics *pango_metrics;
gdk_threads_enter();
pfont = (struct peerfont *) NSA_GET_FONT_PTR (env, java_font);
g_assert (pfont != NULL);
pango_metrics
= pango_context_get_metrics (pfont->ctx, pfont->desc,
gtk_get_default_language ());
native_metrics
= (*env)->GetDoubleArrayElements (env, java_metrics, NULL);
g_assert (native_metrics != NULL);
native_metrics[FONT_METRICS_ASCENT]
= PANGO_PIXELS (pango_font_metrics_get_ascent (pango_metrics));
native_metrics[FONT_METRICS_MAX_ASCENT]
= native_metrics[FONT_METRICS_ASCENT];
native_metrics[FONT_METRICS_DESCENT]
= PANGO_PIXELS (pango_font_metrics_get_descent (pango_metrics));
if (native_metrics[FONT_METRICS_DESCENT] < 0)
native_metrics[FONT_METRICS_DESCENT]
= - native_metrics[FONT_METRICS_DESCENT];
native_metrics[FONT_METRICS_MAX_DESCENT]
= native_metrics[FONT_METRICS_DESCENT];
native_metrics[FONT_METRICS_MAX_ADVANCE]
= PANGO_PIXELS (pango_font_metrics_get_approximate_char_width
(pango_metrics));
(*env)->ReleaseDoubleArrayElements (env,
java_metrics,
native_metrics, 0);
pango_font_metrics_unref (pango_metrics);
gdk_threads_leave();
}
static void
dma_data_view_data_size_request (DmaDataView *view,
GtkRequisition *requisition)
{
PangoFontMetrics *metrics;
PangoContext *context;
context = gtk_widget_get_pango_context (view->data);
metrics = pango_context_get_metrics (context,
gtk_widget_get_style (view->data)->font_desc,
pango_context_get_language (context));
requisition->height = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
pango_font_metrics_get_descent (metrics));
requisition->width = (pango_font_metrics_get_approximate_char_width (metrics) + PANGO_SCALE - 1) / PANGO_SCALE;
pango_font_metrics_unref (metrics);
}
static int sg_font_width(PangoFontDescription *font)
{
/* returns size in pixels */
int wid = 0;
double dpi = 96.0; /* see below */
PangoContext *ctx;
PangoFontMetrics *m;
#if HAVE_GTK_LINK_BUTTON_NEW
dpi = gdk_screen_get_resolution(gdk_display_get_default_screen(gdk_display_get_default())); /* pixels/inch */
#endif
ctx = gdk_pango_context_get();
m = pango_context_get_metrics(ctx, font, gtk_get_default_language()); /* returns size in pango-scaled points (1024/72 inch) */
wid = (int)((dpi / 72.0) * PANGO_PIXELS(pango_font_metrics_get_approximate_char_width(m)));
pango_font_metrics_unref(m);
g_object_unref(ctx);
return(wid);
}
static void cdgetfontdim(cdCtxCanvas *ctxcanvas, int *max_width, int *height, int *ascent, int *descent)
{
PangoFontMetrics* metrics;
int charwidth, charheight, charascent, chardescent;
if(!ctxcanvas->fontdesc)
return;
metrics = pango_context_get_metrics(ctxcanvas->fontcontext, ctxcanvas->fontdesc, pango_context_get_language(ctxcanvas->fontcontext));
charascent = pango_font_metrics_get_ascent(metrics);
chardescent = pango_font_metrics_get_descent(metrics);
charheight = charascent + chardescent;
charwidth = pango_font_metrics_get_approximate_char_width(metrics);
if (max_width) *max_width = (((charwidth) + PANGO_SCALE/2) / PANGO_SCALE);
if (height) *height = (((charheight) + PANGO_SCALE/2) / PANGO_SCALE);
if (ascent) *ascent = (((charascent) + PANGO_SCALE/2) / PANGO_SCALE);
if (descent) *descent = (((chardescent) + PANGO_SCALE/2) / PANGO_SCALE);
pango_font_metrics_unref(metrics);
}
static void
get_widget_char_size (GtkWidget *widget, gint *width, gint *height)
{
PangoFontMetrics *metrics;
PangoContext *context;
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string ("Monospace 10");
context = gtk_widget_get_pango_context (widget);
metrics = pango_context_get_metrics (context,
/*widget->style->font_desc,*/
font_desc,
pango_context_get_language (context));
*height = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
pango_font_metrics_get_descent (metrics));
*width = (pango_font_metrics_get_approximate_char_width (metrics) + PANGO_SCALE - 1) / PANGO_SCALE;
pango_font_metrics_unref (metrics);
pango_font_description_free (font_desc);
}
static gint
wnck_selector_get_width (GtkWidget *widget, const char *text)
{
GtkStyleContext *style_context;
GtkStateFlags state;
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *description;
gint char_width;
PangoLayout *layout;
PangoRectangle natural;
gint max_width;
gint screen_width;
gint width;
state = gtk_widget_get_state_flags (widget);
style_context = gtk_widget_get_style_context (widget);
gtk_style_context_get (style_context, state, GTK_STYLE_PROPERTY_FONT, &description, NULL);
context = gtk_widget_get_pango_context (widget);
metrics = pango_context_get_metrics (context, description,
pango_context_get_language (context));
char_width = pango_font_metrics_get_approximate_char_width (metrics);
pango_font_metrics_unref (metrics);
max_width = PANGO_PIXELS (SELECTOR_MAX_WIDTH * char_width);
layout = gtk_widget_create_pango_layout (widget, text);
pango_layout_get_pixel_extents (layout, NULL, &natural);
g_object_unref (G_OBJECT (layout));
screen_width = gdk_screen_get_width (gtk_widget_get_screen (widget));
width = MIN (natural.width, max_width);
width = MIN (width, 3 * (screen_width / 4));
return width;
}
static gint
gimp_tag_popup_layout_tags (GimpTagPopup *popup,
gint width)
{
PangoFontMetrics *font_metrics;
gint x;
gint y;
gint height = 0;
gint i;
gint line_height;
gint space_width;
x = GIMP_TAG_POPUP_MARGIN;
y = GIMP_TAG_POPUP_MARGIN;
font_metrics = pango_context_get_metrics (popup->context,
pango_context_get_font_description (popup->context),
NULL);
line_height = PANGO_PIXELS ((pango_font_metrics_get_ascent (font_metrics) +
pango_font_metrics_get_descent (font_metrics)));
space_width = PANGO_PIXELS (pango_font_metrics_get_approximate_char_width (font_metrics));
pango_font_metrics_unref (font_metrics);
for (i = 0; i < popup->tag_count; i++)
{
PopupTagData *tag_data = &popup->tag_data[i];
gint w, h;
pango_layout_set_text (popup->layout,
gimp_tag_get_name (tag_data->tag), -1);
pango_layout_get_pixel_size (popup->layout, &w, &h);
tag_data->bounds.width = w + 2 * GIMP_TAG_POPUP_PADDING;
tag_data->bounds.height = h + 2 * GIMP_TAG_POPUP_PADDING;
if (x + space_width + tag_data->bounds.width +
GIMP_TAG_POPUP_MARGIN - 1 > width)
{
x = GIMP_TAG_POPUP_MARGIN;
y += line_height + 2 * GIMP_TAG_POPUP_PADDING + GIMP_TAG_POPUP_LINE_SPACING;
}
tag_data->bounds.x = x;
tag_data->bounds.y = y;
x += tag_data->bounds.width + space_width;
}
if (gtk_widget_get_direction (GTK_WIDGET (popup)) == GTK_TEXT_DIR_RTL)
{
for (i = 0; i < popup->tag_count; i++)
{
PopupTagData *tag_data = &popup->tag_data[i];
tag_data->bounds.x = (width -
tag_data->bounds.x -
tag_data->bounds.width);
}
}
height = y + line_height + GIMP_TAG_POPUP_MARGIN;
return height;
}
void ttext::recalculate(const bool force) const
{
if(calculation_dirty_ || force) {
assert(layout_);
calculation_dirty_ = false;
surface_dirty_ = true;
tfont font(get_font_families(font_class_), font_size_, font_style_);
pango_layout_set_font_description(layout_, font.get());
if(font_style_ & ttext::STYLE_UNDERLINE) {
PangoAttrList *attribute_list = pango_attr_list_new();
pango_attr_list_insert(attribute_list
, pango_attr_underline_new(PANGO_UNDERLINE_SINGLE));
pango_layout_set_attributes (layout_, attribute_list);
pango_attr_list_unref(attribute_list);
}
int maximum_width = 0;
if(characters_per_line_ != 0) {
PangoFont* f = pango_font_map_load_font(
pango_cairo_font_map_get_default()
, context_
, font.get());
PangoFontMetrics* m = pango_font_get_metrics(f, nullptr);
int w = pango_font_metrics_get_approximate_char_width(m);
w *= characters_per_line_;
maximum_width = ceil(pango_units_to_double(w));
} else {
maximum_width = maximum_width_;
}
if(maximum_width_ != -1) {
maximum_width = std::min(maximum_width, maximum_width_);
}
/*
* See set_maximum_width for some more background info as well.
* In order to fix the problem first set a width which seems to render
* correctly then lower it to fit. For the campaigns the 4 does "the
* right thing" for the terrain labels it should use the value 0 to set
* the ellipse properly. Need to see whether this is a bug in pango or
* a bug in my understanding of the pango api.
*/
int hack = 4;
do {
pango_layout_set_width(layout_, maximum_width == -1
? -1
: (maximum_width + hack) * PANGO_SCALE);
pango_layout_get_pixel_extents(layout_, nullptr, &rect_);
DBG_GUI_L << "ttext::" << __func__
<< " text '" << gui2::debug_truncate(text_)
<< "' maximum_width " << maximum_width
<< " hack " << hack
<< " width " << rect_.x + rect_.width
<< ".\n";
--hack;
} while(maximum_width != -1
&& hack >= 0 && rect_.x + rect_.width > maximum_width);
DBG_GUI_L << "ttext::" << __func__
<< " text '" << gui2::debug_truncate(text_)
<< "' font_size " << font_size_
<< " markedup_text " << markedup_text_
<< " font_style " << std::hex << font_style_ << std::dec
<< " maximum_width " << maximum_width
<< " maximum_height " << maximum_height_
<< " result " << rect_
<< ".\n";
if(maximum_width != -1 && rect_.x + rect_.width > maximum_width) {
DBG_GUI_L << "ttext::" << __func__
<< " text '" << gui2::debug_truncate(text_)
<< " ' width " << rect_.x + rect_.width
<< " greater as the wanted maximum of " << maximum_width
<< ".\n";
}
}
}
static void
thunar_text_renderer_set_widget (ThunarTextRenderer *text_renderer,
GtkWidget *widget)
{
PangoFontMetrics *metrics;
PangoContext *context;
gint focus_padding;
gint focus_line_width;
if (G_LIKELY (widget == text_renderer->widget))
return;
/* disconnect from the previously set widget */
if (G_UNLIKELY (text_renderer->widget != NULL))
{
g_signal_handlers_disconnect_by_func (G_OBJECT (text_renderer->widget), thunar_text_renderer_invalidate, text_renderer);
g_object_unref (G_OBJECT (text_renderer->layout));
g_object_unref (G_OBJECT (text_renderer->widget));
}
/* activate the new widget */
text_renderer->widget = widget;
/* connect to the new widget */
if (G_LIKELY (widget != NULL))
{
/* take a reference on the widget */
g_object_ref (G_OBJECT (widget));
/* we need to recalculate the metrics when a new style (and thereby a new font) is set */
g_signal_connect_swapped (G_OBJECT (text_renderer->widget), "destroy", G_CALLBACK (thunar_text_renderer_invalidate), text_renderer);
g_signal_connect_swapped (G_OBJECT (text_renderer->widget), "style-set", G_CALLBACK (thunar_text_renderer_invalidate), text_renderer);
/* allocate a new pango layout for this widget */
context = gtk_widget_get_pango_context (widget);
text_renderer->layout = pango_layout_new (context);
/* disable automatic text direction, but use the direction specified by Gtk+ */
pango_layout_set_auto_dir (text_renderer->layout, FALSE);
/* we don't want to interpret line separators in file names */
pango_layout_set_single_paragraph_mode (text_renderer->layout, TRUE);
/* calculate the average character dimensions */
metrics = pango_context_get_metrics (context, widget->style->font_desc, pango_context_get_language (context));
text_renderer->char_width = PANGO_PIXELS (pango_font_metrics_get_approximate_char_width (metrics));
text_renderer->char_height = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent (metrics));
pango_font_metrics_unref (metrics);
/* tell the cell renderer about the fixed height if we're not wrapping text */
if (G_LIKELY (text_renderer->wrap_width < 0))
gtk_cell_renderer_set_fixed_size (GTK_CELL_RENDERER (text_renderer), -1, text_renderer->char_height);
/* determine the focus-padding and focus-line-width style properties from the widget */
gtk_widget_style_get (widget, "focus-padding", &focus_padding, "focus-line-width", &focus_line_width, NULL);
text_renderer->focus_width = focus_padding + focus_line_width;
}
else
{
text_renderer->layout = NULL;
text_renderer->char_width = 0;
text_renderer->char_height = 0;
}
}
static void
gd_two_lines_renderer_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
gint *minimum_size,
gint *natural_size)
{
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *font_desc;
GtkStyleContext *style_context;
gint nat_width, min_width;
gint xpad, char_width, wrap_width, text_width;
gint width_chars, ellipsize_chars;
g_object_get (cell,
"xpad", &xpad,
"width-chars", &width_chars,
"wrap-width", &wrap_width,
NULL);
style_context = gtk_widget_get_style_context (widget);
gtk_cell_renderer_get_padding (cell, &xpad, NULL);
gd_two_lines_renderer_get_size (cell, widget,
NULL, NULL,
&text_width, NULL,
NULL,
NULL, NULL, NULL);
/* Fetch the average size of a character */
context = gtk_widget_get_pango_context (widget);
gtk_style_context_save (style_context);
gtk_style_context_set_state (style_context, 0);
gtk_style_context_get (style_context, gtk_style_context_get_state (style_context),
"font", &font_desc, NULL);
gtk_style_context_restore (style_context);
metrics = pango_context_get_metrics (context, font_desc,
pango_context_get_language (context));
char_width = pango_font_metrics_get_approximate_char_width (metrics);
pango_font_metrics_unref (metrics);
pango_font_description_free (font_desc);
/* enforce minimum width for ellipsized labels at ~3 chars */
ellipsize_chars = 3;
/* If no width-chars set, minimum for wrapping text will be the wrap-width */
if (wrap_width > -1)
min_width = xpad * 2 + MIN (text_width, wrap_width);
else
min_width = xpad * 2 +
MIN (text_width,
(PANGO_PIXELS (char_width) * MAX (width_chars, ellipsize_chars)));
if (width_chars > 0)
nat_width = xpad * 2 +
MAX ((PANGO_PIXELS (char_width) * width_chars), text_width);
else
nat_width = xpad * 2 + text_width;
nat_width = MAX (nat_width, min_width);
if (minimum_size)
*minimum_size = min_width;
if (natural_size)
*natural_size = nat_width;
}
static IgtkFont* gtkFindFont(const char *standardfont)
{
PangoFontMetrics* metrics;
PangoFontDescription* fontdesc;
int i,
is_underline = 0,
is_strikeout = 0,
count = iupArrayCount(gtk_fonts);
IgtkFont* fonts = (IgtkFont*)iupArrayGetData(gtk_fonts);
/* Check if the standardfont already exists in cache */
for (i = 0; i < count; i++)
{
if (iupStrEqualNoCase(standardfont, fonts[i].standardfont))
return &fonts[i];
}
/* not found, create a new one */
{
int size = 0, is_pango = 0;
int is_bold = 0,
is_italic = 0;
char typeface[1024];
const char* mapped_name;
/* parse the old Windows format first */
if (!iupFontParseWin(standardfont, typeface, &size, &is_bold, &is_italic, &is_underline, &is_strikeout))
{
if (!iupFontParseX(standardfont, typeface, &size, &is_bold, &is_italic, &is_underline, &is_strikeout))
{
if (!iupFontParsePango(standardfont, typeface, &size, &is_bold, &is_italic, &is_underline, &is_strikeout))
return NULL;
else
is_pango = 1;
}
}
mapped_name = iupFontGetPangoName(typeface);
if (mapped_name)
strcpy(typeface, mapped_name);
if (is_pango && !is_underline && !is_strikeout && size>0)
fontdesc = pango_font_description_from_string(standardfont);
else
{
char new_standardfont[200];
if (size<0)
{
double res = ((double)gdk_screen_get_width(gdk_screen_get_default()) / (double)gdk_screen_get_width_mm(gdk_screen_get_default())); /* pixels/mm */
/* 1 point = 1/72 inch 1 inch = 25.4 mm */
/* pixel = ((point/72)*25.4)*pixel/mm */
size = (int)((-size/res)*2.83464567 + 0.5); /* from pixels to points */
}
sprintf(new_standardfont, "%s, %s%s%d", typeface, is_bold?"Bold ":"", is_italic?"Italic ":"", size);
fontdesc = pango_font_description_from_string(new_standardfont);
}
}
if (!fontdesc)
return NULL;
/* create room in the array */
fonts = (IgtkFont*)iupArrayInc(gtk_fonts);
strcpy(fonts[i].standardfont, standardfont);
fonts[i].fontdesc = fontdesc;
fonts[i].strikethrough = pango_attr_strikethrough_new(is_strikeout? TRUE: FALSE);
fonts[i].underline = pango_attr_underline_new(is_underline? PANGO_UNDERLINE_SINGLE: PANGO_UNDERLINE_NONE);
fonts[i].layout = pango_layout_new(gtk_fonts_context);
metrics = pango_context_get_metrics(gtk_fonts_context, fontdesc, pango_context_get_language(gtk_fonts_context));
fonts[i].charheight = pango_font_metrics_get_ascent(metrics) + pango_font_metrics_get_descent(metrics);
fonts[i].charheight = IUPGTK_PANGOUNITS2PIXELS(fonts[i].charheight);
fonts[i].charwidth = pango_font_metrics_get_approximate_char_width(metrics);
fonts[i].charwidth = IUPGTK_PANGOUNITS2PIXELS(fonts[i].charwidth);
pango_font_metrics_unref(metrics);
gtkFontUpdate(&(fonts[i]));
return &fonts[i];
}
static IgtkFont* gtkFindFont(const char *standardfont)
{
PangoFontMetrics* metrics;
PangoFontDescription* fontdesc;
int i,
is_underline = 0,
is_strikeout = 0,
count = iupArrayCount(gtk_fonts);
IgtkFont* fonts = (IgtkFont*)iupArrayGetData(gtk_fonts);
/* Check if the standardfont already exists in cache */
for (i = 0; i < count; i++)
{
if (iupStrEqualNoCase(standardfont, fonts[i].standardfont))
return &fonts[i];
}
/* not found, create a new one */
{
int size;
int is_bold = 0,
is_italic = 0;
char typeface[1024];
char *new_standardfont = NULL;
const char* mapped_name;
if (!iupFontParsePango(standardfont, typeface, &size, &is_bold, &is_italic, &is_underline, &is_strikeout))
return NULL;
mapped_name = iupFontGetPangoName(typeface);
if (mapped_name)
strcpy(typeface, mapped_name);
if (is_underline || is_strikeout || size<0)
new_standardfont = iupStrDup(standardfont);
if (is_underline)
{
char* under = strstr(standardfont, "Underline");
int len = strlen(standardfont);
int len1 = (size_t)(under-standardfont);
memcpy(new_standardfont, standardfont, len1);
memcpy(new_standardfont+len1, under+9+1, len-len1-9+1); /* strlen("Underline") */
standardfont = new_standardfont;
}
if (is_strikeout)
{
char* strike = strstr(standardfont, "Strikeout");
int len = strlen(standardfont);
int len1 = (size_t)(strike-standardfont);
memcpy(new_standardfont, standardfont, len1);
memcpy(new_standardfont+len1, strike+9+1, len-len1-9+1); /* strlen("Strikeout") */
standardfont = new_standardfont;
}
if (size<0)
{
double res;
int len1, len2;
char *sz, size_str[10];
sprintf(size_str, "%d", size);
sz = strstr(standardfont, size_str);
len1 = (size_t)(sz-standardfont);
res = ((double)gdk_screen_get_width(gdk_screen_get_default()) / (double)gdk_screen_get_width_mm(gdk_screen_get_default())); /* pixels/mm */
/* 1 point = 1/72 inch 1 inch = 25.4 mm */
/* pixel = ((point/72)*25.4)*pixel/mm */
size = (int)((-size/res)*2.83464567 + 0.5); /* from pixels to points */
len2 = sprintf(size_str, "%d", size);
memcpy(new_standardfont, standardfont, len1);
memcpy(new_standardfont+len1, size_str, len2+1);
}
fontdesc = pango_font_description_from_string(standardfont);
if (new_standardfont) free(new_standardfont);
}
if (!fontdesc)
return NULL;
/* create room in the array */
fonts = (IgtkFont*)iupArrayInc(gtk_fonts);
strcpy(fonts[i].standardfont, standardfont);
fonts[i].fontdesc = fontdesc;
fonts[i].strikethrough = pango_attr_strikethrough_new(is_strikeout? TRUE: FALSE);
fonts[i].underline = pango_attr_underline_new(is_underline? PANGO_UNDERLINE_SINGLE: PANGO_UNDERLINE_NONE);
fonts[i].layout = pango_layout_new(gtk_fonts_context);
metrics = pango_context_get_metrics(gtk_fonts_context, fontdesc, pango_context_get_language(gtk_fonts_context));
fonts[i].charheight = pango_font_metrics_get_ascent(metrics) + pango_font_metrics_get_descent(metrics);
fonts[i].charheight = IUPGTK_PANGOUNITS2PIXELS(fonts[i].charheight);
fonts[i].charwidth = pango_font_metrics_get_approximate_char_width(metrics);
fonts[i].charwidth = IUPGTK_PANGOUNITS2PIXELS(fonts[i].charwidth);
pango_font_metrics_unref(metrics);
gtkFontUpdate(&(fonts[i]));
return &fonts[i];
}
