OdDbDimension.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 4.0.2
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Teigha.TD {
 
using System;
using System.Runtime.InteropServices;
using Teigha.Core;
 
public class OdDbDimension : OdDbEntity {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDbDimension(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdDbDimension_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDbDimension obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }
 
  protected override void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          TD_DbPINVOKE.delete_OdDbDimension(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  public static OdDbDimension cast(OdRxObject pObj) {//  OdSmartPtr<OdDbDimension>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_cast(OdRxObject.getCPtr(pObj));
 
          OdDbDimension ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbDimension),ptr, true));
                ret = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbDimension),ptr, false);
          }
          else
          {
                  ret = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbDimension),ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public new static OdRxClass desc() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TD_DbPINVOKE.OdDbDimension_desc(),false);  /*createInt 3_2*/
     
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxClass isA() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TD_DbPINVOKE.OdDbDimension_isA(swigCPtr),false);  /*createInt 3_2*/
     
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxObject queryX(OdRxClass protocolClass) { 
     OdRxObject ret = (OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),TD_DbPINVOKE.OdDbDimension_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public new static OdDbDimension createObject() {//  OdSmartPtr<OdDbDimension>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_createObject();
 
          OdDbDimension ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbDimension),ptr, true));
                ret = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbDimension),ptr, false);
          }
          else
          {
                  ret = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbDimension),ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdGePoint3d textPosition() {
    OdGePoint3d ret = new OdGePoint3d(TD_DbPINVOKE.OdDbDimension_textPosition(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTextPosition(OdGePoint3d textPosition) {
    TD_DbPINVOKE.OdDbDimension_setTextPosition(swigCPtr, OdGePoint3d.getCPtr(textPosition));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool isUsingDefaultTextPosition() {
    bool ret = TD_DbPINVOKE.OdDbDimension_isUsingDefaultTextPosition(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void useSetTextPosition() {
    TD_DbPINVOKE.OdDbDimension_useSetTextPosition(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void useDefaultTextPosition() {
    TD_DbPINVOKE.OdDbDimension_useDefaultTextPosition(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeVector3d normal() {
    OdGeVector3d ret = new OdGeVector3d(TD_DbPINVOKE.OdDbDimension_normal(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setNormal(OdGeVector3d normal) {
    TD_DbPINVOKE.OdDbDimension_setNormal(swigCPtr, OdGeVector3d.getCPtr(normal));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override bool isPlanar() {
    bool ret = TD_DbPINVOKE.OdDbDimension_isPlanar(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override OdResult getPlane(OdGePlane plane, out Planarity planarity) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_getPlane(swigCPtr, OdGePlane.getCPtr(plane), out planarity);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double elevation() {
    double ret = TD_DbPINVOKE.OdDbDimension_elevation(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setElevation(double elevation) {
    TD_DbPINVOKE.OdDbDimension_setElevation(swigCPtr, elevation);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String dimensionText() {
  string ret = TD_DbPINVOKE.OdDbDimension_dimensionText(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setDimensionText(String dimensionText) {
    TD_DbPINVOKE.OdDbDimension_setDimensionText(swigCPtr, dimensionText);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double textRotation() {
    double ret = TD_DbPINVOKE.OdDbDimension_textRotation(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTextRotation(double textRotation) {
    TD_DbPINVOKE.OdDbDimension_setTextRotation(swigCPtr, textRotation);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbObjectId dimensionStyle() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimensionStyle(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void setDimensionStyle(OdDbObjectId objectID) {
    TD_DbPINVOKE.OdDbDimension_setDimensionStyle(swigCPtr, OdDbObjectId.getCPtr(objectID));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbMText.AttachmentPoint textAttachment() {
    OdDbMText.AttachmentPoint ret = (OdDbMText.AttachmentPoint)TD_DbPINVOKE.OdDbDimension_textAttachment(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTextAttachment(OdDbMText.AttachmentPoint attachmentPoint) {
    TD_DbPINVOKE.OdDbDimension_setTextAttachment(swigCPtr, (int)attachmentPoint);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public LineSpacingStyle textLineSpacingStyle() {
    LineSpacingStyle ret = (LineSpacingStyle)TD_DbPINVOKE.OdDbDimension_textLineSpacingStyle(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTextLineSpacingStyle(LineSpacingStyle lineSpacingStyle) {
    TD_DbPINVOKE.OdDbDimension_setTextLineSpacingStyle(swigCPtr, (int)lineSpacingStyle);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double textLineSpacingFactor() {
    double ret = TD_DbPINVOKE.OdDbDimension_textLineSpacingFactor(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTextLineSpacingFactor(double lineSpacingFactor) {
    TD_DbPINVOKE.OdDbDimension_setTextLineSpacingFactor(swigCPtr, lineSpacingFactor);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void getDimstyleData(OdDbDimStyleTableRecord pRecord) {
    TD_DbPINVOKE.OdDbDimension_getDimstyleData(swigCPtr, OdDbDimStyleTableRecord.getCPtr(pRecord));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setDimstyleData(OdDbDimStyleTableRecord pDimstyle) {
    TD_DbPINVOKE.OdDbDimension_setDimstyleData__SWIG_0(swigCPtr, OdDbDimStyleTableRecord.getCPtr(pDimstyle));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setDimstyleData(OdDbObjectId dimstyleID) {
    TD_DbPINVOKE.OdDbDimension_setDimstyleData__SWIG_1(swigCPtr, OdDbObjectId.getCPtr(dimstyleID));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double horizontalRotation() {
    double ret = TD_DbPINVOKE.OdDbDimension_horizontalRotation(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setHorizontalRotation(double horizontalRotation) {
    TD_DbPINVOKE.OdDbDimension_setHorizontalRotation(swigCPtr, horizontalRotation);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbObjectId dimBlockId() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimBlockId(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void setDimBlockId(OdDbObjectId dimBlockId, bool singleReferenced) {
    TD_DbPINVOKE.OdDbDimension_setDimBlockId__SWIG_0(swigCPtr, OdDbObjectId.getCPtr(dimBlockId), singleReferenced);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setDimBlockId(OdDbObjectId dimBlockId) {
    TD_DbPINVOKE.OdDbDimension_setDimBlockId__SWIG_1(swigCPtr, OdDbObjectId.getCPtr(dimBlockId));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool isSingleDimBlockReference() {
    bool ret = TD_DbPINVOKE.OdDbDimension_isSingleDimBlockReference(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGePoint3d dimBlockPosition() {
    OdGePoint3d ret = new OdGePoint3d(TD_DbPINVOKE.OdDbDimension_dimBlockPosition(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimBlockPosition(OdGePoint3d dimBlockPosition) {
    TD_DbPINVOKE.OdDbDimension_setDimBlockPosition(swigCPtr, OdGePoint3d.getCPtr(dimBlockPosition));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double dimBlockRotation() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimBlockRotation(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimBlockRotation(double dimBlockRotation) {
    TD_DbPINVOKE.OdDbDimension_setDimBlockRotation(swigCPtr, dimBlockRotation);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeScale3d dimBlockScale() {
    OdGeScale3d ret = new OdGeScale3d(TD_DbPINVOKE.OdDbDimension_dimBlockScale(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimBlockScale(OdGeScale3d dimBlockScale) {
    TD_DbPINVOKE.OdDbDimension_setDimBlockScale(swigCPtr, OdGeScale3d.getCPtr(dimBlockScale));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeMatrix3d dimBlockTransform() {
    OdGeMatrix3d ret = new OdGeMatrix3d(TD_DbPINVOKE.OdDbDimension_dimBlockTransform(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void recomputeDimBlock(bool forceUpdate) {
    TD_DbPINVOKE.OdDbDimension_recomputeDimBlock__SWIG_0(swigCPtr, forceUpdate);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void recomputeDimBlock() {
    TD_DbPINVOKE.OdDbDimension_recomputeDimBlock__SWIG_1(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getMeasurement() {
    double ret = TD_DbPINVOKE.OdDbDimension_getMeasurement(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double measurement() {
    double ret = TD_DbPINVOKE.OdDbDimension_measurement(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public UInt16 getBgrndTxtColor(OdCmColor bgrndTxtColor) { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TD_DbPINVOKE.OdDbDimension_getBgrndTxtColor(swigCPtr, OdCmColor.getCPtr(bgrndTxtColor)); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setBgrndTxtColor(OdCmColor bgrndTxtColor, UInt16 /*SIMPLETYPE*/ bgrndTxtFlags) {
    TD_DbPINVOKE.OdDbDimension_setBgrndTxtColor(swigCPtr, OdCmColor.getCPtr(bgrndTxtColor), bgrndTxtFlags /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getExtLineFixLenEnable() {
    bool ret = TD_DbPINVOKE.OdDbDimension_getExtLineFixLenEnable(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setExtLineFixLenEnable(bool extLineFixLenEnable) {
    TD_DbPINVOKE.OdDbDimension_setExtLineFixLenEnable(swigCPtr, extLineFixLenEnable);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getExtLineFixLen() {
    double ret = TD_DbPINVOKE.OdDbDimension_getExtLineFixLen(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setExtLineFixLen(double extLineFixLen) {
    TD_DbPINVOKE.OdDbDimension_setExtLineFixLen(swigCPtr, extLineFixLen);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbObjectId getDimLinetype() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_getDimLinetype(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void setDimLinetype(OdDbObjectId linetypeId) {
    TD_DbPINVOKE.OdDbDimension_setDimLinetype(swigCPtr, OdDbObjectId.getCPtr(linetypeId));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbObjectId getDimExt1Linetype() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_getDimExt1Linetype(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void setDimExt1Linetype(OdDbObjectId linetypeId) {
    TD_DbPINVOKE.OdDbDimension_setDimExt1Linetype(swigCPtr, OdDbObjectId.getCPtr(linetypeId));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbObjectId getDimExt2Linetype() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_getDimExt2Linetype(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void setDimExt2Linetype(OdDbObjectId linetypeId) {
    TD_DbPINVOKE.OdDbDimension_setDimExt2Linetype(swigCPtr, OdDbObjectId.getCPtr(linetypeId));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getArrowFirstIsFlipped() {
    bool ret = TD_DbPINVOKE.OdDbDimension_getArrowFirstIsFlipped(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool getArrowSecondIsFlipped() {
    bool ret = TD_DbPINVOKE.OdDbDimension_getArrowSecondIsFlipped(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setArrowFirstIsFlipped(bool bIsFlipped) {
    TD_DbPINVOKE.OdDbDimension_setArrowFirstIsFlipped(swigCPtr, bIsFlipped);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setArrowSecondIsFlipped(bool bIsFlipped) {
    TD_DbPINVOKE.OdDbDimension_setArrowSecondIsFlipped(swigCPtr, bIsFlipped);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool inspection() {
    bool ret = TD_DbPINVOKE.OdDbDimension_inspection(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setInspection(bool val) {
    TD_DbPINVOKE.OdDbDimension_setInspection(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public int inspectionFrame() {
    int ret = TD_DbPINVOKE.OdDbDimension_inspectionFrame(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setInspectionFrame(int frame) {
    TD_DbPINVOKE.OdDbDimension_setInspectionFrame(swigCPtr, frame);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String inspectionLabel() {
  string ret = TD_DbPINVOKE.OdDbDimension_inspectionLabel(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setInspectionLabel(String label) {
    TD_DbPINVOKE.OdDbDimension_setInspectionLabel(swigCPtr, label);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String inspectionRate() {
  string ret = TD_DbPINVOKE.OdDbDimension_inspectionRate(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setInspectionRate(String label) {
    TD_DbPINVOKE.OdDbDimension_setInspectionRate(swigCPtr, label);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdResult dwgInFields(OdDbDwgFiler pFiler) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_dwgInFields(swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void dwgOutFields(OdDbDwgFiler pFiler) {
    TD_DbPINVOKE.OdDbDimension_dwgOutFields(swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdResult dxfInFields(OdDbDxfFiler pFiler) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_dxfInFields(swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void dxfOutFields(OdDbDxfFiler pFiler) {
    TD_DbPINVOKE.OdDbDimension_dxfOutFields(swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdResult dxfInFields_R12(OdDbDxfFiler pFiler) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_dxfInFields_R12(swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void dxfOutFields_R12(OdDbDxfFiler pFiler) {
    TD_DbPINVOKE.OdDbDimension_dxfOutFields_R12(swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdResult subGetClassID(IntPtr /*SIMPLETYPE*/ pClsid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetClassID(swigCPtr, pClsid /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override UInt32 subSetAttributes(OdGiDrawableTraits pTraits) { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TD_DbPINVOKE.OdDbDimension_subSetAttributes(swigCPtr, OdGiDrawableTraits.getCPtr(pTraits)); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public override bool subWorldDraw(OdGiWorldDraw pWd) {
    bool ret = TD_DbPINVOKE.OdDbDimension_subWorldDraw(swigCPtr, OdGiWorldDraw.getCPtr(pWd));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void subViewportDraw(OdGiViewportDraw pVd) {
    TD_DbPINVOKE.OdDbDimension_subViewportDraw(swigCPtr, OdGiViewportDraw.getCPtr(pVd));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual new OdResult subExplode(OdRxObjectPtrArray entitySet) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_subExplode(swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void subClose() {
    TD_DbPINVOKE.OdDbDimension_subClose(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void modified(OdDbObject pObject) {
    TD_DbPINVOKE.OdDbDimension_modified(swigCPtr, OdDbObject.getCPtr(pObject));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual new OdResult subTransformBy(OdGeMatrix3d xfm) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_subTransformBy(swigCPtr, OdGeMatrix3d.getCPtr(xfm));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual new OdResult subGetTransformedCopy(OdGeMatrix3d xfm, ref OdDbEntity /*OUT_PARAM for SMARTPTR*/ pCopy) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pCopy = pCopy == null ? IntPtr.Zero : OdDbEntity.getCPtr(pCopy).Handle; 
 IntPtr saved_pCopy = tmp_pCopy; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetTransformedCopy(swigCPtr, OdGeMatrix3d.getCPtr(xfm), ref tmp_pCopy /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pCopy == IntPtr.Zero) pCopy = null; 
 if(tmp_pCopy != IntPtr.Zero && tmp_pCopy != saved_pCopy) 
 { 
 MemoryTransaction mTrans_pCopy = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pCopy != null)
 mTrans_pCopy.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbEntity>(typeof(OdDbEntity), tmp_pCopy, true)); 
 pCopy = Teigha.Core.Helpers.odCreateObjectInternal<OdDbEntity>(typeof(OdDbEntity), tmp_pCopy, mTrans_pCopy == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public override void subSetDatabaseDefaults(OdDbDatabase pDb, bool doSubents) {
    TD_DbPINVOKE.OdDbDimension_subSetDatabaseDefaults(swigCPtr, OdDbDatabase.getCPtr(pDb), doSubents);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void appendToOwner(OdDbIdPair idPair, OdDbObject pOwnerObject, OdDbIdMapping ownerIdMap) {
    TD_DbPINVOKE.OdDbDimension_appendToOwner(swigCPtr, OdDbIdPair.getCPtr(idPair), OdDbObject.getCPtr(pOwnerObject), OdDbIdMapping.getCPtr(ownerIdMap));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void formatMeasurement(ref string formattedMeasurement, double measurementValue, String dimensionText) {
IntPtr tmp_formattedMeasurement = Marshal.StringToCoTaskMemUni(formattedMeasurement);
   IntPtr saved_formattedMeasurement = tmp_formattedMeasurement;
    try {
      TD_DbPINVOKE.OdDbDimension_formatMeasurement(swigCPtr, ref tmp_formattedMeasurement, measurementValue, dimensionText);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    } finally {
if (tmp_formattedMeasurement != saved_formattedMeasurement) formattedMeasurement = Marshal.PtrToStringUni(tmp_formattedMeasurement);
    }
  }
 
  public override OdResult explodeGeometry(OdRxObjectPtrArray entitySet) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_explodeGeometry(swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdDbObject dimBlock(OpenMode openMode) {//  OdDbObjectPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimBlock__SWIG_0(swigCPtr, (int)openMode);
 
          OdDbObject ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbObject),ptr, true));
                ret = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbObject),ptr, false);
          }
          else
          {
                  ret = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbObject),ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDbObject dimBlock() {//  OdDbObjectPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimBlock__SWIG_1(swigCPtr);
 
          OdDbObject ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbObject),ptr, true));
                ret = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbObject),ptr, false);
          }
          else
          {
                  ret = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDbObject),ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual new OdResult subGetCompoundObjectTransform(OdGeMatrix3d xM) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetCompoundObjectTransform(swigCPtr, OdGeMatrix3d.getCPtr(xM));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isDynamicDimension() {
    bool ret = TD_DbPINVOKE.OdDbDimension_isDynamicDimension(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDynamicDimension(bool bDynamic) {
    TD_DbPINVOKE.OdDbDimension_setDynamicDimension(swigCPtr, bDynamic);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool isConstraintObject() {
    bool ret = TD_DbPINVOKE.OdDbDimension_isConstraintObject__SWIG_0(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdResult isConstraintObject(out bool isConstraintObject, out bool hasExpression, out bool isReferenceConstraint) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_isConstraintObject__SWIG_1(swigCPtr, out isConstraintObject, out hasExpression, out isReferenceConstraint);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool isConstraintDynamic() {
    bool ret = TD_DbPINVOKE.OdDbDimension_isConstraintDynamic(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdResult setConstraintDynamic(bool bDynamic) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_setConstraintDynamic(swigCPtr, bDynamic);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool shouldParticipateInOPM() {
    bool ret = TD_DbPINVOKE.OdDbDimension_shouldParticipateInOPM(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setShouldParticipateInOPM(bool bShouldParticipate) {
    TD_DbPINVOKE.OdDbDimension_setShouldParticipateInOPM(swigCPtr, bShouldParticipate);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setDIMTALN(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDIMTALN(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDIMTALN() {
    bool ret = TD_DbPINVOKE.OdDbDimension_getDIMTALN(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void removeTextField() {
    TD_DbPINVOKE.OdDbDimension_removeTextField(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void fieldToMText(ref OdDbMText /*OUT_PARAM for SMARTPTR*/ pDimMText) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pDimMText = pDimMText == null ? IntPtr.Zero : OdDbMText.getCPtr(pDimMText).Handle; 
 IntPtr saved_pDimMText = tmp_pDimMText; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      TD_DbPINVOKE.OdDbDimension_fieldToMText(swigCPtr, ref tmp_pDimMText /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    } finally {
if(tmp_pDimMText == IntPtr.Zero) pDimMText = null; 
 if(tmp_pDimMText != IntPtr.Zero && tmp_pDimMText != saved_pDimMText) 
 { 
 MemoryTransaction mTrans_pDimMText = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pDimMText != null)
 mTrans_pDimMText.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbMText>(typeof(OdDbMText), tmp_pDimMText, true)); 
 pDimMText = Teigha.Core.Helpers.odCreateObjectInternal<OdDbMText>(typeof(OdDbMText), tmp_pDimMText, mTrans_pDimMText == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public void fieldFromMText(ref OdDbMText /*OUT_PARAM for SMARTPTR*/ pDimMText) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pDimMText = pDimMText == null ? IntPtr.Zero : OdDbMText.getCPtr(pDimMText).Handle; 
 IntPtr saved_pDimMText = tmp_pDimMText; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      TD_DbPINVOKE.OdDbDimension_fieldFromMText(swigCPtr, ref tmp_pDimMText /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    } finally {
if(tmp_pDimMText == IntPtr.Zero) pDimMText = null; 
 if(tmp_pDimMText != IntPtr.Zero && tmp_pDimMText != saved_pDimMText) 
 { 
 MemoryTransaction mTrans_pDimMText = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pDimMText != null)
 mTrans_pDimMText.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbMText>(typeof(OdDbMText), tmp_pDimMText, true)); 
 pDimMText = Teigha.Core.Helpers.odCreateObjectInternal<OdDbMText>(typeof(OdDbMText), tmp_pDimMText, mTrans_pDimMText == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public override OdGeMatrix3d getEcs() {
    OdGeMatrix3d ret = new OdGeMatrix3d(TD_DbPINVOKE.OdDbDimension_getEcs(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void resetTextDefinedSize() {
    TD_DbPINVOKE.OdDbDimension_resetTextDefinedSize(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setTextDefinedSize(double width, double height) {
    TD_DbPINVOKE.OdDbDimension_setTextDefinedSize(swigCPtr, width, height);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void textDefinedSize(out double width, out double height) {
    TD_DbPINVOKE.OdDbDimension_textDefinedSize(swigCPtr, out width, out height);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual new OdResult subGetGeomExtents(OdGeExtents3d extents) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetGeomExtents(swigCPtr, OdGeExtents3d.getCPtr(extents));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  protected static string getRealClassName(IntPtr /*SIMPLETYPE*/ ptr) {
    string ret = TD_DbPINVOKE.OdDbDimension_getRealClassName(ptr /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
     public  void vb_gripStatus(Teigha.Core.GripStat status) { this.gripStatus(status); }
  
     public  Teigha.TD.Visibility vb_visibility() { return this.visibility(); }
  
     public  double vb_textRotation() { return this.textRotation(); }
  
     public  string vb_material() { return this.material(); }
  
     public  virtual  Teigha.TD.CollisionType vb_collisionType() { return this.collisionType(); }
  
     public  string vb_linetype() { return this.linetype(); }
  
     public  Teigha.Core.LineWeight vb_lineWeight() { return this.lineWeight(); }
  
     public  virtual  Teigha.Core.OdGiDrawable.DrawableType vb_drawableType() { return this.drawableType(); }
  
  public virtual Int16 dimadec() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimadec(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimadec(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimadec(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimalt() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimalt(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimalt(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimalt(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt16 dimaltd() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TD_DbPINVOKE.OdDbDimension_dimaltd(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimaltd(UInt16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltd(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimaltf() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimaltf(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimaltf(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltf(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimaltrnd() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimaltrnd(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimaltrnd(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltrnd(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimalttd() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimalttd(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimalttd(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimalttd(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte dimalttz() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TD_DbPINVOKE.OdDbDimension_dimalttz(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimalttz(byte /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimalttz(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimaltu() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimaltu(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimaltu(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltu(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte dimaltz() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TD_DbPINVOKE.OdDbDimension_dimaltz(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimaltz(byte /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltz(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String dimapost() {
  string ret = TD_DbPINVOKE.OdDbDimension_dimapost(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setDimapost(String val) {
    TD_DbPINVOKE.OdDbDimension_setDimapost(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimasz() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimasz(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimasz(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimasz(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimaunit() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimaunit(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimaunit(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimaunit(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimazin() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimazin(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimazin(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimazin(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimcen() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimcen(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimcen(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimcen(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdCmColor dimclrd() {
    OdCmColor ret = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimclrd(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimclrd(OdCmColor val) {
    TD_DbPINVOKE.OdDbDimension_setDimclrd(swigCPtr, OdCmColor.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdCmColor dimclre() {
    OdCmColor ret = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimclre(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimclre(OdCmColor val) {
    TD_DbPINVOKE.OdDbDimension_setDimclre(swigCPtr, OdCmColor.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdCmColor dimclrt() {
    OdCmColor ret = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimclrt(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimclrt(OdCmColor val) {
    TD_DbPINVOKE.OdDbDimension_setDimclrt(swigCPtr, OdCmColor.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimdec() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimdec(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimdec(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimdec(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimdle() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimdle(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimdle(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimdle(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimdli() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimdli(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimdli(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimdli(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimdsep() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimdsep(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimdsep(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimdsep(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimexe() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimexe(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimexe(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimexe(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimexo() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimexo(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimexo(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimexo(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimfrac() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimfrac(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimfrac(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimfrac(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimgap() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimgap(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimgap(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimgap(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt16 dimjust() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TD_DbPINVOKE.OdDbDimension_dimjust(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimjust(UInt16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimjust(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbHardPointerId dimldrblk() {
    OdDbHardPointerId ret = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimldrblk(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimldrblk(OdDbHardPointerId val) {
    TD_DbPINVOKE.OdDbDimension_setDimldrblk(swigCPtr, OdDbHardPointerId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimlfac() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimlfac(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimlfac(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimlfac(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimlim() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimlim(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimlim(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimlim(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimlunit() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimlunit(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimlunit(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimlunit(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual LineWeight dimlwd() {
    LineWeight ret = (LineWeight)TD_DbPINVOKE.OdDbDimension_dimlwd(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimlwd(LineWeight val) {
    TD_DbPINVOKE.OdDbDimension_setDimlwd(swigCPtr, (int)val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual LineWeight dimlwe() {
    LineWeight ret = (LineWeight)TD_DbPINVOKE.OdDbDimension_dimlwe(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimlwe(LineWeight val) {
    TD_DbPINVOKE.OdDbDimension_setDimlwe(swigCPtr, (int)val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String dimpost() {
  string ret = TD_DbPINVOKE.OdDbDimension_dimpost(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setDimpost(String val) {
    TD_DbPINVOKE.OdDbDimension_setDimpost(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimrnd() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimrnd(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimrnd(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimrnd(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimsah() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimsah(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimsah(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimsah(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimscale() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimscale(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimscale(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimscale(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimsd1() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimsd1(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimsd1(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimsd1(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimsd2() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimsd2(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimsd2(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimsd2(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimse1() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimse1(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimse1(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimse1(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimse2() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimse2(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimse2(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimse2(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimtad() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimtad(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimtad(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimtad(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimtdec() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimtdec(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimtdec(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimtdec(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimtfac() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimtfac(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtfac(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimtfac(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimtih() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimtih(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtih(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimtih(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimtm() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimtm(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtm(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimtm(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimtoh() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimtoh(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtoh(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimtoh(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimtol() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimtol(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtol(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimtol(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte dimtolj() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TD_DbPINVOKE.OdDbDimension_dimtolj(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimtolj(byte /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimtolj(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimtp() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimtp(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtp(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimtp(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimtsz() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimtsz(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtsz(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimtsz(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimtvp() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimtvp(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtvp(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimtvp(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbObjectId dimtxsty() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimtxsty(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual void setDimtxsty(OdDbObjectId val) {
    TD_DbPINVOKE.OdDbDimension_setDimtxsty(swigCPtr, OdDbObjectId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimtxt() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimtxt(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtxt(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimtxt(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte dimtzin() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TD_DbPINVOKE.OdDbDimension_dimtzin(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimtzin(byte /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimtzin(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimupt() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimupt(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimupt(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimupt(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte dimzin() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TD_DbPINVOKE.OdDbDimension_dimzin(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimzin(byte /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimzin(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimfxl() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimfxl(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimfxl(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimfxl(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimfxlon() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimfxlon(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimfxlon(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimfxlon(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimjogang() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimjogang(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimjogang(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimjogang(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimtfill() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimtfill(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimtfill(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimtfill(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdCmColor dimtfillclr() {
    OdCmColor ret = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimtfillclr(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtfillclr(OdCmColor val) {
    TD_DbPINVOKE.OdDbDimension_setDimtfillclr(swigCPtr, OdCmColor.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimarcsym() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimarcsym(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimarcsym(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimarcsym(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbObjectId dimltype() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimltype(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual void setDimltype(OdDbObjectId val) {
    TD_DbPINVOKE.OdDbDimension_setDimltype(swigCPtr, OdDbObjectId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbObjectId dimltex1() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimltex1(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual void setDimltex1(OdDbObjectId val) {
    TD_DbPINVOKE.OdDbDimension_setDimltex1(swigCPtr, OdDbObjectId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbObjectId dimltex2() {
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #27
          IntPtr ptr = TD_DbPINVOKE.OdDbDimension_dimltex2(swigCPtr);
 
          OdDbObjectId ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject(new OdDbObjectId(ptr, true));
                ret = new OdDbObjectId(ptr, false);
          }
          else
          {
                  ret = new OdDbObjectId(ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual void setDimltex2(OdDbObjectId val) {
    TD_DbPINVOKE.OdDbDimension_setDimltex2(swigCPtr, OdDbObjectId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimtxtdirection() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimtxtdirection(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtxtdirection(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimtxtdirection(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimmzf() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimmzf(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimmzf(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimmzf(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String dimmzs() {
  string ret = TD_DbPINVOKE.OdDbDimension_dimmzs(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setDimmzs(String val) {
    TD_DbPINVOKE.OdDbDimension_setDimmzs(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double dimaltmzf() {
    double ret = TD_DbPINVOKE.OdDbDimension_dimaltmzf(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimaltmzf(double val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltmzf(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String dimaltmzs() {
  string ret = TD_DbPINVOKE.OdDbDimension_dimaltmzs(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setDimaltmzs(String val) {
    TD_DbPINVOKE.OdDbDimension_setDimaltmzs(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbHardPointerId dimblk() {
    OdDbHardPointerId ret = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimblk(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimblk(OdDbHardPointerId val) {
    TD_DbPINVOKE.OdDbDimension_setDimblk(swigCPtr, OdDbHardPointerId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbHardPointerId dimblk1() {
    OdDbHardPointerId ret = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimblk1(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimblk1(OdDbHardPointerId val) {
    TD_DbPINVOKE.OdDbDimension_setDimblk1(swigCPtr, OdDbHardPointerId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDbHardPointerId dimblk2() {
    OdDbHardPointerId ret = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimblk2(swigCPtr), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimblk2(OdDbHardPointerId val) {
    TD_DbPINVOKE.OdDbDimension_setDimblk2(swigCPtr, OdDbHardPointerId.getCPtr(val));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimatfit() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimatfit(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimatfit(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimatfit(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimsoxd() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimsoxd(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimsoxd(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimsoxd(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimtix() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimtix(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtix(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimtix(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 dimtmove() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TD_DbPINVOKE.OdDbDimension_dimtmove(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimtmove(Int16 /*SIMPLETYPE*/ val) {
    TD_DbPINVOKE.OdDbDimension_setDimtmove(swigCPtr, val /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool dimtofl() {
    bool ret = TD_DbPINVOKE.OdDbDimension_dimtofl(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimtofl(bool val) {
    TD_DbPINVOKE.OdDbDimension_setDimtofl(swigCPtr, val);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  [System.Flags] public enum  DimInspect {
    kShapeRemove = 0x00,
    kShapeRound = 0x01,
    kShapeAngular = 0x02,
    kShapeNone = 0x04,
    kShapeLabel = 0x10,
    kShapeRate = 0x20
  }
 
}
 
}