X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=otk%2Ffont.cc;h=ee9c37d79a22483ff0f808a4b2201b7fec33c5a0;hb=77a46782db2996c0bc662c0f6d191df7a39c2cce;hp=91f8ffb656109f237621d9c76f14e78114004100;hpb=85c41a1aec90b8daefc425596ea34b6f9d0e643c;p=chaz%2Fopenbox

diff --git a/otk/font.cc b/otk/font.cc
index 91f8ffb6..ee9c37d7 100644
--- a/otk/font.cc
+++ b/otk/font.cc
@@ -1,128 +1,102 @@
 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
 
-#ifdef    HAVE_CONFIG_H
-#  include "../config.h"
-#endif // HAVE_CONFIG_H
+#include "config.h"
+
+#include "font.hh"
+#include "surface.hh"
+#include "util.hh"
+#include "display.hh"
+#include "screeninfo.hh"
 
 extern "C" {
-#ifdef HAVE_STDLIB_H
-#  include <stdlib.h>
-#endif // HAVE_STDLIB_H
+#include "../src/gettext.h"
+#define _(str) gettext(str)
 }
 
+#include <cstdio>
+#include <cstdlib>
 #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";
-
-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) {
-  _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
-
-  _valid = True;
-}
+namespace otk {
+
+bool        Font::_xft_init      = false;
+
+Font::Font(int screen_num, const std::string &fontstring,
+             bool shadow, unsigned char offset, unsigned char tint)
+  : _screen_num(screen_num),
+    _fontstring(fontstring),
+    _shadow(shadow),
+    _offset(offset),
+    _tint(tint),
+    _xftfont(0)
+{
+  assert(screen_num >= 0);
+  assert(tint <= CHAR_MAX);
+  
+  if (!_xft_init) {
+    if (!XftInit(0)) {
+      printf(_("Couldn't initialize Xft.\n\n"));
+      ::exit(3);
+    }
+#ifdef DEBUG
+    int version = XftGetVersion();
+    printf("Using Xft %d.%d.%d (Built against %d.%d.%d).\n",
+           version / 10000 % 100, version / 100 % 100, version % 100,
+           XFT_MAJOR, XFT_MINOR, XFT_REVISION);
+#endif
+    _xft_init = true;
+  }
 
+  if ((_xftfont = XftFontOpenName(**display, _screen_num,
+                                  _fontstring.c_str())))
+    return;
 
-BFont::~BFont(void) {
-  if (_xftfont)
-    XftFontClose(_display, _xftfont);
-}
+  printf(_("Unable to load font: %s\n"), _fontstring.c_str());
+  printf(_("Trying fallback font: %s\n"), "fixed");
 
+  if ((_xftfont = XftFontOpenName(**display, _screen_num,
+                                  "fixed")))
+    return;
 
-void BFont::drawString(Drawable d, int x, int y, const BColor &color,
-                       const string &string) const {
-  assert(_valid);
+  printf(_("Unable to load font: %s\n"), "fixed");
+  printf(_("Aborting!.\n"));
 
-  XftDraw *draw = XftDrawCreate(_display, d, _screen->getVisual(),
-                                _screen->getColormap());
-  assert(draw);
+  ::exit(3); // can't continue without a font
+}
 
-  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());
 
-    XftDrawStringUtf8(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
-
-  XftDrawStringUtf8(draw, &c, _xftfont, x, _xftfont->ascent + y,
-                    (XftChar8 *) string.c_str(), string.size());
-
-  XftDrawDestroy(draw);
-  return;
+Font::~Font(void)
+{
+  if (_xftfont)
+    XftFontClose(**display, _xftfont);
 }
 
 
-unsigned int BFont::measureString(const string &string) const {
-  assert(_valid);
-
+int Font::measureString(const ustring &string) const
+{
   XGlyphInfo info;
 
-  XftTextExtentsUtf8(_display, _xftfont, (XftChar8 *) string.c_str(),
-                     string.size(), &info);
+  if (string.utf8())
+    XftTextExtentsUtf8(**display, _xftfont,
+                       (FcChar8*)string.c_str(), string.bytes(), &info);
+  else
+    XftTextExtents8(**display, _xftfont,
+                    (FcChar8*)string.c_str(), string.bytes(), &info);
 
-  return info.xOff + (_shadow ? _offset : 0);
+  return (signed) info.xOff + (_shadow ? _offset : 0);
 }
 
 
-unsigned int BFont::height(void) const {
-  assert(_valid);
-
-  return _xftfont->height + (_shadow ? _offset : 0);
+int Font::height(void) const
+{
+  return (signed) _xftfont->height + (_shadow ? _offset : 0);
 }
 
 
-unsigned int BFont::maxCharWidth(void) const {
-  assert(_valid);
+int Font::maxCharWidth(void) const
+{
+  return (signed) _xftfont->max_advance_width;
+}
 
-  return _xftfont->max_advance_width;
 }