DbTableStyle.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_DBTABLESTYLE_H
#define OD_DBTABLESTYLE_H
 
#include "TD_PackPush.h"
#include "DbObject.h"
#include "DbColor.h"
#include "OdValue.h"
#include "StringArray.h"

namespace OdDb
{
  // OdDbTable and OdTbTableStyle specific enum
  //
  
  enum CellType          
  { 
    kUnknownCell    = 0,
    kTextCell       = 1,
    kBlockCell      = 2,
    kMultipleContentCell = 3
  };
 
  enum CellContentType   
  { 
    kCellContentTypeUnknown = 0x0,
    kCellContentTypeValue   = 0x1,
    kCellContentTypeField   = 0x2,
    kCellContentTypeBlock   = 0x4
  };
 
  enum CellEdgeMask      
  { 
    kTopMask        = 0x1,
    kRightMask      = 0x2,
    kBottomMask     = 0x4,
    kLeftMask       = 0x8 
  };
 
  enum SelectType
  { 
    kWindow         = 1,
    kCrossing       = 2 
  };
 
  enum FlowDirection
  { 
    kTtoB           = 0,
    kBtoT           = 1 
  };
 
  enum RotationAngle     
  { 
    kDegreesUnknown = -1,
    kDegrees000     = 0,
    kDegrees090     = 1,
    kDegrees180     = 2,
    kDegrees270     = 3 
  };
 
  enum CellAlignment
  { 
    kTopLeft        = 1,
    kTopCenter      = 2,
    kTopRight       = 3,
    kMiddleLeft     = 4,
    kMiddleCenter   = 5,
    kMiddleRight    = 6,
    kBottomLeft     = 7,
    kBottomCenter   = 8,
    kBottomRight    = 9 
  };
 
  enum GridLineType
  { 
    kInvalidGridLine= 0x00,
    kHorzTop        = 0x01,
    kHorzInside     = 0x02,
    kHorzBottom     = 0x04,
    kVertLeft       = 0x08,
    kVertInside     = 0x10,
    kVertRight      = 0x20,
    kHorzGridLineTypes     = kHorzTop | kHorzBottom | kHorzInside,
    kVertGridLineTypes     = kVertLeft | kVertRight | kVertInside,
    kOuterGridLineTypes    = kHorzTop | kHorzBottom | kVertLeft | kVertRight,
    kInnerGridLineTypes    = kHorzInside | kVertInside,
    kAllGridLineTypes      = kOuterGridLineTypes | kInnerGridLineTypes
  };
 
 
  enum RowType
  { 
    kUnknownRow     = 0x0,
    kDataRow        = 0x1,
    kTitleRow       = 0x2,
    kHeaderRow      = 0x4
  };
 
  enum TableStyleFlags
  { 
    kHorzInsideLineFirst  = 0x1,
    kHorzInsideLineSecond = 0x2,
    kHorzInsideLineThird  = 0x4,
    kTableStyleModified   = 0x8
  };
 
  enum RowTypes
  { 
    kAllRows = kDataRow | kTitleRow | kHeaderRow 
  };
    
  enum GridLineTypes 
  {   
    kAllGridLines = kHorzTop | kHorzInside | kHorzBottom | kVertLeft | kVertInside | kVertRight 
  };
 
  enum GridLineStyle  
  { 
    kGridLineStyleSingle = 1,
    kGridLineStyleDouble = 2
  };
 
  enum CellMargin        
  { 
    kCellMarginTop         = 0x01,
    kCellMarginLeft        = 0x02,
    kCellMarginBottom      = 0x04,
    kCellMarginRight       = 0x08,
    kCellMarginHorzSpacing = 0x10,
    kCellMarginVertSpacing = 0x20 
  };
 
  enum CellContentLayout
  { 
    kCellContentLayoutFlow              = 0x1,
    kCellContentLayoutStackedHorizontal = 0x2,
    kCellContentLayoutStackedVertical   = 0x4
  };
 
  enum CellState
  { 
    kCellStateNone                        = 0x00,
    kCellStateContentLocked               = 0x01,
    kCellStateContentReadOnly             = 0x02,
    kCellStateLinked                      = 0x04,
    kCellStateContentModifiedAfterUpdate  = 0x08,
    kCellStateFormatLocked                = 0x10,
    kCellStateFormatReadOnly              = 0x20,
    kCellStateFormatModifiedAfterUpdate   = 0x40,
    kAllCellStates  = (kCellStateContentLocked | kCellStateContentReadOnly |
                       kCellStateLinked | kCellStateContentModifiedAfterUpdate | 
                       kCellStateFormatLocked | kCellStateFormatReadOnly |
                       kCellStateFormatModifiedAfterUpdate)
  };
 
