manipulator.h

/* This file is part of the KDE project
   Copyright (C) 2005 Stefan Nikolaus <stefan.nikolaus@kdemail.net>
 
   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.
 
   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 KSPREAD_MANIPULATOR
#define KSPREAD_MANIPULATOR
 
#include <tqrect.h>
#include <tqstring.h>
#include <tqvaluelist.h>
 
#include <kcommand.h>
#include <tdelocale.h>
 
#include <koffice_export.h>
 
#include "kspread_format.h"
#include "kspread_undo.h"
#include "region.h"
 
namespace KSpread
{
class Cell;
class ColumnFormat;
class RowFormat;
class Sheet;
 
 
// struct layoutCell {
//   int row;
//   int col;
//   Format *l;
// };
//
// struct layoutColumn {
//   int col;
//   ColumnFormat *l;
// };
//
// struct layoutRow {
//   int row;
//   RowFormat *l;
// };
 
 

class Manipulator : public Region, public KCommand
{
public:
  Manipulator();
  virtual ~Manipulator();
 
  Sheet* sheet() const { return m_sheet; }
  void setSheet(Sheet* sheet) { m_sheet = sheet; }
 
  bool creation() { return m_creation; }
  void setCreation(bool creation) { m_creation = creation; }

  bool format() { return m_format; };
  void setFormat (bool f) { m_format = f; };
 
  virtual void execute();
  virtual void unexecute();
 
  virtual void setArgument(const TQString& /*arg*/, const TQString& /*val*/) {};
 
  virtual void setReverse(bool reverse) { m_reverse = reverse; }
  void setRegisterUndo(bool registerUndo) { m_register = registerUndo; }
 
  virtual void setName (const TQString &n) { m_name = n; }
  virtual TQString name() const { return m_name; };
 
protected:
  virtual bool process(Element*);
  virtual bool process(Cell*) { return true; }
  virtual bool process(Format*) { return true; }
 
  virtual bool preProcessing() { return true; }
  virtual bool postProcessing() { return true; }
 
 
  Sheet* m_sheet;
  TQString m_name;
  bool   m_creation : 1;
  bool   m_reverse  : 1;
  bool   m_firstrun : 1;
  bool   m_format   : 1;
  bool   m_register : 1;
private:
};
 
 

class FormatManipulator : public Manipulator
{
public:
  FormatManipulator();
  virtual ~FormatManipulator();
 
  void setProperty(Format::Properties property) { m_properties |= property; }
  bool isEmpty() { return m_properties == 0; }
 
  // SetSelectionFontWorker
  // SetSelectionSizeWorker
  void setFontFamily(const TQString& font) { m_properties |= Format::PFont; m_font = font; }
  void setFontSize(int size) { m_properties |= Format::PFont; m_size = size; }
  void setFontBold(uint bold) { m_properties |= Format::PFont; m_bold = bold; }
  void setFontItalic(uint italic) { m_properties |= Format::PFont; m_italic = italic; }
  void setFontStrike(uint strike) { m_properties |= Format::PFont; m_strike = strike; }
  void setFontUnderline(uint underline) { m_properties |= Format::PFont; m_underline = underline; }
  // SetSelectionAngleWorker
  void setAngle(int angle) { m_properties |= Format::PAngle; m_angle = angle; }
  // SetSelectionTextColorWorker
  void setTextColor(const TQColor& textColor) { m_properties |= Format::PTextPen; m_textColor = textColor; }
  // SetSelectionBgColorWorker
  void setBackgroundColor(const TQColor& bgColor) { m_properties |= Format::PBackgroundColor; m_backgroundColor = bgColor; }
  // SetSelectionBorderAllWorker
  void setTopBorderPen(const TQPen& pen) { m_properties |= Format::PTopBorder; m_topBorderPen = pen; }
  void setBottomBorderPen(const TQPen& pen) { m_properties |= Format::PBottomBorder; m_bottomBorderPen = pen; }
  void setLeftBorderPen(const TQPen& pen) { m_properties |= Format::PLeftBorder; m_leftBorderPen = pen; }
  void setRightBorderPen(const TQPen& pen) { m_properties |= Format::PRightBorder; m_rightBorderPen = pen; }
  void setHorizontalPen(const TQPen& pen) { m_properties |= Format::PTopBorder | Format::PBottomBorder; m_horizontalPen = pen; }
  void setVerticalPen(const TQPen& pen) { m_properties |= Format::PLeftBorder | Format::PRightBorder; m_verticalPen = pen; }
  void setFallDiagonalPen(const TQPen& pen) { m_properties |= Format::PFallDiagonal; m_fallDiagonalPen = pen; }
  void setGoUpDiagonalPen(const TQPen& pen) { m_properties |= Format::PGoUpDiagonal; m_goUpDiagonalPen = pen; }
  // SetSelectionAlignWorker
  void setHorizontalAlignment(Format::Align align) { m_properties |= Format::PAlign; m_horAlign = align; }
  // SetSelectionAlignWorker
  void setVerticalAlignment(Format::AlignY align) { m_properties |= Format::PAlignY; m_verAlign = align; }
 
