/* attributes.h

 *

 * Copyright (C) 2002 The gtkmm Development Team

 *

 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <pangomm/language.h>

#include <pangomm/rectangle.h>

#include <pangomm/color.h>

#include <pangomm/fontdescription.h>

#include <pango/pango-attributes.h>

#include <glibmm/slisthandle.h>

_DEFS(pangomm,pango)

namespace Pango

{

_CC_INCLUDE(pango/pango-enum-types.h)

/** Pango::AttrType distinguishes between different types of attributes.

 * Along with the predefined values, it is possible to allocate additional values for

 * custom attributes using Pango::Attribute::register_type(). The predefined values

 * are given below.

 */

_WRAP_ENUM(AttrType, PangoAttrType)

/** A Pango::Underline is used to specify whether text should be underlined, and if so, the type of underlining.

 */

_WRAP_ENUM(Underline, PangoUnderline)

/** A Pango::LogAttr stores information about the attributes of a single character.

 */

typedef PangoLogAttr LogAttr;

class AttrString;

class AttrLanguage;

class AttrColor;

class AttrInt;

class AttrFloat;

class AttrFontDesc;

class AttrShape;

/** The Pango::Attribute structure represents the common portions of all attributes.

 * Particular types of attributes derive this class. It holds the range in which the

 * value in the type-specific part of the attribute applies.

 *

 * Attributed text is used in a number of places in pango. It is used as the input to

 * the itemization process and also when creating a Pango::Layout.

 */

class Attribute

{

  _CLASS_GENERIC(Attribute, PangoAttribute)

  _IGNORE(pango_attribute_copy,pango_attribute_destroy)

public:

  /** Constructs an invalid attribute.

   */

  Attribute();

  Attribute(const Attribute& src);

  explicit Attribute(PangoAttribute* castitem, bool take_copy=true);

  ~Attribute();

  Attribute& operator=(const Attribute& src);

  /** Gets the type ID for this attribute.

   * @return The type ID for this attribute or ATTR_INVALID if the attribute is invalid.

   */

  AttrType get_type() const;

  /** Allocate a new attribute type ID.

   * @param name An identifier for the type (currently unused).

   * @return The new type ID.

   */

  static AttrType register_type(const Glib::ustring& name);

  /** Gets the start index of the range.

   * @return The start index of the range.

   */

  _MEMBER_GET(start_index, start_index, unsigned int, guint)

  /** Gets the end index of the range. The character at this index is not included in the range.

   * @return The end index of the range.

   */

  _MEMBER_GET(end_index, end_index, unsigned int, guint)

  /** Sets the start index of the range.

   * @param value The new start index (in bytes).

   */

  _MEMBER_SET(start_index, start_index, unsigned int, guint)

  /** Sets the end index of the range. The character at this index is not included in the range.

   * @param value The new end index (in bytes).

   */

  _MEMBER_SET(end_index, end_index, unsigned int, guint)

  _WRAP_METHOD(bool equal(const Attribute& attr2) const, pango_attribute_equal)

  /// Provides access to the underlying C GObject.  

  PangoAttribute*       gobj()       { return gobject_; }

  /// Provides access to the underlying C GObject.

  const PangoAttribute* gobj() const { return gobject_; }

  /** Create a new font family attribute.

   * @param family The family or comma separated list of families.

   * @return An attribute of type AttrString.

   */

  static AttrString create_attr_family(const Glib::ustring& family);

  /** Create a new language tag attribute

   * @param language The language tag.

   * @return An attribute of type AttrLanguage.

   */

  static AttrLanguage create_attr_language(const Language& language);

  /** Create a new foreground color attribute.

   * @param red The red value (ranging from 0 to 65535).

   * @param green The green value (ranging from 0 to 65535).

   * @param blue The blue value (ranging from 0 to 65535).

   * @return An attribute of type AttrColor.

   */

  static AttrColor create_attr_foreground(guint16 red, guint16 green, guint16 blue);

  /** Create a new background color attribute.

   * @param red The red value (ranging from 0 to 65535).

   * @param green The green value (ranging from 0 to 65535).

   * @param blue The blue value (ranging from 0 to 65535).

   * @return An attribute of type AttrColor.

   */

