Geografic-Information-System/lib/cairodriver/text.c

/*!
  \file lib/cairodriver/text.c

  \brief GRASS cairo display driver - text subroutines

  (C) 2007-2008 by Lars Ahlzen and the GRASS Development Team
  
  This program is free software under the GNU General Public License
  (>=v2). Read the file COPYING that comes with GRASS for details.
  
  \author Lars Ahlzen <lars ahlzen.com> (original contributor)
  \author Glynn Clements  
*/

#include <grass/glocale.h>
#include "cairodriver.h"

#if CAIRO_HAS_FT_FONT
#include <cairo-ft.h>
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1,10,0) || defined(CAIRO_HAS_FC_FONT)
#define USE_FONTCONFIG 1
#include <fontconfig/fontconfig.h>
#else
#define USE_FONTCONFIG 0
#endif
#endif /* CAIRO_HAS_FT_FONT */

#ifdef HAVE_ICONV_H
#include <iconv.h>
#endif

static char *convert(const char *in)
{
    size_t ilen, olen;
    char *out;

    ilen = strlen(in);
    olen = 3 * ilen + 1;

    out = G_malloc(olen);

#ifdef HAVE_ICONV_H
    {
	const char *encoding = font_get_encoding();
	char *p1 = (char *) in;
	char *p2 = out;
	size_t ret;
	iconv_t cd;

	if ((cd = iconv_open("UTF-8", encoding)) == (iconv_t) -1)
	    G_fatal_error(_("Unable to convert from <%s> to UTF-8"),
			  encoding);

	ret = iconv(cd, &p1, &ilen, &p2, &olen);

	iconv_close(cd);

	*p2++ = '\0';

	if (ret > 0)
	    G_warning(_("Some characters could not be converted to UTF-8"));
    }
#else
    {
	const unsigned char *p1 = (const unsigned char *) in;
	unsigned char *p2 = (unsigned char *) out;
	int i, j;

	for (i = j = 0; i < ilen; i++) {
	    int c = p1[i];
	    if (c < 0x80)
		p2[j++] = c;
	    else {
		p2[j++] = 0xC0 + (c >> 6);
		p2[j++] = 0x80 + (c & 0x3F);
	    }
	}

	p2[j++] = '\0';
    }
#endif

    return out;
}

static void set_matrix(void)
{
    static cairo_matrix_t mat;

    if (matrix_valid)
	return;

    cairo_matrix_init_identity(&mat);
    cairo_matrix_scale(&mat, text_size_x, text_size_y);
    cairo_matrix_rotate(&mat, -text_rotation * M_PI / 180);

    cairo_set_font_matrix(cairo, &mat);

    matrix_valid = 1;
}

/*!
  \brief Draw text
  
  \param str string to be drawn
*/
void Cairo_Text(const char *str)
{
    char *utf8 = convert(str);

    if (!utf8)
	return;

    set_matrix();

    cairo_move_to(cairo, cur_x, cur_y);
    cairo_show_text(cairo, utf8);

    G_free(utf8);

    ca.modified = 1;
}

/*
  \brief Get text bounding box

  \param str string
  \param[out] t,b,l,r top, bottom, left, right corner
*/
void Cairo_text_box(const char *str, double *t, double *b, double *l, double *r)
{
    char *utf8 = convert(str);
    cairo_text_extents_t ext;

    if (!utf8)
	return;

    set_matrix();

    cairo_text_extents(cairo, utf8, &ext);

    G_free(utf8);

    *l = cur_x + ext.x_bearing;
    *r = cur_x + ext.x_bearing + ext.width;
    *t = cur_y + ext.y_bearing;
    *b = cur_y + ext.y_bearing + ext.height;
}

static void set_font_toy(const char *name)
{
    char *font = G_store(name);
    cairo_font_weight_t weight = CAIRO_FONT_WEIGHT_NORMAL;
    cairo_font_slant_t slant = CAIRO_FONT_SLANT_NORMAL;

    for (;;) {
	char *p = strrchr(font, '-');
	if (!p)
	    break;

	if (G_strcasecmp(p, "-bold") == 0)
	    weight = CAIRO_FONT_WEIGHT_BOLD;
	else if (strcasecmp(p, "-italic") == 0)
	    slant = CAIRO_FONT_SLANT_ITALIC;
	else if (G_strcasecmp(p, "-oblique") == 0)
	    slant = CAIRO_FONT_SLANT_OBLIQUE;
	else
	    break;

	*p = '\0';
    }

    cairo_select_font_face(cairo, font, slant, weight);

    G_free(font);
}

