kspread_cell.h

/* This file is part of the KDE project
 
   Copyright 2006 Stefan Nikolaus <stefan.nikolaus@kdemail.net>
   Copyright 2004 Tomas Mecir <mecirt@gmail.com>
   Copyright 1999-2002,2004 Laurent Montel <montel@kde.org>
   Copyright 2002,2004 Ariya Hidayat <ariya@kde.org>
   Copyright 2002-2003 Norbert Andres <nandres@web.de>
   Copyright 2003 Stefan Hetzl <shetzl@chello.at>
   Copyright 2001-2002 Philipp Mueller <philipp.mueller@gmx.de>
   Copyright 2002 Harri Porten <porten@kde.org>
   Copyright 2002 John Dailey <dailey@vt.edu>
   Copyright 1999-2001 David Faure <faure@kde.org>
   Copyright 2000-2001 Werner Trobin <trobin@kde.org>
   Copyright 2000 Simon Hausmann <hausmann@kde.org
   Copyright 1998-1999 Torben Weis <weis@kde.org>
   Copyright 1999 Michael Reiher <michael.reiher.gmx.de>
   Copyright 1999 Reginald Stadlbauer <reggie@kde.org>
 
   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 KSPREAD_CELL
#define KSPREAD_CELL
 
#include <tqpainter.h>
#include <tqptrlist.h>
#include <tqdatetime.h>
 
#include "kspread_condition.h"
 
class TDELocale;
class TQDomElement;
class TQDomDocument;
class KoXmlWriter;
class KoGenStyles;
class KoGenStyle;
class KSParseNode;
class KoRect;
class KoPoint;
class KoOasisStyles;
class KoOasisLoadingContext;
 
namespace KSpread
{
class Canvas;
class Format;
class GenValidationStyles;
class Sheet;
class Value;
class View;
class ConditionalDialog;
 
struct Validity
{
  Validity()
  {
      valMin = 0.0;
      valMax = 0.0;
      m_cond = Conditional::None;
      m_action = Action::Stop;
      m_restriction = Restriction::None;
      displayMessage = true;
      allowEmptyCell = false;
      displayValidationInformation = false;
  };
 
  bool operator==( const Validity& other ) const
  {
    if ( message == other.message &&
         title == other.title &&
         titleInfo == other.titleInfo &&
         messageInfo == other.messageInfo &&
         valMin == other.valMin &&
         valMax == other.valMax &&
         m_cond == other.m_cond &&
         m_action == other.m_action &&
         m_restriction == other.m_restriction &&
         timeMin == other.timeMin &&
         timeMax == other.timeMax &&
         dateMin == other.dateMin &&
         dateMax == other.dateMax &&
         displayMessage == other.displayMessage &&
         allowEmptyCell == other.allowEmptyCell &&
         displayValidationInformation == other.displayValidationInformation &&
         listValidity == other.listValidity )
    {
      return true;
    }
    return false;
  }
  inline bool operator!=( const Validity& other ) const { return !operator==( other ); }
 
    TQString message;
    TQString title;
    TQString titleInfo;
    TQString messageInfo;
    double valMin;
    double valMax;
    Conditional::Type m_cond;
    Action::Type m_action;
    Restriction::Type m_restriction;
    TQTime  timeMin;
    TQTime  timeMax;
    TQDate  dateMin;
    TQDate  dateMax;
    bool displayMessage;
    bool allowEmptyCell;
    bool displayValidationInformation;
    TQStringList listValidity;
};
 
class Formula;
 
class KSPREAD_EXPORT Cell
{
  friend class Conditions;
public:
 
  Cell (Sheet *_sheet, int _column, int _row);
  Cell (Sheet *_sheet, Style * _style, int _column, int _row);
 
    ~Cell();
 
    Sheet* sheet() const;
 
    bool isDefault() const;
 
    bool isEmpty() const;
 
    int column() const;
 
    int row() const;
 
    TQString name() const;
 
    TQString fullName() const;
 
    TQString columnName() const;
 
    static TQString name( int col, int row );
 
    static TQString fullName( const Sheet *s, int col, int row );
 
    static TQString columnName( uint column );
 
    TDELocale* locale() const;
    bool isFormula() const;
 
    TQString text() const;
 
    TQString strOutText() const;
 
    Formula *formula () const;
 
    Format* format() const;
 
    const Value value() const;
 
    void setValue( const Value& value );
 
    void setCellValue (const Value& value, FormatType fmtType = No_format,
                       const TQString& inputText = TQString());
 
    Cell* previousCell() const;
    Cell* nextCell() const;
    void setPreviousCell( Cell* c );
    void setNextCell( Cell* c );
 
    void move( int column, int row );
 
    // Note:  This used to remove any links from this cell to other cells.  However, this caused a problem
    // in other parts of the code which relied upon walking from one cell to the next using
    // nextCell().
    void sheetDies();
 
    TQDomElement save( TQDomDocument& doc, int _x_offset = 0, int _y_offset = 0, bool force = false, bool copy = false, bool era = false );
 
    bool saveOasis( KoXmlWriter& xmlwriter, KoGenStyles& mainStyles,
                    int row, int column, int &repeated,
                    GenValidationStyles &valStyle );
 
    void saveOasisValue (KoXmlWriter &xmlWriter);
 
    TQString saveOasisCellStyle( KoGenStyle &currentCellStyle,KoGenStyles &mainStyles );
 
    bool load( const TQDomElement& cell, int _xshift, int _yshift, Paste::Mode pm = Paste::Normal,
               Paste::Operation op = Paste::OverWrite, bool paste = false );
 
    bool loadOasis( const TQDomElement & element, KoOasisLoadingContext &oasisContext , Style* style);
 
    TQTime toTime(const TQDomElement &element);
    TQDate toDate(const TQDomElement &element);
 
    void copyFormat( const int column, const int row );
    void copyFormat( const Cell* cell );
    void copyContent( const Cell* cell );
    void copyAll( Cell *cell);
 
    enum BorderSides
    {
      Border_None   =0x00,
      Border_Left   =0x01,
      Border_Right  =0x02,
      Border_Top    =0x04,
      Border_Bottom =0x08,
      Border_SizeGrip   =0x10   //the size grip is the little square on the bottom right-hand corner of a highlighted range of cells
              //which the user can click and drag to resize the range and change which cells are included.
              //this is not used with normal borders
    };
 
    void paintCell( const KoRect & rect, TQPainter & painter,
                    View * view, const KoPoint & coordinate,
                    const TQPoint & cellRef,
            int paintBorder,
            TQPen & rightPen,
                    TQPen & bottomPen,
                    TQPen & leftPen,
                    TQPen & topPen,
            TQValueList<TQPoint> &mergedCellsPainted,
                    bool drawCursor = true );
 
 
    int width( int _col = -1, const Canvas *_canvas = 0L ) const;
 
    int height( int _row = -1, const Canvas *_canvas = 0L ) const;
 
    double dblWidth( int _col = -1, const Canvas *_canvas = 0L ) const;
 
    double dblHeight( int _row = -1, const Canvas *_canvas = 0L ) const;
 
    TQRect cellRect();
 
    bool needsPrinting() const;
 
    void incPrecision();
    void decPrecision();
 
    void setCellText( const TQString& _text, bool asString = false );
 
    void setDisplayText( const TQString& _text );
 
    void setLink( const TQString& link );
 
    TQString link() const;
 
    //
    // Methods for querying format stuff.
    //
 
    const TQPen & effLeftBorderPen( int col, int row ) const;
    const TQPen & effTopBorderPen( int col, int row ) const;
    const TQPen & effRightBorderPen( int col, int row ) const;
    const TQPen & effBottomBorderPen( int col, int row ) const;
    const TQPen & effGoUpDiagonalPen( int col, int row ) const;
    const TQPen & effFallDiagonalPen( int col, int row ) const;
    const TQColor & effTextColor( int col, int row ) const;
 
    uint effBottomBorderValue( int col, int row ) const;
    uint effRightBorderValue( int col, int row ) const;
    uint effLeftBorderValue( int col, int row ) const;
    uint effTopBorderValue( int col, int row ) const;
 
    const TQPen& leftBorderPen( int col, int row ) const;
 
    const TQPen& topBorderPen( int col, int row ) const;
 
    const TQPen& rightBorderPen( int col, int row ) const;
 
    const TQPen& bottomBorderPen( int col, int row ) const;
 
    const TQColor& bgColor( int col, int row ) const;
 
    const TQBrush& backGroundBrush( int col, int row ) const;
 
    //
    // Methods for setting format stuff.
    //
 
    void setLeftBorderPen( const TQPen& p );
 
    void setTopBorderPen( const TQPen& p );
 
    void setRightBorderPen( const TQPen& p );
 
    void setBottomBorderPen( const TQPen& p );
 
    //
    // Other stuff
    //
 
    FormatType formatType() const;
 
    bool isDate() const;
    bool isTime() const;
 
    void setNumber( double number );
 
    double getDouble ();
 
    void convertToDouble ();
    void convertToPercent ();
    void convertToMoney ();
    void convertToTime ();
    void convertToDate ();
 
    double textWidth() const;
    double textHeight() const;
 
 
    bool updateChart(bool refresh=true);
 
    TQString testAnchor( int _x, int _y ) const;
 
    bool calc(bool delay = true);
 
    void setCalcDirtyFlag();
    bool calcDirtyFlag();
 
    void NotifyDepending( int col, int row, Sheet* sheet, bool isDepending );
 
    void setLayoutDirtyFlag( bool format = false );
    bool layoutDirtyFlag() const;
 
    void clearDisplayDirtyFlag();
    void setDisplayDirtyFlag();
 
    void obscure( Cell *cell, bool isForcing = false);
    void unobscure(Cell* cell);
    bool isObscured() const;
    bool isPartOfMerged() const;
 
    Cell *ultimateObscuringCell() const;
 
    TQValueList<Cell*> obscuringCells() const;
 
    void clearObscuringCells();
 
 
    void mergeCells( int _col, int _row, int _x, int _y );
 
    bool doesMergeCells() const;
 
    int mergedXCells() const;
 
    int mergedYCells() const;
 
    int extraXCells() const;
 
    int extraYCells() const;
 
    double extraWidth() const;
    double extraHeight() const;
 
    TQString encodeFormula( bool _era = false, int _col = -1, int _row = -1 ) const;
    TQString decodeFormula( const TQString &_text, int _col = -1, int _row = -1 ) const;
 
    TQString pasteOperation( const TQString &new_text, const TQString &old_text, Paste::Operation op );
 
    bool hasError() const;
 
    void clearAllErrors();
 
    void makeLayout( TQPainter &_painter, int _col, int _row );
 
    bool makeFormula();
 
 
    void defaultStyle();
 
    TQValueList<Conditional> conditionList() const;
 
    void setConditionList(const TQValueList<Conditional> &newList);
 
    Validity * getValidity( int newStruct = -1 );
 
    void removeValidity();
 
    bool testValidity() const;
 
    void calculateTextParameters( TQPainter &painter, int _col, int _row );
 
    int defineAlignX();
 
 
 
 
    bool operator > ( const Cell & ) const;
    bool operator < ( const Cell & ) const;
 
    bool operator==( const Cell& other ) const;
    inline bool operator!=( const Cell& other ) const { return !operator==( other ); }
 
    void freeAllObscuredCells();
 
    /* descriptions of the flags are just below */
    enum CellFlags{
    /* this uses the same flags variable as Format.  The least significant
       16 bits are reserved for the base class, and the most significant 16
       have been left for this subclass to use. */
      Flag_LayoutDirty           = 0x00010000,
      Flag_CalcDirty             = 0x00020000,
      Flag_Progress              = 0x00040000,
      Flag_UpdatingDeps          = 0x00080000,
      Flag_DisplayDirty          = 0x00100000,
      Flag_Merged                = 0x00200000,
      Flag_CellTooShortX         = 0x00400000,
      Flag_CellTooShortY         = 0x00800000,
      Flag_ParseError            = 0x01000000,
      Flag_CircularCalculation   = 0x02000000,
      Flag_DependancyError       = 0x04000000,
      Flag_PaintingCell          = 0x08000000, // On during painting
      Flag_TextFormatDirty       = 0x10000000
     // Flag_Highlight     = 0x20000000
    };
 
    void clearFlag( CellFlags flag );
    void setFlag( CellFlags flag );
    bool testFlag( CellFlags flag ) const;
 
  /* descriptions of the flags are as follows: */
 
  /*
   * Error
   * True if the cell is calculated and there was an error during calculation
   * In that case the cell usually displays "#####"
   *
   * LayoutDirty
   * Flag showing whether the current layout is OK.
   * If you change for example the fonts point size, set this flag. When the
   * cell must draw itself on the screen it will first recalculate its layout.
   *
   * CalcDirty
   * Shows whether recalculation is necessary.
   * If this cell must be recalculated for some reason, for example the user
   * entered a new formula, then this flag is set. If @ref #bFormula is false
   * nothing will happen at all.
   *
   * Progress
   * Tells whether this cell it currently under calculation.
   * If a cell thats 'progressFlag' is set is told to calculate we
   * have detected a circular reference and we must stop calulating.
   *
   * UpdatingDeps
   * Tells whether we've already calculated the reverse dependancies for this
   * cell.  Similar to the Progress flag but it's for when we are calculating
   * in the reverse direction.
   * @see updateDependancies()
   *
   * DisplayDirty - TODO - is this unused now??
   * If this flag is set, then it is known that this cell has to be updated
   * on the display. This means that somewhere in the calling stack there is a
   * function which will call @ref Sheet::updateCell once it retains
   * the control. If a function changes the contents/layout of this cell and this
   * flag is not set, then the function must set it at once. After the changes
   * are done the function must call <tt>m_pSheet->updateCell(...).
   * The flag is cleared by the function format()->sheet()->updateCell.
   *
   * Merged
   * Tells whether the cell is merged with other cells.  Cells may
   * occupy other cells space on demand. You may force a cell to
   * do so by setting this flag. Merging the cell with 0 in both
   * directions, will disable this flag!
   *
   * CellTooShortX
   * When it's True displays ** and/or the red triangle and when the
   * mouse is over it, the tooltip displays the full value
   * it's true when text size is bigger that cell size
   * and when Align is center or left
   *
   * CellTooShortY
   * When it's True when mouseover it, the tooltip displays the full value
   * it's true when text size is bigger that cell height
   */
 
