MWAWFont.hxx

Go to the documentation of this file.

/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libmwaw
* Version: MPL 2.0 / LGPLv2+
*
* The contents of this file are subject to the Mozilla Public License Version
* 2.0 (the "License"); you may not use this file except in compliance with
* the License or as specified alternatively below. You may obtain a copy of
* the License at http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* Major Contributor(s):
* Copyright (C) 2002 William Lachance (wrlach@gmail.com)
* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)
* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)
* Copyright (C) 2006, 2007 Andrew Ziem
* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)
*
*
* All Rights Reserved.
*
* For minor contributions see the git repository.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),
* in which case the provisions of the LGPLv2+ are applicable
* instead of those above.
*/

#ifndef MWAW_FONT
#  define MWAW_FONT

#include <assert.h>
#include <string>
#include <vector>

#include "libmwaw_internal.hxx"

class MWAWFont
{
public:
  struct Line {
    enum Style { None, Simple, Dot, LargeDot, Dash, Wave };
    enum Type { Single, Double, Triple };
    Line(Style style=None, Type type=Single, bool wordFlag=false, float w=1.0) :
      m_style(style), m_type(type), m_word(wordFlag), m_width(w), m_color(MWAWColor::black()) { }
    bool isSet() const
    {
      return m_style != None && m_width>0;
    }
    void addTo(librevenge::RVNGPropertyList &propList, std::string const &type) const;
    friend std::ostream &operator<<(std::ostream &o, Line const &line);
    bool operator==(Line const &oth) const
    {
      return cmp(oth)==0;
    }
    bool operator!=(Line const &oth) const
    {
      return cmp(oth)!=0;
    }
    int cmp(Line const &oth) const
    {
      if (m_style != oth.m_style) return int(m_style)-int(oth.m_style);
      if (m_type != oth.m_type) return int(m_type)-int(oth.m_type);
      if (m_word != oth.m_word) return m_word ? -1 : 1;
      if (m_width < oth.m_width) return -1;
      if (m_width > oth.m_width) return 1;
      if (m_color.isSet() != oth.m_color.isSet())
        return m_color.isSet();
      if (m_color.get() < oth.m_color.get()) return -1;
      if (m_color.get() > oth.m_color.get()) return 1;
      return 0;
    }
    Style m_style;
    Type m_type;
    bool m_word;
    float m_width;
    MWAWVariable<MWAWColor> m_color;
  };
  struct Script {
    Script(float delta=0, librevenge::RVNGUnit deltaUnit=librevenge::RVNG_PERCENT, int scale=100) :
      m_delta(delta), m_deltaUnit(deltaUnit), m_scale(scale)
    {
    }
    bool isSet() const
    {
      return *this != Script();
    }
    static Script sub()
    {
      return Script(-33,librevenge::RVNG_PERCENT,58);
    }
    static Script sub100()
    {
      return Script(-20);
    }
    static Script super()
    {
      return Script(33,librevenge::RVNG_PERCENT,58);
    }
    static Script super100()
    {
      return Script(20);
    }
    std::string str(float fSize) const;

    bool operator==(Script const &oth) const
    {
      return cmp(oth)==0;
    }
    bool operator!=(Script const &oth) const
    {
      return cmp(oth)!=0;
    }
    bool operator<(Script const &oth) const
    {
      return cmp(oth)<0;
    }
    bool operator<=(Script const &oth) const
    {
      return cmp(oth)<=0;
    }
    bool operator>(Script const &oth) const
    {
      return cmp(oth)>0;
    }
    bool operator>=(Script const &oth) const
    {
      return cmp(oth)>=0;
    }
    int cmp(Script const &oth) const
    {
      if (m_delta > oth.m_delta) return -1;
      if (m_delta < oth.m_delta) return 1;
      if (m_deltaUnit != oth.m_deltaUnit) return int(m_deltaUnit)-int(oth.m_deltaUnit);
      if (m_scale != oth.m_scale) return m_scale-oth.m_scale;
      return 0;
    }
    float m_delta;
    librevenge::RVNGUnit m_deltaUnit;
    int m_scale;
  };