  void setBackgroundBrush(const TQBrush& brush) { m_properties |= Format::PBackgroundBrush; m_backgroundBrush = brush; }
  void setIndent(double indent) { m_properties |= Format::PIndent; m_indent = indent; }
  void setMultiRow(bool multiRow) { m_properties |= Format::PMultiRow; m_multiRow = multiRow; }
  void setVerticalText(bool verticalText) { m_properties |= Format::PVerticalText; m_verticalText = verticalText; }
  void setDontPrintText(bool dontPrintText) { m_properties |= Format::PDontPrintText; m_dontPrintText = dontPrintText; }
  void setNotProtected(bool notProtected) { m_properties |= Format::PNotProtected; m_notProtected = notProtected; }
  void setHideAll(bool hideAll) { m_properties |= Format::PHideAll; m_hideAll = hideAll; }
  void setHideFormula(bool hideFormula) { m_properties |= Format::PHideFormula; m_hideFormula = hideFormula; }
  void setComment(const TQString& comment) { m_properties |= Format::PComment; m_comment = comment; }
  void setPrefix(const TQString& prefix) { m_properties |= Format::PPrefix; m_prefix = prefix; }
  void setPostfix(const TQString& postfix) { m_properties |= Format::PPostfix; m_postfix = postfix; }
  void setPrecision(int precision) { m_properties |= Format::PPrecision; m_precision = precision; }
  void setFloatFormat(Format::FloatFormat floatFormat) { m_properties |= Format::PFloatFormat; m_floatFormat = floatFormat; }
  void setFloatColor(Format::FloatColor floatColor) { m_properties |= Format::PFloatColor; m_floatColor = floatColor; }
  void setFormatType(FormatType formatType) { m_properties |= Format::PFormatType; m_formatType = formatType; }
  void setCurrency(int type, const TQString& symbol) { m_currencyType = type; m_currencySymbol = symbol; }
 
protected:
  virtual TQString name() const { return i18n("Format Change"); }
 
  virtual bool preProcessing();
  virtual bool process(Element*);
 
  void copyFormat(TQValueList<layoutCell> &list,
                  TQValueList<layoutColumn> &listCol,
                  TQValueList<layoutRow> &listRow);
  bool testCondition(RowFormat*);
  void doWork(Format*, bool isTop, bool isBottom, bool isLeft, bool isRight);
  void prepareCell(Cell*);
 
private:
  TQ_UINT32 m_properties;
 
  // TODO Stefan: find a more elegant way to store the format
  TQValueList<layoutCell> m_lstFormats;
  TQValueList<layoutCell> m_lstRedoFormats;
  TQValueList<layoutColumn> m_lstColFormats;
  TQValueList<layoutColumn> m_lstRedoColFormats;
  TQValueList<layoutRow> m_lstRowFormats;
  TQValueList<layoutRow> m_lstRedoRowFormats;
 
  // SetSelectionFontWorker
  // SetSelectionSizeWorker
  TQString m_font;
  int m_size;
  signed char m_bold;
  signed char m_italic;
  signed char m_strike;
  signed char m_underline;
  // SetSelectionAngleWorker
  int m_angle;
  int m_precision;
  int m_currencyType;
  double m_indent;
  bool m_multiRow;
  bool m_verticalText;
  bool m_dontPrintText;
  bool m_notProtected;
  bool m_hideAll;
  bool m_hideFormula;
 
  // SetSelectionTextColorWorker
  TQColor m_textColor;
  // SetSelectionBgColorWorker
  TQColor m_backgroundColor;
  // SetSelectionBorderAllWorker
  TQPen m_topBorderPen;
  TQPen m_bottomBorderPen;
  TQPen m_leftBorderPen;
  TQPen m_rightBorderPen;
  TQPen m_horizontalPen;
  TQPen m_verticalPen;
  TQPen m_fallDiagonalPen;
  TQPen m_goUpDiagonalPen;
 
  TQBrush m_backgroundBrush;
  TQString m_comment;
  TQString m_prefix;
  TQString m_postfix;
  TQString m_currencySymbol;
 
  // SetSelectionAlignWorker
  Format::Align m_horAlign;
  // SetSelectionAlignWorker
  Format::AlignY m_verAlign;
  Format::FloatFormat m_floatFormat;
  Format::FloatColor m_floatColor;
  FormatType m_formatType;
};
 
 

class ResizeColumnManipulator : public Manipulator
{
public:
  ResizeColumnManipulator();
  ~ResizeColumnManipulator();
 
  void setSize(double size) { m_newSize = size; }
  void setOldSize(double size) { m_oldSize = size; }
 
protected:
  virtual bool process(Element*);
 
  virtual TQString name() const { return i18n("Resize Column"); }
 
private:
  double m_newSize;
  double m_oldSize;
};
 
 

class ResizeRowManipulator : public Manipulator
{
public:
  ResizeRowManipulator();
  ~ResizeRowManipulator();
 