  static AttrColor create_attr_background(guint16 red, guint16 green, guint16 blue);

  /** Create a new foreground alpha attribute.

   * @param alpha The alpha value, between 1 and 65536.

   */

  static AttrInt create_attr_foreground_alpha(guint16 alpha);

  /** Create a new background alpha attribute.

   * @param alpha The alpha value, between 1 and 65536.

   */

  static AttrInt create_attr_background_alpha(guint16 alpha);

  /** Create a new font-size attribute.

   * @param size The font size, in 1000ths of a point.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_size(int size);

  /** Create a new font slant style attribute.

   * @param style The slant style.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_style(Style style);

  /** Create a new font weight attribute.

   * @param weight The weight.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_weight(Weight weight);

  /** Create a new font variant attribute (normal or small caps).

   * @param variant The variant.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_variant(Variant variant);

  /** Create a new font stretch attribute.

   * @param stretch The stretch.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_stretch(Stretch stretch);

  /** Create a new font description attribute.

   * This attribute allows setting family, style, weight, variant, stretch, and size simultaneously.

   * @param desc The font description.

   * @return An attribute of type AttrFontDesc.

   */

  static AttrFontDesc create_attr_font_desc(const FontDescription& desc);

  /** Create a new underline-style object.

   * @param underline The underline style.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_underline(Underline underline);

  /** Create a new font strike-through attribute.

   * @param strikethrough True indicates the text should be struck-through.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_strikethrough(bool strikethrough);

  /** Create a new baseline displacement attribute.

   * @param rise The amount that the text should be displaced vertically, in 10'000ths of an em. Positive values displace the text upwards.

   * @return An attribute of type AttrInt.

   */

  static AttrInt create_attr_rise(int rise);

  /** Create a new font size scale attribute.

   * The base font for the affected text will have its size multiplied by scale_factor.

   * @param scale_factor Factor to scale the font.

   * @return An attribute of type AttrFloat.

   */

  static AttrFloat create_attr_scale(double scale_factor);

  /** Create a new shape attribute.

   * A shape is used to impose a particular ink and logical rect on the result of shaping a particular glyph.

   * This might be used, for instance, for embedding a picture or a widget inside a PangoLayout.

   * @param ink_rect Ink rectangle to assign to each character.

   * @param logical_rect Logical rectangle assign to each character.

   * @return An attribute of type AttrShape.

   */

  static AttrShape create_attr_shape(const Rectangle& ink_rect, const Rectangle& logical_rect);

protected:

  PangoAttribute* gobject_;

};

/** @relates Pango::Attribute */

inline bool operator==(const Attribute& lhs, const Attribute& rhs)

{

  return lhs.equal(rhs);

}

/** @relates Pango::Attribute */

inline bool operator!=(const Attribute& lhs, const Attribute& rhs)

{

  return !lhs.equal(rhs);

}

/** A Pango::AttrString is used to represent an attribute with a string value.

 */

class AttrString : public Attribute

{

  _CLASS_GENERIC(AttrString, PangoAttrString)

protected:

  AttrString();

public:

  AttrString(const AttrString& src);

  explicit AttrString(PangoAttrString* castitem, bool take_copy=true);

  AttrString& operator=(const AttrString& src);

  /** Gets the string which is the value of the attribute.

   * @return The string value of the attribute.

   */

  _MEMBER_GET(string, value, Glib::ustring, char*)

  /** Sets the string which is the value of the attribute.

   * @param string The new string value for the attribute.

   */

  void set_string(const Glib::ustring& string);

  /// Provides access to the underlying C GObject.  

  PangoAttrString*       gobj()       { return reinterpret_cast<PangoAttrString*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrString* gobj() const { return reinterpret_cast<const PangoAttrString*>(gobject_); }

};

/** A Pango::AttrLanguage is used to represent an attribute that is a language.

 */

class AttrLanguage : public Attribute

{

  _CLASS_GENERIC(AttrLanguage, PangoAttrLanguage)

protected:

  AttrLanguage();

public:

  AttrLanguage(const AttrLanguage& src);

  explicit AttrLanguage(PangoAttrLanguage* castitem, bool take_copy=true);

  AttrLanguage& operator=(const AttrLanguage& src);

  /** Gets the language which is the value of the attribute.

   * @return The language tag of the attribute.

   */

  _MEMBER_GET(language, value, Language, PangoLanguage*)

  /** Sets the language which is the value of the attribute.

   * @param value The new language tag for the attribute.

   */

  _MEMBER_SET_PTR(language, value, const Language&, PangoLanguage*)

  /// Provides access to the underlying C GObject.  

  PangoAttrLanguage*       gobj()       { return reinterpret_cast<PangoAttrLanguage*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrLanguage* gobj() const { return reinterpret_cast<const PangoAttrLanguage*>(gobject_); }

};

/** A Pango::AttrColor is used to represent an attribute which is a color.

 */

class AttrColor : public Attribute

{

  _CLASS_GENERIC(AttrColor, PangoAttrColor)

protected:

  AttrColor();

public:

  AttrColor(const AttrColor& src);

  explicit AttrColor(PangoAttrColor* castitem, bool take_copy=true);

  AttrColor& operator=(const AttrColor& src);

  /** Gets the color which is the value of the attribute.

   * @return The color value of the attribute.

   */

  _MEMBER_GET(color, color, Color, PangoColor)

  /** Sets the color which is the value of the attribute.

   * @param value The new color value for the attribute.

   */

  _MEMBER_SET(color, color, Color, PangoColor)

  /// Provides access to the underlying C GObject.  

  PangoAttrColor*       gobj()       { return reinterpret_cast<PangoAttrColor*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrColor* gobj() const { return reinterpret_cast<const PangoAttrColor*>(gobject_); }

};

/** A Pango::AttrInt is used to represent an attribute with an integer or enumeration value.

 */

class AttrInt : public Attribute

{

  _CLASS_GENERIC(AttrInt, PangoAttrInt)

protected:

  AttrInt();

public:

  AttrInt(const AttrInt& src);

  explicit AttrInt(PangoAttrInt* castitem, bool take_copy=true);

  AttrInt& operator=(const AttrInt& src);

  /** Gets the integer value of the attribute.

   * @return The integer value of the attribute.

   */

  _MEMBER_GET(value, value, int, int)

  /** Sets the integer value of the attribute.

   * @param value The new integer value for the attribute.

   */

  _MEMBER_SET(value, value, int, int)

  /// Provides access to the underlying C GObject.  

  PangoAttrInt*       gobj()       { return reinterpret_cast<PangoAttrInt*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrInt* gobj() const { return reinterpret_cast<const PangoAttrInt*>(gobject_); }

};

/** A Pango::AttrFloat is used to represent an attribute with a float or double value.

 */

class AttrFloat : public Attribute

{

  _CLASS_GENERIC(AttrFloat, PangoAttrFloat)

protected:

  AttrFloat();

public:

  AttrFloat(const AttrFloat& src);

  explicit AttrFloat(PangoAttrFloat* castitem, bool take_copy=true);

  AttrFloat& operator=(const AttrFloat& src);

  /** Gets the floating point value of the attribute.

   * @return The floating point value of the attribute.

   */

  _MEMBER_GET(value, value, double, double)

  /** Sets the floating point value of the attribute.

   * @param value The new floating point value for the attribute.

   */

  _MEMBER_SET(value, value, double, double)

  /// Provides access to the underlying C GObject.

  PangoAttrFloat*       gobj()       { return reinterpret_cast<PangoAttrFloat*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrFloat* gobj() const { return reinterpret_cast<const PangoAttrFloat*>(gobject_); }

};

/** A Pango::AttrFontDesc is used to represent an attribute that sets all aspects of the font description at once.

 */

class AttrFontDesc : public Attribute

{

  _CLASS_GENERIC(AttrFontDesc, PangoAttrFontDesc)

protected:

  AttrFontDesc();

public:

  AttrFontDesc(const AttrFontDesc& src);

