kspread/excel/sidewinder/format.h

/* Sidewinder - Portable library for spreadsheet
   Copyright (C) 2003-2006 Ariya Hidayat <ariya@kde.org>
   Copyright (C) 2006 Marijn Kruisselbrink <m.kruisselbrink@student.tue.nl>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA
*/
 
#ifndef SWINDER_FORMAT_H
#define SWINDER_FORMAT_H
 
#include "ustring.h"
#include <cstdio>   // for sscanf
 
namespace Swinder
{

class Color
{
public:
 
  unsigned red, green, blue;

  Color(){ red = green = blue = 0; };

  Color( const Color& c )
    { red = c.red; green = c.green; blue = c.blue; }

  Color( unsigned r, unsigned g, unsigned b )
    { red = r; green = g; blue = b; }

  Color( const char* c )
    { std::sscanf(c, "#%2x%2x%2x", &red, &green, &blue); }
 
  friend inline bool operator==(const Color&, const Color&);
  friend inline bool operator!=(const Color&, const Color&);
};

inline bool operator==(const Color& c1, const Color& c2)
{ return c1.red == c2.red && c1.green == c2.green && c1.blue == c2.blue; }

inline bool operator!=(const Color& c1, const Color& c2)
{ return c1.red != c2.red || c1.green != c2.green || c1.blue != c2.blue; }
 
class Pen
{
public:
 
  unsigned style;
 
  unsigned width;
 
  Color color;
 
  enum {
    NoLine,         // no line at all
    SolidLine,      // a simple solid line
    DashLine,       // dashes separated by a few pixels
    DotLine,        // dots separated by a few pixels
    DashDotLine,    // alternate dots and dashes
    DashDotDotLine  // one dash, two dots, one dash, two dots
  };
 
  Pen(): style( SolidLine ), width( 0 ){}
 
  friend inline bool operator==(const Pen&, const Pen&);
  friend inline bool operator!=(const Pen&, const Pen&);
};

inline bool operator==(const Pen& p1, const Pen& p2)
{ return p1.style == p2.style && p1.width == p1.width && p1.color == p2.color; }

inline bool operator!=(const Pen& p1, const Pen& p2)
{ return p1.style != p2.style || p1.width != p1.width || p1.color != p2.color; }
 

 
class FormatFont
{
public:

  FormatFont();

  ~FormatFont();

  FormatFont( const FormatFont& );

  FormatFont& operator=( const FormatFont& );

  FormatFont& assign( const FormatFont& );

  bool isNull() const;

  const UString& fontFamily() const;

  void setFontFamily( const UString& fontFamily );

  double fontSize() const;

  void setFontSize( double fs );

  Color color() const;

  void setColor( const Color& color );

  bool bold() const;

  void setBold( bool b );

  bool italic() const;

  void setItalic( bool i );

  bool underline() const;

  void setUnderline( bool u );

  bool strikeout() const;

  void setStrikeout( bool s );

  bool subscript() const;

  void setSubscript( bool s );

  bool superscript() const;

  void setSuperscript( bool s );

  bool operator==(const FormatFont& f) const;

  bool operator!=(const FormatFont& f) const;
 
private:
  class Private;
  Private *d;
};
 

 
class FormatAlignment
{
public:

  FormatAlignment();

  ~FormatAlignment();

  FormatAlignment( const FormatAlignment& );

  FormatAlignment& operator=( const FormatAlignment& );

  FormatAlignment& assign( const FormatAlignment& );

  bool isNull() const;

  unsigned alignX() const;

  void setAlignX( unsigned xa );

  unsigned alignY() const;

   void setAlignY( unsigned xa );

   bool wrap() const;

   void setWrap( bool w );

   unsigned indentLevel() const;

   void setIndentLevel( unsigned i );

   unsigned rotationAngle() const;

   void setRotationAngle( unsigned r );

  bool operator==(const FormatAlignment& f) const;

  bool operator!=(const FormatAlignment& f) const;
 
private:
  class Private;
  Private *d;
};

class FormatBackground
{
public:
  FormatBackground();

  ~FormatBackground();

  FormatBackground( const FormatBackground& );

  FormatBackground& operator=( const FormatBackground& );

  FormatBackground& assign( const FormatBackground& );

  bool isNull() const;
 
  enum {
    SolidPattern,
    Dense1Pattern,
    Dense2Pattern,
    Dense3Pattern,
    Dense4Pattern,
    Dense5Pattern,
    Dense6Pattern,
    Dense7Pattern,
    HorPattern,     // Horizonatal lines
    VerPattern,     // Vertical lines
    CrossPattern,   // Horizontal and vertical lines
    BDiagPattern,   // Left-bottom to right-top diagonal lines
    FDiagPattern,   // Left-top to right-bottom diagonal lines
    DiagCrossPattern,   // Crossing diagonal lines
    EmptyPattern
  };

  unsigned pattern() const;

  void setPattern( unsigned );

  Color backgroundColor() const;

  void setBackgroundColor( const Color& );

  Color foregroundColor() const;

  void setForegroundColor( const Color& );

  bool operator==(const FormatBackground& f) const;

  bool operator!=(const FormatBackground& f) const;
 
private:
  class Private;
  Private *d;
};

 
class FormatBorders
{
public:

  FormatBorders();

  ~FormatBorders();

  FormatBorders( const FormatBorders& );

  FormatBorders& operator=( const FormatBorders& );

  FormatBorders& assign( const FormatBorders& );

  bool isNull() const;

  const Pen& leftBorder() const;

  void setLeftBorder( const Pen& pen );

  const Pen& rightBorder() const;

  void setRightBorder( const Pen& pen );

  const Pen& topBorder() const;

  void setTopBorder( const Pen& pen );

  const Pen& bottomBorder() const;

  void setBottomBorder( const Pen& pen );

  bool operator==(const FormatBorders& f) const;

  bool operator!=(const FormatBorders& f) const;
 
private:
  class Private;
  Private *d;
};

 
 
class Format
{
public:

  Format();

  ~Format();

  Format( const Format& f );

  Format& operator= ( const Format& f );

  Format& assign( const Format& f );

  bool isNull() const;

  FormatFont& font() const;

  void setFont( const FormatFont& font );

  FormatAlignment& alignment() const;

  void setAlignment( const FormatAlignment& alignment );

  FormatBorders& borders() const;

  void setBorders( const FormatBorders& border );

  FormatBackground& background() const;

  void setBackground( const FormatBackground& );

  const UString& valueFormat() const;

  void setValueFormat( const UString& valueFormat );
 
  enum { Left, Center, Right };
 
  enum { Top, Middle, Bottom };

  Format& apply( const Format& f );

  bool operator==(const Format& f) const;

  bool operator!=(const Format& f) const;
 
private:
  class Private;
  Private* d; // can't never be 0
};
 
}
 
#endif // SWINDER_FORMAT_H