  enum GridProperty      
  { 
    kGridPropInvalid           = 0x00,
    kGridPropLineStyle         = 0x01,
    kGridPropLineWeight        = 0x02,
    kGridPropLinetype          = 0x04,
    kGridPropColor             = 0x08,
    kGridPropVisibility        = 0x10,
    kGridPropDoubleLineSpacing = 0x20,
    kGridPropAll               = (kGridPropLineStyle | kGridPropLineWeight | kGridPropLinetype |
                                  kGridPropColor | kGridPropVisibility | kGridPropDoubleLineSpacing)
  };
 
  enum CellOption        
  {
    kCellOptionNone    = 0x0,
    kInheritCellFormat = 0x1
  };
 
  enum CellProperty      
  { 
    kCellPropInvalid               = 0x00000,
    kCellPropDataType              = 0x00001,
    kCellPropDataFormat            = 0x00002,
    kCellPropRotation              = 0x00004,
    kCellPropScale                 = 0x00008,
    kCellPropAlignment             = 0x00010,
    kCellPropContentColor          = 0x00020,
    kCellPropTextStyle             = 0x00040,
    kCellPropTextHeight            = 0x00080,
    kCellPropAutoScale             = 0x00100,
    kCellPropBackgroundColor       = 0x00200,
    kCellPropMarginLeft            = 0x00400,
    kCellPropMarginTop             = 0x00800,
    kCellPropMarginRight           = 0x01000,
    kCellPropMarginBottom          = 0x02000,
    kCellPropContentLayout         = 0x04000,
    kCellPropMergeAll              = 0x08000,
    kCellPropFlowDirBtoT           = 0x10000,
    kCellPropMarginHorzSpacing     = 0x20000,
    kCellPropMarginVertSpacing     = 0x40000,
    kCellPropDataTypeAndFormat     = (kCellPropDataType | kCellPropDataFormat),
    kCellPropContent               = (kCellPropDataType | kCellPropDataFormat | kCellPropRotation |
                                      kCellPropScale | kCellPropContentColor |  kCellPropTextStyle | 
                                      kCellPropTextHeight | kCellPropAutoScale),
    kCellPropBitProperties         = (kCellPropAutoScale | kCellPropMergeAll | kCellPropFlowDirBtoT),
    kCellPropAll                   = (kCellPropDataType | kCellPropDataFormat | kCellPropRotation |
                                      kCellPropScale | kCellPropAlignment | kCellPropContentColor | kCellPropBackgroundColor | 
                                      kCellPropTextStyle | kCellPropTextHeight | kCellPropMarginLeft | kCellPropMarginTop |
                                      kCellPropMarginRight | kCellPropMarginBottom | kCellPropMarginHorzSpacing | 
                                      kCellPropMarginVertSpacing | kCellPropAutoScale | kCellPropMergeAll | 
                                      kCellPropFlowDirBtoT | kCellPropContentLayout)
  };
 
  enum TableFillOption
  {
    kTableFillOptionNone = 0,
    kTableFillOptionRow = 0x1,
    kTableFillOptionReverse = 0x2,
    kTableFillOptionGenerateSeries = 0x4,
    kTableFillOptionCopyContent = 0x8,
    kTableFillOptionCopyFormat = 0x10,
    kTableFillOptionOverwriteReadOnlyContent = 0x20,
    kTableFillOptionOverwriteReadOnlyFormat = 0x40
  };

  enum TableCopyOption
  {
    kTableCopyOptionNone = 0,
    