#if USE_FONTCONFIG

static void fc_init(void)
{
    static int initialized;

    if (!initialized) {
	FcInit();
	initialized = 1;
    }
}

static void set_font_fc(const char *name)
{
    static cairo_font_face_t *face;
    FcPattern *pattern;
    FcResult result;

    fc_init();

    if (face) {
	cairo_font_face_destroy(face);
	face = NULL;
    }

    pattern = FcNameParse((FcChar8 *)name);
    FcDefaultSubstitute(pattern);
    FcConfigSubstitute(FcConfigGetCurrent(), pattern, FcMatchPattern);
    pattern = FcFontMatch(FcConfigGetCurrent(), pattern, &result);
    face = cairo_ft_font_face_create_for_pattern(pattern);
    cairo_set_font_face(cairo, face);
}

static void font_list_fc(char ***list, int *count, int verbose)
{
    FcPattern *pattern;
    FcObjectSet *objset;
    FcFontSet *fontset;
    char **fonts = *list;
    int num_fonts = *count;
    int i;

    fc_init();

    pattern = FcPatternCreate();
    objset = FcObjectSetBuild(FC_FAMILY, FC_STYLE, (char *) NULL);
    fontset = FcFontList(NULL, pattern, objset);

    fonts = G_realloc(fonts, (num_fonts + fontset->nfont) * sizeof(char *));

    for (i = 0; i < fontset->nfont; i++) {
	char buf[1024];
	FcPattern *pat = fontset->fonts[i];
	FcChar8 *family = (FcChar8 *)"", *style = (FcChar8 *)"";

	FcPatternGetString(pat, FC_FAMILY, 0, &family);
	FcPatternGetString(pat, FC_STYLE , 0, &style );

	if (verbose)
	    sprintf(buf, "%s:%s|%s:%s|%d|%s|%d|%s|",
		    family, style, family, style, GFONT_DRIVER, "", 0, "utf-8");
	else
	    sprintf(buf, "%s:%s", family, style);

	fonts[num_fonts++] = G_store(buf);
    }

    FcObjectSetDestroy(objset);
    FcPatternDestroy(pattern);
    FcFontSetDestroy (fontset);

    *list = fonts;
    *count = num_fonts;
}

#endif

static const char *toy_fonts[12] = {
    "sans",
    "sans-italic",
    "sans-bold",
    "sans-bold-italic",
    "serif",
    "serif-italic",
    "serif-bold",
    "serif-bold-italic",
    "mono",
    "mono-italic",
    "mono-bold",
    "mono-bold-italic",
};
static const int num_toy_fonts = 12;

static int is_toy_font(const char *name)
{
    int i;

    for (i = 0; i < num_toy_fonts; i++)
	if (G_strcasecmp(name, toy_fonts[i]) == 0)
	    return 1;

    return 0;
}

/*!
  \brief Set font

  \param name font name
*/
void Cairo_set_font(const char *name)
{
#if USE_FONTCONFIG
    if (is_toy_font(name))
	set_font_toy(name);
    else
	set_font_fc(name);
#else
    set_font_toy(name);
#endif
}

static void font_list_toy(char ***list, int *count, int verbose)
{
    char **fonts = *list;
    int num_fonts = *count;
    int i;

    fonts = G_realloc(fonts, (num_fonts + num_toy_fonts) * sizeof(char *));

    for (i = 0; i < num_toy_fonts; i++) {
	char buf[256];
	if (verbose)
	    sprintf(buf, "%s|%s|%d|%s|%d|%s|",
		    toy_fonts[i], toy_fonts[i], GFONT_DRIVER, "", 0, "utf-8");
	else
	    strcpy(buf, toy_fonts[i]);
	fonts[num_fonts++] = G_store(buf);
    }

    *list = fonts;
    *count = num_fonts;
}

/*!
  \brief Get list of fonts

  \param[out] list font list
  \param[out] count number of items in the list
*/
void Cairo_font_list(char ***list, int *count)
{
    font_list_toy(list, count, 0);
#if USE_FONTCONFIG
    font_list_fc(list, count, 0);
#endif
}

/*!
  \brief Get fonts into

  \param[out] list font list
  \param[out] count number of items in the list
*/
void Cairo_font_info(char ***list, int *count)
{
    font_list_toy(list, count, 1);
#if USE_FONTCONFIG
    font_list_fc(list, count, 1);
#endif
}