  enum FontBits { boldBit=1, italicBit=2, blinkBit=4, embossBit=8, engraveBit=0x10,
                  hiddenBit=0x20, outlineBit=0x40, shadowBit=0x80,
                  reverseVideoBit=0x100, smallCapsBit=0x200, allCapsBit=0x400,
                  lowercaseBit=0x800, boxedBit=0x1000, boxedRoundedBit=0x2000,
                  reverseWritingBit=0x4000
                };
  MWAWFont(int newId=-1, float sz=12, uint32_t f = 0) : m_id(newId), m_size(sz), m_deltaSpacing(0), m_texteWidthScaling(1.0), m_scriptPosition(),
    m_flags(f), m_overline(Line::None), m_strikeoutline(Line::None), m_underline(Line::None),
    m_color(MWAWColor::black()), m_backgroundColor(MWAWColor::white()), m_language(""), m_extra("")
  {
    resetColor();
  };
  bool isSet() const
  {
    return m_id.isSet();
  }
  void insert(MWAWFont const &ft)
  {
    m_id.insert(ft.m_id);
    m_size.insert(ft.m_size);
    m_deltaSpacing.insert(ft.m_deltaSpacing);
    m_texteWidthScaling.insert(ft.m_texteWidthScaling);
    m_scriptPosition.insert(ft.m_scriptPosition);
    if (ft.m_flags.isSet()) {
      if (m_flags.isSet())
        setFlags(flags()| ft.flags());
      else
        m_flags = ft.m_flags;
    }
    m_overline.insert(ft.m_overline);
    m_strikeoutline.insert(ft.m_strikeoutline);
    m_underline.insert(ft.m_underline);
    m_color.insert(ft.m_color);
    m_extra += ft.m_extra;
  }
  void setFont(int newId)
  {
    resetColor();
    m_id=newId;
  }

  int id() const
  {
    return m_id.get();
  }
  void setId(int newId)
  {
    m_id = newId;
  }

  float size() const
  {
    return m_size.get();
  }
  void setSize(float sz)
  {
    m_size = sz;
  }

  float deltaLetterSpacing() const
  {
    return m_deltaSpacing.get();
  }
  void setDeltaLetterSpacing(float d)
  {
    m_deltaSpacing=d;
  }
  float texteWidthScaling() const
  {
    return m_texteWidthScaling.get();
  }
  void setTexteWidthScaling(float scale=1.0)
  {
    m_texteWidthScaling = scale;
  }
  Script const &script() const
  {
    return m_scriptPosition.get();
  }

  void set(Script const &newscript)
  {
    m_scriptPosition = newscript;
  }

  uint32_t flags() const
  {
    return m_flags.get();
  }
  void setFlags(uint32_t fl)
  {
    m_flags = fl;
  }

  bool hasColor() const
  {
    return m_color.isSet() && !m_color.get().isBlack();
  }
  void getColor(MWAWColor &c) const
  {
    c = m_color.get();
  }
  void setColor(MWAWColor color)
  {
    m_color = color;
  }

  void getBackgroundColor(MWAWColor &c) const
  {
    c = m_backgroundColor.get();
  }
  void setBackgroundColor(MWAWColor color)
  {
    m_backgroundColor = color;
  }
  void resetColor()
  {
    m_color = MWAWColor::black();
    m_backgroundColor = MWAWColor::white();
  }

  bool hasDecorationLines() const
  {
    return (m_overline.isSet() && m_overline->isSet()) ||
           (m_strikeoutline.isSet() && m_strikeoutline->isSet()) ||
           (m_underline.isSet() && m_underline->isSet());
  }
  void resetDecorationLines()
  {
    if (m_overline.isSet()) m_overline=Line(Line::None);
    if (m_strikeoutline.isSet()) m_strikeoutline=Line(Line::None);
    if (m_underline.isSet()) m_underline=Line(Line::None);
  }
  Line const &getOverline() const
  {
    return m_overline.get();
  }
  void setOverline(Line const &line)
  {
    m_overline = line;
  }
  void setOverlineStyle(Line::Style style=Line::None, bool doReset=true)
  {
    if (doReset)
      m_overline = Line(style);
    else
      m_overline->m_style = style;
  }
  void setOverlineType(Line::Type type=Line::Single)
  {
    m_overline->m_type = type;
  }
  void setOverlineWordFlag(bool wordFlag=false)
  {
    m_overline->m_word = wordFlag;
  }
  void setOverlineWidth(float w)
  {
    m_overline->m_width = w;
  }
  void setOverlineColor(MWAWColor const &color)
  {
    m_overline->m_color = color;
  }

