de/font.c

   1 /*
   2  * ion/de/font.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <string.h>
  10
  11 #include <libtu/objp.h>
  12 #include <ioncore/common.h>
  13 #include "font.h"
  14 #include "fontset.h"
  15 #include "brush.h"
  16 #include "precompose.h"
  17
  18
  19 /*{{{ UTF-8 processing */
  20
  21
  22 #define UTF_DATA 0x3F
  23 #define UTF_2_DATA 0x1F
  24 #define UTF_3_DATA 0x0F
  25 #define UTF_1 0x80
  26 #define UTF_2 0xC0
  27 #define UTF_3 0xE0
  28 #define UTF_4 0xF0
  29 #define UTF_5 0xF8
  30 #define UTF_6 0xFC
  31
  32 static void toucs(const char *str_, int len, XChar2b **str16, int *len16)
  33 {
  34     int i=0;
  35     const uchar *str=(const uchar*)str_;
  36     wchar_t prev=0;
  37
  38     *str16=ALLOC_N(XChar2b, len);
  39     *len16=0;
  40
  41     while(i<len){
  42         wchar_t ch=0;
  43
  44         if((str[i] & UTF_3) == UTF_3){
  45              if(i+2>=len)
  46                  break;
  47              ch=((str[i] & UTF_3_DATA) << 12)
  48                  | ((str[i+1] & UTF_DATA) << 6)
  49                  | (str[i+2] & UTF_DATA);
  50             i+=3;
  51         }else if((str[i] & UTF_2) == UTF_2){
  52             if(i+1>=len)
  53                 break;
  54             ch = ((str[i] & UTF_2_DATA) << 6) | (str[i+1] & UTF_DATA);
  55             i+=2;
  56         }else if(str[i] < UTF_1){
  57             ch = str[i];
  58             i++;
  59         }else{
  60             ch='?';
  61             i++;
  62         }
  63
  64         if(*len16>0){
  65             wchar_t precomp=do_precomposition(prev, ch);
  66             if(precomp!=-1){
  67                 (*len16)--;
  68                 ch=precomp;
  69             }
  70         }
  71
  72         (*str16)[*len16].byte2=ch&0xff;
  73         (*str16)[*len16].byte1=(ch>>8)&0xff;
  74         (*len16)++;
  75         prev=ch;
  76     }
  77 }
  78
  79
  80 /*}}}*/
  81
  82
  83 /*{{{ Load/free */
  84
  85
  86 static DEFont *fonts=NULL;
  87
  88
  89 static bool iso10646_font(const char *fontname)
  90 {
  91     const char *iso;
  92
  93     if(strchr(fontname, ',')!=NULL)
  94         return FALSE; /* fontset */
  95
  96     iso=strstr(fontname, "iso10646-1");
  97     return (iso!=NULL && iso[10]=='\0');
  98 }
  99
 100
 101 DEFont *de_load_font(const char *fontname)
 102 {
 103     DEFont *fnt;
 104     XFontSet fontset=NULL;
 105     XFontStruct *fontstruct=NULL;
 106
 107     assert(fontname!=NULL);
 108
 109     /* There shouldn't be that many fonts... */
 110     for(fnt=fonts; fnt!=NULL; fnt=fnt->next){
 111         if(strcmp(fnt->pattern, fontname)==0){
 112             fnt->refcount++;
 113             return fnt;
 114         }
 115     }
 116
 117     if(ioncore_g.use_mb && !(ioncore_g.enc_utf8 && iso10646_font(fontname))){
 118         fontset=de_create_font_set(fontname);
 119         if(fontset!=NULL){
 120             if(XContextDependentDrawing(fontset)){
 121                 warn(TR("Fontset for font pattern '%s' implements context "
 122                         "dependent drawing, which is unsupported. Expect "
 123                         "clutter."), fontname);
 124             }
 125         }
 126     }else{
 127         fontstruct=XLoadQueryFont(ioncore_g.dpy, fontname);
 128     }
 129
 130     if(fontstruct==NULL && fontset==NULL){
 131         if(strcmp(fontname, CF_FALLBACK_FONT_NAME)!=0){
 132             DEFont *fnt;
 133             warn(TR("Could not load font \"%s\", trying \"%s\""),
 134                  fontname, CF_FALLBACK_FONT_NAME);
 135             fnt=de_load_font(CF_FALLBACK_FONT_NAME);
 136             if(fnt==NULL)
 137                 warn(TR("Failed to load fallback font."));
 138             return fnt;
 139         }
 140         return NULL;
 141     }
 142
 143     fnt=ALLOC(DEFont);
 144
 145     if(fnt==NULL)
 146         return NULL;
 147
 148     fnt->fontset=fontset;
 149     fnt->fontstruct=fontstruct;
 150     fnt->pattern=scopy(fontname);
 151     fnt->next=NULL;
 152     fnt->prev=NULL;
 153     fnt->refcount=1;
 154
 155     LINK_ITEM(fonts, fnt, next, prev);
 156
 157     return fnt;
 158 }
 159
 160
 161 bool de_set_font_for_style(DEStyle *style, DEFont *font)
 162 {
 163     if(style->font!=NULL)
 164         de_free_font(style->font);
 165
 166     style->font=font;
 167     font->refcount++;
 168
 169     if(style->font->fontstruct!=NULL){
 170         XSetFont(ioncore_g.dpy, style->normal_gc,
 171                  style->font->fontstruct->fid);
 172     }
 173
 174     return TRUE;
 175 }
 176
 177
 178 bool de_load_font_for_style(DEStyle *style, const char *fontname)
 179 {
 180     if(style->font!=NULL)
 181         de_free_font(style->font);
 182
 183     style->font=de_load_font(fontname);
 184
 185     if(style->font==NULL)
 186         return FALSE;
 187
 188     if(style->font->fontstruct!=NULL){
 189         XSetFont(ioncore_g.dpy, style->normal_gc,
 190                  style->font->fontstruct->fid);
 191     }
 192
 193     return TRUE;
 194 }
 195
 196
 197 void de_free_font(DEFont *font)
 198 {
 199     if(--font->refcount!=0)
 200         return;
 201
 202     if(font->fontset!=NULL)
 203         XFreeFontSet(ioncore_g.dpy, font->fontset);
 204     if(font->fontstruct!=NULL)
 205         XFreeFont(ioncore_g.dpy, font->fontstruct);
 206     if(font->pattern!=NULL)
 207         free(font->pattern);
 208
 209     UNLINK_ITEM(fonts, font, next, prev);
 210     free(font);
 211 }
 212
 213
 214 /*}}}*/
 215
 216
 217 /*{{{ Lengths */
 218
 219
 220 void debrush_get_font_extents(DEBrush *brush, GrFontExtents *fnte)
 221 {
 222     if(brush->d->font==NULL){
 223         DE_RESET_FONT_EXTENTS(fnte);
 224         return;
 225     }
 226
 227     defont_get_font_extents(brush->d->font, fnte);
 228 }
 229
 230
 231 void defont_get_font_extents(DEFont *font, GrFontExtents *fnte)
 232 {
 233     if(font->fontset!=NULL){
 234         XFontSetExtents *ext=XExtentsOfFontSet(font->fontset);
 235         if(ext==NULL)
 236             goto fail;
 237         fnte->max_height=ext->max_logical_extent.height;
 238         fnte->max_width=ext->max_logical_extent.width;
 239         fnte->baseline=-ext->max_logical_extent.y;
 240         return;
 241     }else if(font->fontstruct!=NULL){
 242         XFontStruct *fnt=font->fontstruct;
 243         fnte->max_height=fnt->ascent+fnt->descent;
 244         fnte->max_width=fnt->max_bounds.width;
 245         fnte->baseline=fnt->ascent;
 246         return;
 247     }
 248
 249 fail:
 250     DE_RESET_FONT_EXTENTS(fnte);
 251 }
 252
 253
 254 uint debrush_get_text_width(DEBrush *brush, const char *text, uint len)
 255 {
 256     if(brush->d->font==NULL || text==NULL || len==0)
 257         return 0;
 258
 259     return defont_get_text_width(brush->d->font, text, len);
 260 }
 261
 262
 263 uint defont_get_text_width(DEFont *font, const char *text, uint len)
 264 {
 265     if(font->fontset!=NULL){
 266         XRectangle lext;
 267 #ifdef CF_DE_USE_XUTF8
 268         if(ioncore_g.enc_utf8)
 269             Xutf8TextExtents(font->fontset, text, len, NULL, &lext);
 270         else
 271 #endif
 272             XmbTextExtents(font->fontset, text, len, NULL, &lext);
 273         return lext.width;
 274     }else if(font->fontstruct!=NULL){
 275         if(ioncore_g.enc_utf8){
 276             XChar2b *str16; int len16=0;
 277             uint res;
 278
 279             toucs(text, len, &str16, &len16);
 280
 281             res=XTextWidth16(font->fontstruct, str16, len16);
 282
 283             free(str16);
 284
 285             return res;
 286         }else{
 287             return XTextWidth(font->fontstruct, text, len);
 288         }
 289     }else{
 290         return 0;
 291     }
 292 }
 293
 294
 295 /*}}}*/
 296
 297
 298 /*{{{ String drawing */
 299
 300
 301 void debrush_do_draw_string_default(DEBrush *brush, int x, int y,
 302                                     const char *str, int len, bool needfill,
 303                                     DEColourGroup *colours)
 304 {
 305     GC gc=brush->d->normal_gc;
 306
 307     if(brush->d->font==NULL)
 308         return;
 309
 310     XSetForeground(ioncore_g.dpy, gc, colours->fg);
 311
 312     if(!needfill){
 313         if(brush->d->font->fontset!=NULL){
 314 #ifdef CF_DE_USE_XUTF8
 315             if(ioncore_g.enc_utf8)
 316                 Xutf8DrawString(ioncore_g.dpy, brush->win,
 317                                 brush->d->font->fontset,
 318                                 gc, x, y, str, len);
 319             else
 320 #endif
 321                 XmbDrawString(ioncore_g.dpy, brush->win,
 322                               brush->d->font->fontset,
 323                               gc, x, y, str, len);
 324         }else if(brush->d->font->fontstruct!=NULL){
 325             if(ioncore_g.enc_utf8){
 326                 XChar2b *str16; int len16=0;
 327                 toucs(str, len, &str16, &len16);
 328                 XDrawString16(ioncore_g.dpy, brush->win, gc, x, y, str16, len16);
 329                 free(str16);
 330             }else{
 331                 XDrawString(ioncore_g.dpy, brush->win, gc, x, y, str, len);
 332             }
 333         }
 334     }else{
 335         XSetBackground(ioncore_g.dpy, gc, colours->bg);
 336         if(brush->d->font->fontset!=NULL){
 337 #ifdef CF_DE_USE_XUTF8
 338             if(ioncore_g.enc_utf8)
 339                 Xutf8DrawImageString(ioncore_g.dpy, brush->win,
 340                                      brush->d->font->fontset,
 341                                      gc, x, y, str, len);
 342             else
 343 #endif
 344                 XmbDrawImageString(ioncore_g.dpy, brush->win,
 345                                    brush->d->font->fontset,
 346                                    gc, x, y, str, len);
 347         }else if(brush->d->font->fontstruct!=NULL){
 348             if(ioncore_g.enc_utf8){
 349                 XChar2b *str16; int len16=0;
 350                 toucs(str, len, &str16, &len16);
 351                 XDrawImageString16(ioncore_g.dpy, brush->win, gc, x, y, str16, len16);
 352                 free(str16);
 353             }else{
 354                 XDrawImageString(ioncore_g.dpy, brush->win, gc, x, y, str, len);
 355             }
 356         }
 357     }
 358 }
 359
 360
 361 void debrush_do_draw_string(DEBrush *brush, int x, int y,
 362                             const char *str, int len, bool needfill,
 363                             DEColourGroup *colours)
 364 {
 365     CALL_DYN(debrush_do_draw_string, brush, (brush, x, y, str, len,
 366                                              needfill, colours));
 367 }
 368
 369
 370 void debrush_draw_string(DEBrush *brush, int x, int y,
 371                          const char *str, int len, bool needfill)
 372 {
 373     DEColourGroup *cg=debrush_get_current_colour_group(brush);
 374     if(cg!=NULL)
 375         debrush_do_draw_string(brush, x, y, str, len, needfill, cg);
 376 }
 377
 378
 379 /*}}}*/
 380