    kTableCopyOptionExpandOrContractTable = 0x1,
    kTableCopyOptionSkipContent = 0x2,
    kTableCopyOptionSkipValue = 0x4,
    kTableCopyOptionSkipField = 0x8,
    kTableCopyOptionSkipFormula = 0x10,
    kTableCopyOptionSkipBlock = 0x20,
    kTableCopyOptionSkipDataLink = 0x40,
    kTableCopyOptionSkipLabelCell = 0x80,
    kTableCopyOptionSkipDataCell = 0x100,
    kTableCopyOptionSkipFormat = 0x200,
    kTableCopyOptionSkipCellStyle = 0x400,
    kTableCopyOptionConvertFormatToOverrides = 0x800,
    kTableCopyOptionSkipCellState = 0x1000,
    kTableCopyOptionSkipContentFormat = 0x2000,
    kTableCopyOptionSkipDissimilarContentFormat = 0x4000,
    kTableCopyOptionSkipGeometry = 0x8000,
    kTableCopyOptionSkipMerges = 0x10000,
    kTableCopyOptionFillTarget = 0x20000,
    kTableCopyOptionOverwriteReadOnlyContent = 0x40000,
    kTableCopyOptionOverwriteReadOnlyFormat = 0x80000,
    kTableCopyOptionOverwriteContentModifiedAfterUpdate = 0x100000,
    kTableCopyOptionOverwriteFormatModifiedAfterUpdate = 0x200000,
    kTableCopyOptionOnlyContentModifiedAfterUpdate = 0x400000,
    kTableCopyOptionOnlyFormatModifiedAfterUpdate = 0x800000,
    kTableCopyOptionRowHeight = 0x1000000,
    kTableCopyOptionColumnWidth = 0x2000000,
    kTableCopyOptionFullCellState = 0x4000000,
    kTableCopyOptionForRountrip = 0x8000000,
    kTableCopyOptionConvertFieldToValue = 0x10000000,
    kTableCopyOptionSkipFieldTranslation = 0x20000000
  };

  enum MergeCellStyleOption {
    kMergeCellStyleNone = 0,
    kMergeCellStyleCopyDuplicates = 0x1,
    kMergeCellStyleOverwriteDuplicates = 0x2,
    kMergeCellStyleConvertDuplicatesToOverrides = 0x4,
    kMergeCellStyleIgnoreNewStyles = 0x8,
  };
 
  enum TableIteratorOption {
    kTableIteratorNone = 0,
    kTableIteratorIterateSelection = 0x1,
    kTableIteratorIterateRows = 0x2,
    kTableIteratorIterateColumns = 0x4,
    kTableIteratorIterateDataLinks = 0x80, // TODO: Re order
    kTableIteratorReverseOrder = 0x8,
    kTableIteratorSkipReadOnlyContent = 0x10,
    kTableIteratorSkipReadOnlyFormat = 0x20,
    kTableIteratorSkipMerged = 0x40,
  };
}

class OdCellRange
{
public:
  OdInt32  m_topRow;
  OdInt32  m_leftColumn;
  OdInt32  m_bottomRow;
  OdInt32  m_rightColumn;
 
  OdCellRange() : m_topRow(-1)
    , m_leftColumn(-1)
    , m_bottomRow(-1)
    , m_rightColumn(-1) {}
 
  OdCellRange(OdInt32 topRow, OdInt32 leftColumn, OdInt32 bottomRow, OdInt32 rightColumn)
    : m_topRow(topRow)
    , m_leftColumn(leftColumn)
    , m_bottomRow(bottomRow)
    , m_rightColumn(rightColumn)
  {}
 
  bool operator ==(
    const OdCellRange& range) const
  {
    return ( m_topRow == range.m_topRow &&
              m_leftColumn == range.m_leftColumn &&
              m_bottomRow == range.m_bottomRow &&
              m_rightColumn == range.m_rightColumn );
  }
  bool operator !=(
    const OdCellRange& range) const
  {
    return !( *this == range);
  }
};
 
typedef OdArray<OdCellRange> OdCellRangeArray;

class OdGridProperty
{
public:
 
  OdDb::GridProperty  m_propMask;
  OdDb::GridLineStyle m_lineStyle;
  OdDb::LineWeight    m_lineWeight;
  OdDbHardPointerId   m_linetype;
  OdCmColor           m_color;
  OdDb::Visibility    m_visibility;
  double              m_doubleLineSpacing;
 
  OdGridProperty() : m_propMask(OdDb::kGridPropInvalid)
    , m_lineStyle(OdDb::kGridLineStyleSingle)
    , m_lineWeight(OdDb::kLnWtByBlock)
    , m_visibility(OdDb::kVisible)
    , m_doubleLineSpacing(0.0) {}
 
};

class DBENT_EXPORT OdDbTableStyle : public OdDbObject
{
public:
  ODDB_DECLARE_MEMBERS(OdDbTableStyle);
 
  OdDbTableStyle();
  // virtual ~OdDbTableStyle();
 
  // General Properties
  //
  
  virtual OdString getName() const;

  virtual void setName(const OdString& name);

  virtual OdString description() const;

  virtual void setDescription(
    const OdString& description);

