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