  void setSize(double size) { m_newSize = size; }
  void setOldSize(double size) { m_oldSize = size; }
 
protected:
  virtual bool process(Element*);
 
  virtual TQString name() const { return i18n("Resize Row"); }
 
private:
  double m_newSize;
  double m_oldSize;
};
 
 

class BorderManipulator : public FormatManipulator
{
public:
  BorderManipulator() {}
  ~BorderManipulator() {}
 
protected:
  virtual TQString name() const { return i18n("Change Border"); }
 
private:
};
 
 

class BackgroundColorManipulator : public FormatManipulator
{
public:
  BackgroundColorManipulator() {}
  ~BackgroundColorManipulator() {}
 
protected:
  virtual TQString name() const { return i18n("Change Background Color"); }
 
private:
};
 
 

class FontColorManipulator : public FormatManipulator
{
public:
  FontColorManipulator() {}
  ~FontColorManipulator() {}
 
protected:
  virtual TQString name() const { return i18n("Change Text Color"); }
 
private:
};
 
 

class FontManipulator : public FormatManipulator
{
public:
  FontManipulator() {}
  ~FontManipulator() {}
 
protected:
  virtual TQString name() const { return i18n("Change Font"); }
 
private:
};
 
 

class AngleManipulator : public FormatManipulator
{
  public:
    AngleManipulator() {}
    ~AngleManipulator() {}
 
  protected:
    virtual TQString name() const { return i18n("Change Angle"); }
 
  private:
};
 
 

class HorAlignManipulator : public FormatManipulator
{
  public:
    HorAlignManipulator() {}
    ~HorAlignManipulator() {}
 
  protected:
    virtual TQString name() const { return i18n("Change Horizontal Alignment"); }
 
  private:
};
 
 

class VerAlignManipulator : public FormatManipulator
{
  public:
    VerAlignManipulator() {}
    ~VerAlignManipulator() {}
 
  protected:
    virtual TQString name() const { return i18n("Change Vertical Alignment"); }
 
  private:
};
 
 
 

class MergeManipulator : public Manipulator
{
public:
  MergeManipulator();
  virtual ~MergeManipulator();
 
  virtual bool preProcessing();
 
  virtual void setReverse(bool reverse) { m_merge = !reverse; }
  void setHorizontalMerge(bool state) { m_mergeHorizontal = state; }
  void setVerticalMerge(bool state) { m_mergeVertical = state; }
 
protected:
  virtual bool process(Element*);
 
  virtual bool postProcessing();
 
  virtual TQString name() const;
 
  bool m_merge;
private:
  bool m_mergeHorizontal : 1;
  bool m_mergeVertical   : 1;
  Manipulator* m_unmerger; // to restore old merging
};
 
 

class DilationManipulator : public Manipulator
{
public:
  DilationManipulator();
  virtual ~DilationManipulator();
 
  virtual void execute();
  virtual void unexecute();
 
protected:
  virtual TQString name() const { return i18n("Dilate Region"); }
 
private:
};
 
 

class AdjustColumnRowManipulator : public Manipulator
{
public:
  AdjustColumnRowManipulator();
  virtual ~AdjustColumnRowManipulator();
 
  virtual bool process(Element*);
  virtual bool preProcessing();
 
  void setAdjustColumn(bool state) { m_adjustColumn = state; }
  void setAdjustRow(bool state) { m_adjustRow = state; }
 
protected:
  virtual TQString name() const;
 
  double adjustColumnHelper( Cell * c, int _col, int _row );
  double adjustRowHelper( Cell * c, int _col, int _row );
 
private:
  bool m_adjustColumn : 1;
  bool m_adjustRow    : 1;
  TQMap<int, double> m_newWidths;
  TQMap<int, double> m_oldWidths;
  TQMap<int, double> m_newHeights;
  TQMap<int, double> m_oldHeights;
};
 
 

class HideShowManipulator : public Manipulator
{
public:
  HideShowManipulator();
  virtual ~HideShowManipulator();
 
  virtual bool process(Element*);
  virtual bool preProcessing();
  virtual bool postProcessing();
 
  void setManipulateColumns(bool state) { m_manipulateColumns = state; }
  void setManipulateRows(bool state) { m_manipulateRows = state; }
 
protected:
  virtual TQString name() const;
 
private:
  bool m_manipulateColumns : 1;
  bool m_manipulateRows    : 1;
};
 
 

class InsertDeleteManipulator : public Manipulator
{
public:
  InsertDeleteManipulator();
  ~InsertDeleteManipulator();
 
protected:
 
private:
  bool m_manipulateColumns : 1;
  bool m_manipulateRows    : 1;
};
 
 
 
 

class ManipulatorManager
{
  public:
    static ManipulatorManager* self();
    ~ManipulatorManager();
    Manipulator* create(const TQString&);
 
  private:
    ManipulatorManager();
    static ManipulatorManager* m_self;
};
 
} // namespace KSpread
 
#endif // KSPREAD_MANIPULATOR