  virtual OdUInt32 bitFlags() const;

  virtual void setBitFlags(
    OdUInt32 bitFlags);

  virtual OdDb::FlowDirection flowDirection() const; 

  virtual void setFlowDirection(
    OdDb::FlowDirection flowDirection);

  virtual double horzCellMargin() const;

  virtual void   setHorzCellMargin(
    double cellMargin);
 

  virtual double vertCellMargin() const;

  virtual void setVertCellMargin(
    double cellMargin);

  virtual bool isTitleSuppressed() const;

  virtual void suppressTitleRow(
    bool suppress);

  virtual bool isHeaderSuppressed() const;

  virtual void suppressHeaderRow(
    bool suppress);
 

  virtual OdDbObjectId textStyle(
    OdDb::RowType rowType = OdDb::kDataRow) const;

  virtual void setTextStyle(
    const OdDbObjectId textStyleId, 
    int rowTypes = OdDb::kAllRows);

  virtual double textHeight(
    OdDb::RowType rowType = OdDb::kDataRow) const;

  virtual void setTextHeight(
    double height, 
    int rowTypes = OdDb::kAllRows);

  virtual OdDb::CellAlignment alignment(
    OdDb::RowType rowType = OdDb::kDataRow) const;
 

  virtual void setAlignment(
    OdDb::CellAlignment alignment, 
    int rowTypes = OdDb::kAllRows);

  virtual OdCmColor color(
    OdDb::RowType rowType = OdDb::kDataRow) const;
    

  virtual void setColor(
    const OdCmColor& color,
    int rowTypes = OdDb::kAllRows);

  virtual OdCmColor backgroundColor(
    OdDb::RowType rowType = OdDb::kDataRow) const;

  virtual void setBackgroundColor(
    const OdCmColor& color,
    int rowTypes = OdDb::kAllRows);

  virtual bool isBackgroundColorNone(
    OdDb::RowType rowType = OdDb::kDataRow) const;

  virtual void setBackgroundColorNone(
    bool disable,
    int rowTypes = OdDb::kAllRows);
 
  //Gridline properties
  //
  
