libs/Flocale.h

   1 /* -*-c-*- */
   2 /* Copyright (C) 2002  Olivier Chapuis */
   3
   4 #ifndef FLOCALE_H
   5 #define FLOCALE_H
   6
   7 /* ---------------------------- included header files ---------------------- */
   8
   9 #include "config.h"
  10
  11 #include <X11/Xlocale.h>
  12 #include <X11/Xutil.h>
  13
  14 #include "fvwmlib.h"
  15 #include "gravity.h"
  16 #include "Fft.h"
  17 #include "Colorset.h"
  18
  19 /* FlocaleCharset.h and Ficonv.h should not be included */
  20
  21
  22 /* ---------------------------- global definitions ------------------------- */
  23
  24 #define FWS_HAVE_LENGTH (1)
  25
  26 #define FLC_ENCODING_TYPE_NONE     0
  27 #define FLC_ENCODING_TYPE_FONT     1
  28 #define FLC_ENCODING_TYPE_UTF_8    2
  29 #define FLC_ENCODING_TYPE_USC_2    3
  30 #define FLC_ENCODING_TYPE_USC_4    4
  31 #define FLC_ENCODING_TYPE_UTF_16   5
  32
  33 #define FLC_FFT_ENCODING_ISO8859_1  "ISO8859-1"
  34 #define FLC_FFT_ENCODING_ISO10646_1 "ISO10646-1"
  35
  36 #define FLOCALE_FALLBACK_XCHARSET "ISO8859-1"
  37 #define FLOCALE_UTF8_XCHARSET     "ISO10646-1"
  38 #define FLOCALE_ICONV_CONVERSION_MAX_NUMBER_OF_WARNING 10
  39
  40 #define FLC_INDEX_ICONV_CHARSET_NOT_FOUND         -1
  41 #define FLC_INDEX_ICONV_CHARSET_NOT_INITIALIZED   -2
  42
  43 #define FLC_TRANSLIT_NOT_SUPPORTED ((char*)-1)
  44
  45 #define FLOCALE_DEBUG_SETLOCALE 0
  46 #define FLOCALE_DEBUG_CHARSET   0
  47 #define FLOCALE_DEBUG_ICONV     0
  48
  49 /* ---------------------------- global macros ------------------------------ */
  50
  51 #define IS_TEXT_DRAWN_VERTICALLY(x) \
  52         ((x) == TEXT_ROTATED_90 || (x) == TEXT_ROTATED_270)
  53
  54 #define FLC_GET_X_CHARSET(fc)         ((fc) != NULL)? (fc)->x:NULL
  55 #define FLC_SET_ICONV_INDEX(fc, i)    (fc)->iconv_index = i
  56 #define FLC_GET_LOCALE_CHARSET(fc, i) (fc)->locale[i]
  57 #define FLC_GET_ICONV_CHARSET(fc) \
  58         ((fc) != NULL && (fc)->iconv_index >= 0)? (fc)->locale[(fc)->iconv_index]:NULL
  59 #define FLC_DO_ICONV_CHARSET_INITIALIZED(fc) \
  60         ((fc) != NULL && (fc)->iconv_index != FLC_INDEX_ICONV_CHARSET_NOT_INITIALIZED)
  61 #define FLC_HAVE_ICONV_CHARSET(fc) ((fc) != NULL && (fc)->iconv_index >= 0)
  62 #define FLC_GET_BIDI_CHARSET(fc) ((fc) != NULL)? (fc)->bidi : NULL
  63 #define FLC_ENCODING_TYPE_IS_UTF_8(fc) \
  64         ((fc) != NULL && (fc)->encoding_type == FLC_ENCODING_TYPE_UTF_8)
  65 #define FLC_ENCODING_TYPE_IS_USC_2(fc) \
  66         ((fc) != NULL && (fc)->encoding_type == FLC_ENCODING_TYPE_USC_2)
  67 #define FLC_ENCODING_TYPE_IS_USC_4(fc) \
  68         ((fc) != NULL && (fc)->encoding_type == FLC_ENCODING_TYPE_USC_4)
  69
  70 #define FLC_DEBUG_GET_X_CHARSET(fc)  \
  71         ((fc) == NULL || (fc)->x == NULL)? "None":(fc)->x
  72 #define FLC_DEBUG_GET_ICONV_CHARSET(fc) \
  73         ((fc) != NULL && (fc)->iconv_index >= 0)? (fc)->locale[(fc)->iconv_index]:"None"
  74 #define FLC_DEBUG_GET_BIDI_CHARSET(fc) \
  75         ((fc) == NULL || (fc)->bidi == NULL)? "None":(fc)->bidi
  76
  77 #define FLC_IS_TRANSLIT_SUPPORTED(fc) \
  78         ((fc) != NULL && (fc)->translit_csname != FLC_TRANSLIT_NOT_SUPPORTED \
  79          && (fc)->translit_csname != NULL)
  80
  81 #define FLC_GET_ICONV_TRANSLIT_CHARSET(fc) \
  82         ((fc) != NULL && (fc)->translit_csname != FLC_TRANSLIT_NOT_SUPPORTED)?\
  83         (fc)->translit_csname : NULL
  84 #define FLC_SET_ICONV_TRANSLIT_CHARSET(fs, csname) \
  85         (fc)->translit_csname = csname
  86
  87 #define FLF_MULTIDIR_HAS_UPPER(flf) \
  88         (((flf)->flags.shadow_dir & MULTI_DIR_NW) || \
  89          ((flf)->flags.shadow_dir & MULTI_DIR_N) || \
  90          ((flf)->flags.shadow_dir & MULTI_DIR_NE))
  91 #define FLF_MULTIDIR_HAS_BOTTOM(flf) \
  92         (((flf)->flags.shadow_dir & MULTI_DIR_SW) || \
  93          ((flf)->flags.shadow_dir & MULTI_DIR_S) || \
  94          ((flf)->flags.shadow_dir & MULTI_DIR_SE))
  95 #define FLF_MULTIDIR_HAS_LEFT(flf) \
  96         (((flf)->flags.shadow_dir & MULTI_DIR_SW) || \
  97          ((flf)->flags.shadow_dir & MULTI_DIR_W) || \
  98          ((flf)->flags.shadow_dir & MULTI_DIR_NW))
  99 #define FLF_MULTIDIR_HAS_RIGHT(flf) \
 100         (((flf)->flags.shadow_dir & MULTI_DIR_SE) || \
 101          ((flf)->flags.shadow_dir & MULTI_DIR_E) || \
 102          ((flf)->flags.shadow_dir & MULTI_DIR_NE))
 103
 104 #define FLF_SHADOW_FULL_SIZE(flf) ((flf)->shadow_size + (flf)->shadow_offset)
 105 #define FLF_SHADOW_HEIGHT(flf) \
 106         (FLF_SHADOW_FULL_SIZE((flf)) * \
 107          (FLF_MULTIDIR_HAS_UPPER((flf))+FLF_MULTIDIR_HAS_BOTTOM((flf))))
 108 #define FLF_SHADOW_WIDTH(flf) \
 109         (FLF_SHADOW_FULL_SIZE((flf)) * \
 110          (FLF_MULTIDIR_HAS_LEFT((flf))+FLF_MULTIDIR_HAS_RIGHT((flf))))
 111 #define FLF_SHADOW_ASCENT(flf) \
 112         (FLF_SHADOW_FULL_SIZE((flf)) * FLF_MULTIDIR_HAS_UPPER((flf)))
 113 #define FLF_SHADOW_DESCENT(flf) \
 114         (FLF_SHADOW_FULL_SIZE((flf)) * FLF_MULTIDIR_HAS_BOTTOM((flf)))
 115
 116 #define FLF_SHADOW_LEFT_SIZE(flf) \
 117         (FLF_SHADOW_FULL_SIZE((flf)) * FLF_MULTIDIR_HAS_LEFT((flf)))
 118 #define FLF_SHADOW_RIGHT_SIZE(flf) \
 119         (FLF_SHADOW_FULL_SIZE((flf)) * FLF_MULTIDIR_HAS_RIGHT((flf)))
 120 #define FLF_SHADOW_UPPER_SIZE(flf) \
 121         (FLF_SHADOW_FULL_SIZE((flf)) * FLF_MULTIDIR_HAS_UPPER((flf)))
 122 #define FLF_SHADOW_BOTTOM_SIZE(flf) \
 123         (FLF_SHADOW_FULL_SIZE((flf)) * FLF_MULTIDIR_HAS_BOTTOM((flf)))
 124
 125 #define FLF_FONT_HAS_ALPHA(flf,cset) \
 126      ((flf && flf->fftf.fftfont != None) ||                      \
 127       (0 && cset >= 0 && Colorset[cset].fg_alpha_percent < 100))
 128 /* ---------------------------- type definitions --------------------------- */
 129
 130 typedef struct FlocaleCharset
 131 {
 132         char *x;               /* X font charset */
 133         char **locale;         /* list of possible charset names */
 134         int iconv_index;       /* defines the iconv charset name */
 135         char *bidi;            /* if not null a fribidi charset */
 136         short encoding_type;   /* encoding: font, utf8 or usc2 */
 137         char *translit_csname; /* iconv csname for transliteration */
 138 } FlocaleCharset;
 139
 140 typedef struct _FlocaleFont
 141 {
 142         struct _FlocaleFont *next;
 143         char *name;
 144         int count;
 145         XFontStruct *font;      /* font structure */
 146         XFontSet fontset;       /* font set */
 147         FftFontType fftf;       /* fvwm xft font */
 148         FlocaleCharset *fc;     /* fvwm charset of the font */
 149         FlocaleCharset *str_fc; /* fvwm charset of the strings to be displayed */
 150         int height;             /* height of the font: ascent + descent */
 151         int ascent;
 152         int descent;
 153         int max_char_width;
 154         int shadow_size;
 155         int shadow_offset;
 156         struct
 157         {
 158                 unsigned shadow_dir : (DIR_ALL_MASK + 1);
 159                 unsigned must_free_fc : 1;
 160                 /* is_mb are used only with a XFontStruct font, for XFontSet
 161                  * everything is done in the good way automatically and this
 162                  * parameters is not needed */
 163                 unsigned is_mb  : 1; /* if true the font is a 2 bytes font */
 164         } flags;
 165 } FlocaleFont;
 166
 167 typedef struct
 168 {
 169         char *str;
 170         char *e_str;    /* tmp */
 171         XChar2b *str2b; /* tmp */
 172         GC gc;
 173         colorset_t *colorset;
 174         Window win;
 175         int x;
 176         int y;
 177         int len;
 178         Region clip_region;
 179         struct
 180         {
 181                 unsigned text_rotation : 2;
 182                 unsigned has_colorset : 1;
 183                 unsigned has_clip_region : 1;
 184         } flags;
 185 } FlocaleWinString;
 186
 187 typedef struct
 188 {
 189         char *name;
 190         char **name_list;
 191 } FlocaleNameString;
 192
 193 typedef struct
 194 {
 195         int step;
 196         int orig_x;
 197         int orig_y;
 198         int offset;
 199         int outer_offset;
 200         multi_direction_t direction;
 201         int inter_step;
 202         int num_inter_steps;
 203         int x_sign;
 204         int y_sign;
 205         int size;
 206         unsigned sdir : (DIR_ALL_MASK + 1);
 207         rotation_t rot;
 208 } flocale_gstp_args;
 209
 210 /* ---------------------------- exported variables (globals) --------------- */
 211
 212 /* ---------------------------- interface functions ------------------------ */
 213
 214 /*
 215  * i18n X initialization
 216  * category: the usual category LC_CTYPE, LC_CTIME, ...
 217  * modifier: "" or NULL if NULL XSetLocaleModifiers is not called
 218  * module: the name of the fvwm module that call the function for reporting
 219  * errors message
 220  * The locale and the modifiers is sotred in Flocale and Fmodifiers.
 221  * Flocale is set to NULL if the locale is not supported by the Xlib.
 222  * In this case the Flocale* functions below does not use the Xmb* functions
 223  *
 224  * The function should be called as FlocaleInit(LC_CTYPE, "", "", "myname");
 225  */
 226 void FlocaleInit(
 227         int category, const char *local, const char *modifier,
 228         const char *module);
 229
 230 /*
 231  * font loading
 232  */
 233
 234 /*
 235  * load a FlocaleFont (create it or load it from a cache)
 236  * fontname: a ";" sperated list of "," separated list of XFLD font names or
 237  * either "xft:" followed by a  Xft font name. Examples:
 238  * "xft:Verdana:Bold:pixelsize=14:rgba=rgb"
 239  * "xft:Verdana:size=12;-adobe-courier-medium-r-normal--14-*,fixed"
 240  * module: name of the fvwm module for errors msg
 241  * If fontname is NULL the "default font" is loaded (2,3,4).
 242  * The following logic is used:
 243  * 0) If fontname has been has been already loaded the cache is used
 244  * 1) We try to load each element "fn" of the ";" seprated list until success
 245  *    as follows:
 246  *    a - if fn begin with "xft:", then if FftSupport fn is loaded as an xft
 247  *        font; if !FftSupport fn is skipped (ignored)
 248  *    b - If the locale is supported fn is loaded using XCreateFontSet. If this
 249  *        fail fallback into 1-c)
 250  *    c - If the locale is not supported or 1-b fail fn is loaded using
 251  *        XLoadQueryFont (the first loadable font in the fn "," separated list
 252  *        is load)
 253  * 2) If 0) and 1) fail:
 254  *    - try to load MB_FALLBACK_FONT with XCreateFontSet
 255  *    - If this fail try to load FALLBACK_FONT with XLoadQueryFont
 256  * 3) If everything fail the function return NULL.
 257  *
 258  * If font loading succed. Only one of the font, fontset, fftfont member of the
 259  * FlocaleFont structure is not NULL/None. The caller should use this to
 260  * set appropriately the gc member of the FlocaleWinString struct (the fid
 261  * gc member should be set only if font is not NULL).
 262  *
 263  */
 264 FlocaleFont *FlocaleLoadFont(Display *dpy, char *fontname, char *module);
 265
 266 /*
 267  * unload the flf FlocaleFont
 268  */
 269 void FlocaleUnloadFont(Display *dpy, FlocaleFont *flf);
 270
 271 /*
 272  * Width and Drawing
 273  */
 274
 275 /*
 276  * Draw the text specified in fstring->str using fstring->gc as GC on the
 277  * fstring->win window at position fstring->{x,y} using the ff FlocaleFont.
 278  * If flags & FWS_HAVE_LENGTH, the fstring->len first characters of the
 279  * string is drawn. If !(flags & FWS_HAVE_LENGTH), the function draw the
 280  * the all string (fstring->len is ignored). Note that if ff->font is NULL
 281  * the gc should not conatins a GCFont, as if ff->font != NULL the GCFont
 282  * value should be ff->font->fid
 283  */
 284 void FlocaleDrawString(
 285         Display *dpy, FlocaleFont *ff, FlocaleWinString *fstring,
 286         unsigned long flags);
 287
 288 /*
 289  * Underline a character in a string (pete@tecc.co.uk) at coffest position
 290  */
 291 void FlocaleDrawUnderline(
 292         Display *dpy, FlocaleFont *flf, FlocaleWinString *fws, int coffset);
 293
 294 /*
 295  * Get the position for shadow text
 296  */
 297 void FlocaleInitGstpArgs(
 298         flocale_gstp_args *args, FlocaleFont *flf, FlocaleWinString *fws,
 299         int start_x, int start_y);
 300
 301 Bool FlocaleGetShadowTextPosition(
 302         int *x, int *y, flocale_gstp_args *args);
 303
 304 /*
 305  * Call XmbTextEscapement(ff->fontset, str, sl) if ff->fontset is not None.
 306  * Call XTextWith(ff->font, str, sl) if ff->font is not NULL.
 307  * If sl is negative, the string is considered to be a vertival string and
 308  * the function returns the height of the text.
 309  */
 310 int FlocaleTextWidth(FlocaleFont *ff, char *str, int sl);
 311
 312 /*
 313  * "y" (or "x" position if rotated and Xft font) of the text relatively to 0
 314  */
 315 int FlocaleGetMinOffset(FlocaleFont *flf, rotation_t rotation);
 316
 317 /*
 318  * Allocate memory for a FlocaleWinString intialized to 0
 319  */
 320 void FlocaleAllocateWinString(FlocaleWinString **pfws);
 321
 322 /*
 323  * Text properties
 324  */
 325
 326 /*
 327  * return the window or icon name of a window w
 328  * func: XGetWMName or XGetWMIconName
 329  * dpy: the display
 330  * w: the window for which we want the (icon) name
 331  * ret_name_list: for
 332  * ret_name: the icon or the window name of the window
 333  */
 334 void FlocaleGetNameProperty(
 335         Status (func)(Display *, Window, XTextProperty *), Display *dpy,
 336         Window w, FlocaleNameString *ret_name);
 337
 338 /*
 339  * Free the name property allocated with FlocaleGetNameProperty
 340  */
 341 void FlocaleFreeNameProperty(
 342         FlocaleNameString *ptext);
 343
 344 /*
 345  * Simple warper to XmbTextListToTextProperty (FlocaleMultibyteSupport and the
 346  * locale is supported by the xlib) or XStringListToTextProperty
 347  */
 348 Bool FlocaleTextListToTextProperty(
 349         Display *dpy, char **list, int count, XICCEncodingStyle style,
 350         XTextProperty *text_prop_return);
 351
 352 /*
 353  * Info
 354  */
 355 void FlocalePrintLocaleInfo(Display *dpy, int verbose);
 356
 357 /*
 358  * Misc
 359  */
 360
 361 /* return number of bytes of character at current position
 362    (pointed to by str) */
 363 int FlocaleStringNumberOfBytes(FlocaleFont *flf, const char *str);
 364
 365 /* given a string, font specifying its locale and a byte offset gives
 366    character offset */
 367 int FlocaleStringByteToCharOffset(FlocaleFont *flf, const char *str,
 368                                   int offset);
 369
 370 /* like above but reversed, ie. return byte offset corresponding to given
 371    charater offset */
 372 int FlocaleStringCharToByteOffset(FlocaleFont *flf, const char *str,
 373                                   int coffset);
 374
 375 /* return length of string in characters */
 376 int FlocaleStringCharLength(FlocaleFont *flf, const char *str);
 377
 378
 379 #endif /* FLOCALE_H */
 380