DbTable.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
#ifndef OD_DBTABLE_H
#define OD_DBTABLE_H
 
#include "TD_PackPush.h"
#include "DbBlockReference.h"
#include "DbTableStyle.h"
#include "DbDataLink.h"
#include "UInt32Array.h"
 
// typedef for OdSubentPathArray
//
 
class OdDbTableImpl;
class OdDbLinkedTableData;
class OdDbTableTemplate;
 
namespace OdDb
{
  enum TableBreakOption  
  { 
    kTableBreakNone                 = 0,
    kTableBreakEnableBreaking       = 0x01,
    kTableBreakRepeatTopLabels      = 0x02,
    kTableBreakRepeatBottomLabels   = 0x04,
    kTableBreakAllowManualPositions = 0x08,
    kTableBreakAllowManualHeights   = 0x10
  };
  
  enum TableBreakFlowDirection 
  { 
    kTableBreakFlowRight      = 0x1,
    kTableBreakFlowDownOrUp   = 0x2,
    kTableBreakFlowLeft       = 0x4
  };
 
  enum TableHitItem        
  { 
    kTableHitNone            = 0,
    kTableHitCell            = 0x1,
    kTableHitRowIndicator    = 0x2,
    kTableHitColumnIndicator = 0x4,
    kTableHitGridLine        = 0x8,
  };
};
 
class TOOLKIT_EXPORT OdDbTable: public OdDbBlockReference
{
public:
  ODDB_DECLARE_MEMBERS(OdDbTable);
 
  enum TableStyleOverrides 
  {
    kTitleSuppressed             = 1,
    kHeaderSuppressed            = 2,
    kFlowDirection               = 3,   
    kHorzCellMargin              = 4,
    kVertCellMargin              = 5,
    kTitleRowColor               = 6,
    kHeaderRowColor              = 7,
    kDataRowColor                = 8,
    kTitleRowFillNone            = 9,
    kHeaderRowFillNone           = 10,
    kDataRowFillNone             = 11,
    kTitleRowFillColor           = 12,
    kHeaderRowFillColor          = 13,
    kDataRowFillColor            = 14,
    kTitleRowAlignment           = 15,
    kHeaderRowAlignment          = 16,
    kDataRowAlignment            = 17,
    kTitleRowTextStyle           = 18,
    kHeaderRowTextStyle          = 19,
    kDataRowTextStyle            = 20,
    kTitleRowTextHeight          = 21,
    kHeaderRowTextHeight         = 22,
    kDataRowTextHeight           = 23,
    kTitleRowDataType            = 24,
    kHeaderRowDataType           = 25,
    kDataRowDataType             = 26,
    kTitleHorzTopColor           = 40,
    kTitleHorzInsideColor        = 41,
    kTitleHorzBottomColor        = 42,
    kTitleVertLeftColor          = 43,
    kTitleVertInsideColor        = 44,
    kTitleVertRightColor         = 45,
    kHeaderHorzTopColor          = 46,
    kHeaderHorzInsideColor       = 47,
    kHeaderHorzBottomColor       = 48,
    kHeaderVertLeftColor         = 49,
    kHeaderVertInsideColor       = 50,
    kHeaderVertRightColor        = 51,
    kDataHorzTopColor            = 52,
    kDataHorzInsideColor         = 53,
    kDataHorzBottomColor         = 54,
    kDataVertLeftColor           = 55,
    kDataVertInsideColor         = 56,
    kDataVertRightColor          = 57,
    kTitleHorzTopLineWeight      = 70,
    kTitleHorzInsideLineWeight   = 71,
    kTitleHorzBottomLineWeight   = 72,
    kTitleVertLeftLineWeight     = 73,
    kTitleVertInsideLineWeight   = 74,
    kTitleVertRightLineWeight    = 75,
    kHeaderHorzTopLineWeight     = 76,
    kHeaderHorzInsideLineWeight  = 77,
    kHeaderHorzBottomLineWeight  = 78,
    kHeaderVertLeftLineWeight    = 79,
    kHeaderVertInsideLineWeight  = 80,
    kHeaderVertRightLineWeight   = 81,
    kDataHorzTopLineWeight       = 82,
    kDataHorzInsideLineWeight    = 83,
    kDataHorzBottomLineWeight    = 84,
    kDataVertLeftLineWeight      = 85,
    kDataVertInsideLineWeight    = 86,
    kDataVertRightLineWeight     = 87,
 
    kTitleHorzTopVisibility      = 100,
    kTitleHorzInsideVisibility   = 101,
    kTitleHorzBottomVisibility   = 102,
    kTitleVertLeftVisibility     = 103,
    kTitleVertInsideVisibility   = 104,
    kTitleVertRightVisibility    = 105,
    kHeaderHorzTopVisibility     = 106,
    kHeaderHorzInsideVisibility  = 107,
    kHeaderHorzBottomVisibility  = 108,
    kHeaderVertLeftVisibility    = 109,
    kHeaderVertInsideVisibility  = 110,
    kHeaderVertRightVisibility   = 111,
    kDataHorzTopVisibility       = 112,
    kDataHorzInsideVisibility    = 113,
    kDataHorzBottomVisibility    = 114,
    kDataVertLeftVisibility      = 115,
    kDataVertInsideVisibility    = 116,
    kDataVertRightVisibility     = 117,
 
    kCellAlignment               = 130,
    kCellBackgroundFillNone      = 131,
    kCellBackgroundColor         = 132,
    kCellContentColor            = 133,
    kCellTextStyle               = 134,
    kCellTextHeight              = 135,
    kCellTopGridColor            = 136,
    kCellRightGridColor          = 137,
    kCellBottomGridColor         = 138,
    kCellLeftGridColor           = 139,
    kCellTopGridLineWeight       = 140,
    kCellRightGridLineWeight     = 141,
    kCellBottomGridLineWeight    = 142,
    kCellLeftGridLineWeight      = 143,
    kCellTopVisibility           = 144,
    kCellRightVisibility         = 145,
    kCellBottomVisibility        = 146,
    kCellLeftVisibility          = 147    
  };
 
  OdDbTable();
  // virtual ~OdDbTable();
 
 
  virtual OdDbObjectId tableStyle() const;
 
  virtual void setTableStyle(
    const OdDbObjectId& tableStyleId);
 
  virtual OdGeVector3d direction() const;
  
  virtual void setDirection(
    const OdGeVector3d& horizVector);
 
  virtual OdUInt32 numRows() const;
 
  virtual void setNumRows(
    OdUInt32 numRows);
 
  virtual OdUInt32 numColumns() const;
 
  virtual void setNumColumns(OdUInt32 numColumns);
 
  virtual double width() const;
 
  virtual void setWidth(double width);
 
  virtual double columnWidth(OdUInt32 column) const;
  
  virtual void setColumnWidth(
    OdUInt32 column, 
    double width);
  
  virtual void setColumnWidth(
    double width);
 
  virtual double height() const;
 
  virtual void setHeight(
    double height);
 
  virtual double rowHeight(
    OdUInt32 row) const;
  
  virtual void setRowHeight(
    OdUInt32 row, 
    double height);
    
  virtual void setRowHeight(
    double height);
  
  virtual double minimumColumnWidth(
    OdUInt32 column) const;
 
  virtual double minimumRowHeight(
    OdUInt32 row) const;    
 
  virtual double minimumTableWidth() const;
  
  virtual double minimumTableHeight() const;        
 
  //********************************************************************
  // Get and set methods for table style overrides
  //********************************************************************
  
  virtual double horzCellMargin() const;
 
  virtual void setHorzCellMargin(
    double cellMargin);
 
  virtual double vertCellMargin() const;
 
  virtual void setVertCellMargin(double cellMargin);
 
  virtual OdDb::FlowDirection flowDirection() const; 
 
  virtual void setFlowDirection(
    OdDb::FlowDirection flowDirection);
 
  virtual bool isTitleSuppressed() const;
 
  virtual void suppressTitleRow(
    bool suppress);
 
  virtual bool isHeaderSuppressed() const;
 
  virtual void suppressHeaderRow(
    bool suppress);
 
  virtual OdDb::CellAlignment alignment(
    OdDb::RowType rowType = OdDb::kDataRow) const;
    
  virtual OdDb::CellAlignment alignment(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setAlignment(
    OdDb::CellAlignment alignment, 
    OdUInt32 rowTypes = OdDb::kAllRows);
 
  virtual void setAlignment(
    OdUInt32 row, 
    OdUInt32 column, 
    OdDb::CellAlignment alignment);
 
  virtual bool isBackgroundColorNone(
    OdDb::RowType rowType = OdDb::kDataRow) const;
    
  virtual bool isBackgroundColorNone(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setBackgroundColorNone(
    bool disable, 
    OdUInt32 rowTypes = OdDb::kAllRows);
    
  virtual void setBackgroundColorNone(
    OdUInt32 row, 
    OdUInt32 column, 
    bool disable);
    
  virtual OdCmColor backgroundColor(
    OdDb::RowType rowType = OdDb::kDataRow) const;
    
  virtual OdCmColor backgroundColor(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setBackgroundColor(
    const OdCmColor& color, 
    OdUInt32 rowTypes = OdDb::kAllRows);
    
  virtual void setBackgroundColor(
    OdUInt32 row, 
    OdUInt32 column,
    const OdCmColor& color);
 
  virtual OdCmColor contentColor(
    OdDb::RowType rowType = OdDb::kDataRow) const;
  
  virtual OdCmColor contentColor(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setContentColor(
    const OdCmColor& color, 
    OdUInt32 nRowType = OdDb::kAllRows);
  
  virtual void setContentColor(
    OdUInt32 row, 
    OdUInt32 column,
    const OdCmColor& color);
 
  virtual OdDbObjectId textStyle(
    OdDb::RowType rowType = OdDb::kDataRow) const;
  
  virtual OdDbObjectId textStyle(
    OdUInt32 row, 
    OdUInt32 column) const;
 
    
  virtual void setTextStyle(
    const OdDbObjectId& textStyleId, 
    OdUInt32 rowTypes = OdDb::kAllRows);
    
  virtual void setTextStyle(
    OdUInt32 row, 
    OdUInt32 column, 
    const OdDbObjectId& textStyleId);
    
  virtual double textHeight(
    OdDb::RowType rowType = OdDb::kDataRow) const;
    
  virtual double textHeight(
    OdUInt32 row, 
    OdUInt32 column) const;
 
 
  virtual void setTextHeight(
    double height, 
    OdUInt32 rowTypes = OdDb::kAllRows);
    
    
  virtual void setTextHeight(
    OdUInt32 row, 
    OdUInt32 column, 
    double height);
 
  virtual OdDb::LineWeight gridLineWeight(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const; 
 
  virtual OdDb::LineWeight gridLineWeight(
    OdUInt32 row, 
    OdUInt32 column,
    OdDb::CellEdgeMask edgeType) const;
    
  virtual void setGridLineWeight(
    OdDb::LineWeight lineWeight, 
    OdUInt32 gridlineTypes, 
    OdUInt32 rowTypes);
    
  virtual void setGridLineWeight(
    OdUInt32 row, 
    OdUInt32 column, 
    OdInt16 edgeTypes,
    OdDb::LineWeight lineWeight);
 
  virtual OdCmColor gridColor(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const; 
    
  virtual OdCmColor gridColor(
    OdUInt32 row, 
    OdUInt32 column,
    OdDb::CellEdgeMask edgeType) const;
 
  virtual OdDb::Visibility gridVisibility(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const; 
    
  virtual OdDb::Visibility gridVisibility(
    OdUInt32 row, 
    OdUInt32 column,
    OdDb::CellEdgeMask edgeType) const;
    
  virtual void setGridVisibility(
    OdDb::Visibility gridVisiblity, 
    OdUInt32 gridlineTypes, 
    OdUInt32 rowTypes);
 
  virtual void setGridVisibility(
    OdUInt32 row, 
    OdUInt32 column, 
    OdInt16 edgeTypes,
    OdDb::Visibility gridVisibility);
 
  virtual bool tableStyleOverrides( 
    OdUInt32Array& overrides) const;
 
  virtual void clearTableStyleOverrides(
    int option = 0);
   
  virtual OdDb::CellType cellType(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setCellType(
    OdUInt32 row, 
    OdUInt32 column, 
    OdDb::CellType cellType);
 
  virtual void getCellExtents(
    OdUInt32 row, 
    OdUInt32 column,
    bool isOuterCell, 
    OdGePoint3dArray& pts) const;
 
  virtual OdGePoint3d attachmentPoint(
    OdUInt32 row, 
    OdUInt32 column) const; 
 
 
  virtual bool cellStyleOverrides(
    OdUInt32 row, 
    OdUInt32 column,
    OdUInt32Array& overrides) const;
 
  void clearCellOverrides(
    OdUInt32 row, 
    OdUInt32 column);
 
  virtual void deleteCellContent(
    OdUInt32 row, 
    OdUInt32 column);
 
  virtual OdDb::RowType rowType(
    OdUInt32 row) const;
 
  virtual OdString textString(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setTextString(
    OdUInt32 row, 
    OdUInt32 column, 
    const OdString& textString);
    
  virtual OdDbObjectId fieldId(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setFieldId(
    OdUInt32 row, 
    OdUInt32 column, 
    const OdDbObjectId& fieldId);
 
 
  virtual OdDb::RotationAngle textRotation(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setTextRotation(
    OdUInt32 row, 
    OdUInt32 column, 
    OdDb::RotationAngle textRotation);
  
 
  virtual bool isAutoScale(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setAutoScale(
    OdUInt32 row, 
    OdUInt32 column, 
    bool autoScale);
 
  virtual OdDbObjectId blockTableRecordId(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setBlockTableRecordId(
    OdUInt32 row, 
    OdUInt32 column,
    const OdDbObjectId& blockId, 
    bool autoScale = false);
 
  virtual double blockScale(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setBlockScale(
    OdUInt32 row, 
    OdUInt32 column, 
    double blockScale);
 
  virtual double blockRotation(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  virtual void setBlockRotation(
    OdUInt32 row, 
    OdUInt32 column, 
    double blockRotation);
 
  virtual void getBlockAttributeValue(
    OdUInt32 row, 
    OdUInt32 column, 
    const OdDbObjectId& attdefId, 
    OdString& attValue) const;
 
  virtual void setBlockAttributeValue(
    OdUInt32 row, 
    OdUInt32 column,
    const OdDbObjectId& attdefId, 
    const OdString& attValue);
 
  virtual void setGridColor(
    const OdCmColor& color, 
    OdUInt32 gridlineTypes, 
    OdUInt32 rowTypes);
    
  virtual void setGridColor(
    OdUInt32 row, 
    OdUInt32 column, 
    OdInt16 edgeTypes,
    const OdCmColor& color);
  
  virtual void insertColumns(
    OdUInt32 column, 
    double width, 
    OdUInt32 numColumns = 1);
 
  virtual void deleteColumns(
    OdUInt32 column, 
    OdUInt32 numColumns = 1);
 
    virtual void insertRows(
    OdUInt32 row, 
    double height, 
    OdUInt32 numRows = 1);
  
  virtual void deleteRows(
    OdUInt32 row, 
    OdUInt32 numRows = 1);
 
    virtual void mergeCells(
    OdUInt32 minRow, 
    OdUInt32 maxRow,
    OdUInt32 minColumn, 
    OdUInt32 maxColumn);
 
    virtual void unmergeCells(
    OdUInt32 minRow, 
    OdUInt32 maxRow,
    OdUInt32 minColumn, 
    OdUInt32 maxColumn);
    
  virtual bool isMergedCell(
    OdUInt32 row, 
    OdUInt32 column, 
    OdUInt32* minRow = 0, 
    OdUInt32* maxRow = 0,
    OdUInt32* minColumn = 0, 
    OdUInt32* maxColumn = 0) const;
 
  OdUInt32 mergedHeight(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  OdUInt32 mergedWidth(
    OdUInt32 row, 
    OdUInt32 column) const;
 
  bool mergedFlag(
    OdUInt32 row, 
    OdUInt32 column) const;
  
  virtual OdResult generateLayout();
 
  virtual OdResult recomputeTableBlock(
    bool forceUpdate = true);
 
  //********************************************************************
  // Methods for sub-selection  
  //********************************************************************
  //
  
  virtual bool  hitTest(const OdGePoint3d& wpt, 
                                    const OdGeVector3d& wviewVec,
                                    double wxaper,
                                    double wyaper,
                                    OdInt32& resultRowIndex, 
                                    OdInt32& resultColumnIndex) const;
  virtual bool  hitTest(const OdGePoint3d& wpt, 
                                    const OdGeVector3d& wviewVec,
                                    double wxaper,
                                    double wyaper,
                                    OdInt32& resultRowIndex, 
                                    OdInt32& resultColumnIndex,
                                    OdInt32& contentIndex,
                                    OdDb::TableHitItem& nItem) const;
  virtual OdResult select(const OdGePoint3d& wpt, 
                                   const OdGeVector3d& wvwVec, 
                                   const OdGeVector3d& wvwxVec, 
                                   double wxaper,
                                   double wyaper,
                                   bool allowOutside,
                                   bool bInPickFirst, 
                                   OdInt32& resultRowIndex, 
                                   OdInt32& resultColumnIndex,
                                   OdDbFullSubentPathArray* pPaths = 0) const;
  virtual OdResult selectSubRegion(const OdGePoint3d& wpt1, 
                                   const OdGePoint3d& wpt2,
                                   const OdGeVector3d& wvwVec, 
                                   const OdGeVector3d& wvwxVec,
                                   double wxaper,
                                   double wyaper,                             
                                   OdDb::SelectType seltype,
                                   bool bIncludeCurrentSelection,
                                   bool bInPickFirst,                             
                                   OdInt32& rowMin,
                                   OdInt32& rowMax,
                                   OdInt32& colMin,
                                   OdInt32& colMax,
                                   OdDbFullSubentPathArray* pPaths = 0) const;
  virtual bool reselectSubRegion(OdDbFullSubentPathArray& paths) const;
          
  virtual OdResult getSubSelection(OdInt32& rowMin,
                                    OdInt32& rowMax,
                                    OdInt32& colMin,
                                    OdInt32& colMax) const;
 
  OdCellRange  getSubSelection (void) const;
 
  virtual OdResult setSubSelection  (const OdCellRange& range);
 
  virtual OdResult setSubSelection(OdInt32 rowMin,
                                    OdInt32 rowMax,
                                    OdInt32 colMin,
                                    OdInt32 colMax);
  virtual void clearSubSelection();
 
  virtual bool hasSubSelection() const;
  
  virtual OdResult select_next_cell(OdInt32 dir,
                                    OdInt32& resultRowIndex, 
                                    OdInt32& resultColumnIndex,
                                    OdDbFullSubentPathArray* pPaths = NULL,
                                    bool bSupportTextCellOnly = true) const;
 
  //********************************************************************
  // Overridden methods from OdDbObject
  //********************************************************************
  //
 
  virtual OdResult dwgInFields (
    OdDbDwgFiler* pFiler);
  virtual void dwgOutFields(
    OdDbDwgFiler* pFiler) const;
 
  virtual OdResult dxfInFields (
    OdDbDxfFiler* pFiler);
  virtual void dxfOutFields(
    OdDbDxfFiler* pFiler) const;
 
  // virtual OdResult audit(OdDbAuditInfo* pAuditInfo);
 
  void subClose();
  
  void subSetDatabaseDefaults(
    OdDbDatabase *pDb,
    bool doSubents);
 
  // virtual void              objectClosed(const OdDbObjectId objId);
  // virtual void              erased(const OdDbObject* dbObj,
  //                                  bool pErasing = true);
  virtual void modified(
    const OdDbObject* pObj);
 
  virtual OdResult subGetClassID(
    void* pClsid) const;
 
  //********************************************************************
  // Overridden methods from OdDbEntity
  //********************************************************************
  //
  /*
  virtual void              list() const;
  */
 
  virtual bool subWorldDraw(
    OdGiWorldDraw* pWd) const;
 
  /*
  virtual OdResult getGripPoints(OdGePoint3dArray&, 
                                          OdDbIntArray&,
                                          OdDbIntArray&) const;
 
  virtual OdResult moveGripPointsAt(const OdDbIntArray&,
                                             const OdGeVector3d&);
 
  virtual OdResult getStretchPoints(OdGePoint3dArray& stretchPoints)
                                             const;
 
  virtual OdResult moveStretchPointsAt(const OdDbIntArray& 
                                               indices,
                                               const OdGeVector3d& offset);
 
  virtual OdResult getOsnapPoints(OdDb::OsnapMode osnapMode,
                                           OdGsMarker   gsSelectionMark,
                                           const OdGePoint3d&  pickPoint,
                                           const OdGePoint3d&  lastPoint,
                                           const OdGeMatrix3d& viewXform,
                                           OdGePoint3dArray&      snapPoints,
                                           OdDbIntArray&   geomIds)
                                           const;
  */
 
  virtual OdResult subTransformBy(
    const OdGeMatrix3d& xfm);
 
  virtual OdResult subGetTransformedCopy(
    const OdGeMatrix3d& xfm,
    OdDbEntityPtr& pCopy) const;
 
  virtual OdResult subGetGeomExtents(OdGeExtents3d& extents) const;
 
  /*
  virtual OdResult explode(OdDbVoidPtrArray& entitySet) const;
  */
 
  //********************************************************************
  // Overridden methods from OdDbBlockReference required for OdDbTable
  //********************************************************************
  //
  //OdGePoint3d            position() const;
  // virtual OdResult setPosition(const OdGePoint3d&);
 
  //OdGeVector3d           normal() const;
  // virtual OdResult setNormal(const OdGeVector3d& newVal);
 
  //********************************************************************
  // Methods for internal use only
  //********************************************************************
  //
  // TODO: Temporary method for navigating after editing cells
  /*
  virtual OdResult select_next_cell(int dir,
                                   int& resultRowIndex, 
                                   int& resultColumnIndex,
                                   OdDbFullSubentPathArray* pPaths = 0,
                                   bool bSupportTextCellOnly = true) const;
 
  virtual void              setRegen();
  virtual void              suppressInvisibleGrid(bool value);
  virtual OdResult getCellExtents(int row, 
                                       int column,
                                       double& cellWidth,
                                       double& cellHeight,
                                       bool bAdjustForMargins) const;
  */
  
  // NEW 2007
  virtual void getDataType(OdValue::DataType& nDataType,
    OdValue::UnitType& nUnitType,
    OdDb::RowType type) const;
  
  virtual void setDataType(OdValue::DataType nDataType,
    OdValue::UnitType nUnitType);
 
  virtual void setDataType(OdValue::DataType nDataType, 
    OdValue::UnitType nUnitType, 
    int nRowTypes);
 
  virtual OdString format(OdDb::RowType type) const;
 
  virtual void setFormat(const OdString& pszFormat);
 
  virtual void setFormat(const OdString& pszFormat, 
    int nRowTypes);
 
  void getDataType(OdUInt32 row, OdUInt32 col,
    OdValue::DataType& nDataType,
    OdValue::UnitType& nUnitType) const;
 
  void setDataType(OdUInt32 row, OdUInt32 col, 
    OdValue::DataType nDataType,
    OdValue::UnitType nUnitType);
  
  OdValue value(OdUInt32 row, OdUInt32 col) const;
 
  void setValue(OdUInt32 row, OdUInt32 col, 
    const OdValue& val);
 
  void setValue(OdUInt32 row, OdUInt32 col, 
    OdString& pszText,
    OdValue::ParseOption nOption);
  
  void resetValue(OdUInt32 row, OdUInt32 col);
 
  OdString format(OdUInt32 row, OdUInt32 col) const;
 
  void setFormat(OdUInt32 row, OdUInt32 col, 
    const OdString& pszFormat);
 
  bool isBreakEnabled(void) const;
  
  void enableBreak (bool bEnable);
  
  OdDb::TableBreakFlowDirection breakFlowDirection(void) const;
 
  void setBreakFlowDirection (OdDb::TableBreakFlowDirection flowDir);
 
   
  double breakHeight (OdUInt32 index) const;
  
  void setBreakHeight (OdUInt32 index, 
    double height);
 
  OdGeVector3d breakOffset (OdUInt32 index) const;
 
  void setBreakOffset (OdUInt32 index, 
    const OdGeVector3d& vec);
 
  OdDb::TableBreakOption breakOption (void) const;
 
  void  setBreakOption (OdDb::TableBreakOption option);
 
  double breakSpacing (void) const;
 
  void setBreakSpacing (double spacing);
 
  //********************************************************************
  // New Methods
  //********************************************************************
 
  void setSize ( 
    OdInt32 rows, 
    OdInt32 cols);
 
  bool canInsert (
    OdInt32 nIndex, 
    bool bRow) const;
 
  void insertRowsAndInherit  (
    OdInt32 nIndex, 
    OdInt32 nInheritFrom, 
    OdInt32 nNumRows);
 
  void insertColumnsAndInherit(
    OdInt32 col, 
    OdInt32 nInheritFrom, 
    OdInt32 nNumCols);
 
  bool canDelete (OdInt32 nIndex, 
    OdInt32 nCount, 
    bool bRow) const;
 
  bool isEmpty (
    OdInt32 row, 
    OdInt32 col) const;
 
  OdCellRange getMergeRange (
    OdInt32 row, 
    OdInt32 col) const;
 
  bool isContentEditable (
    OdInt32 row, 
    OdInt32 col) const;
 
  bool isFormatEditable (
    OdInt32 row, 
    OdInt32 col) const;
 
  OdDb::CellState cellState (
    OdInt32 row, 
    OdInt32 col) const;
 
  void  setCellState (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::CellState nLock);
 
  OdInt32 numContents (
    OdInt32 row, 
    OdInt32 col) const;
 
  OdInt32 createContent (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nIndex);
 
  void  moveContent (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nFromIndex, 
    OdInt32 nToIndex);
 
  void  deleteContent (
    OdInt32 row, 
    OdInt32 col);
 
  void  deleteContent (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nIndex);
 
  void  deleteContent (
    const OdCellRange& range);
 
  OdDb::CellContentType contentType (
    OdInt32 row, 
    OdInt32 col) const;
 
  OdDb::CellContentType contentType (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nIndex) const;
 
  OdValue value (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  OdValue value (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    OdValue::FormatOption nOption) const;
 
  void  setValue (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdValue& val);
 
  void  setValue (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdValue& val, 
    OdValue::ParseOption nOption);
 
  void  setValue (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    OdString sText, 
    OdValue::ParseOption nOption);
 
  OdString dataFormat (
    OdInt32 row,
    OdInt32 col) const;
 
  OdString dataFormat (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setDataFormat (
    OdInt32 row, 
    OdInt32 col, 
    const OdString& sFormat);
 
  void  setDataFormat (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdString& sFormat);
 
  OdString textString (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  OdString textString (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    OdValue::FormatOption nOption) const;
 
  OdString textString (
    OdInt32 row, 
    OdInt32 col, 
    OdValue::FormatOption nOption ) const;
 
  void  setTextString (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdString& text);
 
  bool  hasFormula (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  OdString getFormula (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setFormula (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdString& pszFormula);
 
  OdDbObjectId  fieldId (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setFieldId (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdDbObjectId& fieldId, 
    OdDb::CellOption nFlag);
 
  OdDbObjectId  blockTableRecordId (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setBlockTableRecordId (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdDbObjectId& blkId, 
    bool autoFit);
 
  OdString  getBlockAttributeValue (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdDbObjectId& attdefId) const;
 
  void  setBlockAttributeValue (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdDbObjectId& attdefId, 
    const OdString& atrValue);
 
  OdInt32  getCustomData (
    OdInt32 row, 
    OdInt32 col) const;
 
  void  setCustomData (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nData);
 
  OdValue getCustomData (
    OdInt32 row, 
    OdInt32 col, 
    const OdString sKey) const;
 
  void  setCustomData (
    OdInt32 row, 
    OdInt32 col, 
    const OdString& sKey, 
    const OdValue* pData);
 
  OdString  cellStyle (
    OdInt32 row, 
    OdInt32 col) const;
 
  void  setCellStyle (
    OdInt32 row, 
    OdInt32 col, 
    const OdString& sCellStyle);
 
  double margin (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::CellMargin nMargin) const;
 
  void  setMargin (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::CellMargin nMargins, 
    double fMargin);
 
  OdGePoint3d  attachmentPoint (
     OdInt32 row, 
     OdInt32 col, 
     OdInt32 content) const;
 
  OdCmColor  contentColor (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setContentColor (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdCmColor& color);
 
  void  getDataType (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    OdValue::DataType& nDataType, 
    OdValue::UnitType& nUnitType) const;
 
  void  setDataType (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    OdValue::DataType nDataType, 
    OdValue::UnitType nUnitType);
 
  OdDbObjectId  textStyle (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setTextStyle (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    const OdDbObjectId& id);
 
  double textHeight (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setTextHeight (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    double height);
 
  double rotation() const;
 
  double rotation (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setRotation(double fAngle);
 
  void  setRotation (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    double fAngle);
 
  bool  isAutoScale (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setAutoScale (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    bool autoFit);
 
  double scale (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent) const;
 
  void  setScale (
    OdInt32 row, 
    OdInt32 col, 
    OdInt32 nContent, 
    double scale);
 
  OdDb::CellContentLayout contentLayout (
    OdInt32 row, 
    OdInt32 col) const;
 
  void  setContentLayout (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::CellContentLayout nLayout);
 
   bool  isMergeAllEnabled (
     OdInt32 row, 
     OdInt32 col) const;
 
   void  enableMergeAll (
     OdInt32 row, 
     OdInt32 col, 
     bool bEnable);
 
   OdDb::CellProperty getOverride (
     OdInt32 row, 
     OdInt32 col, 
     OdInt32 nContent) const;
 
   OdDb::GridProperty getOverride (
     OdInt32 row, 
     OdInt32 col, 
     OdDb::GridLineType nGridLineType) const;
 
  
   void  setOverride (
     OdInt32 row, 
     OdInt32 col, 
     OdInt32 nContent, 
     OdDb::CellProperty nOverride);
 
   void  setOverride (
     OdInt32 row, 
     OdInt32 col, 
     OdDb::GridLineType nGridLineType, 
     OdDb::GridProperty nOverride);
 
   void  removeAllOverrides (
     OdInt32 row, 
     OdInt32 col);
  
  OdDb::GridLineStyle gridLineStyle (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType) const;
 
  void  setGridLineStyle (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineTypes, 
    OdDb::GridLineStyle nLineStyle);
 
  OdDb::LineWeight gridLineWeight (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType) const;
 
  void  setGridLineWeight (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineTypes, 
    OdDb::LineWeight nLineWeight);
 
  OdDbObjectId    gridLinetype (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType) const;
 
  void  setGridLinetype (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineTypes, 
    const OdDbObjectId& idLinetype);
 
  OdCmColor gridColor (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType) const;
 
  void  setGridColor (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridlineTypes, 
    const OdCmColor& color);
 
  OdDb::Visibility gridVisibility (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType) const;
 
  void  setGridVisibility (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineTypes, 
    OdDb::Visibility nVisibility);
 
  double gridDoubleLineSpacing (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType) const;
 
  void  setGridDoubleLineSpacing(
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType 
    nGridLineTypes, 
    double fSpacing);
 
  void  getGridProperty (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineType, 
    OdGridProperty& gridProp) const;
 
  void  setGridProperty (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::GridLineType nGridLineTypes, 
    const OdGridProperty& gridProp);
 
  void  setGridProperty  (
    const OdCellRange& rangeIn, 
    OdDb::GridLineType nGridLineTypes, 
    const OdGridProperty& gridProp);
 
  bool isLinked (
    OdInt32 row, 
    OdInt32 col) const;
 
  OdDbObjectId getDataLink (
    OdInt32 row, 
    OdInt32 col) const;
 
  OdDbDataLinkPtr getDataLink (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::OpenMode mode) const;
 
  OdInt32 getDataLink (
    const OdCellRange& pRange, 
    OdDbObjectIdArray& dataLinkIds) const;
 
  void setDataLink (
    OdInt32 row, 
    OdInt32 col, 
    const OdDbObjectId& idDataLink, 
    bool bUpdate);
 
  void setDataLink 
    (const OdCellRange& range, 
    const OdDbObjectId& idDataLink, 
    bool bUpdate);
 
  OdCellRange getDataLinkRange (
    OdInt32 row, 
    OdInt32 col) const;
 
  void  removeDataLink (
    OdInt32 row, 
    OdInt32 col);
 
  void  removeDataLink (void);
  
  void  updateDataLink (
    OdInt32 row, 
    OdInt32 col, 
    OdDb::UpdateDirection nDir, 
    OdDb::UpdateOption nOption);
 
  void  updateDataLink (
    OdDb::UpdateDirection nDir, 
    OdDb::UpdateOption nOption);
 
  OdString  getColumnName (
    OdInt32 nIndex) const;
 
  void setColumnName (
    OdInt32 nIndex, 
    const OdString& sName);
 
  OdString getToolTip (
    OdInt32 row, 
    OdInt32 col) const;
 
  void  setToolTip (
    OdInt32 row, 
    OdInt32 col, 
    const OdString sToolTip);
  // void  createTemplate (OdDbTableTemplate*& pTemplate, OdDb::TableCopyOption nCopyOption);
  // void  getIndicatorSize (double& fWidth, double& fHeight) const;
 
  virtual void copyFrom(
    const OdRxObject* pSource);
 
  void copyFrom (
    const OdDbLinkedTableData* pSrc, 
    OdDb::TableCopyOption nOption);
 
  void copyFrom (const OdDbLinkedTableData* pSrc, 
    OdDb::TableCopyOption nOption, 
    const OdCellRange& srcRange, 
    const OdCellRange& targetRange,
    OdCellRange* pNewTargetRangeOut);
 
  void copyFrom  (const OdDbTable* pSrc, 
    OdDb::TableCopyOption nOption, 
    const OdCellRange& srcRange, 
    const OdCellRange& targetRange,
    OdCellRange* pNewTargetRangeOut);
 
  void appendToOwner(
    OdDbIdPair& idPair, 
    OdDbObject* pOwnerObject, 
    OdDbIdMapping& ownerIdMap);
 
  bool isRegenerateTableSuppressed() const;
 
  void suppressRegenerateTable(bool bSuppress);
 
  virtual OdResult subExplode(
    OdRxObjectPtrArray& entitySet) const ODRX_OVERRIDE;
 
  void createTemplate(OdDbTableTemplate* target, OdDb::TableCopyOption nCopyOption);
 
};
 
typedef OdSmartPtr<OdDbTable> OdDbTablePtr;
 
#include "TD_PackPop.h"
 
#endif