  virtual OdDb::LineWeight gridLineWeight(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const; 
  
  virtual void setGridLineWeight(
    OdDb::LineWeight lineWeight, 
    int gridlineTypes = OdDb::kAllGridLines, 
    int rowTypes = OdDb::kAllRows);
 

  virtual OdCmColor gridColor(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const; 

  virtual void setGridColor(
    const OdCmColor color, 
    int gridlineTypes = OdDb::kAllGridLines, 
    int rowTypes = OdDb::kAllRows);
 

  virtual OdDb::Visibility gridVisibility(
    OdDb::GridLineType gridlineType,
    OdDb::RowType rowType = OdDb::kDataRow) const; 
 

  virtual void setGridVisibility(
    OdDb::Visibility gridVisiblity, 
    int gridlineTypes = OdDb::kAllGridLines, 
    int rowTypes = OdDb::kAllRows);
 
 
  // NEW 2007
 
  virtual void getDataType(
    OdValue::DataType& nDataType,
    OdValue::UnitType& nUnitType,
    OdDb::RowType rowType = OdDb::kDataRow ) const;
 
  virtual void setDataType(
    OdValue::DataType nDataType, 
    OdValue::UnitType nUnitType,
    int rowTypes = OdDb::kAllRows);
 
  virtual OdString format (
    OdDb::RowType rowType = OdDb::kDataRow) const;
 
  virtual void setFormat(
    const OdString& pszFormat,
    int rowTypes = OdDb::kAllRows);
 
 
  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);
 
  // Utility functions
  //

  void setDatabaseDefaults(OdDbDatabase* pDb = 0);

  virtual OdDbObjectId postTableStyleToDb(OdDbDatabase* pDb, const OdString& styleName);
 
 
  const OdString  createCellStyle(void);
 
  void createCellStyle(const OdString& cellStyle);
 
  void createCellStyle(const OdString& cellStyle, const OdString& fromCellStyle);
 
  void renameCellStyle(const OdString& oldName, const OdString& newName);
 
  void deleteCellStyle(const OdString& cellStyle);
 
  void copyCellStyle(const OdString& srcCellStyle, const OdString& targetCellStyle);
 
  void copyCellStyle(const OdDbTableStyle* pSrc, const OdString& srcCellStyle, const OdString& targetCellStyle);
  
  void getUniqueCellStyleName(const OdString& baseName, OdString& sUniqueName) const;
 
  bool isCellStyleInUse(const OdString& cellStyle) const;
 
  OdInt32 numCellStyles(void) const;
 
  OdInt32 getCellStyles(OdStringArray& cellstyles) const;
 
  OdInt32 cellStyleId(const OdString& cellStyle) const;
  OdString cellStyleName(OdInt32 cellStyle) const;
 
  OdDbObjectId textStyle(const OdString& cellStyle) const;
  void setTextStyle (const OdDbObjectId& id, const OdString& cellStyle);
 
  double textHeight(const OdString& cellStyle) const;
  void setTextHeight(double dHeight, const OdString& cellStyle);
 
  OdDb::CellAlignment alignment(const OdString& cellStyle) const;
  void setAlignment(OdDb::CellAlignment alignment, const OdString& cellStyle);
 
  OdCmColor color(const OdString& cellStyle) const;
  void setColor(const OdCmColor& color, const OdString& cellStyle);
 
  OdCmColor backgroundColor(const OdString& cellStyle) const;
  void setBackgroundColor(const OdCmColor& color, const OdString& cellStyle);
 
  void getDataType(OdValue::DataType& nDataType, OdValue::UnitType& nUnitType, const OdString& cellStyle) const;
  void setDataType(OdValue::DataType nDataType, OdValue::UnitType nUnitType, const OdString& cellStyle);
 
  const OdString format(const OdString& cellStyle) const;
  void setFormat(const OdString& format, const OdString& cellStyle);
 
  OdInt32 cellClass(const OdString& cellStyle) const;
  void setCellClass(OdInt32 nClass, const OdString& cellStyle);
 
  double rotation(const OdString& cellStyle) const;
  void setRotation(double rotation, const OdString& cellStyle);
 
  bool isMergeAllEnabled (const OdString& cellStyle) const;
  void enableMergeAll(bool bEnable, const OdString& cellStyle);
 
  double margin(OdDb::CellMargin nMargin, const OdString& cellStyle) const;
  void setMargin(OdDb::CellMargin nMargins, double fMargin, const OdString& cellStyle);
 
  //Gridline properties
  //
  OdDb::LineWeight gridLineWeight(OdDb::GridLineType gridLineType, const OdString& cellStyle) const;
  void setGridLineWeight(OdDb::LineWeight lineWeight, OdDb::GridLineType gridLineTypes, const OdString& cellStyle);
 
  OdCmColor gridColor(OdDb::GridLineType gridLineType, const OdString& cellStyle) const;
  void setGridColor(const OdCmColor color, OdDb::GridLineType gridLineTypes, const OdString& cellStyle);
 
  OdDb::Visibility gridVisibility(OdDb::GridLineType gridLineType, const OdString& cellStyle) const;
  void setGridVisibility(OdDb::Visibility visible, OdDb::GridLineType gridLineTypes, const OdString& cellStyle);
 
  double gridDoubleLineSpacing(OdDb::GridLineType gridLineType, const OdString& cellStyle) const;
  void setGridDoubleLineSpacing(double fSpacing, OdDb::GridLineType gridLineTypes, const OdString& cellStyle);
 
  OdDb::GridLineStyle gridLineStyle(OdDb::GridLineType gridLineType, const OdString& cellStyle) const;
  void setGridLineStyle(OdDb::GridLineStyle nLineStyle, OdDb::GridLineType gridLineTypes, const OdString& cellStyle);
 
  OdDbObjectId gridLinetype(OdDb::GridLineType gridLineType, const OdString& cellStyle) const;
  void setGridLinetype(const OdDbObjectId& id, OdDb::GridLineType gridLineTypes, const OdString& cellStyle);
 
  void getGridProperty(OdGridProperty& gridProp, OdDb::GridLineType nGridLineTypes, const OdString& cellStyle) const;
  void setGridProperty (const OdGridProperty& gridProp, OdDb::GridLineType nGridLineTypes, const OdString& cellStyle);
 
  virtual OdResult subGetClassID(void* pClsid) const;
 
  // Template functions
  OdDbObjectId  getTemplate(void) const;
 
  void setTemplate(const OdDbObjectId templateId, OdDb::MergeCellStyleOption nOption);
 
  OdDbObjectId removeTemplate(void);
};

typedef OdSmartPtr<OdDbTableStyle> OdDbTableStylePtr;
 
#include "TD_PackPop.h"
 
#endif // OD_DBTABLESTYLE_H