TableTypes.h

//========================================================================================
// 
// $File$
// 
// Owner: Joe Shankar
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// Purpose: Base types for tables.
// 
//========================================================================================

#ifndef __TableTypes__
#define __TableTypes__

#include <algorithm>

#include "IPMStream.h"
#include "K2Vector.h"
#include "ParcelKey.h"

#ifdef PUBLIC_BUILD
#endif

template <class T>
inline void UNUSED(const volatile T&) {} // Note that this generates no code on Mac or Win (if inlining is on).


//-----------------------------------
// Forward References
//
class GridAddress;
class GridArea;
class GridID;
class RowRange;
class ColRange;
class CellParcelAddr;
//-----------------------------------
// Types
//
typedef int32 GridCoord; // Row or column number

namespace Tables
{
 enum ECellEdge {eLeft, eRight, eTop, eBottom};

 enum ERowColumn { eRow, eColumn };

 enum ERelativePosition { eBefore, eAfter };

 enum EContinuation {
 eStructureAllAttrs, // content and table attributes
 eStructureTableAttrs, // no content attributes
 eNoStructureAllAttrs // content and table attributes, not not struct
 };

 enum ESelectionSides {
 eNoSides = 0,
 eLeftSide = 1,
 eRightSide = 2,
 eTopSide = 4,
 eBottomSide = 8,
 eInteriorRows = 16,
 eInteriorCols = 32,
 eAllSides = 63
 };

 enum ERowStartAtValue {
 eStartAnywhere = 0,
 eStartNextColumn = 2,
 eStartNextFrame = 3,
 eStartNextPage = 4,
 eStartNextOddPage = 5,
 eStartNextEvenPage = 6
 };

 enum EHeaderFootersBreakValues {
 eStartEachTextColumn = 0,
 eStartEachTextFrame = 1,
 eStartEachPage = 2
 };

 enum EStrokeDrawingOrder {
 eBestJoins = 0,
 eRowOnTop = 1,
 eColumnOnTop = 2,
 eInDesign2Compatibility = 3
 };

 enum EDirection {eLTR, eRTL};

 inline ESelectionSides operator|(ESelectionSides first, ESelectionSides second)
 {
 ASSERT(first >= eNoSides && first <= eAllSides);
 ASSERT(second >= eNoSides && second <= eAllSides);

 ESelectionSides result = (ESelectionSides)((uint32)first | (uint32)second);

 ASSERT(result >= eNoSides && result <= eAllSides);
 return result;
 };
}

typedef K2Vector<uint32> GridIDCollection;
typedef K2Vector<GridIDCollection*> GridIDCollectionVector;

typedef ClassID CellType;

//-----------------------------------
// Constants
//
 extern const GridID kInvalidGridID;
 extern const GridAddress kBadGridAddress;
 extern const GridCoord kBadCoord;
 extern const GridArea kZeroGridArea;
 extern const CellParcelAddr kBadParcelAddr;
 extern const CellType kNoContentType;

//===================================================================================
// class GridAddress
//===================================================================================
class GridAddress {

public:
 typedef base_type data_type;

 GridAddress() : row(kBadCoord), col(kBadCoord) {}
 GridAddress(GridCoord inRow, GridCoord inCol) : row(inRow), col(inCol) {}

 void Set(GridCoord inRow, GridCoord inCol) {row = inRow; col = inCol;}

 GridAddress operator+(const GridAddress& rhs) const {return GridAddress(row + rhs.row, col + rhs.col);}

 GridAddress operator-(const GridAddress& rhs) const {return GridAddress(row - rhs.row, col - rhs.col);}

 GridAddress& operator+=(const GridAddress& rhs) {row += rhs.row; col += rhs.col; return *this;}

 GridAddress& operator-=(const GridAddress& rhs) {row -= rhs.row; col -= rhs.col; return *this;}

 bool16 operator ==(const GridAddress& rhs) const {return row == rhs.row && col == rhs.col;}

 bool16 operator !=(const GridAddress& rhs) const {return row != rhs.row || col != rhs.col;}

 bool16 operator < (const GridAddress& rhs) const {return row < rhs.row || (row == rhs.row && col < rhs.col);}

 bool16 operator <=(const GridAddress& rhs) const {return row < rhs.row || (row == rhs.row && col <= rhs.col);}

 bool16 operator > (const GridAddress& rhs) const {return row > rhs.row || (row == rhs.row && col > rhs.col);}

 bool16 operator >=(const GridAddress& rhs) const {return row > rhs.row || (row == rhs.row && col >= rhs.col);}

 void ReadWrite(IPMStream* stream) {stream->XferInt32(row); stream->XferInt32(col);}

public:
 GridCoord row;
 GridCoord col;
};


//===================================================================================
// class GridID
//===================================================================================
class GridID {
public:
 explicit GridID(uint32 id = 0) : fGridID(id) {}
 operator uint32() const {return fGridID;}
private:
 uint32 fGridID;
};


//===================================================================================
// class GridSpan
//===================================================================================
class GridSpan {

public:
 typedef base_type data_type;

 GridSpan() : height(1), width(1) {} // $$$ better to initialize to -1?
 GridSpan(int32 inHeight, int32 inWidth) : height(inHeight), width(inWidth) {}

 void Set(int32 inHeight, int32 inWidth) {height = inHeight; width = inWidth;}

 bool16 IsUnitSpan() const {return height == 1 && width == 1;}

 bool16 IsEmpty() const {return height == 0 || width == 0;}

 bool16 operator ==(const GridSpan& rhs) const {return height == rhs.height && width == rhs.width;}
 bool16 operator !=(const GridSpan& rhs) const {return height != rhs.height || width != rhs.width;}

 void ReadWrite(IPMStream* stream) {stream->XferInt32(height); stream->XferInt32(width);}

public:
 int32 height;
 int32 width;
};


//===================================================================================
// class GridArea
//===================================================================================
class GridArea {

public:
 typedef base_type data_type;

 // ----- Constructors -----
 GridArea();

 GridArea(GridCoord topRow, GridCoord leftCol, GridCoord bottomRow, GridCoord right);

 GridArea(const GridAddress& topLeftElement, const GridAddress& bottomRightElement);

 GridArea(const GridAddress& anchor, const GridSpan& span);

 GridArea(const RowRange& rows, const ColRange& cols);

 void Set(GridCoord topRow, GridCoord leftCol, GridCoord bottomRow, GridCoord right);

 // ----- Corners -----
 GridAddress GetTopLeft() const {return GridAddress(topRow, leftCol);}

 GridAddress GetBottomRight() const {return GridAddress(bottomRow, rightCol);}

 GridAddress GetTopLeftElem() const {return this->GetTopLeft();}

 GridAddress GetTopRightElem() const {return GridAddress(topRow, rightCol-1);}

 GridAddress GetBottomLeftElem() const {return GridAddress(bottomRow-1, leftCol);}

 GridAddress GetBottomRightElem() const {return GridAddress(bottomRow-1, rightCol-1);}

 void SetTopLeft (const GridAddress& tl) {topRow = tl.row; leftCol = tl.col;}

 void SetBottomRight(const GridAddress& br) {bottomRow = br.row; rightCol = br.col;}

 inline RowRange GetRows() const;

 inline ColRange GetCols() const;

 // ----- Dimensions -----
 GridSpan GetSpan() const {return GridSpan(bottomRow - topRow, rightCol - leftCol);}

 int32 Width() const {return rightCol - leftCol;}

 int32 Height() const {return bottomRow - topRow;}

 bool16 IsEmpty() const {return leftCol >= rightCol || topRow >= bottomRow;}

 // ----- Operations -----
 GridArea operator&(const GridArea& rhs) const;
 GridArea operator|(const GridArea& rhs) const;
 // Intersect and union operators.

 GridArea& operator&=(const GridArea& rhs) {*this = *this & rhs; return *this;}

 GridArea& operator|=(const GridArea& rhs) {*this = *this | rhs; return *this;}

 // ----- Relational Operators -----
 bool16 operator ==(const GridArea& rhs) const {return topRow == rhs.topRow && bottomRow == rhs.bottomRow && leftCol == rhs.leftCol && rightCol == rhs.rightCol;}

 bool16 operator !=(const GridArea& rhs) const {return !this->operator==(rhs);}

 // ----- Misc -----
 bool16 Normalize();

 bool16 IsNormalized() const {return topRow <= bottomRow && leftCol <= rightCol;}

 bool16 Contains(const GridAddress& element) const {return element.row >= topRow && element.row < bottomRow && element.col >= leftCol && element.col < rightCol;}


 bool16 Contains(const GridArea& area) const {return area.topRow >= topRow && area.bottomRow <= bottomRow && area.leftCol >= leftCol && area.rightCol <= rightCol;}

 bool16 Intersects(const GridArea& area) const {return leftCol < area.rightCol && rightCol > area.leftCol && topRow < area.bottomRow && bottomRow > area.topRow;}
 void ReadWrite(IPMStream* stream) {stream->XferInt32(topRow); stream->XferInt32(leftCol); stream->XferInt32(bottomRow); stream->XferInt32(rightCol);}

public:
 GridCoord topRow;
 GridCoord leftCol;
 GridCoord bottomRow;

 GridCoord rightCol;
};

//===================================================================================
// class RowRange
//===================================================================================
class RowRange {
public:

 typedef base_type data_type;

 RowRange() : start(0), count(0) {}
 RowRange(int32 inStart, int32 inCount) : start(inStart), count(inCount) { ASSERT(count >= 0); }
 explicit RowRange(const GridArea& area) : start(area.topRow), count(area.Height()) { ASSERT(count >= 0); }


 void Set(int32 sstart, int32 ccount) { start = sstart; count = ccount; ASSERT(count >= 0); }

