src/SDL_Pango.c

   1 /*  SDL_Pango.c -- A companion library to SDL for working with Pango.
   2     Copyright (C) 2004 NAKAMURA Ken'ichi
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Lesser General Public
   6     License as published by the Free Software Foundation; either
   7     version 2.1 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Lesser General Public License for more details.
  13
  14     You should have received a copy of the GNU Lesser General Public
  15     License along with this library; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
  17 */
  18
  19 /*!
  20     \mainpage
  21
  22     \section intro Introduction
  23
  24     Pango is the text rendering engine of GNOME 2.x. SDL_Pango connects the
  25     engine to SDL. In Windows, pre-built binary package (MSI and merge module)
  26     is provided.
  27
  28     \subsection dist Distribution
  29
  30     If you are a game software developer, you should know the difficulties of
  31     distribution. So I will start to introduce SDL_Pango from the viewpoint
  32     of distribution.
  33
  34     In Un*x, SDL_Pango is hard to use as system-independent module, because
  35     it depends on fontconfig and Pango which are designed as system-singleton
  36     modules. If you use SDL_Pango, your software will require those modules
  37     installed to target system. If your software is shipped as shrink-wrap
  38     package, it may cause much problem on your support desk. You should
  39     carefully design your installation process.
  40
  41     In Windows, SDL_Pango is distributed as "merge module" which contains
  42     fontconfig and Pango. Those binaries are modified as side-by-side components.
  43     You should use Windows Installer and merge the module
  44     on your MSI package. The merge module not only contains files, but also includes
  45     custom action which must be run at installation.
  46
  47     \subsection api High-level API
  48
  49     From the viewpoint of text rendering, the heart of SDL_Pango is high-level API.
  50     Other text rendering APIs, like DrawText() of Windows, font and text must be
  51     specified separately. In SDL_Pango, font specification is embedded in text like
  52     HTML:
  53
  54     \code
  55     <span font_family="Courier New"><i>This is Courier New and italic.</i></span>
  56     \endcode
  57
  58     Color, size, subscript/superscript, obliquing, weight, and other many features
  59     are also available in same way.
  60
  61     \subsection i18n Internationalized Text
  62
  63     Internationalized text is another key feature. Text is specified by UTF-8. RTL
  64     script (Arabic and Hebrew) and complicated rendering (Arabic, Indic and Thai) are
  65     supported. You can see it with GNOME 2.x.
  66
  67     \section get Getting Started
  68
  69     \subsection getlatest Get latest files
  70
  71     Get latest files from http://sourceforge.net/projects/sdlpango/ .
  72
  73     \subsection install Install Header and Library
  74
  75     In Windows and VS2003, I strongly recommend you to install MSI package. It contains Pango
  76     and fontconfig binaries which are modified as side-by-side components. It is
  77     nearly impossible to build them. (I spent much time to build them...)
  78
  79     In MinGW, I recommend you to use VS2003. Otherwise you may run into the maze of
  80     distribution. If you insist MinGW, you should use MinGW binary archive.
  81
  82     In Un*x, installation consists of:
  83
  84     \code
  85     ./configure
  86     make
  87     make install
  88     \endcode
  89
  90     \subsection inc Includes
  91
  92     To use SDL_Pango functions in a C/C++ source code file, you must use the SDL_Pango.h
  93     include file:
  94
  95     \code
  96     #include "SDL_Pango.h"
  97     \endcode
  98
  99     In Windows, SDL_Pango.h is installed on \c \%ProgramFiles\%\\SDL_Pango \c Development\\include
 100     (usually \c C:\\Program \c Files\\SDL_Pango \c Development\\include). You should add this
 101     directory to include path.
 102
 103     \subsection comp Compiling
 104
 105     In Un*x, to link with SDL_Pango you should use sdl-config to get the required SDL
 106     compilation options. After that, compiling with SDL_Pango is quite easy.
 107
 108     Note: Some systems may not have the SDL_Pango library and include file in the same
 109     place as the SDL library and includes are located, in that case you will need to
 110     add more -I and -L paths to these command lines.
 111
 112     Simple Example for compiling an object file:
 113
 114     \code
 115     cc -c `sdl-config --cflags` mysource.c
 116     \endcode
 117
 118     Simple Example for linking an object file:
 119
 120     \code
 121     cc -o myprogram mysource.o `sdl-config --libs` -lSDL_Pango
 122     \endcode
 123
 124     Now myprogram is ready to run.
 125
 126     You can see a sample of autoconfiscation in 'test' directory.
 127
 128     In Windows, MSI package installs many dlls to \c \%ProgramFiles\%\\SDL_Pango \c Development\\import_lib.
 129     To link with SDL_Pango you should use SDL_Pango.lib.
 130
 131     SDL_Pango.dll depends on many dlls and other many files. Those dlls are installed on
 132     \c \%ProgramFiles\%\\SDL_Pango \c Development\\bin. MSI package adds the directory to PATH environment
 133     variable.
 134
 135     \section devel Development
 136
 137     \subsection font Font Handling
 138
 139     In Un*x, font handling depends on fontconfig of your system.
 140
 141     In Windows, local.conf of fontconfig is placed on \c \%ProgramFiles\%\\SDL_Pango \c Development\\etc\\fonts.
 142     You should know about fontconfig's font cache mechanism.
 143
 144     \subsection example Step-by-step Example
 145
 146     The operation of SDL_Pango is done via context.
 147
 148     \code
 149     SDLPango_Context *context = SDLPango_CreateContext();
 150     \endcode
 151
 152     Specify default colors and minimum surface size.
 153
 154     \code
 155     SDLPango_SetDefaultColor(context, MATRIX_TRANSPARENT_BACK_WHITE_LETTER);
 156     SDLPango_SetMinimumSize(context, 640, 0);
 157     \endcode
 158
 159     Set markup text.
 160
 161     \code
 162     SDLPango_SetMarkup(context, "This is <i>markup</i> text.", -1);
 163     \endcode
 164
 165     Now you can get the size of surface.
 166
 167     \code
 168     int w = SDLPango_GetLayoutWidth(context);
 169     int h = SDLPango_GetLayoutHeight(context);
 170     \endcode
 171
 172     Create surface to draw.
 173
 174     \code
 175     int margin_x = 10;
 176     int margin_y = 10;
 177     SDL_Surface *surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
 178         w + margin_x * 2, h + margin_y * 2,
 179         32, (Uint32)(255 << (8 * 3)), (Uint32)(255 << (8 * 2)),
 180         (Uint32)(255 << (8 * 1)), 255);
 181     \endcode
 182
 183     And draw on it.
 184
 185     \code
 186     SDLPango_Draw(context, surface, margin_x, margin_y);
 187     \endcode
 188
 189     You must free the surface by yourself.
 190
 191     \code
 192     SDL_FreeSurface(surface);
 193     \endcode
 194
 195     Free context.
 196
 197     \code
 198     SDLPango_FreeContext(context);
 199     \endcode
 200
 201     You can see actual code in \c test/testbench.cpp.
 202
 203     \subsection pack Packaging
 204
 205     In Un*x, do it yourself.
 206
 207     In Windows, font files must be installed on apprication folder (usually
 208     \c C:\\Program \c Files\\[Manufacturer]\\[ProductName]). The property of
 209     apprication folder must be \c TARGETDIR (this is default setting of VS2003).
 210     SDL.dll also must be installed on apprication folder. Add SDL_Pango.msm to
 211     your MSI package.
 212
 213     \section ack Acknowledgment
 214
 215     SDL_Pango is developed with financial assistance of Information-technology Promotion Agency, Japan.
 216
 217 - NAKAMURA Ken'ichi <nakamura@sbp.fp.a.u-tokyo.ac.jp>
 218
 219 */
 220
 221 /*! @file
 222     @brief Implementation of SDL_Pango
 223
 224     @author NAKAMURA Ken'ichi
 225     @date   2004/12/07
 226     $Revision: 1.6 $
 227 */
 228
 229 #include <pango/pango.h>
 230 #include <pango/pangoft2.h>
 231
 232 #include "SDL_Pango.h"
 233
 234 //! non-zero if initialized
 235 static int IS_INITIALIZED = 0;
 236
 237 #define DEFAULT_FONT_FAMILY "sans-serif"
 238 #define DEFAULT_FONT_SIZE 12
 239 #define DEFAULT_DPI 96
 240 #define _MAKE_FONT_NAME(family, size) family " " #size
 241 #define MAKE_FONT_NAME(family, size) _MAKE_FONT_NAME(family, size)
 242 #define DEFAULT_DEPTH 32
 243 #define DEFAULT_RMASK (Uint32)(255 << (8 * 3))
 244 #define DEFAULT_GMASK (Uint32)(255 << (8 * 2))
 245 #define DEFAULT_BMASK (Uint32)(255 << (8 * 1))
 246 #define DEFAULT_AMASK (Uint32)255
 247
 248 static FT_Bitmap *createFTBitmap(int width, int height);
 249
 250 static void freeFTBitmap(FT_Bitmap *bitmap);
 251
 252 static void getItemProperties (
 253     PangoItem      *item,
 254     PangoUnderline *uline,
 255     gboolean       *strikethrough,
 256     gint           *rise,
 257     PangoColor     *fg_color,
 258     gboolean       *fg_set,
 259     PangoColor     *bg_color,
 260     gboolean       *bg_set,
 261     gboolean       *shape_set,
 262     PangoRectangle *ink_rect,
 263     PangoRectangle *logical_rect);
 264
 265 static void clearFTBitmap(FT_Bitmap *bitmap);
 266
 267 typedef struct _surfaceArgs {
 268     Uint32 flags;
 269     int depth;
 270     Uint32 Rmask;
 271     Uint32 Gmask;
 272     Uint32 Bmask;
 273     Uint32 Amask;
 274 } surfaceArgs;
 275
 276 typedef struct _contextImpl {
 277     PangoContext *context;
 278     PangoFontMap *font_map;
 279     PangoFontDescription *font_desc;
 280     PangoLayout *layout;
 281     surfaceArgs surface_args;
 282     FT_Bitmap *tmp_ftbitmap;
 283     SDLPango_Matrix color_matrix;
 284     int min_width;
 285     int min_height;
 286 } contextImpl;
 287
 288
 289 const SDLPango_Matrix _MATRIX_WHITE_BACK
 290     = {255, 0, 0, 0,
 291        255, 0, 0, 0,
 292        255, 0, 0, 0,
 293        255, 255, 0, 0,};
 294
 295 /*!
 296     Specifies white back and black letter.
 297 */
 298 const SDLPango_Matrix *MATRIX_WHITE_BACK = &_MATRIX_WHITE_BACK;
 299
 300 const SDLPango_Matrix _MATRIX_BLACK_BACK
 301     = {0, 255, 0, 0,
 302        0, 255, 0, 0,
 303        0, 255, 0, 0,
 304        255, 255, 0, 0,};
 305 /*!
 306     Specifies black back and white letter.
 307 */
 308 const SDLPango_Matrix *MATRIX_BLACK_BACK = &_MATRIX_BLACK_BACK;
 309
 310 const SDLPango_Matrix _MATRIX_TRANSPARENT_BACK_BLACK_LETTER
 311     = {0, 0, 0, 0,
 312        0, 0, 0, 0,
 313        0, 0, 0, 0,
 314        0, 255, 0, 0,};
 315 /*!
 316     Specifies transparent back and black letter.
 317 */
 318 const SDLPango_Matrix *MATRIX_TRANSPARENT_BACK_BLACK_LETTER = &_MATRIX_TRANSPARENT_BACK_BLACK_LETTER;
 319
 320 const SDLPango_Matrix _MATRIX_TRANSPARENT_BACK_WHITE_LETTER
 321     = {255, 255, 0, 0,
 322        255, 255, 0, 0,
 323        255, 255, 0, 0,
 324        0, 255, 0, 0,};
 325 /*!
 326     Specifies transparent back and white letter.
 327 */
 328 const SDLPango_Matrix *MATRIX_TRANSPARENT_BACK_WHITE_LETTER = &_MATRIX_TRANSPARENT_BACK_WHITE_LETTER;
 329
 330 const SDLPango_Matrix _MATRIX_TRANSPARENT_BACK_TRANSPARENT_LETTER
 331     = {255, 255, 0, 0,
 332        255, 255, 0, 0,
 333        255, 255, 0, 0,
 334        0, 0, 0, 0,};
 335 /*!
 336     Specifies transparent back and transparent letter.
 337     This is useful for KARAOKE like rendering.
 338 */
 339 const SDLPango_Matrix *MATRIX_TRANSPARENT_BACK_TRANSPARENT_LETTER = &_MATRIX_TRANSPARENT_BACK_TRANSPARENT_LETTER;
 340
 341
 342 /*!
 343     Initialize the Glib and Pango API.
 344     This must be called before using other functions in this library,
 345     excepting SDLPango_WasInit.
 346     SDL does not have to be initialized before this call.
 347
 348
 349     @return always 0.
 350 */
 351 int
 352 SDLPango_Init()
 353 {
 354     g_type_init();
 355
 356     IS_INITIALIZED = -1;
 357
 358     return 0;
 359 }
 360
 361 /*!
 362     Query the initilization status of the Glib and Pango API.
 363     You may, of course, use this before SDLPango_Init to avoid
 364     initilizing twice in a row.
 365
 366     @return zero when already initialized.
 367     non-zero when not initialized.
 368 */
 369 int
 370 SDLPango_WasInit()
 371 {
 372     return IS_INITIALIZED;
 373 }
 374
 375 /*!
 376     Draw glyphs on rect.
 377
 378     @param *context [in] Context
 379     @param *surface [out] Surface to draw on it
 380     @param *color_matrix [in] Foreground and background color
 381     @param *font [in] Innter variable of Pango
 382     @param *glyphs [in] Innter variable of Pango
 383     @param *rect [in] Draw on this area
 384     @param baseline [in] Horizontal location of glyphs
 385 */
 386 static void
 387 drawGlyphString(
 388     SDLPango_Context *context,
 389     SDL_Surface *surface,
 390     SDLPango_Matrix *color_matrix,
 391     PangoFont *font,
 392     PangoGlyphString *glyphs,
 393     SDL_Rect *rect,
 394     int baseline)
 395 {
 396     pango_ft2_render(context->tmp_ftbitmap, font, glyphs, rect->x, rect->y + baseline);
 397
 398     SDLPango_CopyFTBitmapToSurface(
 399         context->tmp_ftbitmap,
 400         surface,
 401         color_matrix,
 402         rect);
 403
 404     clearFTBitmap(context->tmp_ftbitmap);
 405 }
 406
 407 /*!
 408     Draw horizontal line of a pixel.
 409
 410     @param *surface [out] Surface to draw on it
 411     @param *color_matrix [in] Foreground and background color
 412     @param y [in] Y location of line
 413     @param start [in] Left of line
 414     @param end [in] Right of line
 415 */
 416 static void drawHLine(
 417     SDL_Surface *surface,
 418     SDLPango_Matrix *color_matrix,
 419     int y,
 420     int start,
 421     int end)
 422 {
 423     Uint8 *p;
 424     Uint16 *p16;
 425     Uint32 *p32;
 426     Uint32 color;
 427     int ix;
 428     int pixel_bytes = surface->format->BytesPerPixel;
 429
 430     if (y < 0 || y >= surface->h)
 431         return;
 432
 433     if (end <= 0 || start >= surface->w)
 434         return;
 435
 436     if (start < 0)
 437         start = 0;
 438
 439     if (end >= surface->w)
 440         end = surface->w;
 441
 442     p = (Uint8 *)(surface->pixels) + y * surface->pitch + start * pixel_bytes;
 443     color = SDL_MapRGBA(surface->format,
 444         color_matrix->m[0][1],
 445         color_matrix->m[1][1],
 446         color_matrix->m[2][1],
 447         color_matrix->m[3][1]);
 448
 449     switch(pixel_bytes) {
 450     case 2:
 451         p16 = (Uint16 *)p;
 452         for (ix = 0; ix < end - start; ix++)
 453             *p16++ = (Uint16)color;
 454         break;
 455     case 4:
 456         p32 = (Uint32 *)p;
 457         for (ix = 0; ix < end - start; ix++)
 458             *p32++ = color;
 459         break;
 460     default:
 461         SDL_SetError("surface->format->BytesPerPixel is invalid value");
 462         break;
 463     }
 464 }
 465
 466 /*!
 467     Draw a line.
 468
 469     @param *context [in] Context
 470     @param *surface [out] Surface to draw on it
 471     @param *line [in] Innter variable of Pango
 472     @param x [in] X location of line
 473     @param y [in] Y location of line
 474     @param height [in] Height of line
 475     @param baseline [in] Rise / sink of line (for super/subscript)
 476 */
 477 static void
 478 drawLine(
 479     SDLPango_Context *context,
 480     SDL_Surface *surface,
 481     PangoLayoutLine *line,
 482     gint x,
 483     gint y,
 484     gint height,
 485     gint baseline)
 486 {
 487     GSList *tmp_list = line->runs;
 488     PangoColor fg_color, bg_color;
 489     PangoRectangle logical_rect;
 490     PangoRectangle ink_rect;
 491     int x_off = 0;
 492
 493     while (tmp_list) {
 494         SDLPango_Matrix color_matrix = context->color_matrix;
 495         PangoUnderline uline = PANGO_UNDERLINE_NONE;
 496         gboolean strike, fg_set, bg_set, shape_set;
 497         gint rise, risen_y;
 498         PangoLayoutRun *run = tmp_list->data;
 499         SDL_Rect d_rect;
 500
 501         tmp_list = tmp_list->next;
 502
 503         getItemProperties(run->item,
 504             &uline, &strike, &rise,
 505             &fg_color, &fg_set, &bg_color, &bg_set,
 506             &shape_set, &ink_rect, &logical_rect);
 507
 508         risen_y = y + baseline - PANGO_PIXELS (rise);
 509
 510         if(fg_set) {
 511             color_matrix.m[0][1] = (Uint8)(fg_color.red >> 8);
 512             color_matrix.m[1][1] = (Uint8)(fg_color.green >> 8);
 513             color_matrix.m[2][1] = (Uint8)(fg_color.blue >> 8);
 514             color_matrix.m[3][1] = 255;
 515             if(color_matrix.m[3][0] == 0) {
 516                 color_matrix.m[0][0] = (Uint8)(fg_color.red >> 8);
 517                 color_matrix.m[1][0] = (Uint8)(fg_color.green >> 8);
 518                 color_matrix.m[2][0] = (Uint8)(fg_color.blue >> 8);
 519             }
 520         }
 521
 522         if (bg_set) {
 523             color_matrix.m[0][0] = (Uint8)(bg_color.red >> 8);
 524             color_matrix.m[1][0] = (Uint8)(bg_color.green >> 8);
 525             color_matrix.m[2][0] = (Uint8)(bg_color.blue >> 8);
 526             color_matrix.m[3][0] = 255;
 527         }
 528
 529         if(! shape_set) {
 530             if (uline == PANGO_UNDERLINE_NONE)
 531                 pango_glyph_string_extents (run->glyphs, run->item->analysis.font,
 532                                             NULL, &logical_rect);
 533             else
 534                 pango_glyph_string_extents (run->glyphs, run->item->analysis.font,
 535                                             &ink_rect, &logical_rect);
 536
 537             d_rect.w = (Uint16)PANGO_PIXELS(logical_rect.width);
 538             d_rect.h = (Uint16)height;
 539             d_rect.x = (Uint16)(x + PANGO_PIXELS (x_off));
 540             d_rect.y = (Uint16)(risen_y - baseline);
 541
 542             if((! context->tmp_ftbitmap) || d_rect.w + d_rect.x > context->tmp_ftbitmap->width
 543                 || d_rect.h + d_rect.y > context->tmp_ftbitmap->rows)
 544             {
 545                 freeFTBitmap(context->tmp_ftbitmap);
 546                 context->tmp_ftbitmap = createFTBitmap(d_rect.w + d_rect.x, d_rect.h + d_rect.y);
 547             }
 548
 549             drawGlyphString(context, surface,
 550                 &color_matrix,
 551                 run->item->analysis.font, run->glyphs, &d_rect, baseline);
 552         }
 553         switch (uline) {
 554         case PANGO_UNDERLINE_NONE:
 555             break;
 556         case PANGO_UNDERLINE_DOUBLE:
 557             drawHLine(surface, &color_matrix,
 558                 risen_y + 4,
 559                 x + PANGO_PIXELS (x_off + ink_rect.x),
 560                 x + PANGO_PIXELS (x_off + ink_rect.x + ink_rect.width));
 561           /* Fall through */
 562         case PANGO_UNDERLINE_SINGLE:
 563             drawHLine(surface, &color_matrix,
 564                 risen_y + 2,
 565                 x + PANGO_PIXELS (x_off + ink_rect.x),
 566                 x + PANGO_PIXELS (x_off + ink_rect.x + ink_rect.width));
 567             break;
 568         case PANGO_UNDERLINE_ERROR:
 569             {
 570                 int point_x;
 571                 int counter = 0;
 572                 int end_x = x + PANGO_PIXELS (x_off + ink_rect.x + ink_rect.width);
 573
 574                 for (point_x = x + PANGO_PIXELS (x_off + ink_rect.x) - 1;
 575                     point_x <= end_x;
 576                     point_x += 2)
 577                 {
 578                     if (counter)
 579                         drawHLine(surface, &color_matrix,
 580                             risen_y + 2,
 581                             point_x, MIN (point_x + 1, end_x));
 582                     else
 583                         drawHLine(surface, &color_matrix,
 584                             risen_y + 3,
 585                             point_x, MIN (point_x + 1, end_x));
 586
 587                     counter = (counter + 1) % 2;
 588                 }
 589             }
 590             break;
 591         case PANGO_UNDERLINE_LOW:
 592             drawHLine(surface, &color_matrix,
 593                 risen_y + PANGO_PIXELS (ink_rect.y + ink_rect.height),
 594                 x + PANGO_PIXELS (x_off + ink_rect.x),
 595                 x + PANGO_PIXELS (x_off + ink_rect.x + ink_rect.width));
 596           break;
 597         }
 598
 599         if (strike)
 600             drawHLine(surface, &color_matrix,
 601                 risen_y + PANGO_PIXELS (logical_rect.y + logical_rect.height / 2),
 602                 x + PANGO_PIXELS (x_off + logical_rect.x),
 603                 x + PANGO_PIXELS (x_off + logical_rect.x + logical_rect.width));
 604
 605         x_off += logical_rect.width;
 606     }
 607 }
 608
 609 /*!
 610     Innter function of Pango. Stolen from GDK.
 611
 612     @param *item [in] The item to get property
 613     @param *uline [out] Kind of underline
 614     @param *strikethrough [out] Strike-through line
 615     @param *rise [out] Rise/sink of line (for super/subscript)
 616     @param *fg_color [out] Color of foreground
 617     @param *fg_set [out] True if fg_color set
 618     @param *bg_color [out] Color of background
 619     @param *bg_set [out] True if bg_color valid
 620     @param *shape_set [out] True if ink_rect and logical_rect valid
 621     @param *ink_rect [out] Ink rect
 622     @param *logical_rect [out] Logical rect
 623 */
 624 static void
 625 getItemProperties (
 626     PangoItem *item,
 627     PangoUnderline *uline,
 628     gboolean *strikethrough,
 629     gint *rise,
 630     PangoColor *fg_color,
 631     gboolean *fg_set,
 632     PangoColor *bg_color,
 633     gboolean *bg_set,
 634     gboolean *shape_set,
 635     PangoRectangle *ink_rect,
 636     PangoRectangle *logical_rect)
 637 {
 638     GSList *tmp_list = item->analysis.extra_attrs;
 639
 640     if (strikethrough)
 641         *strikethrough = FALSE;
 642
 643     if (fg_set)
 644         *fg_set = FALSE;
 645
 646     if (bg_set)
 647         *bg_set = FALSE;
 648
 649     if (shape_set)
 650         *shape_set = FALSE;
 651
 652     if (rise)
 653         *rise = 0;
 654
 655     while (tmp_list) {
 656         PangoAttribute *attr = tmp_list->data;
 657
 658         switch (attr->klass->type) {
 659         case PANGO_ATTR_UNDERLINE:
 660             if (uline)
 661                 *uline = ((PangoAttrInt *)attr)->value;
 662             break;
 663
 664         case PANGO_ATTR_STRIKETHROUGH:
 665             if (strikethrough)
 666                 *strikethrough = ((PangoAttrInt *)attr)->value;
 667             break;
 668
 669         case PANGO_ATTR_FOREGROUND:
 670             if (fg_color)
 671                 *fg_color = ((PangoAttrColor *)attr)->color;
 672             if (fg_set)
 673                 *fg_set = TRUE;
 674             break;
 675
 676         case PANGO_ATTR_BACKGROUND:
 677             if (bg_color)
 678                 *bg_color = ((PangoAttrColor *)attr)->color;
 679             if (bg_set)
 680                 *bg_set = TRUE;
 681             break;
 682
 683         case PANGO_ATTR_SHAPE:
 684             if (shape_set)
 685                 *shape_set = TRUE;
 686             if (logical_rect)
 687                 *logical_rect = ((PangoAttrShape *)attr)->logical_rect;
 688             if (ink_rect)
 689                 *ink_rect = ((PangoAttrShape *)attr)->ink_rect;
 690             break;
 691
 692         case PANGO_ATTR_RISE:
 693             if (rise)
 694                 *rise = ((PangoAttrInt *)attr)->value;
 695             break;
 696
 697         default:
 698             break;
 699         }
 700         tmp_list = tmp_list->next;
 701     }
 702 }
 703
 704 /*!
 705     Copy bitmap to surface.
 706     From (x, y)-(w, h) to (x, y)-(w, h) of rect.
 707
 708     @param *bitmap [in] Grayscale bitmap
 709     @param *surface [out] Surface
 710     @param *matrix [in] Foreground and background color
 711     @param *rect [in] Rect to copy
 712 */
 713 void
 714 SDLPango_CopyFTBitmapToSurface(
 715     const FT_Bitmap *bitmap,
 716     SDL_Surface *surface,
 717     const SDLPango_Matrix *matrix,
 718     SDL_Rect *rect)
 719 {
 720     int i;
 721     Uint8 *p_ft;
 722     Uint8 *p_sdl;
 723     int width = rect->w;
 724     int height = rect->h;
 725     int x = rect->x;
 726     int y = rect->y;
 727
 728     if(x + width > surface->w) {
 729         width = surface->w - x;
 730         if(width <= 0)
 731             return;
 732     }
 733     if(y + height > surface->h) {
 734         height = surface->h - y;
 735         if(height <= 0)
 736             return;
 737     }
 738
 739     if(SDL_LockSurface(surface)) {
 740         SDL_SetError("surface lock failed");
 741         SDL_FreeSurface(surface);
 742         return;
 743     }
 744
 745     p_ft = (Uint8 *)bitmap->buffer + (bitmap->pitch * y);
 746     p_sdl = (Uint8 *)surface->pixels + (surface->pitch * y);
 747     for(i = 0; i < height; i ++) {
 748         int k;
 749         for(k = 0; k < width; k ++) {
 750             /* TODO: rewrite by matrix calculation library */
 751             Uint8 pixel[4];     /* 4: RGBA */
 752             int n;
 753
 754             for(n = 0; n < 4; n ++) {
 755                 Uint16 w;
 756                 w = ((Uint16)matrix->m[n][0] * (256 - p_ft[k + x])) + ((Uint16)matrix->m[n][1] * p_ft[k + x]);
 757                 pixel[n] = (Uint8)(w >> 8);
 758             }
 759
 760             switch(surface->format->BytesPerPixel) {
 761             case 2:
 762                 ((Uint16 *)p_sdl)[k + x] = (Uint16)SDL_MapRGBA(surface->format, pixel[0], pixel[1], pixel[2], pixel[3]);
 763                 break;
 764             case 4:
 765                 ((Uint32 *)p_sdl)[k + x] = SDL_MapRGBA(surface->format, pixel[0], pixel[1], pixel[2], pixel[3]);
 766                 break;
 767             default:
 768                 SDL_SetError("surface->format->BytesPerPixel is invalid value");
 769                 return;
 770             }
 771         }
 772         p_ft += bitmap->pitch;
 773         p_sdl += surface->pitch;
 774     }
 775
 776     SDL_UnlockSurface(surface);
 777 }
 778
 779
 780 SDLPango_Context*
 781 SDLPango_CreateContext_GivenFontDesc(const char* font_desc)
 782 {
 783     SDLPango_Context *context = g_malloc(sizeof(SDLPango_Context));
 784     G_CONST_RETURN char *charset;
 785
 786     context->font_map = pango_ft2_font_map_new ();
 787     pango_ft2_font_map_set_resolution (PANGO_FT2_FONT_MAP (context->font_map), DEFAULT_DPI, DEFAULT_DPI);
 788
 789     context->context = pango_ft2_font_map_create_context (PANGO_FT2_FONT_MAP (context->font_map));
 790
 791     g_get_charset(&charset);
 792     pango_context_set_language (context->context, pango_language_from_string (charset));
 793     pango_context_set_base_dir (context->context, PANGO_DIRECTION_LTR);
 794
 795     context->font_desc = pango_font_description_from_string(font_desc);
 796
 797     context->layout = pango_layout_new (context->context);
 798
 799     SDLPango_SetSurfaceCreateArgs(context, SDL_SWSURFACE | SDL_SRCALPHA, DEFAULT_DEPTH,
 800         DEFAULT_RMASK, DEFAULT_GMASK, DEFAULT_BMASK, DEFAULT_AMASK);
 801
 802     context->tmp_ftbitmap = NULL;
 803
 804     context->color_matrix = *MATRIX_TRANSPARENT_BACK_BLACK_LETTER;
 805
 806     context->min_height = 0;
 807     context->min_width = 0;
 808
 809     return context;
 810 }
 811
 812 /*!
 813     Create a context which contains Pango objects.
 814
 815     @return A pointer to the context as a SDLPango_Context*.
 816 */
 817 SDLPango_Context*
 818 SDLPango_CreateContext()
 819 {
 820     SDLPango_CreateContext_GivenFontDesc(MAKE_FONT_NAME(DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE));
 821 }
 822
 823 /*!
 824     Free a context.
 825
 826     @param *context [i/o] Context to be free
 827 */
 828 void
 829 SDLPango_FreeContext(SDLPango_Context *context)
 830 {
 831     freeFTBitmap(context->tmp_ftbitmap);
 832
 833     g_object_unref (context->layout);
 834
 835     pango_font_description_free(context->font_desc);
 836
 837     g_object_unref(context->context);
 838
 839     g_object_unref(context->font_map);
 840
 841     g_free(context);
 842 }
 843
 844 /*!
 845     Specify Arguments when create a surface.
 846     When SDL_Pango creates a surface, the arguments are used.
 847
 848     @param *context [i/o] Context
 849     @param flags [in] Same as SDL_CreateRGBSurface()
 850     @param depth [in] Same as SDL_CreateRGBSurface()
 851     @param Rmask [in] Same as SDL_CreateRGBSurface()
 852     @param Gmask [in] Same as SDL_CreateRGBSurface()
 853     @param Bmask [in] Same as SDL_CreateRGBSurface()
 854     @param Amask [in] Same as SDL_CreateRGBSurface()
 855 */
 856 void
 857 SDLPango_SetSurfaceCreateArgs(
 858     SDLPango_Context *context,
 859     Uint32 flags,
 860     int depth,
 861     Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
 862 {
 863     context->surface_args.flags = flags;
 864     context->surface_args.depth = depth;
 865     context->surface_args.Rmask = Rmask;
 866     context->surface_args.Gmask = Gmask;
 867     context->surface_args.Bmask = Bmask;
 868     context->surface_args.Amask = Amask;
 869 }
 870
 871 /*!
 872     Create a surface and draw text on it.
 873     The size of surface is same as lauout size.
 874
 875     @param *context [in] Context
 876     @return A newly created surface
 877 */
 878 SDL_Surface * SDLPango_CreateSurfaceDraw(
 879     SDLPango_Context *context)
 880 {
 881     PangoRectangle logical_rect;
 882     SDL_Surface *surface;
 883     int width, height;
 884
 885     pango_layout_get_extents (context->layout, NULL, &logical_rect);
 886     width = PANGO_PIXELS (logical_rect.width);
 887     height = PANGO_PIXELS (logical_rect.height);
 888     if(width < context->min_width)
 889         width = context->min_width;
 890     if(height < context->min_height)
 891         height = context->min_height;
 892
 893     surface = SDL_CreateRGBSurface(
 894         context->surface_args.flags,
 895         width, height, context->surface_args.depth,
 896         context->surface_args.Rmask,
 897         context->surface_args.Gmask,
 898         context->surface_args.Bmask,
 899         context->surface_args.Amask);
 900
 901     SDLPango_Draw(context, surface, 0, 0);
 902
 903     return surface;
 904 }
 905
 906 /*!
 907     Draw text on a existing surface.
 908
 909     @param *context [in] Context
 910     @param *surface [i/o] Surface to draw on it
 911     @param x [in] X of left-top of drawing area
 912     @param y [in] Y of left-top of drawing area
 913 */
 914 void
 915 SDLPango_Draw(
 916     SDLPango_Context *context,
 917     SDL_Surface *surface,
 918     int x, int y)
 919 {
 920     PangoLayoutIter *iter;
 921     PangoRectangle logical_rect;
 922     int width, height;
 923
 924     if(! surface) {
 925         SDL_SetError("surface is NULL");
 926         return;
 927     }
 928
 929     iter = pango_layout_get_iter (context->layout);
 930
 931     pango_layout_get_extents (context->layout, NULL, &logical_rect);
 932     width = PANGO_PIXELS (logical_rect.width);
 933     height = PANGO_PIXELS (logical_rect.height);
 934
 935     SDL_FillRect(surface, NULL, SDL_MapRGBA(surface->format, 0, 0, 0, 0));
 936
 937     if((! context->tmp_ftbitmap) || context->tmp_ftbitmap->width < width
 938         || context->tmp_ftbitmap->rows < height)
 939     {
 940         freeFTBitmap(context->tmp_ftbitmap);
 941         context->tmp_ftbitmap = createFTBitmap(width, height);
 942     }
 943
 944     do {
 945         PangoLayoutLine *line;
 946         int baseline;
 947
 948         line = pango_layout_iter_get_line (iter);
 949
 950         pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
 951         baseline = pango_layout_iter_get_baseline (iter);
 952
 953         drawLine(
 954             context,
 955             surface,
 956             line,
 957             x + PANGO_PIXELS (logical_rect.x),
 958             y + PANGO_PIXELS (logical_rect.y),
 959             PANGO_PIXELS (logical_rect.height),
 960             PANGO_PIXELS (baseline - logical_rect.y));
 961     } while (pango_layout_iter_next_line (iter));
 962
 963     pango_layout_iter_free (iter);
 964 }
 965
 966 /*!
 967     Allocate buffer and create a FTBitmap object.
 968
 969     @param width [in] Width
 970     @param height [in] Height
 971     @return FTBitmap object
 972 */
 973 static FT_Bitmap *
 974 createFTBitmap(
 975     int width, int height)
 976 {
 977     FT_Bitmap *bitmap;
 978     guchar *buf;
 979
 980     bitmap = g_malloc(sizeof(FT_Bitmap));
 981     bitmap->width = width;
 982     bitmap->rows = height;
 983     bitmap->pitch = (width + 3) & ~3;
 984     bitmap->num_grays = 256;
 985     bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
 986     buf = g_malloc (bitmap->pitch * bitmap->rows);
 987     memset (buf, 0x00, bitmap->pitch * bitmap->rows);
 988     bitmap->buffer = buf;
 989
 990     return bitmap;
 991 }
 992
 993 /*!
 994     Free a FTBitmap object.
 995
 996     @param *bitmap [i/o] FTbitmap to be free
 997 */
 998 static void
 999 freeFTBitmap(
1000     FT_Bitmap *bitmap)
1001 {
1002     if(bitmap) {
1003         g_free(bitmap->buffer);
1004         g_free(bitmap);
1005     }
1006 }
1007
1008 /*!
1009     Clear a FTBitmap object.
1010
1011     @param *bitmap [i/o] FTbitmap to be clear
1012 */
1013 static void
1014 clearFTBitmap(
1015     FT_Bitmap *bitmap)
1016 {
1017     Uint8 *p = (Uint8 *)bitmap->buffer;
1018     int length = bitmap->pitch * bitmap->rows;
1019
1020     memset(p, 0, length);
1021 }
1022
1023 /*!
1024     Specify minimum size of drawing rect.
1025
1026     @param *context [i/o] Context
1027     @param width [in] Width. -1 means no wrapping mode.
1028     @param height [in] Height. zero/minus value means non-specified.
1029 */
1030 void
1031 SDLPango_SetMinimumSize(
1032     SDLPango_Context *context,
1033     int width, int height)
1034 {
1035     int pango_width;
1036     if(width > 0)
1037         pango_width = width * PANGO_SCALE;
1038     else
1039         pango_width = -1;
1040     pango_layout_set_width(context->layout, pango_width);
1041
1042     context->min_width = width;
1043     context->min_height = height;
1044 }
1045
1046 /*!
1047     Specify default color.
1048
1049     @param *context [i/o] Context
1050     @param *color_matrix [in] Foreground and background color
1051 */
1052 void
1053 SDLPango_SetDefaultColor(
1054     SDLPango_Context *context,
1055     const SDLPango_Matrix *color_matrix)
1056 {
1057     context->color_matrix = *color_matrix;
1058 }
1059
1060 /*!
1061     Get layout width.
1062
1063     @param *context [in] Context
1064     @return Width
1065 */
1066 int
1067 SDLPango_GetLayoutWidth(
1068     SDLPango_Context *context)
1069 {
1070     PangoRectangle logical_rect;
1071
1072     pango_layout_get_extents (context->layout, NULL, &logical_rect);
1073
1074     return PANGO_PIXELS (logical_rect.width);
1075 }
1076
1077 /*!
1078     Get layout height.
1079
1080     @param *context [in] Context
1081     @return Height
1082 */
1083 int
1084 SDLPango_GetLayoutHeight(
1085     SDLPango_Context *context)
1086 {
1087     PangoRectangle logical_rect;
1088
1089     pango_layout_get_extents (context->layout, NULL, &logical_rect);
1090
1091     return PANGO_PIXELS (logical_rect.height);
1092 }
1093
1094 /*!
1095     Set markup text to context.
1096     Text must be utf-8.
1097     Markup format is same as pango.
1098
1099     @param *context [i/o] Context
1100     @param *markup [in] Markup text
1101     @param length [in] Text length. -1 means NULL-terminated text.
1102 */
1103 void
1104 SDLPango_SetMarkup(
1105     SDLPango_Context *context,
1106     const char *markup,
1107     int length)
1108 {
1109     pango_layout_set_markup (context->layout, markup, length);
1110     pango_layout_set_auto_dir (context->layout, TRUE);
1111     pango_layout_set_alignment (context->layout, PANGO_ALIGN_LEFT);
1112     pango_layout_set_font_description (context->layout, context->font_desc);
1113 }
1114
1115 void
1116 SDLPango_SetText_GivenAlignment(
1117     SDLPango_Context *context,
1118     const char *text,
1119     int length,
1120     SDLPango_Alignment alignment)
1121 {
1122     pango_layout_set_attributes(context->layout, NULL);
1123     pango_layout_set_text (context->layout, text, length);
1124     pango_layout_set_auto_dir (context->layout, TRUE);
1125     pango_layout_set_alignment (context->layout, alignment);
1126     pango_layout_set_font_description (context->layout, context->font_desc);
1127 }
1128
1129 /*!
1130     Set plain text to context.
1131     Text must be utf-8.
1132
1133     @param *context [i/o] Context
1134     @param *text [in] Plain text
1135     @param length [in] Text length. -1 means NULL-terminated text.
1136 */
1137 void
1138 SDLPango_SetText(
1139     SDLPango_Context *context,
1140     const char *text,
1141     int length)
1142 {
1143     SDLPango_SetText_GivenAlignment(context, text, length, SDLPANGO_ALIGN_LEFT);
1144 }
1145
1146 /*!
1147     Set DPI to context.
1148
1149     @param *context [i/o] Context
1150     @param dpi_x [in] X dpi
1151     @param dpi_y [in] Y dpi
1152 */
1153 void
1154 SDLPango_SetDpi(
1155     SDLPango_Context *context,
1156     double dpi_x, double dpi_y)
1157 {
1158     pango_ft2_font_map_set_resolution (PANGO_FT2_FONT_MAP (context->font_map), dpi_x, dpi_y);
1159 }
1160
1161 /*!
1162     Set language to context.
1163
1164     @param *context [i/o] Context
1165     @param *language_tag [in] A RFC-3066 format language tag
1166 */
1167 void SDLCALL SDLPango_SetLanguage(
1168     SDLPango_Context *context,
1169     const char *language_tag)
1170 {
1171     pango_context_set_language (context->context, pango_language_from_string (language_tag));
1172 }
1173
1174 /*!
1175     Set base direction to context.
1176
1177     @param *context [i/o] Context
1178     @param direction [in] Direction
1179 */
1180 void SDLCALL SDLPango_SetBaseDirection(
1181     SDLPango_Context *context,
1182     SDLPango_Direction direction)
1183 {
1184     PangoDirection pango_dir;
1185
1186     switch(direction) {
1187     case SDLPANGO_DIRECTION_LTR:
1188         pango_dir = PANGO_DIRECTION_LTR;
1189         break;
1190     case SDLPANGO_DIRECTION_RTL:
1191         pango_dir = PANGO_DIRECTION_RTL;
1192         break;
1193     case SDLPANGO_DIRECTION_WEAK_LTR:
1194         pango_dir = PANGO_DIRECTION_WEAK_LTR;
1195         break;
1196     case SDLPANGO_DIRECTION_WEAK_RTL:
1197         pango_dir = PANGO_DIRECTION_WEAK_RTL;
1198         break;
1199     case SDLPANGO_DIRECTION_NEUTRAL:
1200         pango_dir = PANGO_DIRECTION_NEUTRAL;
1201         break;
1202     default:
1203         SDL_SetError("unknown direction value");
1204         return;
1205     }
1206
1207     pango_context_set_base_dir (context->context, pango_dir);
1208 }
1209
1210 /*!
1211     Get font map from context.
1212
1213     @param *context [in] Context
1214     @return Font map
1215 */
1216 PangoFontMap* SDLCALL SDLPango_GetPangoFontMap(
1217     SDLPango_Context *context)
1218 {
1219     return context->font_map;
1220 }
1221
1222 /*!
1223     Get font description from context.
1224
1225     @param *context [in] Context
1226     @return Font description
1227 */
1228 PangoFontDescription* SDLCALL SDLPango_GetPangoFontDescription(
1229     SDLPango_Context *context)
1230 {
1231     return context->font_desc;
1232 }
1233
1234 /*!
1235     Get layout from context.
1236
1237     @param *context [in] Context
1238     @return Layout
1239 */
1240 PangoLayout* SDLCALL SDLPango_GetPangoLayout(
1241     SDLPango_Context *context)
1242 {
1243     return context->layout;
1244 }