  explicit AttrFontDesc(PangoAttrFontDesc* castitem, bool take_copy=true);

  AttrFontDesc& operator=(const AttrFontDesc& src);

  /** Gets the font description which is the value of the attribute.

   * @return The font description of the attribute.

   */

  _MEMBER_GET(desc, desc, FontDescription, PangoFontDescription*)

  /** Sets the font description which is the value of the attribute.

   * @param desc The new font description for the attribute.

   */

  void set_desc(const FontDescription& desc);

  /// Provides access to the underlying C GObject.

  PangoAttrFontDesc*       gobj()       { return reinterpret_cast<PangoAttrFontDesc*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrFontDesc* gobj() const { return reinterpret_cast<const PangoAttrFontDesc*>(gobject_); }

};

/** A Pango::AttrShape structure is used to represent an attribute which imposes shape restrictions.

 */

class AttrShape : public Attribute

{

  _CLASS_GENERIC(AttrShape, PangoAttrShape)

protected:

  AttrShape();

public:

  AttrShape(const AttrShape& src);

  explicit AttrShape(PangoAttrShape* castitem, bool take_copy=true);

  AttrShape& operator=(const AttrShape& src);

  /** Gets the ink rectangle to restrict to.

   * @return The ink rectangle of the attribute.

   */

  _MEMBER_GET(ink_rect, ink_rect, Rectangle, PangoRectangle)

  /** Gets the logical rectangle to restrict to.

   * @return The logical rectangle of the attribute.

   */

  _MEMBER_GET(logical_rect, logical_rect, Rectangle, PangoRectangle)

  /** Sets the ink rectangle to restrict to.

   * @param value The new ink rectangle for the attribute.

   */

  _MEMBER_SET(ink_rect, ink_rect, Rectangle, PangoRectangle)

  /** Sets the logical rectangle to restrict to.

   * @param value The new logical rectangle for the attribute.

   */

  _MEMBER_SET(logical_rect, logical_rect, Rectangle, PangoRectangle)

  /// Provides access to the underlying C GObject.  

  PangoAttrShape*       gobj()       { return reinterpret_cast<PangoAttrShape*>(gobject_); }

  /// Provides access to the underlying C GObject.

  const PangoAttrShape* gobj() const { return reinterpret_cast<const PangoAttrShape*>(gobject_); }

};

struct AttributeTraits

{

  typedef Pango::Attribute      CppType;

  typedef const PangoAttribute* CType;

  typedef PangoAttribute*       CTypeNonConst;

  static CType   to_c_type      (const CppType& obj) { return obj.gobj(); }

  static CType   to_c_type      (CType ptr) { return ptr; }

  static CppType to_cpp_type    (CType ptr) { return CppType(const_cast<CTypeNonConst>(ptr), true); }

  static void    release_c_type (CType ptr) { pango_attribute_destroy(const_cast<CTypeNonConst>(ptr)); }

};

typedef Glib::SListHandle<Attribute, AttributeTraits> SListHandle_Attribute;

} // namespace Pango

namespace Glib

{

/** @relates Pango::Attribute */

Pango::Attribute wrap(PangoAttribute* object, bool take_copy = false);

/** @relates Pango::AttrString */

Pango::AttrString wrap(PangoAttrString* object, bool take_copy = false);

/** @relates Pango::AttrLanguage */

Pango::AttrLanguage wrap(PangoAttrLanguage* object, bool take_copy = false);

/** @relates Pango::AttrColor */

Pango::AttrColor wrap(PangoAttrColor* object, bool take_copy = false);

/** @relates Pango::AttrInt */

Pango::AttrInt wrap(PangoAttrInt* object, bool take_copy = false);

/** @relates Pango::AttrFloat */

Pango::AttrFloat wrap(PangoAttrFloat* object, bool take_copy = false);

/** @relates Pango::AttrFontDesc */

Pango::AttrFontDesc wrap(PangoAttrFontDesc* object, bool take_copy = false);

/** @relates Pango::AttrShape */

Pango::AttrShape wrap(PangoAttrShape* object, bool take_copy = false);

} //namespace Glib