ufont.hpp

/************************************************************************
 *
 *  ufont.hpp: Font Attribute
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | http://www.enst.fr/~elc/ubit
 *
 * ***********************************************************************
 * COPYRIGHT NOTICE :
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE
 * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU
 * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
 * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
 * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
 * ***********************************************************************/

#ifndef _ufont_hpp_
#define _ufont_hpp_ 1
#include <ubit/uattr.hpp>
#include <ubit/ustr.hpp>
namespace ubit {
  
  class UFont : public UAttr {
  public:
    UCLASS(UFont)
    
    enum Style {
      PLAIN         = 0,
      BOLD          = 1<<0, // DON'T CHANGE VALUE!
      ITALIC        = 1<<1, // DON'T CHANGE VALUE!
      FILL          = 1<<2,
      UNDERLINE     = 1<<3,
      OVERLINE      = 1<<4,
      STRIKETHROUGH = 1<<5
    };
    
    static UFont sans_serif, serif, monospace;
    
    static UFont xx_small, x_small, small, medium, large, x_large, xx_large;
    
    static UFont plain, bold, italic, fill, underline, overline, strikethrough;
    UFont();
    
    UFont(const UFont&);
    
    UFont(const UFont& font, int style, float pixel_size);
    UFont(const UFontFamily&, int style, float point_size);
    virtual UFont& operator=(const UFont& f) {set(f); return *this;}
    
    virtual void set(const UFont&);
    
    virtual bool operator==(const UFont& f) const {return equals(f);}
    virtual bool operator!=(const UFont& f) const {return !equals(f);}
    virtual bool equals(const UFont&) const;
    
    const UFontFamily& getFamily() const {return *family;}
    
    float getPixelSize() const {return fsize;}
    
    float getPointSize() const;
    
    int getStyles() const {return on_styles;}
    
    UFont& setFamily(const UFontFamily&);
    
    UFont& setFamily(const UStr& font_families);
    
    UFont& setSize(const UStr& size);
    
    UFont& setPixelSize(float pixel_size);
    
    UFont& setPointSize(float point_size);
    
    UFont& setStyles(int styles);
    
    UFont& changeStyles(int styles, bool add);
    bool isPlain() const;
    bool isBold() const;
    bool isItalic() const;
    bool isFilled() const;
    bool isUnderlined() const;
    bool isOverlined() const;
    bool isStrikethrough() const;
    
    UFont& setBold(bool = true);
    UFont& setItalic(bool = true);
    UFont& setFilled(bool = true);
    UFont& setUnderlined(bool = true);
    UFont& setOverlined(bool = true);
    UFont& setStrikethrough(bool = true);
    
    void merge(const UFont&);
    virtual void update();
    
    // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    virtual void realize(UDisp*);
    virtual void putProp(UUpdateContext*, UElem&);
    
  private:
    friend class UDisp;
    friend class UFontDesc;
    const UFontFamily* family;
    //short size;
    float fsize;
    short on_styles, off_styles;  // activated and disactivated styles
    UFont(const UFontFamily*, int styles, float pixel_size, UConst);
  };
  
  inline UFont& ufont(const UFont& f) {return *new UFont(f);}
  
  
  /* ==================================================== ===== ======= */
  class UFontFamily : public UObject {
  public:
    static UFontFamily sans_serif, serif, monospace;
    
    static UFontFamily defaults;
    UFontFamily(const UStr& logical_name);
    
    UFontFamily& operator=(const UFontFamily&);  
    
    const UStr& getName() const {return name;}
    
    void setFamily(const char* native_families);
    
    void setStyles(const char* normal_styles, const char* italic_styles);
    
    void setWeights(const char* normal_weights, const char* bold_weights);
    
    void setCompression(const char* compressions);
    
    void setEncoding(const char* encodings);
    
    void setPreferredSizes(const char* sizes);
    
    void setFreeType(const char* regular_files, 
                     const char* bold_files,
                     const char* italic_files, 
                     const char* bold_italic_files);
    // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  protected:
    friend class UFontDesc;  
    friend class UHardFont;  
    friend class UDisp;  
    
    UFontFamily(const char* logical_name, UConst);  // private constr
    UFontFamily(const UFontFamily&); // forbidden
    
    void initSizes() const;
    int sizeToIndex(float fsize) const;
    
    static int family_count;
    mutable int ffindex;
    mutable bool ready;
    UStr name;
    mutable std::vector<int> fsizes;
    struct Defs {
      UStr
      families, 
      normal_style,
      italic_style,
      normal_weight,
      bold_weight,
      compression,
      encoding,  
      preferred_sizes,
      fty_regular, fty_bold, fty_italic, fty_bold_italic;  // freetype
    } defs;
  };
  
}
#endif