layouterCSS.h

Go to the documentation of this file.

/*
 * STLL Simple Text Layouting Library
 *
 * STLL is the legal property of its developers, whose
 * names are listed in the COPYRIGHT file, which is included
 * within the source distribution.
 *
 * This program 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 program 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 General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef STLL_LAYOUTER_CSS_H
#define STLL_LAYOUTER_CSS_H

#include "layouterFont.h"

#include "internal/xmllibraries.h"
#include "internal/layouterCSS_internal.h"

#include <string>
#include <memory>
#include <vector>
#include <map>

namespace STLL {

class XhtmlException_c : public std::runtime_error
{
  public:
    explicit XhtmlException_c(const std::string & what_arg) : std::runtime_error(what_arg) {}

};

class TextStyleSheet_c
{
    typedef struct
    {
      std::string selector;
      std::string attribute;
      std::string value;
    } rule;

  public:

    TextStyleSheet_c(std::shared_ptr<FontCache_c> c = 0);

    void addFont(const std::string & family, const FontResource_c & res,
                 const std::string & style = "normal",
                 const std::string & variant = "normal",
                 const std::string & weight = "normal",
                 const std::string & stretch = "normal");

    std::shared_ptr<FontFamily_c> findFamily(const std::string & family) const
    {
      auto i = families.find(family);

      if (i != families.end())
        return families.find(family)->second;
      else
        return 0;
    }

    void addRule(const std::string sel, const std::string attr, const std::string val);

    void setUseOptimizingLayouter(bool on)
    {
      useOptimizingLayouter = on;
    }

    bool getUseOptimizingLayouter(void) const { return useOptimizingLayouter; }

    void setHyphenate(bool on)
    {
      hyphenate = on;
    }

    bool getHyphenate(void) const { return hyphenate; }

    template <class X>
    const std::string & getValue(X node, const std::string & attribute, const std::string & def = "") const
    {
      // go through all rules, check only the ones that give a value to the requested attribute
      // evaluate rule by priority (look at the CSS priority rules
      // choose the highest priority

      while (!internal::xml_isEmpty(node))
      {
        uint16_t prio = 0;
        size_t bestI;

        for (size_t i = 0; i < rules.size(); i++)
        {
          if (   rules[i].attribute == attribute
            && internal::ruleFits(rules[i].selector, node)
            && internal::rulePrio(rules[i].selector) > prio
          )
          {
            prio = internal::rulePrio(rules[i].selector);
            bestI = i;
          }
        }

        if (prio)
          return rules[bestI].value;

        if (!internal::isInheriting(attribute))
        {
          if (def.empty())
          {
            return internal::getDefault(attribute);
          }
          else
          {
            return def;
          }
        }

          node = internal::xml_getParent(node);
      }

      return internal::getDefault(attribute);
    }

  private:
    std::vector<rule> rules;
    std::map<std::string, std::shared_ptr<FontFamily_c> > families;
    std::shared_ptr<FontCache_c> cache;
    bool useOptimizingLayouter = true;
    bool hyphenate = true;
};

}

#endif