OdDgDimension.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.TG {
 
using System;
using System.Runtime.InteropServices;
using Teigha.Core;
 
public class OdDgDimension : OdDgGraphicsElement {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDgDimension(IntPtr cPtr, bool cMemoryOwn) : base(TG_DbPINVOKE.OdDgDimension_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDgDimension 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;
          TG_DbPINVOKE.delete_OdDgDimension(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  public override OdDgElement.ElementTypes getElementType() {
    OdDgElement.ElementTypes ret = (OdDgElement.ElementTypes)TG_DbPINVOKE.OdDgDimension_getElementType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override byte getElementSubType() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TG_DbPINVOKE.OdDgDimension_getElementSubType(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public static OdDgDimension cast(OdRxObject pObj) {//  OdSmartPtr<OdDgDimension>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgDimension_cast(OdRxObject.getCPtr(pObj));
 
          OdDgDimension ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimension),ptr, true));
                ret = (OdDgDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimension),ptr, false);
          }
          else
          {
                  ret = (OdDgDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimension),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public new static OdRxClass desc() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TG_DbPINVOKE.OdDgDimension_desc(),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxClass isA() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TG_DbPINVOKE.OdDgDimension_isA(swigCPtr),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxObject queryX(OdRxClass protocolClass) { 
     OdRxObject ret = (OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),TG_DbPINVOKE.OdDgDimension_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public new static OdDgDimension createObject() {//  OdSmartPtr<OdDgDimension>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgDimension_createObject();
 
          OdDgDimension ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimension),ptr, true));
                ret = (OdDgDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimension),ptr, false);
          }
          else
          {
                  ret = (OdDgDimension)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimension),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual OdDgDimension.ToolType dimensionType() {
    OdDgDimension.ToolType ret = (OdDgDimension.ToolType)TG_DbPINVOKE.OdDgDimension_dimensionType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdDgDimension.ToolType getDimensionType() {
    OdDgDimension.ToolType ret = (OdDgDimension.ToolType)TG_DbPINVOKE.OdDgDimension_getDimensionType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDimensionType(OdDgDimension.ToolType tType) {
    TG_DbPINVOKE.OdDgDimension_setDimensionType(swigCPtr, (int)tType);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getPointsCount() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getPointsCount(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual OdDgDimPoint getPoint(UInt32 iIdx) {
    OdDgDimPoint ret = new OdDgDimPoint(TG_DbPINVOKE.OdDgDimension_getPoint(swigCPtr, iIdx /*SIMPLETYPE*/), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPoint(UInt32 iIdx, OdDgDimPoint ptDim) {
    TG_DbPINVOKE.OdDgDimension_setPoint(swigCPtr, iIdx /*SIMPLETYPE*/, OdDgDimPoint.getCPtr(ptDim));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void addPoint(OdDgDimPoint ptDim) {
    TG_DbPINVOKE.OdDgDimension_addPoint(swigCPtr, OdDgDimPoint.getCPtr(ptDim));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool removePoint(UInt32 uIndex) {
    bool ret = TG_DbPINVOKE.OdDgDimension_removePoint(swigCPtr, uIndex /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void breakAssociation() {
    TG_DbPINVOKE.OdDgDimension_breakAssociation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getFreezeGroup() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getFreezeGroup(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void getDimTextInfo(OdDgDimTextInfo info) {
    TG_DbPINVOKE.OdDgDimension_getDimTextInfo(swigCPtr, OdDgDimTextInfo.getCPtr(info));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setDimTextInfo(OdDgDimTextInfo info, bool bCheckFontId) {
    TG_DbPINVOKE.OdDgDimension_setDimTextInfo__SWIG_0(swigCPtr, OdDgDimTextInfo.getCPtr(info), bCheckFontId);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setDimTextInfo(OdDgDimTextInfo info) {
    TG_DbPINVOKE.OdDgDimension_setDimTextInfo__SWIG_1(swigCPtr, OdDgDimTextInfo.getCPtr(info));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void getDimTextFormat(OdDgDimTextFormat format) {
    TG_DbPINVOKE.OdDgDimension_getDimTextFormat(swigCPtr, OdDgDimTextFormat.getCPtr(format));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setDimTextFormat(OdDgDimTextFormat format) {
    TG_DbPINVOKE.OdDgDimension_setDimTextFormat(swigCPtr, OdDgDimTextFormat.getCPtr(format));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void getDimGeometry(OdDgDimGeometry geom) {
    TG_DbPINVOKE.OdDgDimension_getDimGeometry(swigCPtr, OdDgDimGeometry.getCPtr(geom));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setDimGeometry(OdDgDimGeometry geom) {
    TG_DbPINVOKE.OdDgDimension_setDimGeometry(swigCPtr, OdDgDimGeometry.getCPtr(geom));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int32 getAltLineStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     Int32 ret = TG_DbPINVOKE.OdDgDimension_getAltLineStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setAltLineStyleEntryId(Int32 val) {
    TG_DbPINVOKE.OdDgDimension_setAltLineStyleEntryId(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getAltLineWeight() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getAltLineWeight(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setAltLineWeight(UInt32 val) {
    TG_DbPINVOKE.OdDgDimension_setAltLineWeight(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getAltColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getAltColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setAltColorIndex(UInt32 val) {
    TG_DbPINVOKE.OdDgDimension_setAltColorIndex(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getScaleFactor() {
    double ret = TG_DbPINVOKE.OdDgDimension_getScaleFactor(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setScaleFactor(double dScale) {
    TG_DbPINVOKE.OdDgDimension_setScaleFactor(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getAnnotationScale() {
    double ret = TG_DbPINVOKE.OdDgDimension_getAnnotationScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScale(double dScale, bool bRescaleGeometry) {
    TG_DbPINVOKE.OdDgDimension_setAnnotationScale__SWIG_0(swigCPtr, dScale, bRescaleGeometry);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScale(double dScale) {
    TG_DbPINVOKE.OdDgDimension_setAnnotationScale__SWIG_1(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAnnotationScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getAnnotationScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet, double dAnnotationScale, bool bRescaleGeometry) {
    TG_DbPINVOKE.OdDgDimension_setAnnotationScaleFlag__SWIG_0(swigCPtr, bSet, dAnnotationScale, bRescaleGeometry);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet, double dAnnotationScale) {
    TG_DbPINVOKE.OdDgDimension_setAnnotationScaleFlag__SWIG_1(swigCPtr, bSet, dAnnotationScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setAnnotationScaleFlag__SWIG_2(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextInfo.TextLocation getTextLocation() {
    OdDgDimTextInfo.TextLocation ret = (OdDgDimTextInfo.TextLocation)TG_DbPINVOKE.OdDgDimension_getTextLocation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTextLocation(OdDgDimTextInfo.TextLocation iLocation) {
    TG_DbPINVOKE.OdDgDimension_setTextLocation(swigCPtr, (int)iLocation);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getInlineTextLift() {
    double ret = TG_DbPINVOKE.OdDgDimension_getInlineTextLift(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setInlineTextLift(double dMargin) {
    TG_DbPINVOKE.OdDgDimension_setInlineTextLift(swigCPtr, dMargin);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextInfo.FitOptions getFitOptions() {
    OdDgDimTextInfo.FitOptions ret = (OdDgDimTextInfo.FitOptions)TG_DbPINVOKE.OdDgDimension_getFitOptions(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFitOptions(OdDgDimTextInfo.FitOptions iOptions) {
    TG_DbPINVOKE.OdDgDimension_setFitOptions(swigCPtr, (int)iOptions);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSuppressUnfitTerminators() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getSuppressUnfitTerminators(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSuppressUnfitTerminators(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setSuppressUnfitTerminators(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getTextAboveOptimalFit() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getTextAboveOptimalFit(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTextAboveOptimalFit(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setTextAboveOptimalFit(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getPrimaryRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getPrimaryRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrimaryRetainFractionalAccuracy(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setPrimaryRetainFractionalAccuracy(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSecondaryRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getSecondaryRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSecondaryRetainFractionalAccuracy(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setSecondaryRetainFractionalAccuracy(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getPrimaryAltFormatRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getPrimaryAltFormatRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrimaryAltFormatRetainFractionalAccuracy(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setPrimaryAltFormatRetainFractionalAccuracy(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSecondaryAltFormatRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getSecondaryAltFormatRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSecondaryAltFormatRetainFractionalAccuracy(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setSecondaryAltFormatRetainFractionalAccuracy(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getPrimaryToleranceRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getPrimaryToleranceRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrimaryToleranceRetainFractionalAccuracy(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setPrimaryToleranceRetainFractionalAccuracy(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSecondaryToleranceRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getSecondaryToleranceRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSecondaryToleranceRetainFractionalAccuracy(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setSecondaryToleranceRetainFractionalAccuracy(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getStackedFractionScale() {
    double ret = TG_DbPINVOKE.OdDgDimension_getStackedFractionScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setStackedFractionScale(double dScale) {
    TG_DbPINVOKE.OdDgDimension_setStackedFractionScale(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getPrimaryToleranceAccuracy(out OdDgDimTextFormat.Accuracy iAccuracy) {
    bool ret = TG_DbPINVOKE.OdDgDimension_getPrimaryToleranceAccuracy(swigCPtr, out iAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrimaryToleranceAccuracy(OdDgDimTextFormat.Accuracy iAccuracy) {
    TG_DbPINVOKE.OdDgDimension_setPrimaryToleranceAccuracy(swigCPtr, (int)iAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSecondaryToleranceAccuracy(out OdDgDimTextFormat.Accuracy iAccuracy) {
    bool ret = TG_DbPINVOKE.OdDgDimension_getSecondaryToleranceAccuracy(swigCPtr, out iAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSecondaryToleranceAccuracy(OdDgDimTextFormat.Accuracy iAccuracy) {
    TG_DbPINVOKE.OdDgDimension_setSecondaryToleranceAccuracy(swigCPtr, (int)iAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getAlignmentView() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getAlignmentView(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setAlignmentView(UInt32 uView) {
    TG_DbPINVOKE.OdDgDimension_setAlignmentView(swigCPtr, uView /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLSDDimensionFontFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getLSDDimensionFontFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLSDDimensionFontFlag(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_setLSDDimensionFontFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimOption getOption(OdDgDimOption.Type type) {//  OdDgDimOptionPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgDimension_getOption(swigCPtr, (int)type);
 
          OdDgDimOption ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgDimOption)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimOption),ptr, true));
                ret = (OdDgDimOption)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimOption),ptr, false);
          }
          else
          {
                  ret = (OdDgDimOption)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimOption),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual void setOption(OdDgDimOption pOption) {
    TG_DbPINVOKE.OdDgDimension_setOption(swigCPtr, OdDgDimOption.getCPtr(pOption));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void removeOption(OdDgDimOption.Type type) {
    TG_DbPINVOKE.OdDgDimension_removeOption(swigCPtr, (int)type);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void setThickness(double dThickness, bool doSubents) {
    TG_DbPINVOKE.OdDgDimension_setThickness__SWIG_0(swigCPtr, dThickness, doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void setThickness(double dThickness) {
    TG_DbPINVOKE.OdDgDimension_setThickness__SWIG_1(swigCPtr, dThickness);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getFlags() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getFlags(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setFlags(UInt32 flags) {
    TG_DbPINVOKE.OdDgDimension_setFlags(swigCPtr, flags /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getJoinerFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getJoinerFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setJoinerFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setJoinerFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getBoxTextFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getBoxTextFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setBoxTextFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setBoxTextFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getCapsuleTextFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getCapsuleTextFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCapsuleTextFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setCapsuleTextFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getLeadingZerosFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getLeadingZerosFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setLeadingZerosFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setLeadingZerosFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getTrailingZerosFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getTrailingZerosFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTrailingZerosFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setTrailingZerosFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDualFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getDualFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDualFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setDualFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getToleranceFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getToleranceFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setToleranceFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setToleranceFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getTolmodeFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getTolmodeFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTolmodeFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setTolmodeFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getEmbedFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getEmbedFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setEmbedFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setEmbedFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getHorizontalFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getHorizontalFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setHorizontalFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setHorizontalFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getNoAutoTextLiftFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getNoAutoTextLiftFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setNoAutoTextLiftFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setNoAutoTextLiftFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getCrossCenterFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getCrossCenterFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCrossCenterFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setCrossCenterFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getUnderlineTextFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getUnderlineTextFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setUnderlineTextFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setUnderlineTextFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getRelDimLineFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getRelDimLineFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setRelDimLineFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setRelDimLineFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getStackFractFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getStackFractFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setStackFractFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setStackFractFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getLeadingZero2Flag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getLeadingZero2Flag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setLeadingZero2Flag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setLeadingZero2Flag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getTrailingZeros2Flag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getTrailingZeros2Flag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTrailingZeros2Flag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setTrailingZeros2Flag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getThousandCommaFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getThousandCommaFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setThousandCommaFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setThousandCommaFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getCentesimalFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getCentesimalFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCentesimalFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setCentesimalFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getNoLevelSymbFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getNoLevelSymbFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setNoLevelSymbFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setNoLevelSymbFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getRelStatFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getRelStatFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setRelStatFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setRelStatFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getTextHeapPadFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getTextHeapPadFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTextHeapPadFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setTextHeapPadFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgDimension.PlacementAlignment getAlignment() {
    OdDgDimension.PlacementAlignment ret = (OdDgDimension.PlacementAlignment)TG_DbPINVOKE.OdDgDimension_getAlignment(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAlignment(OdDgDimension.PlacementAlignment val) {
    TG_DbPINVOKE.OdDgDimension_setAlignment(swigCPtr, (int)val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgDimension.TerminatorArrowHeadType getArrowHead() {
    OdDgDimension.TerminatorArrowHeadType ret = (OdDgDimension.TerminatorArrowHeadType)TG_DbPINVOKE.OdDgDimension_getArrowHead(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setArrowHead(OdDgDimension.TerminatorArrowHeadType val) {
    TG_DbPINVOKE.OdDgDimension_setArrowHead(swigCPtr, (int)val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgDimension.TerminatorOrientation getTermMode() {
    OdDgDimension.TerminatorOrientation ret = (OdDgDimension.TerminatorOrientation)TG_DbPINVOKE.OdDgDimension_getTermMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTermMode(OdDgDimension.TerminatorOrientation val) {
    TG_DbPINVOKE.OdDgDimension_setTermMode(swigCPtr, (int)val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt16 getExtendedFlags() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgDimension_getExtendedFlags(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setExtendedFlags(UInt16 data) {
    TG_DbPINVOKE.OdDgDimension_setExtendedFlags(swigCPtr, data /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDimExtNoLineThruArrowTermFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getDimExtNoLineThruArrowTermFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimExtNoLineThruArrowTermFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setDimExtNoLineThruArrowTermFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDimExtNoLineThruStrokeTermFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getDimExtNoLineThruStrokeTermFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimExtNoLineThruStrokeTermFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setDimExtNoLineThruStrokeTermFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDimExtNoLineThruOriginTermFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getDimExtNoLineThruOriginTermFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimExtNoLineThruOriginTermFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setDimExtNoLineThruOriginTermFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDimExtNoLineThruDotTermFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getDimExtNoLineThruDotTermFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimExtNoLineThruDotTermFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setDimExtNoLineThruDotTermFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getDimExtClockwiseAngleFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimension_getDimExtClockwiseAngleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDimExtClockwiseAngleFlag(bool val) {
    TG_DbPINVOKE.OdDgDimension_setDimExtClockwiseAngleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void getRotation(OdGeMatrix2d rot) {
    TG_DbPINVOKE.OdDgDimension_getRotation__SWIG_0(swigCPtr, OdGeMatrix2d.getCPtr(rot));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setRotation(OdGeMatrix2d quat) {
    TG_DbPINVOKE.OdDgDimension_setRotation__SWIG_0(swigCPtr, OdGeMatrix2d.getCPtr(quat));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void getRotation(OdGeQuaternion quat) {
    TG_DbPINVOKE.OdDgDimension_getRotation__SWIG_1(swigCPtr, OdGeQuaternion.getCPtr(quat));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setRotation(OdGeQuaternion rotation) {
    TG_DbPINVOKE.OdDgDimension_setRotation__SWIG_1(swigCPtr, OdGeQuaternion.getCPtr(rotation));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String getPrimaryMasterUnitName() {
  string ret = TG_DbPINVOKE.OdDgDimension_getPrimaryMasterUnitName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setPrimaryMasterUnitName(String strUnitName) {
    TG_DbPINVOKE.OdDgDimension_setPrimaryMasterUnitName(swigCPtr, strUnitName);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String getPrimarySubUnitName() {
  string ret = TG_DbPINVOKE.OdDgDimension_getPrimarySubUnitName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setPrimarySubUnitName(String strUnitName) {
    TG_DbPINVOKE.OdDgDimension_setPrimarySubUnitName(swigCPtr, strUnitName);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String getSecondaryMasterUnitName() {
  string ret = TG_DbPINVOKE.OdDgDimension_getSecondaryMasterUnitName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setSecondaryMasterUnitName(String strUnitName) {
    TG_DbPINVOKE.OdDgDimension_setSecondaryMasterUnitName(swigCPtr, strUnitName);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual String getSecondarySubUnitName() {
  string ret = TG_DbPINVOKE.OdDgDimension_getSecondarySubUnitName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public virtual void setSecondarySubUnitName(String strUnitName) {
    TG_DbPINVOKE.OdDgDimension_setSecondarySubUnitName(swigCPtr, strUnitName);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool Is3D() {
    bool ret = TG_DbPINVOKE.OdDgDimension_Is3D(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void set3dFlag(bool bSet) {
    TG_DbPINVOKE.OdDgDimension_set3dFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getTextStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getTextStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setTextStyleEntryId(UInt32 uTextStyleId) {
    TG_DbPINVOKE.OdDgDimension_setTextStyleEntryId(swigCPtr, uTextStyleId /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getDimensionStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_getDimensionStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setDimensionStyleEntryId(UInt32 uDimStyle) {
    TG_DbPINVOKE.OdDgDimension_setDimensionStyleEntryId(swigCPtr, uDimStyle /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool applyDimensionStyle(UInt32 uDimStyle) {
    bool ret = TG_DbPINVOKE.OdDgDimension_applyDimensionStyle(swigCPtr, uDimStyle /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void subSetDatabaseDefaults(OdDgDatabase pDb, bool doSubents) {
    TG_DbPINVOKE.OdDgDimension_subSetDatabaseDefaults(swigCPtr, OdDgDatabase.getCPtr(pDb), doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdResult subExplode(OdRxObjectPtrArray entitySet) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgDimension_subExplode(swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override UInt32 subSetAttributes(OdGiDrawableTraits pTraits) { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimension_subSetAttributes(swigCPtr, OdGiDrawableTraits.getCPtr(pTraits)); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public override OdRxObject clone() {//  OdRxObjectPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgDimension_clone(swigCPtr);
 
          OdRxObject ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),ptr, true));
                ret = (OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),ptr, false);
          }
          else
          {
                  ret = (OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public override OdResult subGetGeomExtents(OdDgElementId idView, OdGeExtents3d extents) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgDimension_subGetGeomExtents(swigCPtr, OdDgElementId.getCPtr(idView), OdGeExtents3d.getCPtr(extents));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult recomputeDimensionPoints() {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgDimension_recomputeDimensionPoints(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  protected static string getRealClassName(IntPtr ptr) {
    string ret = TG_DbPINVOKE.OdDgDimension_getRealClassName(ptr /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
     public  virtual  void vb_gripStatus(Teigha.TG.OdDgElement.GripStat status) { this.gripStatus(status); }
  
     public  virtual  Teigha.Core.OdGiDrawable.DrawableType vb_drawableType() { return this.drawableType(); }
  
  public enum ToolType {
    kToolTypeInvalid = 0,
    kToolTypeSizeArrow = 1,
    kToolTypeSizeStroke = 2,
    kToolTypeLocateSingle = 3,
    kToolTypeLocateStacked = 4,
    kToolTypeAngleSize = 5,
    kToolTypeArcSize = 6,
    kToolTypeAngleLocation = 7,
    kToolTypeArcLocation = 8,
    kToolTypeAngleLines = 9,
    kToolTypeAngleAxis = 10,
    kToolTypeRadius = 11,
    kToolTypeDiameter = 12,
    kToolTypeDiameterPara = 13,
    kToolTypeDiameterPerp = 14,
    kToolTypeCustomLinear = 15,
    kToolTypeOrdinate = 16,
    kToolTypeRadiusExtended = 17,
    kToolTypeDiameterExtended = 18,
    kToolTypeCenter = 19,
    kToolTypeEnum,
    kToolTypeAngleAxisX = 50,
    kToolTypeAngleAxisY = 51,
    kToolTypeLabelLine = 52,
    kToolTypeNote = 53,
    kToolTypeTheLastType = kToolTypeNote
  }
 
  public enum PlacementAlignment {
    kPaView = 0,
    kPaDrawing = 1,
    kPaTrue = 2,
    kPaArbitrary = 3
  }
 
  public enum TerminatorArrowHeadType {
    kOpened = 0,
    kClosed = 1,
    kFilled = 2
  }
 
  public enum TerminatorOrientation {
    kAutomatic = 0,
    kReversed = 1,
    kInside = 2,
    kOutside = 3
  }
 
}
 
}