static void try_to_get_windows_font (void)
{
gchar *fontspec = default_windows_menu_fontspec();
if (fontspec != NULL) {
int match = 0;
PangoFontDescription *pfd;
PangoFont *pfont;
PangoContext *pc;
GtkWidget *w;
pfd = pango_font_description_from_string(fontspec);
w = gtk_label_new(NULL);
pc = gtk_widget_get_pango_context(w);
pfont = pango_context_load_font(pc, pfd);
match = (pfont != NULL);
pango_font_description_free(pfd);
g_object_unref(G_OBJECT(pc));
gtk_widget_destroy(w);
if (match) set_app_font(fontspec);
g_free(fontspec);
}
}
static void
dump_font_sizes (PangoContext *context, FILE *f, guint flags)
{
PangoFont *font;
PangoFontDescription *pfd;
int nf;
real height;
fprintf (f, "height/cm");
for (nf = 0; test_families[nf] != NULL; ++nf)
fprintf (f, "\t%s", test_families[nf]);
fprintf (f, "\n");
for (height = 0.1; height <= 10.0; height += 0.1) {
fprintf (f, "%g", height);
for (nf = 0; test_families[nf] != NULL; ++nf) {
pfd = pango_font_description_new ();
pango_font_description_set_family (pfd, test_families[nf]);
//pango_font_description_set_size (pfd, height * pixels_per_cm * PANGO_SCALE);
if (flags & DUMP_ABSOLUTE)
pango_font_description_set_absolute_size (pfd, height * pixels_per_cm * PANGO_SCALE);
else
pango_font_description_set_size (pfd, height * pixels_per_cm * PANGO_SCALE);
font = pango_context_load_font (context, pfd);
if (font) {
PangoFontMetrics *metrics = pango_font_get_metrics (font, NULL);
/* now make a font-size where the font/line-height matches the given pixel size */
real total = ((double)pango_font_metrics_get_ascent (metrics)
+ pango_font_metrics_get_descent (metrics)) / PANGO_SCALE;
real factor = height*pixels_per_cm/total;
real line_height;
if (flags & DUMP_ABSOLUTE)
pango_font_description_set_absolute_size (pfd, factor * height * pixels_per_cm * PANGO_SCALE);
else
pango_font_description_set_size (pfd, factor * height * pixels_per_cm * PANGO_SCALE);
pango_font_metrics_unref (metrics);
g_object_unref (font);
font = pango_context_load_font (context, pfd);
metrics = pango_font_get_metrics (font, NULL);
line_height = ((double)pango_font_metrics_get_ascent (metrics)
+ pango_font_metrics_get_descent (metrics)) / PANGO_SCALE;
fprintf (f, "\t%.3g", flags & DUMP_FACTORS ? factor : line_height);
g_object_unref (font);
}
pango_font_description_free (pfd);
}
fprintf (f, "\n");
}
}
static bool
pango_load (Lisp_Font *f)
{
PangoLanguage *language;
PangoFontDescription *fontdesc;
PangoFont *font;
PangoFontMetrics *metrics;
if (pango_context)
{
language = pango_context_get_language (pango_context);
}
else
{
char *langname, *p;
#ifdef HAVE_PANGO_XFT
pango_context = pango_xft_get_context (dpy, screen_num);
#endif
langname = g_strdup (setlocale (LC_CTYPE, NULL));
p = strchr (langname, '.');
if (p)
*p = 0;
p = strchr (langname, '@');
if (p)
*p = 0;
language = pango_language_from_string (langname);
pango_context_set_language (pango_context, language);
g_free (langname);
}
fontdesc = pango_font_description_from_string (rep_STR (f->name));
if (!pango_font_description_get_family (fontdesc))
pango_font_description_set_family (fontdesc, "Sans");
if (pango_font_description_get_size (fontdesc) <= 0)
pango_font_description_set_size (fontdesc, 12 * PANGO_SCALE);
pango_context_set_font_description (pango_context, fontdesc);
font = pango_context_load_font (pango_context, fontdesc);
if (!font) {
pango_font_description_free(fontdesc);
return FALSE;
}
metrics = pango_font_get_metrics (font, language);
f->ascent = metrics->ascent / PANGO_SCALE;
f->descent = metrics->descent / PANGO_SCALE;
pango_font_metrics_unref (metrics);
f->font = fontdesc; /* We save the font description, not the font itself!
That's because it seems we can't recover it perfectly
later, and the layout routines want a description */
return TRUE;
}
void GtkPaintContext::updatePixmap(GtkWidget *area, int w, int h) {
if ((myPixmap != 0) && ((myWidth != w) || (myHeight != h))) {
gdk_pixmap_unref(myPixmap);
myPixmap = 0;
if (myTextGC != 0) {
gdk_gc_unref(myTextGC);
gdk_gc_unref(myFillGC);
gdk_gc_unref(myBackGC);
myTextGC = 0;
myFillGC = 0;
myBackGC = 0;
}
}
if (myPixmap == 0) {
myWidth = w;
myHeight = h;
myPixmap = gdk_pixmap_new(area->window, myWidth, myHeight, gdk_drawable_get_depth(area->window));
}
if (myTextGC == 0) {
myTextGC = gdk_gc_new(myPixmap);
myFillGC = gdk_gc_new(myPixmap);
myBackGC = gdk_gc_new(myPixmap);
}
if (myContext == 0) {
myContext = gtk_widget_get_pango_context(area);
if (myFontDescription != 0) {
myAnalysis.font = pango_context_load_font(myContext, myFontDescription);
myAnalysis.shape_engine = pango_font_find_shaper(myAnalysis.font, 0, 0);
}
}
}
static void set_app_font (const char *fontname)
{
GtkSettings *settings;
if (fontname != NULL && *fontname == 0) return;
settings = gtk_settings_get_default();
if (fontname == NULL) {
g_object_set(G_OBJECT(settings), "gtk-font-name", appfontname, NULL);
} else {
GtkWidget *w;
PangoFontDescription *pfd;
PangoContext *pc;
PangoFont *pfont;
w = gtk_label_new(NULL);
pfd = pango_font_description_from_string(fontname);
pc = gtk_widget_get_pango_context(w);
pfont = pango_context_load_font(pc, pfd);
if (pfont != NULL) {
strcpy(appfontname, fontname);
g_object_set(G_OBJECT(settings), "gtk-font-name", appfontname,
NULL);
}
gtk_widget_destroy(w);
pango_font_description_free(pfd);
}
}
/*----------------------------------------------------------------------------------------------
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;
}
const std::string ZLGtkPaintContext::realFontFamilyName(std::string &fontFamily) const {
if (myContext == 0) {
return fontFamily;
}
PangoFontDescription *description = pango_font_description_new();
pango_font_description_set_family(description, fontFamily.c_str());
pango_font_description_set_size(description, 12);
PangoFont *font = pango_context_load_font(myContext, description);
pango_font_description_free(description);
description = pango_font_describe(font);
std::string realFamily = pango_font_description_get_family(description);
pango_font_description_free(description);
return realFamily;
}
static void
dia_font_check_for_font(int font)
{
DiaFont *check;
PangoFont *loaded;
static real height = 1.0;
check = dia_font_new_from_style(font, height);
loaded = pango_context_load_font(dia_font_get_context(), check->pfd);
if (!loaded) {
message_error(_("Can't load font %s.\n"), dia_font_get_family(check));
} else {
g_object_unref (loaded);
}
}
static void fontspec_to_win32 (CHOOSEFONT *cf, const char *src, int which)
{
PangoFontDescription *pfd;
PangoFontMap *map;
PangoContext *pc;
PangoFont *font;
pfd = pango_font_description_from_string(src);
map = pango_win32_font_map_for_display();
pc = pango_font_map_create_context(map);
font = pango_context_load_font(pc, pfd);
cf->lpLogFont = pango_win32_font_logfont(font);
g_object_unref(font);
g_object_unref(pc);
pango_font_description_free(pfd);
}
PP_Resource
ppb_browser_font_trusted_create(PP_Instance instance,
const struct PP_BrowserFont_Trusted_Description *description)
{
PP_Resource font = pp_resource_allocate(PP_RESOURCE_BROWSER_FONT, instance);
struct pp_browser_font_s *bf = pp_resource_acquire(font, PP_RESOURCE_BROWSER_FONT);
PangoFontDescription *font_desc = pp_font_desc_to_pango_font_desc(description);
bf->family = description->face.type == PP_VARTYPE_STRING ? -1 : description->family;
bf->letter_spacing = description->letter_spacing;
bf->word_spacing = description->word_spacing;
bf->font = pango_context_load_font(tables_get_pango_ctx(), font_desc);
bf->font_desc = pango_font_describe_with_absolute_size(bf->font);
pango_font_description_free(font_desc);
pp_resource_release(font);
return font;
}
void ZLGtkPaintContext::setFont(const std::string &family, int size, bool bold, bool italic) {
bool fontChanged = false;
if (myFontDescription == 0) {
myFontDescription = pango_font_description_new();
fontChanged = true;
}
const char *oldFamily = pango_font_description_get_family(myFontDescription);
if ((oldFamily == 0) || (family != oldFamily)) {
pango_font_description_set_family(myFontDescription, family.c_str());
fontChanged = true;
}
int newSize = size * PANGO_SCALE;
if (pango_font_description_get_size(myFontDescription) != newSize) {
pango_font_description_set_size(myFontDescription, newSize);
fontChanged = true;
}
PangoWeight newWeight = bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL;
if (pango_font_description_get_weight(myFontDescription) != newWeight) {
pango_font_description_set_weight(myFontDescription, newWeight);
fontChanged = true;
}
PangoStyle newStyle = italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL;
if (pango_font_description_get_style(myFontDescription) != newStyle) {
pango_font_description_set_style(myFontDescription, newStyle);
fontChanged = true;
}
if (fontChanged) {
if (myContext != 0) {
myAnalysis.font = pango_context_load_font(myContext, myFontDescription);
myAnalysis.shape_engine = pango_font_find_shaper(myAnalysis.font, 0, 0);
PangoFontMetrics *metrics = pango_font_get_metrics(myAnalysis.font, myAnalysis.language);
myDescent = pango_font_metrics_get_descent(metrics) / PANGO_SCALE;
}
myStringHeight = -1;
mySpaceWidth = -1;
}
}
/*!
* In Dia a font is usually referred to by it's (line-) height, not it's size.
*
* This methods "calculates" the latter from the former. This used to be some magic factor of 0.7 which did not
* solve the resolution dependencance of the former calculation. In fact there is new magic factor now because
* really calculating the font size from the height would involve two font loads which seem to be two expensive.
*/
static void
_dia_font_adjust_size (DiaFont *font, real height, gboolean recalc_alwways)
{
if (font->height != height || !font->metrics || recalc_alwways) {
PangoFont *loaded;
dia_pfd_set_height (font->pfd, height);
/* need to load a font to get it's metrics */
loaded = font->loaded;
font->loaded = pango_context_load_font(dia_font_get_context(), font->pfd);
if (loaded) /* drop old reference */
g_object_unref (loaded);
if (font->metrics)
pango_font_metrics_unref (font->metrics);
/* caching metrics */
font->metrics = pango_font_get_metrics (font->loaded, NULL);
font->height = height;
}
}
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;
}
void wxSVGCanvasTextCairo::InitText(const wxString& text, const wxCSSStyleDeclaration& style, wxSVGMatrix* matrix) {
BeginChar(matrix);
// create path from text
cairo_t* cr = ((wxSVGCanvasPathCairo*) m_char->path)->GetCr();
#if defined(__WXMSW__) || defined(__WXMAC__)
int size = (int) style.GetFontSize();
int fstyle = style.GetFontStyle() == wxCSS_VALUE_ITALIC ? wxFONTSTYLE_ITALIC
: (style.GetFontStyle() == wxCSS_VALUE_OBLIQUE ? wxFONTSTYLE_SLANT : wxFONTSTYLE_NORMAL);
wxFontWeight weight = style.GetFontWeight() == wxCSS_VALUE_BOLD ? wxFONTWEIGHT_BOLD
: style.GetFontWeight() == wxCSS_VALUE_BOLDER ? wxFONTWEIGHT_MAX
: style.GetFontWeight() == wxCSS_VALUE_LIGHTER ? wxFONTWEIGHT_LIGHT : wxFONTWEIGHT_NORMAL;
wxFont fnt(size, wxFONTFAMILY_DEFAULT, fstyle, weight, false, style.GetFontFamily());
#ifdef __WXMSW__
HFONT hfont = (HFONT) fnt.GetResourceHandle();
cairo_set_font_face(cr, cairo_win32_font_face_create_for_hfont(hfont));
#else
CGFontRef cgFont = fnt.OSXGetCGFont();
cairo_set_font_face(cr, cairo_quartz_font_face_create_for_cgfont(cgFont));
#endif
cairo_set_font_size(cr, style.GetFontSize());
cairo_font_extents_t fextents;
cairo_font_extents(cr, &fextents);
double maxWidth = 0;
if (style.GetTextAnchor() == wxCSS_VALUE_MIDDLE || style.GetTextAnchor() == wxCSS_VALUE_END) {
wxStringTokenizer tokenzr(text, wxT("\n"));
while (tokenzr.HasMoreTokens()) {
wxString token = tokenzr.GetNextToken();
cairo_text_extents_t extents;
cairo_text_extents(cr, (const char*) token.utf8_str(), &extents);
if (maxWidth < extents.width)
maxWidth = extents.width;
}
}
wxStringTokenizer tokenzr(text, wxT("\n"));
double x_advance = 0;
double width = 0;
double height = 0;
double y = 0;
while (tokenzr.HasMoreTokens()) {
wxString token = tokenzr.GetNextToken();
// get text extents
cairo_text_extents_t extents;
cairo_text_extents(cr, (const char*) token.utf8_str(), &extents);
double x = style.GetTextAnchor() == wxCSS_VALUE_END ? maxWidth - extents.width
: style.GetTextAnchor() == wxCSS_VALUE_MIDDLE ? (maxWidth - extents.width) / 2 : 0;
m_char->path->MoveTo(m_tx + x, m_ty + y);
cairo_text_path(cr, (const char*) token.utf8_str());
if (x_advance < extents.x_advance)
x_advance = extents.x_advance;
if (width < extents.width)
width = extents.width;
height += fextents.height;
if (tokenzr.HasMoreTokens())
y += fextents.height;
}
// set bbox
m_char->bbox = wxSVGRect(m_tx, m_ty, width, height);
// increase current position (m_tx)
if (style.GetTextAnchor() == wxCSS_VALUE_MIDDLE || style.GetTextAnchor() == wxCSS_VALUE_END) {
wxSVGRect bbox = m_char->path->GetResultBBox(style);
m_tx += x_advance > bbox.GetWidth() ? x_advance : bbox.GetWidth();
} else
m_tx += x_advance;
#else
PangoLayout* layout = pango_cairo_create_layout(cr);
PangoFontDescription* font = pango_font_description_new();
pango_font_description_set_family(font, style.GetFontFamily().ToAscii());
pango_font_description_set_weight(font, style.GetFontWeight() == wxCSS_VALUE_BOLD ? PANGO_WEIGHT_BOLD
: PANGO_WEIGHT_NORMAL);
pango_font_description_set_style(font, style.GetFontStyle() == wxCSS_VALUE_ITALIC ? PANGO_STYLE_ITALIC
: (style.GetFontStyle() == wxCSS_VALUE_OBLIQUE ? PANGO_STYLE_OBLIQUE : PANGO_STYLE_NORMAL));
pango_font_description_set_absolute_size(font, style.GetFontSize() * PANGO_SCALE);
PangoContext* ctx = pango_layout_get_context(layout);
PangoFont* f = pango_context_load_font(ctx, font);
if (f == NULL)
pango_font_description_set_style(font, PANGO_STYLE_NORMAL);
pango_layout_set_font_description(layout, font);
if (style.GetTextAnchor() != wxCSS_VALUE_START)
pango_layout_set_alignment(layout, style.GetTextAnchor() == wxCSS_VALUE_MIDDLE ? PANGO_ALIGN_CENTER : PANGO_ALIGN_RIGHT);
pango_layout_set_text(layout, (const char*) text.utf8_str(), -1);
int baseline = pango_layout_get_baseline(layout);
m_char->path->MoveTo(m_tx, m_ty - ((double)baseline / PANGO_SCALE));
pango_cairo_layout_path(cr, layout);
// set bbox and increase current position (m_tx)
int lwidth, lheight;
pango_layout_get_size(layout, &lwidth, &lheight);
double width = ((double)lwidth / PANGO_SCALE);
double height = ((double)lheight / PANGO_SCALE);
m_char->bbox = wxSVGRect(m_tx, m_ty, width, height);
if (style.GetTextAnchor() == wxCSS_VALUE_MIDDLE || style.GetTextAnchor() == wxCSS_VALUE_END) {
wxSVGRect bbox = m_char->path->GetResultBBox(style);
m_tx += width > bbox.GetWidth() ? width : bbox.GetWidth();
} else
m_tx += width;
g_object_unref(layout);
pango_font_description_free(font);
#endif
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkFontPeer_setFont
(JNIEnv *env, jobject self, jstring family_name_str, jint style_int, jint size, jboolean useGraphics2D)
{
struct peerfont *pfont = NULL;
char const *family_name = NULL;
enum java_awt_font_style style;
PangoFT2FontMap *ft2_map;
gdk_threads_enter ();
style = (enum java_awt_font_style) style_int;
g_assert (self != NULL);
pfont = (struct peerfont *)NSA_GET_FONT_PTR (env, self);
g_assert (pfont != NULL);
if (pfont->ctx != NULL)
g_object_unref (pfont->ctx);
if (pfont->font != NULL)
g_object_unref (pfont->font);
if (pfont->desc != NULL)
pango_font_description_free (pfont->desc);
pfont->desc = pango_font_description_new ();
g_assert (pfont->desc != NULL);
family_name = (*env)->GetStringUTFChars(env, family_name_str, 0);
g_assert (family_name != NULL);
pango_font_description_set_family (pfont->desc, family_name);
(*env)->ReleaseStringUTFChars(env, family_name_str, family_name);
if (style & java_awt_font_BOLD)
pango_font_description_set_weight (pfont->desc, PANGO_WEIGHT_BOLD);
if (style & java_awt_font_ITALIC)
pango_font_description_set_style (pfont->desc, PANGO_STYLE_ITALIC);
if (useGraphics2D)
{
pango_font_description_set_size (pfont->desc, size * PANGO_SCALE);
if (pfont->ctx == NULL)
{
ft2_map = PANGO_FT2_FONT_MAP(pango_ft2_font_map_for_display ());
pfont->ctx = pango_ft2_font_map_create_context (ft2_map);
}
}
else
{
/* GDK uses a slightly different DPI setting. */
pango_font_description_set_size (pfont->desc,
size * dpi_conversion_factor);
if (pfont->ctx == NULL)
pfont->ctx = gdk_pango_context_get();
}
g_assert (pfont->ctx != NULL);
if (pfont->font != NULL)
{
g_object_unref (pfont->font);
pfont->font = NULL;
}
pango_context_set_font_description (pfont->ctx, pfont->desc);
pango_context_set_language (pfont->ctx, gtk_get_default_language());
pfont->font = pango_context_load_font (pfont->ctx, pfont->desc);
g_assert (pfont->font != NULL);
if (pfont->layout == NULL)
pfont->layout = pango_layout_new (pfont->ctx);
g_assert (pfont->layout != NULL);
gdk_threads_leave ();
}
static void
set_font(DiaRenderer *self, DiaFont *font, real height)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::LPCTSTR sFace;
W32::DWORD dwItalic = 0;
W32::DWORD dwWeight = FW_DONTCARE;
DiaFontStyle style = dia_font_get_style(font);
real font_size = dia_font_get_size (font) * (height / dia_font_get_height (font));
DIAG_NOTE(renderer, "set_font %s %f\n",
dia_font_get_family (font), height);
if (renderer->hFont) {
W32::DeleteObject(renderer->hFont);
renderer->hFont = NULL;
}
if (renderer->pango_context) {
g_object_unref (renderer->pango_context);
renderer->pango_context = NULL;
}
if (renderer->use_pango) {
#ifdef __PANGOWIN32_H__ /* with the pangowin32 backend there is a better way */
if (!renderer->pango_context)
renderer->pango_context = pango_win32_get_context ();
PangoFont* pf = pango_context_load_font (renderer->pango_context, dia_font_get_description (font));
if (pf)
{
W32::LOGFONT* lf = pango_win32_font_logfont (pf);
/* .93 : sligthly smaller looks much better */
lf->lfHeight = -SC(height*.93);
lf->lfHeight = -SC(font_size);
renderer->hFont = (W32::HFONT)W32::CreateFontIndirect (lf);
g_free (lf);
g_object_unref (pf);
}
else
{
gchar *desc = pango_font_description_to_string (dia_font_get_description (font));
dia_context_add_message(renderer->ctx, _("Cannot render unknown font:\n%s"), desc);
g_free (desc);
}
#else
g_assert_not_reached();
#endif
} else {
sFace = dia_font_get_family (font);
dwItalic = DIA_FONT_STYLE_GET_SLANT(style) != DIA_FONT_NORMAL;
/* although there is a known algorithm avoid it for cleanness */
switch (DIA_FONT_STYLE_GET_WEIGHT(style)) {
case DIA_FONT_ULTRALIGHT : dwWeight = FW_ULTRALIGHT; break;
case DIA_FONT_LIGHT : dwWeight = FW_LIGHT; break;
case DIA_FONT_MEDIUM : dwWeight = FW_MEDIUM; break;
case DIA_FONT_DEMIBOLD : dwWeight = FW_DEMIBOLD; break;
case DIA_FONT_BOLD : dwWeight = FW_BOLD; break;
case DIA_FONT_ULTRABOLD : dwWeight = FW_ULTRABOLD; break;
case DIA_FONT_HEAVY : dwWeight = FW_HEAVY; break;
default : dwWeight = FW_NORMAL; break;
}
//Hack to get BYTE out of namespace W32
# ifndef BYTE
# define BYTE unsigned char
# endif
renderer->hFont = (W32::HFONT)W32::CreateFont(
- SC (font_size), // logical height of font
0, // logical average character width
0, // angle of escapement
0, // base-line orientation angle
dwWeight, // font weight
dwItalic, // italic attribute flag
0, // underline attribute flag
0, // strikeout attribute flag
DEFAULT_CHARSET, // character set identifier
OUT_TT_PRECIS, // output precision
CLIP_DEFAULT_PRECIS, // clipping precision
PROOF_QUALITY, // output quality
DEFAULT_PITCH, // pitch and family
sFace); // pointer to typeface name string
}
}
static void CreateErrorWindow(void) {
GtkWidget *hbox5;
GtkWidget *view;
GtkWidget *vscrollbar2;
GdkPixbuf *Warning_icon_pixbuf;
PangoContext *context;
PangoFont *font;
PangoFontMetrics *fm;
int as, ds;
GtkRequisition desired;
errdata.gw = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (errdata.gw, "Warnings");
gtk_widget_set_events (errdata.gw, GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_PROPERTY_CHANGE_MASK);
gtk_window_set_title (GTK_WINDOW (errdata.gw), _("Warnings"));
Warning_icon_pixbuf = create_pixbuf ("fontview2.xbm");
if (Warning_icon_pixbuf) {
gtk_window_set_icon (GTK_WINDOW (errdata.gw), Warning_icon_pixbuf);
gdk_pixbuf_unref (Warning_icon_pixbuf);
}
hbox5 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox5, "hbox5");
gtk_widget_show (hbox5);
gtk_container_add (GTK_CONTAINER (errdata.gw), hbox5);
view = gtk_drawing_area_new ();
gtk_widget_set_name (view, "view");
gtk_widget_show (view);
gtk_box_pack_start (GTK_BOX (hbox5), view, TRUE, TRUE, 0);
gtk_widget_set_size_request (view, 16*24+1, 4*24+1);
vscrollbar2 = gtk_vscrollbar_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 0, 0, 0, 0)));
gtk_widget_set_name (vscrollbar2, "vscrollbar2");
gtk_widget_show (vscrollbar2);
gtk_box_pack_start (GTK_BOX (hbox5), vscrollbar2, FALSE, TRUE, 0);
g_signal_connect ((gpointer) errdata.gw, "delete_event",
G_CALLBACK (Warning_Hide),
NULL);
g_signal_connect ((gpointer) vscrollbar2, "value_changed",
G_CALLBACK (Warning_VScroll),
NULL);
g_signal_connect ((gpointer) view, "configure_event",
G_CALLBACK (Warning_Resize),
NULL);
g_signal_connect ((gpointer) view, "expose_event",
G_CALLBACK (Warning_Expose),
NULL);
errdata.v = view;
errdata.vsb = vscrollbar2;
errdata.layout = gtk_widget_create_pango_layout( view, NULL );
pango_layout_set_width(errdata.layout, -1); /* Don't wrap long lines */
context = gtk_widget_get_pango_context( view );
font = pango_context_load_font( context, pango_context_get_font_description(context));
fm = pango_font_get_metrics(font,NULL);
as = pango_font_metrics_get_ascent(fm);
ds = pango_font_metrics_get_descent(fm);
errdata.as = as / PANGO_SCALE;
errdata.fh = (as+ds) / PANGO_SCALE;
gtk_widget_set_size_request(view, 40*errdata.fh, 5*errdata.fh );
gtk_widget_size_request(errdata.gw,&desired);
/* This function is deprecated, but I can find no other way to position */
/* a window in the bottom right corner (or at all). So I use it */
gtk_widget_set_uposition(errdata.gw,
gdk_screen_get_width(gdk_screen_get_default())-desired.width-5,
gdk_screen_get_height(gdk_screen_get_default())-desired.height-errdata.fh-5);
errdata.linecnt = 5;
gtk_widget_show(errdata.gw);
}
static GnmFont *
style_font_new_simple (PangoContext *context,
char const *font_name, double size_pts,
gboolean bold, gboolean italic)
{
GnmFont *font;
GnmFont key;
if (font_name == NULL) {
g_warning ("font_name == NULL, using %s", DEFAULT_FONT);
font_name = DEFAULT_FONT;
}
if (size_pts <= 0) {
g_warning ("font_size <= 0, using %f", DEFAULT_SIZE);
size_pts = DEFAULT_SIZE;
}
/* This cast does not mean we will change the name. */
key.font_name = (char *)font_name;
key.size_pts = size_pts;
key.is_bold = bold;
key.is_italic = italic;
key.context = context;
font = (GnmFont *) g_hash_table_lookup (style_font_hash, &key);
if (font == NULL) {
PangoFontDescription *desc;
PangoFont *pango_font;
if (g_hash_table_lookup (style_font_negative_hash, &key))
return NULL;
font = g_new0 (GnmFont, 1);
font->font_name = g_strdup (font_name);
font->size_pts = size_pts;
font->is_bold = bold;
font->is_italic = italic;
font->context = g_object_ref (context);
/* One reference for the cache, one for the caller. */
font->ref_count = 2;
desc = pango_font_description_new ();
pango_font_description_set_family (desc, font_name);
pango_font_description_set_weight (desc,
bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
pango_font_description_set_style (desc,
italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
pango_font_description_set_size (desc, size_pts * PANGO_SCALE);
pango_font = pango_context_load_font (context, desc);
if (pango_font == NULL) {
/* if we fail, try to be smart and map to something similar */
char const *sub = get_substitute_font (font_name);
if (sub != NULL) {
pango_font_description_set_family (desc, font_name);
pango_font = pango_context_load_font (context,
desc);
}
if (pango_font == NULL) {
pango_font_description_free (desc);
g_hash_table_insert (style_font_negative_hash,
font, font);
return NULL;
}
}
if (pango_font)
g_object_unref (pango_font);
font->go.font = go_font_new_by_desc (desc);
font->go.metrics = go_font_metrics_new (context, font->go.font);
g_hash_table_insert (style_font_hash, font, font);
} else
font->ref_count++;
#ifdef DEBUG_REF_COUNT
g_message (__FUNCTION__ " font=%p name=%s%s%s ref_count=%d\n",
font, font->font_name,
font->is_bold ? " bold" : "",
font->is_italic ? " italic" : "",
font->ref_count);
#endif
return font;
}
JNIEXPORT jobject JNICALL
Java_gnu_java_awt_peer_gtk_GdkFontPeer_getGlyphVector
(JNIEnv *env, jobject self,
jstring chars,
jobject font,
jobject fontRenderContext)
{
struct peerfont *pfont = NULL;
GList *items = NULL, *i = NULL;
gchar *str = NULL;
int len, j;
double *native_extents;
int *native_codes;
jintArray java_codes = NULL;
jdoubleArray java_extents = NULL;
gdk_threads_enter ();
pfont = (struct peerfont *)NSA_GET_FONT_PTR (env, self);
g_assert (pfont != NULL);
len = (*gdk_env())->GetStringUTFLength (env, chars);
str = (gchar *)(*env)->GetStringUTFChars (env, chars, NULL);
g_assert (str != NULL);
if (attrs == NULL)
attrs = pango_attr_list_new ();
if (len > 0 && str[len-1] == '\0')
len--;
items = pango_itemize (pfont->ctx, str, 0, len, attrs, NULL);
i = g_list_first (items);
if (i == NULL)
{
java_extents = (*env)->NewDoubleArray (env, 0);
java_codes = (*env)->NewIntArray (env, 0);
}
else
{
PangoGlyphString *glyphs;
PangoItem *item = (PangoItem *)i->data;
pango_context_set_font_description (pfont->ctx, pfont->desc);
pango_context_set_language (pfont->ctx, gtk_get_default_language());
pango_context_load_font (pfont->ctx, pfont->desc);
glyphs = pango_glyph_string_new ();
g_assert (glyphs != NULL);
pango_shape (str + item->offset, item->length,
&(item->analysis), glyphs);
if (glyphs->num_glyphs > 0)
{
int x = 0;
double scale = ((double) PANGO_SCALE);
java_extents = (*env)->NewDoubleArray (env, glyphs->num_glyphs * NUM_GLYPH_METRICS);
java_codes = (*env)->NewIntArray (env, glyphs->num_glyphs);
native_extents = (*env)->GetDoubleArrayElements (env, java_extents, NULL);
native_codes = (*env)->GetIntArrayElements (env, java_codes, NULL);
for (j = 0; j < glyphs->num_glyphs; ++j)
{
PangoRectangle ink;
PangoRectangle logical;
PangoGlyphGeometry *geom = &glyphs->glyphs[j].geometry;
pango_font_get_glyph_extents (pfont->font,
glyphs->glyphs[j].glyph,
&ink, &logical);
native_codes[j] = glyphs->glyphs[j].glyph;
native_extents[ GLYPH_LOG_X(j) ] = (logical.x) / scale;
native_extents[ GLYPH_LOG_Y(j) ] = (- logical.y) / scale;
native_extents[ GLYPH_LOG_WIDTH(j) ] = (logical.width) / scale;
native_extents[ GLYPH_LOG_HEIGHT(j) ] = (logical.height) / scale;
native_extents[ GLYPH_INK_X(j) ] = (ink.x) / scale;
native_extents[ GLYPH_INK_Y(j) ] = (- ink.y) / scale;
native_extents[ GLYPH_INK_WIDTH(j) ] = (ink.width) / scale;
native_extents[ GLYPH_INK_HEIGHT(j) ] = (ink.height) / scale;
native_extents[ GLYPH_POS_X(j) ] = (x + geom->x_offset) / scale;
native_extents[ GLYPH_POS_Y(j) ] = ( - geom->y_offset) / scale;
x += geom->width;
}
(*env)->ReleaseDoubleArrayElements (env, java_extents, native_extents, 0);
(*env)->ReleaseIntArrayElements (env, java_codes, native_codes, 0);
}
pango_glyph_string_free (glyphs);
}
(*env)->ReleaseStringUTFChars (env, chars, str);
for (i = g_list_first (items); i != NULL; i = g_list_next (i))
g_free (i->data);
g_list_free (items);
gdk_threads_leave ();
return (*env)->NewObject (env,
glyphVector_class,
glyphVector_ctor,
java_extents, java_codes,
font, fontRenderContext);
}
