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