diff options
Diffstat (limited to 'src/font.cc')
| -rw-r--r-- | src/font.cc | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/src/font.cc b/src/font.cc new file mode 100644 index 00000000..ba1ae1c1 --- /dev/null +++ b/src/font.cc @@ -0,0 +1,374 @@ +// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*- +// Font.cc for Blackbox - an X11 Window manager +// Copyright (c) 2001 - 2002 Sean 'Shaleh' Perry <shaleh@debian.org> +// Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net) +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +#ifdef HAVE_CONFIG_H +# include "../config.h" +#endif // HAVE_CONFIG_H + +extern "C" { +#ifdef HAVE_STDLIB_H +# include <stdlib.h> +#endif // HAVE_STDLIB_H +} + +#include <iostream> +#include <algorithm> + +using std::string; +using std::cerr; +using std::endl; + +#include "font.hh" +#include "util.hh" +#include "gccache.hh" +#include "color.hh" + +string BFont::_fallback_font = "fixed"; + +#ifdef XFT +BFont::BFont(Display *d, BScreen *screen, const string &family, int size, + bool bold, bool italic, bool shadow, unsigned char offset, + unsigned char tint, bool antialias) : + _display(d), + _screen(screen), + _family(family), + _simplename(False), + _size(size), + _bold(bold), + _italic(italic), + _antialias(antialias), + _shadow(shadow), + _offset(offset), + _tint(tint), + _xftfont(0), + _font(0), + _fontset(0), + _fontset_extents(0) { + _valid = False; + + _xftfont = XftFontOpen(_display, _screen->getScreenNumber(), + XFT_FAMILY, XftTypeString, _family.c_str(), + XFT_SIZE, XftTypeInteger, _size, + XFT_WEIGHT, XftTypeInteger, (_bold ? + XFT_WEIGHT_BOLD : + XFT_WEIGHT_MEDIUM), + XFT_SLANT, XftTypeInteger, (_italic ? + XFT_SLANT_ITALIC : + XFT_SLANT_ROMAN), + XFT_ANTIALIAS, XftTypeBool, _antialias, + 0); + if (! _xftfont) + return; // failure + + _font = XLoadQueryFont(_display, buildXlfd().c_str()); + if (! _font) + return; // failure + + _valid = True; +} +#endif + + +BFont::BFont(Display *d, BScreen *screen, const string &xlfd) : + _display(d), + _screen(screen), +#ifdef XFT + _antialias(False), + _shadow(False), + _xftfont(0), +#endif // XFT + _font(0), + _fontset(0), + _fontset_extents(0) { + string int_xlfd; + if (xlfd.empty()) + int_xlfd = _fallback_font; + else + int_xlfd = xlfd; + + if ((_valid = createXFont(int_xlfd))) + return; // success + + if (int_xlfd != _fallback_font) { + // try the fallback + cerr << "BFont::BFont(): couldn't load font '" << _family << "'" << endl << + "Falling back to default '" << _fallback_font << "'" << endl; + + if ((_valid = createXFont(_fallback_font))) + return; // success + } + + cerr << "BFont::BFont(): couldn't load font '" << _family << "'" << endl << + "Giving up!" << endl; + return; // failure +} + + +bool BFont::createXFont(const std::string &xlfd) { + /* + Even though this is only used for font sets (multibyte), it is still parsed + out so that the bold/italic/etc information is still available from the + class when using non-multibyte. + + This is where _simplename, _bold, _italic, and _size are initialized, since + they are not initialized in the constructor. This needs to occur before + calling any Xlfd-building functions. + */ + if (! parseXlfd(xlfd)) + return False; + + if (i18n.multibyte()) { + char **missing, *def = "-"; + int nmissing; + + _fontset = XCreateFontSet(_display, buildMultibyteXlfd().c_str(), + &missing, &nmissing, &def); + if (nmissing) XFreeStringList(missing); + if (_fontset) + _fontset_extents = XExtentsOfFontSet(_fontset); + else + return False; + + assert(_fontset_extents); + } + + _font = XLoadQueryFont(_display, xlfd.c_str()); + if (! _font) + return False; + return True; +} + + +BFont::~BFont(void) { +#ifdef XFT + if (_xftfont) + XftFontClose(_display, _xftfont); +#endif // XFT + + if (i18n.multibyte() && _fontset) + XFreeFontSet(_display, _fontset); + if (_font) + XFreeFont(_display, _font); +} + + +/* + * Takes _family, _size, _bold, _italic, etc and builds them into a full XLFD. + */ +string BFont::buildXlfd(void) const { + if (_simplename) + return _family; + + string weight = _bold ? "bold" : "medium"; + string slant = _italic ? "i" : "r"; + string sizestr= _size ? itostring(_size * 10) : "*"; + + return "-*-" + _family + "-" + weight + "-" + slant + "-*-*-*-" + sizestr + + "-*-*-*-*-*-*"; +} + + +/* + * Takes _family, _size, _bold, _italic, etc and builds them into a full XLFD. + */ +string BFont::buildMultibyteXlfd(void) const { + string weight = _bold ? "bold" : "medium"; + string slant = _italic ? "i" : "r"; + string sizestr= _size ? itostring(_size) : "*"; + + return _family + ',' + + "-*-*-" + weight + "-" + slant + "-*-*-*-" + sizestr + + "-*-*-*-*-*-*" + ',' + + "-*-*-*-*-*-*-*-" + sizestr + "-*-*-*-*-*-*" + ',' + + + "*"; +} + + +/* + * Takes a full X font name and parses it out so we know if we're bold, our + * size, etc. + */ +bool BFont::parseXlfd(const string &xlfd) { + if (xlfd.empty() || xlfd[0] != '-') { + _family = xlfd; + _simplename = True; + _bold = False; + _italic = False; + _size = 0; + } else { + _simplename = False; + string weight, + slant, + sizestr; + int i = 0; + + string::const_iterator it = xlfd.begin(), end = xlfd.end(); + while(1) { + string::const_iterator tmp = it; // current string.begin() + it = std::find(tmp, end, '-'); // look for comma between tmp and end + if (i == 2) _family = string(tmp, it); // s[tmp:it] + if (i == 3) weight = string(tmp, it); + if (i == 4) slant = string(tmp, it); + if (i == 7 && string(tmp, it) != "*") sizestr = string(tmp, it); + if (sizestr.empty() && + i == 8 && string(tmp, it) != "*") sizestr = string(tmp, it); + if (it == end || i >= 8) + break; + ++it; + ++i; + } + if (i < 3) // no name even! can't parse that + return False; + _bold = weight == "bold" || weight == "demibold"; + _italic = slant == "i" || slant == "o"; + _size = atoi(sizestr.c_str()) / 10; + } + + // min/max size restrictions for sanity, but 0 is the font's "default size" + if (_size && _size < 3) + _size = 3; + else if (_size > 97) + _size = 97; + + return True; +} + + +void BFont::drawString(Drawable d, int x, int y, const BColor &color, + const string &string) const { + assert(_valid); + +#ifdef XFT + if (_xftfont) { + XftDraw *draw = XftDrawCreate(_display, d, _screen->getVisual(), + _screen->getColormap()); + assert(draw); + + if (_shadow) { + XftColor c; + c.color.red = 0; + c.color.green = 0; + c.color.blue = 0; + c.color.alpha = _tint | _tint << 8; // transparent shadow + c.pixel = BlackPixel(_display, _screen->getScreenNumber()); + +#ifdef XFT_UTF8 + XftDrawStringUtf8( +#else + XftDrawString8( +#endif + draw, &c, _xftfont, x + _offset, + _xftfont->ascent + y + _offset, (XftChar8 *) string.c_str(), + string.size()); + } + + XftColor c; + c.color.red = color.red() | color.red() << 8; + c.color.green = color.green() | color.green() << 8; + c.color.blue = color.blue() | color.blue() << 8; + c.pixel = color.pixel(); + c.color.alpha = 0xff | 0xff << 8; // no transparency in BColor yet + +#ifdef XFT_UTF8 + XftDrawStringUtf8( +#else + XftDrawString8( +#endif + draw, &c, _xftfont, x, _xftfont->ascent + y, + (XftChar8 *) string.c_str(), string.size()); + + XftDrawDestroy(draw); + return; + } +#endif // XFT + + BPen pen(color, _font); + + if (i18n.multibyte()) + XmbDrawString(_display, d, _fontset, pen.gc(), + x, y - _fontset_extents->max_ink_extent.y, + string.c_str(), string.size()); + else + XDrawString(_display, d, pen.gc(), + x, _font->ascent + y, + string.c_str(), string.size()); +} + + +unsigned int BFont::measureString(const string &string) const { + assert(_valid); + +#ifdef XFT + if (_xftfont) { + XGlyphInfo info; + +#ifdef XFT_UTF8 + XftTextExtentsUtf8( +#else + XftTextExtents8( +#endif + _display, _xftfont, (XftChar8 *) string.c_str(), + string.size(), &info); + + return info.xOff + (_shadow ? _offset : 0); + } +#endif // XFT + + if (i18n.multibyte()) { + XRectangle ink, logical; + XmbTextExtents(_fontset, string.c_str(), string.size(), &ink, &logical); + return logical.width; + } else { + return XTextWidth(_font, string.c_str(), string.size()); + } +} + + +unsigned int BFont::height(void) const { + assert(_valid); + +#ifdef XFT + if (_xftfont) + return _xftfont->height + (_shadow ? _offset : 0); +#endif // XFT + + if (i18n.multibyte()) + return _fontset_extents->max_ink_extent.height; + else + return _font->ascent + _font->descent; +} + + +unsigned int BFont::maxCharWidth(void) const { + assert(_valid); + +#ifdef XFT + if (_xftfont) + return _xftfont->max_advance_width; +#endif // XFT + + if (i18n.multibyte()) + return _fontset_extents->max_logical_extent.width; + else + return _font->max_bounds.rbearing - _font->min_bounds.lbearing; +} |