protected:
    void applyZoomedFont( TQPainter &painter, int _col, int _row );
 
    void textSize( TQPainter &_paint );
 
    TQString textDisplaying( TQPainter &painter);
 
    void clearFormula();
 
    void checkTextInput();
 
    void checkNumberFormat();
 
    void loadOasisCellText( const TQDomElement& parent );
    void loadOasisObjects( const TQDomElement& e, KoOasisLoadingContext& oasisContext );
    void loadOasisValidation( const TQString& validationName );
 
    void loadOasisValidationCondition( TQString &valExpression );
    void saveOasisAnnotation( KoXmlWriter &xmlwriter );
    void loadOasisConditional( TQDomElement * style );
 
 
 
private:
 
    class Extra;
    class Private;
    Private *d;
    // static const char* s_dataTypeToString[];
 
    /* helper functions to the paintCell(...) function */
 /*   void paintCellHighlight(TQPainter& painter,
          const KoRect& cellRect,
          const TQPoint& cellRef,
          const int highlightBorder,
          const TQPen& rightPen,
          const TQPen& bottomPen,
          const TQPen& leftPen,
          const TQPen& topPen
         );*/
 
 
    void paintCellBorders( TQPainter& painter, const KoRect &rect,
                           const KoRect &cellRect,
         const TQPoint &cellRef,
                           bool paintBorderRight, bool paintBorderBottom,
                           bool paintBorderLeft, bool paintBorderTop,
                           TQPen & rightPen, TQPen & bottomPen,
                           TQPen & leftPen, TQPen & topPen );
    void paintPageBorders( TQPainter& painter, const KoRect &cellRect,
                           const TQPoint &cellRef,
                           bool paintBorderRight, bool paintBorderBottom );
    void paintText( TQPainter& painter, const KoRect &cellRect,
                    const TQPoint &cellRef );
    void paintMoreTextIndicator( TQPainter& painter, const KoRect &cellRect,
                                 TQColor &backgroundColor );
    void paintCommentIndicator( TQPainter& painter, const KoRect &cellRect,
                                const TQPoint &cellRef, TQColor &backgroundColor );
    void paintFormulaIndicator( TQPainter& painter, const KoRect &cellRect,
                                TQColor &backgroundColor );
    void paintDefaultBorders( TQPainter& painter, const KoRect &rect,
                              const KoRect &cellRect, const TQPoint &cellRef,
                              bool paintBorderRight, bool paintBorderBottom,
                              bool paintBorderLeft, bool paintBorderTop,
                              TQPen const & rightPen, TQPen const & bottomPen,
                              TQPen const & leftPen, TQPen const & topPen );
    void paintBackground( TQPainter& painter, const KoRect &cellRect,
                          const TQPoint &cellRef, bool selected,
                          TQColor &backgroundColor );
    void paintObscuredCells( const KoRect& rect, TQPainter& painter,
                             View* view, const KoRect &cellRect,
                             const TQPoint &cellRef,
                             bool paintBorderRight, bool paintBorderBottom,
                             bool paintBorderLeft, bool paintBorderTop,
                             TQPen & rightPen, TQPen & bottomPen,
                             TQPen & leftPen, TQPen & topPen,
                 TQValueList<TQPoint> &mergedCellsPainted );
    void paintCellDiagonalLines( TQPainter& painter, const KoRect &cellRect,
                                 const TQPoint &cellRef );
 
 
 
 
  void valueChanged ();
 
  /* helper functions to the makeLayout(...) function */
  /* (more to come) */
  void setOutputText();
 
 
  /* helper functions to the load/save routines */
  bool loadCellData(const TQDomElement &text, Paste::Operation op);
  bool saveCellResult( TQDomDocument& doc, TQDomElement& result,
                       TQString str );
  void update();
  int effAlignX();
 
  void offsetAlign( int _col, int _row );
 
    void checkForNamedAreas( TQString & formula ) const;
    TQString convertFormulaToOasisFormat( const TQString & formula ) const;
    void loadOasisValidationValue( const TQStringList &listVal );
 
};
 
} // namespace KSpread
 
#endif  // KSPREAD_CELL