  Line const &getStrikeOut() const
  {
    return m_strikeoutline.get();
  }
  void setStrikeOut(Line const &line)
  {
    m_strikeoutline = line;
  }
  void setStrikeOutStyle(Line::Style style=Line::None, bool doReset=true)
  {
    if (doReset)
      m_strikeoutline = Line(style);
    else
      m_strikeoutline->m_style = style;
  }
  void setStrikeOutType(Line::Type type=Line::Single)
  {
    m_strikeoutline->m_type = type;
  }
  void setStrikeOutWordFlag(bool wordFlag=false)
  {
    m_strikeoutline->m_word = wordFlag;
  }
  void setStrikeOutWidth(float w)
  {
    m_strikeoutline->m_width = w;
  }
  void setStrikeOutColor(MWAWColor const &color)
  {
    m_strikeoutline->m_color = color;
  }

  Line const &getUnderline() const
  {
    return m_underline.get();
  }
  void setUnderline(Line const &line)
  {
    m_underline = line;
  }
  void setUnderlineStyle(Line::Style style=Line::None, bool doReset=true)
  {
    if (doReset)
      m_underline = Line(style);
    else
      m_underline->m_style = style;
  }
  void setUnderlineType(Line::Type type=Line::Single)
  {
    m_underline->m_type = type;
  }
  void setUnderlineWordFlag(bool wordFlag=false)
  {
    m_underline->m_word = wordFlag;
  }
  void setUnderlineWidth(float w)
  {
    m_underline->m_width = w;
  }
  void setUnderlineColor(MWAWColor const &color)
  {
    m_underline->m_color = color;
  }

  std::string const &language() const
  {
    return m_language.get();
  }
  void setLanguage(std::string const &lang)
  {
    m_language=lang;
  }
  void addTo(librevenge::RVNGPropertyList &propList, shared_ptr<MWAWFontConverter> fontConverter) const;

  std::string getDebugString(shared_ptr<MWAWFontConverter> &converter) const;

  bool operator==(MWAWFont const &f) const
  {
    return cmp(f) == 0;
  }
  bool operator!=(MWAWFont const &f) const
  {
    return cmp(f) != 0;
  }

  int cmp(MWAWFont const &oth) const
  {
    int diff = id() - oth.id();
    if (diff != 0) return diff;
    if (size() < oth.size()) return -1;
    if (size() > oth.size()) return -1;
    if (flags() < oth.flags()) return -1;
    if (flags() > oth.flags()) return 1;
    if (m_deltaSpacing.get() < oth.m_deltaSpacing.get()) return -1;
    if (m_deltaSpacing.get() > oth.m_deltaSpacing.get()) return 1;
    if (m_texteWidthScaling.get() < oth.m_texteWidthScaling.get()) return -1;
    if (m_texteWidthScaling.get() > oth.m_texteWidthScaling.get()) return 1;
    diff = script().cmp(oth.script());
    if (diff != 0) return diff;
    diff = m_overline.get().cmp(oth.m_overline.get());
    if (diff != 0) return diff;
    diff = m_strikeoutline.get().cmp(oth.m_strikeoutline.get());
    if (diff != 0) return diff;
    diff = m_underline.get().cmp(oth.m_underline.get());
    if (diff != 0) return diff;
    if (m_color.get() < oth.m_color.get()) return -1;
    if (m_color.get() > oth.m_color.get()) return 1;
    if (m_backgroundColor.get() < oth.m_backgroundColor.get()) return -1;
    if (m_backgroundColor.get() > oth.m_backgroundColor.get()) return 1;
    if (m_language.get() < oth.m_language.get()) return -1;
    if (m_language.get() > oth.m_language.get()) return 1;
    return diff;
  }

protected:
  MWAWVariable<int> m_id ;
  MWAWVariable<float> m_size ;
  MWAWVariable<float> m_deltaSpacing ;
  MWAWVariable<float> m_texteWidthScaling ;
  MWAWVariable<Script> m_scriptPosition ;
  MWAWVariable<uint32_t> m_flags ;
  MWAWVariable<Line> m_overline ;
  MWAWVariable<Line> m_strikeoutline ;
  MWAWVariable<Line> m_underline ;
  MWAWVariable<MWAWColor> m_color ;
  MWAWVariable<MWAWColor> m_backgroundColor ;
  MWAWVariable<std::string> m_language ;
public:
  std::string m_extra;
};


#endif
// vim: set filetype=cpp tabstop=2 shiftwidth=2 cindent autoindent smartindent noexpandtab: