DbTable.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 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"
#include "DbTableIterator.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,
  };
};
 
struct OdDbSubTable
{
  OdGePoint3d position;
  double height;
};

class DBENT_EXPORT OdDbTable: public OdDbBlockReference
{
public:
  //DOM-IGNORE-BEGIN
  ODDB_DECLARE_MEMBERS(OdDbTable);
  //DOM-IGNORE-END

  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,
    kCellDataType                = 148
  };

  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;
 
//DOM-IGNORE-BEGIN
  virtual void setNumRows(
    OdUInt32 numRows);
//DOM-IGNORE-END

  virtual OdUInt32 numColumns() const;
 
//DOM-IGNORE-BEGIN
  virtual void setNumColumns(OdUInt32 numColumns);
//DOM-IGNORE-END

  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
  //********************************************************************
 
//DOM-IGNORE-BEGIN
  virtual double horzCellMargin() const;

  virtual void setHorzCellMargin(
    double cellMargin);

  virtual double vertCellMargin() const;

  virtual void setVertCellMargin(double cellMargin);
//DOM-IGNORE-END

  virtual OdDb::FlowDirection flowDirection() const; 

  virtual void setFlowDirection(
    OdDb::FlowDirection flowDirection);
 
//DOM-IGNORE-BEGIN
  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;
//DOM-IGNORE-END

  virtual OdDb::CellAlignment alignment(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setAlignment(
    OdDb::CellAlignment alignment,
    OdUInt32 rowTypes = OdDb::kAllRows);
//DOM-IGNORE-END

  virtual void setAlignment(
    OdUInt32 row,
    OdUInt32 column,
    OdDb::CellAlignment alignment);
 
//DOM-IGNORE-BEGIN
  virtual bool isBackgroundColorNone(
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual bool isBackgroundColorNone(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setBackgroundColorNone(
    bool disable,
    OdUInt32 rowTypes = OdDb::kAllRows);
//DOM-IGNORE-END

  virtual void setBackgroundColorNone(
    OdUInt32 row,
    OdUInt32 column,
    bool disable);
 
//DOM-IGNORE-BEGIN
  virtual OdCmColor backgroundColor(
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual OdCmColor backgroundColor(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setBackgroundColor(
    const OdCmColor& color,
    OdUInt32 rowTypes = OdDb::kAllRows);
//DOM-IGNORE-END

  virtual void setBackgroundColor(
    OdUInt32 row,
    OdUInt32 column,
    const OdCmColor& color);
 
//DOM-IGNORE-BEGIN
  virtual OdCmColor contentColor(
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual OdCmColor contentColor(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setContentColor(
    const OdCmColor& color,
    OdUInt32 nRowType = OdDb::kAllRows);
//DOM-IGNORE-END

  virtual void setContentColor(
    OdUInt32 row,
    OdUInt32 column,
    const OdCmColor& color);
 
//DOM-IGNORE-BEGIN
  virtual OdDbObjectId textStyle(
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual OdDbObjectId textStyle(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setTextStyle(
    const OdDbObjectId& textStyleId,
    OdUInt32 rowTypes = OdDb::kAllRows);
//DOM-IGNORE-END

  virtual void setTextStyle(
    OdUInt32 row,
    OdUInt32 column,
    const OdDbObjectId& textStyleId);
 
//DOM-IGNORE-BEGIN
  virtual double textHeight(
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual double textHeight(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setTextHeight(
    double height,
    OdUInt32 rowTypes = OdDb::kAllRows);
//DOM-IGNORE-END

  virtual void setTextHeight(
    OdUInt32 row,
    OdUInt32 column,
    double height);
 
//DOM-IGNORE-BEGIN
  virtual OdDb::LineWeight gridLineWeight(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual OdDb::LineWeight gridLineWeight(
    OdUInt32 row,
    OdUInt32 column,
    OdDb::CellEdgeMask edgeType) const;
 
//DOM-IGNORE-BEGIN
  virtual void setGridLineWeight(
    OdDb::LineWeight lineWeight,
    OdUInt32 gridlineTypes,
    OdUInt32 rowTypes);
//DOM-IGNORE-END

  virtual void setGridLineWeight(
    OdUInt32 row,
    OdUInt32 column,
    OdInt16 edgeTypes,
    OdDb::LineWeight lineWeight);
 
//DOM-IGNORE-BEGIN
  virtual OdCmColor gridColor(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual OdCmColor gridColor(
    OdUInt32 row,
    OdUInt32 column,
    OdDb::CellEdgeMask edgeType) const;
 
//DOM-IGNORE-BEGIN
  virtual OdDb::Visibility gridVisibility(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const;
//DOM-IGNORE-END

  virtual OdDb::Visibility gridVisibility(
    OdUInt32 row,
    OdUInt32 column,
    OdDb::CellEdgeMask edgeType) const;
 
//DOM-IGNORE-BEGIN
  virtual void setGridVisibility(
    OdDb::Visibility gridVisiblity,
    OdUInt32 gridlineTypes,
    OdUInt32 rowTypes);
//DOM-IGNORE-END

  virtual void setGridVisibility(
    OdUInt32 row,
    OdUInt32 column,
    OdInt16 edgeTypes,
    OdDb::Visibility gridVisibility);
 
//DOM-IGNORE-BEGIN
  virtual bool tableStyleOverrides(
    OdUInt32Array& overrides) const;

  virtual void clearTableStyleOverrides(
    int option = 0);
//DOM-IGNORE-END

  virtual OdDb::CellType cellType(
    OdUInt32 row,
    OdUInt32 column) const;
 
//DOM-IGNORE-BEGIN
  virtual void setCellType(
    OdUInt32 row,
    OdUInt32 column,
    OdDb::CellType cellType);
//DOM-IGNORE-END

  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);
 
//DOM-IGNORE-BEGIN
  virtual void deleteCellContent(
    OdUInt32 row,
    OdUInt32 column);

  virtual OdDb::RowType rowType(
    OdUInt32 row) const;
//DOM-IGNORE-END

  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);
 
//DOM-IGNORE-BEGIN
  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);
//DOM-IGNORE-END

  virtual OdDbObjectId blockTableRecordId(
    OdUInt32 row,
    OdUInt32 column) const;

  virtual void setBlockTableRecordId(
    OdUInt32 row,
    OdUInt32 column,
    const OdDbObjectId& blockId,
    bool autoScale = false);
 
//DOM-IGNORE-BEGIN
  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);
//DOM-IGNORE-END

  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);
 
//DOM-IGNORE-BEGIN
  virtual void setGridColor(
    const OdCmColor& color,
    OdUInt32 gridlineTypes,
    OdUInt32 rowTypes);
//DOM-IGNORE-END

  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,
                                    OdInt32* subTable = NULL ) const;
  virtual bool  hitTest(const OdGePoint3d& wpt,
                                    const OdGeVector3d& wviewVec,
                                    double wxaper,
                                    double wyaper,
                                    OdInt32& resultRowIndex,
                                    OdInt32& resultColumnIndex,
                                    OdInt32& contentIndex,
                                    OdDb::TableHitItem& nItem,
                                    OdInt32* subTable = NULL) 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,
                                   OdInt32* subTable = NULL) const;
 
  OdCellRange  getSubSelection(OdInt32* subTable = NULL) const;

  virtual OdResult setSubSelection  (const OdCellRange& range,
                                      OdInt32 subTable = 0);

  virtual OdResult setSubSelection(OdInt32 rowMin,
                                   OdInt32 rowMax,
                                   OdInt32 colMin,
                                   OdInt32 colMax, 
                                   OdInt32 subTable = 0);
  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 void subViewportDraw(
    OdGiViewportDraw* pVd) 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
 
//DOM-IGNORE-BEGIN
  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);
//DOM-IGNORE-END

  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);
 
//DOM-IGNORE-BEGIN
  OdString format(OdUInt32 row, OdUInt32 col) const;

  void setFormat(OdUInt32 row, OdUInt32 col,
    const OdString& pszFormat);
//DOM-IGNORE-END

  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);
 
  virtual OdResult subErase(bool erasing);
 
  virtual void subHighlight(bool bDoIt = true,
    const OdDbFullSubentPath* pSubId = 0, 
    bool highlightAll = false) const;
 
  OdInt32 getSubTablesInfo(OdArray<OdDbSubTable>& subTables) const;
 
  OdDbTableIteratorPtr getIterator(void) const;
  OdDbTableIteratorPtr getIterator(const OdCellRange* pRange,
    OdDb::TableIteratorOption nOption) const;

  void getIndicatorSize(double& dWidth, double& dHeight) const;
 
  OdDbObjectPtr subWblockClone(OdDbIdMapping& idMap, OdDbObject* owner, bool bPrimary) const;
};

typedef OdSmartPtr<OdDbTable> OdDbTablePtr;
 
DBENT_EXPORT OdDbTablePtr odDbCreateDataLinkAndTable(OdDbDatabase* pDb, OdString linkName, OdString linkDescription, OdString connectionString);
//FELIX_CHANGE_BEGIN
class DBENT_EXPORT  OdDbTablePE : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS( OdDbTablePE );
  OdDbTablePE() {};
  virtual ~OdDbTablePE() {};
  virtual void DrawTableEditor( OdDbTable* pTable, OdGiWorldDraw* pWd );
  virtual OdCellRange GetSubTableCellRange( OdDbTable* pTable , OdInt32 subTableIndex ) const;
};
typedef OdSmartPtr<OdDbTablePE> OdDbTablePEPtr;
//FELIX_CHANGE_END
#include "TD_PackPop.h"
 
#endif