 int32 End() const { return start + count; }

 bool16 IsEmpty() const { return count == 0; }

 bool16 Contains (const RowRange& rhs) const { return rhs.start >= start && rhs.End() <= this->End(); }

 bool16 Contains (int32 row) const { return row >= start && row < start + count; }

 bool16 Intersects(const RowRange& rhs) const { return start < rhs.End() && this->End() > rhs.start; }

 bool16 operator ==(const RowRange& rhs) const { return start == rhs.start && count == rhs.count; }

 bool16 operator !=(const RowRange& rhs) const { return start != rhs.start || count != rhs.count; }

 RowRange operator&(const RowRange& rhs) const;
 RowRange operator|(const RowRange& rhs) const;

 RowRange& operator&=(const RowRange& rhs) { *this = *this & rhs; return *this; }

 RowRange& operator|=(const RowRange& rhs) { *this = *this | rhs; return *this; }

 void ReadWrite(IPMStream* stream) { stream->XferInt32(start); stream->XferInt32(count); }

public:
 int32 start;
 int32 count;
};


//===================================================================================
// class ColRange
//===================================================================================
class ColRange {

public:
 typedef base_type data_type;

 ColRange() : start(0), count(0) {}

 ColRange(int32 sstart, int32 ccount) : start(sstart), count(ccount) { ASSERT(count >= 0);}

 explicit ColRange(const GridArea& area) : start(area.leftCol), count(area.Width()) { ASSERT(count >= 0);}

 void Set(int32 sstart, int32 ccount) { start = sstart; count = ccount; ASSERT(count >= 0); }

 int32 End() const { return start + count; }

 bool16 IsEmpty() const { return count == 0; }

 bool16 Contains (const ColRange& rhs) const { return rhs.start >= start && rhs.End() <= this->End(); }
 bool16 Contains (int32 col) const { return col >= start && col < this->End(); }
 bool16 Intersects(const ColRange& rhs) const { return start < rhs.End() && this->End() > rhs.start; }

 bool16 operator ==(const ColRange& rhs) const { return start == rhs.start && count == rhs.count; }
 bool16 operator !=(const ColRange& rhs) const { return start != rhs.start || count != rhs.count; }

 ColRange operator&(const ColRange& rhs) const;
 ColRange operator|(const ColRange& rhs) const;

 ColRange& operator&=(const ColRange& rhs) { *this = *this & rhs; return *this; }

 ColRange& operator|=(const ColRange& rhs) { *this = *this | rhs; return *this; }


 void ReadWrite(IPMStream* stream) { stream->XferInt32(start); stream->XferInt32(count); }

public:
 int32 start;
 int32 count;
};

//
// An address to a parcel of a cell
// This contains the gridID of the cell and the parcel identification for the parcel
//
class CellParcelAddr {
public:
 typedef base_type data_type;

 GridAddress cellAddr;
 ParcelKey parcelKey;

public:
 CellParcelAddr() : cellAddr(kBadGridAddress), parcelKey() {}
 CellParcelAddr(GridAddress addr, ParcelKey key) {cellAddr = addr; parcelKey = key;}

 bool16 operator ==(const CellParcelAddr& rhs) const { return cellAddr == rhs.cellAddr && parcelKey == rhs.parcelKey; }
 bool16 operator !=(const CellParcelAddr& rhs) const { return !(*this == rhs); }

};


//===================================================================================
// Inlines
//===================================================================================
inline GridArea::GridArea() :
 topRow(kBadCoord),
 leftCol(kBadCoord),
 bottomRow(kBadCoord),
 rightCol(kBadCoord)
{
}

inline GridArea::GridArea(GridCoord t, GridCoord l, GridCoord b, GridCoord r) :
 topRow(t),
 leftCol(l),
 bottomRow(b),
 rightCol(r)
{
}

inline GridArea::GridArea(const GridAddress& tl, const GridAddress& br) :
 topRow(tl.row),
 leftCol(tl.col),
 bottomRow(br.row),
 rightCol(br.col)
{
}

inline GridArea::GridArea(const GridAddress& tl, const GridSpan& span) :
 topRow(tl.row),
 leftCol(tl.col),
 bottomRow(tl.row + span.height),
 rightCol(tl.col + span.width)
{
}

inline GridArea::GridArea(const RowRange& rows, const ColRange& cols) :
 topRow (rows.start),
 leftCol(cols.start),
 bottomRow(rows.End()),
 rightCol(cols.End())
{
}

inline void GridArea::Set(GridCoord t, GridCoord l, GridCoord b, GridCoord r)
{
 topRow = t;
 leftCol = l;
 bottomRow = b;
 rightCol = r;
}

inline RowRange GridArea::GetRows() const
{
 return RowRange(topRow, bottomRow - topRow);
}

inline ColRange GridArea::GetCols() const
{
 return ColRange(leftCol, rightCol - leftCol);
}

#ifdef PUBLIC_BUILD
#endif

#endif // __TableTypes__