font.cpp

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#include<boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>

#include <wt/font.h>
#include <wt/builtin_font.h>
#include <wt/trace.h>

#define DEFAULT_POINTSIZE 18
#define DEFAULT_RENDERING Blended
#define DEFAULT_ENCODING ASCII
#define DEFAULT_BACKGROUNDCOLOR "black"
#define DEFAULT_FOREGROUNDCOLOR "white"

namespace Wt {

Font::Map Font::map;

Font* Font::default_font = 0;

void Font::Deleter::operator()(TTF_Font* f) {
    if (f)
        TTF_CloseFont(f);
}

Font::Ptr Font::open_default_font(int ptsize) {
    if (!default_font) {
        SDL_RWops *rwop = SDL_RWFromConstMem(BultinFontData,
                                             BultinFontDataSize);
        return Ptr(TTF_OpenFontRW(rwop, true, ptsize), Deleter());
    }
    return default_font->ttf_font;
}

Font::Ptr Font::open_font(const std::string& filename,
                          int ptsize, int style, int index) {
    Ptr f(TTF_OpenFontIndex(filename.c_str(), ptsize, index), Deleter());
    if (!f)
        f = open_default_font(ptsize);

    if (f)
        TTF_SetFontStyle(f.get(), style);
    return f;
}

Font::Font(const std::string& filename, int ptsize, int style, int index) :
        ttf_font(open_font(filename, defaultFontSize(ptsize), style, index)),
        filename_(filename),
        ptsize_(defaultFontSize(ptsize)),
        index_(index),
        rendering_(DEFAULT_RENDERING),
        encoding_(DEFAULT_ENCODING),
        bg_color_(DEFAULT_BACKGROUNDCOLOR),
fg_color_(DEFAULT_FOREGROUNDCOLOR) {
    trace("font", "Creating font %p (%p) (%s)\n", this, ttf_font.get(), filename_.c_str());
    trace("font") << "Adding to Font::Map " << *this <<
    " use count: " << ttf_font.use_count() << std::endl;
    map[this->description()] = *this;
}

Font::Font() :
        ttf_font(open_default_font(defaultFontSize())),
        filename_("*"),
        ptsize_(defaultFontSize()),
        index_(0),
        rendering_(DEFAULT_RENDERING),
        encoding_(DEFAULT_ENCODING),
        bg_color_(DEFAULT_BACKGROUNDCOLOR),
fg_color_(DEFAULT_FOREGROUNDCOLOR) {
    trace("font", "Creating font %p (%p) (default)\n", this, ttf_font.get());
    trace("font") << "Adding to Font::Map " << *this <<
    " use count: " << ttf_font.use_count() << std::endl;
}

Font::Font(const std::string& desc) {
    Map::iterator it = map.find(desc);
    trace("font", "Looking in Font::Map for '%s'\n", desc.c_str());

    // if it is in cache return it
    if (it != map.end()) {
        *this = it->second;
        trace("font") << "Found in Font::Map " << *this <<
        " use count: " << ttf_font.use_count() << std::endl;
        return;
    }

    // let's parse the description and load it in cache
    boost::char_separator<char> sep(", ");
    typedef boost::tokenizer<boost::char_separator<char> > Tokenizer;
    Tokenizer tokens(desc, sep);
    Tokenizer::iterator token = tokens.begin();

    std::string filename;
    if (token != tokens.end()) {
        filename = *token;
        ++token;
    }

    int point_size = 0;
    if (token != tokens.end()) {
        point_size = boost::lexical_cast<int>(*token);
        ++token;
    }

    int st = Normal;
    if (token != tokens.end()) {
        std::string flags = *token;
        for (std::string::iterator ct = flags.begin(),
                ctend = flags.end(); ct != ctend; ++ct) {
            switch (*ct) {
            case 'b':
                st |= Bold;
                break;
            case 'i':
                st |= Italic;
                break;
            case 'u':
                st |= Underline;
                break;
            default:
                Warn("Unknown specifier '%c' in font "
                     "attibute desctrition '%s'\n", *ct, flags.c_str());
                break;
            }
        }
    }

    trace("font", "Parsing font description as '%s, %d, %d'\n",
          filename.c_str(), point_size, st);

    *this = Font(filename, point_size, st);
    trace("font") << "Added to Font::Map " << *this <<
    " use count: " << ttf_font.use_count() << std::endl;
}

void Font::detach() {
    //avoid detaching if we are the only client for this font
    if (!ttf_font.unique()) {
        ttf_font = open_font(filename_, pointSize(), style(), index_);
    }
}

TTF_Font *Font::deconst() const {
    //SDL breakage
    return const_cast<TTF_Font *>
           (static_cast<const TTF_Font *>(*this));
}

void Font::init() {
    TTF_Init();
    default_font = new Font();
    map[default_font->description()] = *default_font;
}

void Font::quit() {
    map.clear();
    delete default_font;
    TTF_Quit();
}

int Font::defaultFontSize(int ptsize) {
    return (ptsize) ? ptsize : DEFAULT_POINTSIZE;
}

Font& Font::defaultFont() {
    return *default_font;
}

std::string Font::description() const {
    std::string desc = filename_ + ", ";
    desc += boost::lexical_cast<std::string>(pointSize())  + ", ";

    int st = style();
    desc += (st & Bold) ? "b" : "";
    desc += (st & Italic) ? "i" : "";
    desc += (st & Underline) ? "u" : "";
    return desc;
}

std::string Font::family() const {
    const char *font_family = TTF_FontFaceFamilyName(deconst());
    if (!font_family)
        font_family = "*";
    return font_family;
}

void Font::setFont(std::string& filename) {
    ttf_font = open_font(filename, pointSize(), style(), index_);
    filename_ = filename;
}

int Font::pointSize() const {
    return ptsize_;
}

void Font::setPointSize(int ptsize) {
    ttf_font = open_font(filename_, ptsize, style(), index_);
    ptsize_ = ptsize;
}

bool Font::style() const {
    return TTF_GetFontStyle(deconst());
}

bool Font::styleFlag(int flag) const {
    return style() & flag;
}

void Font::setStyleFlag(int flag, bool enable) {
    int s = style();

    if (enable && (flag & s))
        return;

    if (!enable && !(~flag & s))
        return;

    detach();

    if (enable)
        TTF_SetFontStyle(*this, flag | s);
    else
        TTF_SetFontStyle(*this, ~flag & s);
}

bool Font::bold() const {
    return styleFlag(TTF_STYLE_BOLD);
}

void Font::setBold(bool enable) {
    setStyleFlag(TTF_STYLE_BOLD, enable);
}

bool Font::italic() const {
    return styleFlag(TTF_STYLE_ITALIC);
}

void Font::setItalic(bool enable) {
    setStyleFlag(TTF_STYLE_ITALIC, enable);
}

bool Font::underline() const {
    return styleFlag(TTF_STYLE_UNDERLINE);

}

void Font::setUnderline(bool enable) {
    setStyleFlag(TTF_STYLE_UNDERLINE, enable);
}

void Font::setRendering(int rendering) {
    detach();
    rendering_ = rendering;
}

int Font::rendering() const {
    return rendering_;
}

void Font::setEncoding(int encoding) {
    detach();
    encoding_ = encoding;
}

int Font::encoding() const {
    return encoding_;
}

void Font::setBackgroundColor(const Color& bg_color) {
    detach();
    bg_color_ = bg_color;
}

const Color& Font::backgroundColor() const {
    return bg_color_;
}

void Font::setForegroundColor(const Color& fg_color) {
    detach();
    fg_color_ = fg_color;
}

const Color& Font::foregroundColor() const {
    return fg_color_;
}

Size Font::size(const std::string& text) const {
    int w = 0, h = 0;
    if (encoding_ == ASCII) {
        TTF_SizeText(deconst(), text.c_str(), &w, &h);
    } else if (encoding_ == UTF8) {
        TTF_SizeUTF8(deconst(), text.c_str(), &w, &h);
    }
    return Size(w, h);
}

Size Font::size(const Uint16 *text) const {
    int w, h;
    TTF_SizeUNICODE(deconst(), text, &w, &h);
    return Size(w, h);
}

Pixmap Font::blitText(const std::string& text) const {
    SDL_Surface *s = 0;
    switch (rendering_) {
    case Solid:
        if (encoding_ == ASCII) {
            s = TTF_RenderText_Solid(deconst(), text.c_str(), fg_color_);
        } else if (encoding_ == UTF8) {
            s = TTF_RenderUTF8_Solid(deconst(), text.c_str(), fg_color_);
        }
        break;
    case Shaded:
        if (encoding_ == ASCII) {
            s = TTF_RenderText_Shaded(deconst(),
                                      text.c_str(), fg_color_, bg_color_);
        } else if (encoding_ == UTF8) {
            s = TTF_RenderUTF8_Shaded(deconst(), text.c_str(),fg_color_, bg_color_);
        }
        break;
    case Blended:
        if (encoding_ == ASCII) {
            s = TTF_RenderText_Blended(deconst(), text.c_str(), fg_color_);
        } else if (encoding_ == UTF8) {
            s = TTF_RenderUTF8_Blended(deconst(), text.c_str(), fg_color_);
        }
        break;
    default:
        break;
    }

    return Pixmap(s);
}

Pixmap Font::blitText(const Uint16 *text) const {
    SDL_Surface *s = 0;
    switch (rendering_) {
    case Solid:
        s = TTF_RenderUNICODE_Solid(deconst(), text, fg_color_);
        break;
    case Shaded:
        s = TTF_RenderUNICODE_Shaded(deconst(), text, fg_color_, bg_color_);
        break;
    case Blended:
        s = TTF_RenderUNICODE_Blended(deconst(), text, fg_color_);
        break;
    default:
        break;
    }

    return Pixmap(s);
}

int Font::ascent() const {
    return TTF_FontAscent(deconst());
}

int Font::descent() const {
    return TTF_FontDescent(deconst());
}

int Font::height() const {
    return TTF_FontHeight(deconst());
}

int Font::lineSpacing() const {
    return TTF_FontLineSkip(deconst());
}

int Font::leading() const {
    return lineSpacing() - height();
}

int Font::faces() const {
    return TTF_FontFaces(deconst());
}

std::string Font::faceStyleName() const {
    const char *face_style_name = TTF_FontFaceStyleName(deconst());
    if (!face_style_name)
        face_style_name = "*";
    return face_style_name;
}

bool Font::monoSpace() const {
    return TTF_FontFaceIsFixedWidth(deconst()) > 0;
}

int Font::leftBearing(Uint16 ch) const {
    int minx;
    TTF_GlyphMetrics(deconst(), ch, &minx, 0, 0, 0, 0);
    return minx;
}

int Font::rightBearing(Uint16 ch) const {
    int maxx, advance;
    TTF_GlyphMetrics(deconst(), ch, 0, &maxx, 0, 0, &advance);
    return advance - maxx;
}

int Font::width(Uint16 ch) const {
    int minx, maxx;
    TTF_GlyphMetrics(deconst(), ch, &minx, &maxx, 0, 0, 0);
    return maxx - minx;
}

Size Font::size(const Uint16 ch) const {
    int minx, maxx, miny, maxy;
    TTF_GlyphMetrics(deconst(), ch, &minx, &maxx, &miny, &maxy, 0);
    return Size(maxx - minx, maxy - miny);
}

Rect Font::boundingRect(const Uint16 ch) const {
    int minx, maxx, miny, maxy;
    TTF_GlyphMetrics(deconst(), ch, &minx, &maxx, &miny, &maxy, 0);
    return Rect(minx, miny, maxx - minx + 1, maxy - miny + 1);
}

Rect Font::boundingRect(const std::string& str, int len) const {
    const std::string s = (len == -1) ? str : str.substr(0, len);
    return Rect(Point(0, 0), size(str));
}

std::ostream& operator<<(std::ostream& s, const Font& f) {
    s << f.description();
    return s;
}

}

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.