region.h

/* This file is part of the KDE project
   Copyright (C) 2005-2006 Stefan Nikolaus <stefan.nikolaus@kdemail.net>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
 
#ifndef KSPREAD_REGION
#define KSPREAD_REGION
 
#include <tqrect.h>
#include <tqstring.h>
#include <tqvaluelist.h>
 
#include <kdebug.h>
 
#include <koffice_export.h>
 
#include "kspread_global.h"
#include "kspread_util.h"
 
namespace KSpread
{
class Manipulator;
class Sheet;
class View;
 
class KSPREAD_EXPORT Region
{
protected:
  class Element;
  class Point;
  class Range;
 
public:
  Region();
 
  Region(const TQPoint& point, Sheet* sheet = 0);
 
  Region(const TQRect& range, Sheet* sheet = 0);
 
  Region(View* view, const TQString& strRegion, Sheet* sheet = 0);
 
  Region(const Region& region);
 
  Region(int col, int row, Sheet* sheet = 0);
 
  Region(int col, int row, int width, int height, Sheet* sheet = 0);
 
  virtual ~Region();
 
 
 
  TQString name(Sheet* originSheet = 0) const;
 
  Sheet* filterSheetName(TQString& sRegion);
 
 
 
  bool isEmpty() const;
 
  bool isSingular() const;
 
  bool isContiguous() const;
 
  bool isValid() const;
 
  bool isColumnSelected(uint col = 0) const;
 
  bool isRowSelected(uint row = 0) const;
 
  bool isColumnOrRowSelected() const;
 
  bool isColumnAffected(uint col) const;
 
  bool isRowAffected(uint row) const;
 
  bool contains(const TQPoint& point, Sheet* sheet = 0) const;
 
 
 
  /* TODO Stefan #2: Optimize! Adjacent Points/Ranges */
  Element* add(const TQPoint& point, Sheet* sheet = 0);
  Element* add(const TQRect& range, Sheet* sheet = 0);
  Element* add(const Region& region);
 
  /* TODO Stefan #3: Improve! */
  void sub(const TQPoint& point);
  void sub(const TQRect& range);
  void sub(const Region& region);
 
  virtual Element* eor(const TQPoint& point, Sheet* sheet = 0);
 
  virtual void clear();
 
 
 
  TQRect boundingRect() const;
 
 
 
  bool operator==(const Region& region) const;
 
  void operator=(const Region& region);
 
 
 
  View* view() const;
 
  void setView(View*);
 
 
  typedef TQValueList<Element*>::Iterator      Iterator;
  typedef TQValueList<Element*>::ConstIterator ConstIterator;
 
  ConstIterator constBegin() const;
  ConstIterator constEnd() const;
 
protected:
  TQValueList<Element*>& cells() const;
 
  Iterator insert(Iterator iterator, const TQPoint& point, Sheet*, bool multi = true);
  Iterator insert(Iterator iterator, const TQRect& range, Sheet*, bool multi = true);
 
  virtual Point* createPoint(const TQPoint&) const;
  virtual Point* createPoint(const TQString&) const;
  virtual Point* createPoint(const Point&) const;
  virtual Range* createRange(const TQRect&) const;
  virtual Range* createRange(const TQString&) const;
  virtual Range* createRange(const Range&) const;
 
private:
  class Private;
  Private *d;
};
 
 
/***************************************************************************
  class Region::Element
****************************************************************************/
class Region::Element
{
public:
  enum Type { Undefined, Point, Range };
 
  Element();
  virtual ~Element();
 
  virtual Type type() const { return Undefined; }
  virtual bool isValid() const { return false; }
  virtual bool isColumn() const { return false; }
  virtual bool isRow() const { return false; }
 
  virtual bool contains(const TQPoint&) const { return false; }
  virtual bool contains(const TQRect&) const { return false; }
 
  virtual TQString name(Sheet* = 0) const { return TQString(""); }
  virtual TQRect rect() const { return TQRect(); }
  virtual const TQColor& color() const { return TQt::black; }
 
  Sheet* sheet() const { return m_sheet; }
  void setSheet(Sheet* sheet) { m_sheet = sheet; }
 
protected:
  /* TODO Stefan #6:
      Elaborate, if this pointer could be avoided by TQDict or whatever in
      Region.
  */
  Sheet* m_sheet;
};
 
 
/***************************************************************************
  class Region::Point
****************************************************************************/
 
class Region::Point : public Region::Element
{
public:
  Point(const TQPoint&);
  Point(const TQString&);
  virtual ~Point();
 
  virtual Type type() const { return Element::Point; }
  virtual bool isValid() const { return (!m_point.isNull() && util_isPointValid(pos())); }
  virtual bool isColumn() const { return false; }
  virtual bool isRow() const { return false; }
 
  virtual bool contains(const TQPoint&) const;
  virtual bool contains(const TQRect&) const;
 
  virtual TQString name(Sheet* originSheet = 0) const;
 
  virtual TQRect rect() const { return TQRect(m_point,m_point); }
 
  TQPoint pos() const { return m_point; }
 
private:
  TQPoint m_point;
};
 
 
/***************************************************************************
  class Region:.Range
****************************************************************************/
 
class Region::Range : public Region::Element
{
public:
  Range(const TQRect&);
  Range(const TQString&);
  virtual ~Range();
 
  virtual Type type() const { return Element::Range; }
  virtual bool isValid() const { return !m_range.isNull() && util_isRectValid(rect()); }
  virtual bool isColumn() const { return (m_range.normalize().top() == 1 && m_range.normalize().bottom() == KS_rowMax); }
  virtual bool isRow() const { return (m_range.normalize().left() == 1 && m_range.normalize().right() == KS_colMax); }
 
  virtual bool contains(const TQPoint&) const;
  virtual bool contains(const TQRect&) const;
 
  virtual TQString name(Sheet* originSheet = 0) const;
 
  virtual TQRect rect() const { return m_range; }
 
  int width() const;
  int height() const;
 
private:
  TQRect m_range;
};
 
} // namespace KSpread
 
 
/***************************************************************************
  kdDebug support
****************************************************************************/
 
inline kdbgstream operator<<( kdbgstream str, const KSpread::Region& r )
{
  str << "Region = " << r.name();
  return str;
}
 
#endif // KSPREAD_REGION