OdDgDimensionInfoLinkage.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 OdDgDimensionInfoLinkage : OdDgDimensionLinkage {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDgDimensionInfoLinkage(IntPtr cPtr, bool cMemoryOwn) : base(TG_DbPINVOKE.OdDgDimensionInfoLinkage_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDgDimensionInfoLinkage 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_OdDgDimensionInfoLinkage(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  public new static OdDgDimensionLinkage cast(OdRxObject pObj) {//  OdSmartPtr<OdDgDimensionLinkage>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgDimensionInfoLinkage_cast(OdRxObject.getCPtr(pObj));
 
          OdDgDimensionLinkage ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgDimensionLinkage)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimensionLinkage),ptr, true));
                ret = (OdDgDimensionLinkage)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimensionLinkage),ptr, false);
          }
          else
          {
                  ret = (OdDgDimensionLinkage)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimensionLinkage),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.OdDgDimensionInfoLinkage_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.OdDgDimensionInfoLinkage_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.OdDgDimensionInfoLinkage_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public new static OdDgDimensionLinkage createObject() {//  OdSmartPtr<OdDgDimensionLinkage>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgDimensionInfoLinkage_createObject();
 
          OdDgDimensionLinkage ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgDimensionLinkage)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimensionLinkage),ptr, true));
                ret = (OdDgDimensionLinkage)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimensionLinkage),ptr, false);
          }
          else
          {
                  ret = (OdDgDimensionLinkage)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgDimensionLinkage),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual bool getUsePrimaryToleranceAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUsePrimaryToleranceAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseSecondaryToleranceAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseSecondaryToleranceAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseDatumValue() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseDatumValue(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseDecrimentInReverceDirection() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseDecrimentInReverceDirection(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseFreeLocationText() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseFreeLocationText(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseStackedFractionScale() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseStackedFractionScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseTextLocation() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseTextLocation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteTermFontId() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteTermFontId(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteTermSymbol() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteTermSymbol(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseAnnotationScaleValue() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseAnnotationScaleValue(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseMinLeaderTermLength() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseMinLeaderTermLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseInlineLeaderLengthValue() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseInlineLeaderLengthValue(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseFitOptionsFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseFitOptionsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseSuppressUnfitTerm() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseSuppressUnfitTerm(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseInlineLeaderLength() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseInlineLeaderLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseTextAboveOptimalFit() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseTextAboveOptimalFit(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNarrowFontOptimalFit() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNarrowFontOptimalFit(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteLeaderLength() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteLeaderLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteLeftMargin() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteLeftMargin(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteLowerMargin() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteLowerMargin(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteFrameScale() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteFrameScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseInlineTextLift() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseInlineTextLift(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseNoteSplineFit() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseNoteSplineFit(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getPrimaryRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getPrimaryRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getSecondaryRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getSecondaryRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getPrimaryAltFormatRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getPrimaryAltFormatRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getSecondaryAltFormatRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getSecondaryAltFormatRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getPrimaryTolerRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getPrimaryTolerRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getSecondaryTolerRetainFractionalAccuracy() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getSecondaryTolerRetainFractionalAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseUnknownUInt16() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseUnknownUInt16(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseUnknownUInt16(bool bSet) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseUnknownUInt16(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt16 getUnknownUInt16() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUnknownUInt16(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setUnknownUInt16(UInt16 /*SIMPLETYPE*/ dValue) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUnknownUInt16(swigCPtr, dValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUsePrimaryToleranceAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUsePrimaryToleranceAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseSecondaryToleranceAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseSecondaryToleranceAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseDatumValue(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseDatumValue(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseDecrimentInReverceDirection(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseDecrimentInReverceDirection(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseFreeLocationText(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseFreeLocationText(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseStackedFractionScale(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseStackedFractionScale(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseTextLocation(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseTextLocation(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteTermFontId(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteTermFontId(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteTermSymbol(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteTermSymbol(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseAnnotationScaleValue(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseAnnotationScaleValue(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseMinLeaderTermLength(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseMinLeaderTermLength(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseInlineLeaderLengthValue(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseInlineLeaderLengthValue(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseFitOptions(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseFitOptions(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseSuppressUnfitTerm(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseSuppressUnfitTerm(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseInlineLeaderLength(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseInlineLeaderLength(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseTextAboveOptimalFit(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseTextAboveOptimalFit(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNarrowFontOptimalFit(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNarrowFontOptimalFit(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteLeaderLength(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteLeaderLength(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteLeftMargin(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteLeftMargin(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteLowerMargin(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteLowerMargin(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteFrameScale(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteFrameScale(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseInlineTextLift(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseInlineTextLift(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseNoteSplineFit(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseNoteSplineFit(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setPrimaryRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setPrimaryRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setSecondaryRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setSecondaryRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setPrimaryAltFormatRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setPrimaryAltFormatRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setSecondaryAltFormatRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setSecondaryAltFormatRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setPrimaryTolerRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setPrimaryTolerRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setSecondaryTolerRetainFractionalAccuracy(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setSecondaryTolerRetainFractionalAccuracy(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextFormat.Accuracy getPrimaryToleranceAccuracy() {
    OdDgDimTextFormat.Accuracy ret = (OdDgDimTextFormat.Accuracy)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getPrimaryToleranceAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrimaryToleranceAccuracy(OdDgDimTextFormat.Accuracy iAccuracy) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setPrimaryToleranceAccuracy(swigCPtr, (int)iAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextFormat.Accuracy getSecondaryToleranceAccuracy() {
    OdDgDimTextFormat.Accuracy ret = (OdDgDimTextFormat.Accuracy)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getSecondaryToleranceAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSecondaryToleranceAccuracy(OdDgDimTextFormat.Accuracy iAccuracy) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setSecondaryToleranceAccuracy(swigCPtr, (int)iAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getStackedFractionScale() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getStackedFractionScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setStackedFractionScale(double dScale) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setStackedFractionScale(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextInfo.TextLocation getTextLocation() {
    OdDgDimTextInfo.TextLocation ret = (OdDgDimTextInfo.TextLocation)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getTextLocation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTextLocation(OdDgDimTextInfo.TextLocation iLocation) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setTextLocation(swigCPtr, (int)iLocation);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getAnnotationScale() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getAnnotationScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScale(double dScale) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setAnnotationScale(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAnnotationScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getAnnotationScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setAnnotationScaleFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getDatumValue() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getDatumValue(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDatumValue(double dValue) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setDatumValue(swigCPtr, dValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getInlineLeaderLength() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getInlineLeaderLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setInlineLeaderLength(double dLength) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setInlineLeaderLength(swigCPtr, dLength);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextInfo.FitOptions getFitOptions() {
    OdDgDimTextInfo.FitOptions ret = (OdDgDimTextInfo.FitOptions)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getFitOptions(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFitOptions(OdDgDimTextInfo.FitOptions iFitOptions) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setFitOptions(swigCPtr, (int)iFitOptions);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimLabelLine.LabelLineDimensionMode getLabelLineDimensionMode() {
    OdDgDimLabelLine.LabelLineDimensionMode ret = (OdDgDimLabelLine.LabelLineDimensionMode)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getLabelLineDimensionMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLabelLineDimensionMode(OdDgDimLabelLine.LabelLineDimensionMode iDimMode) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setLabelLineDimensionMode(swigCPtr, (int)iDimMode);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getFlags() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getFlags(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual double getNoteLeaderLength() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteLeaderLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteLeaderLength(double dLength) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteLeaderLength(swigCPtr, dLength);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getNoteLeftMargin() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteLeftMargin(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteLeftMargin(double dMargin) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteLeftMargin(swigCPtr, dMargin);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getNoteLowerMargin() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteLowerMargin(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteLowerMargin(double dMargin) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteLowerMargin(swigCPtr, dMargin);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getNoteFrameScale() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteFrameScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteFrameScale(double dScale) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteFrameScale(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getInlineTextLift() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getInlineTextLift(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setInlineTextLift(double dMargin) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setInlineTextLift(swigCPtr, dMargin);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimNote.NoteTerminatorType getNoteTerminator() {
    OdDgDimNote.NoteTerminatorType ret = (OdDgDimNote.NoteTerminatorType)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteTerminator(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteTerminator(OdDgDimNote.NoteTerminatorType iType) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteTerminator(swigCPtr, (int)iType);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimTextInfo.TextRotation getNoteTextRotation() {
    OdDgDimTextInfo.TextRotation ret = (OdDgDimTextInfo.TextRotation)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteTextRotation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteTextRotation(OdDgDimTextInfo.TextRotation iRotation) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteTextRotation(swigCPtr, (int)iRotation);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimOptionTerminators.TerminatorStyle getNoteTerminatorStyle() {
    OdDgDimOptionTerminators.TerminatorStyle ret = (OdDgDimOptionTerminators.TerminatorStyle)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteTerminatorStyle(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteTerminatorStyle(OdDgDimOptionTerminators.TerminatorStyle iStyle) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteTerminatorStyle(swigCPtr, (int)iStyle);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getNoteTermFontId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteTermFontId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setNoteTermFontId(UInt32 /*SIMPLETYPE*/ uFontId) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteTermFontId(swigCPtr, uFontId /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt16 getNoteTermSymbol() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteTermSymbol(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setNoteTermSymbol(UInt16 /*SIMPLETYPE*/ uSymbol) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteTermSymbol(swigCPtr, uSymbol /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual Int16 getRetainFractionalAccuracyValue() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getRetainFractionalAccuracyValue(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual Int32 getTextModeValue() { 
// test csout
 /*SIMPLETYPE*/
     Int32 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getTextModeValue(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual Int32 getFitOptionsValue() { 
// test csout
 /*SIMPLETYPE*/
     Int32 ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getFitOptionsValue(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setRetainFractionalAccuracyValue(Int16 /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setRetainFractionalAccuracyValue(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setTextModeValue(Int32 /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setTextModeValue(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setFitOptionsValue(Int32 /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setFitOptionsValue(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool isEmptyLinkage() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_isEmptyLinkage(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void copy(OdDgDimensionInfoLinkage pSource) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_copy(swigCPtr, OdDgDimensionInfoLinkage.getCPtr(pSource));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseTextCenterRightJustification() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseTextCenterRightJustification(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseTextCenterRightJustification(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseTextCenterRightJustification(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUsePrimaryRoundOff() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUsePrimaryRoundOff(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseSecondaryRoundOff() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseSecondaryRoundOff(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getUseAutoLeaderMode() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseAutoLeaderMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUsePrimaryRoundOff(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUsePrimaryRoundOff(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseSecondaryRoundOff(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseSecondaryRoundOff(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUseAutoLeaderMode(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseAutoLeaderMode(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getPrimaryRoundOff() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getPrimaryRoundOff(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrimaryRoundOff(double dOffset) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setPrimaryRoundOff(swigCPtr, dOffset);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getSecondaryRoundOff() {
    double ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getSecondaryRoundOff(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSecondaryRoundOff(double dOffset) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setSecondaryRoundOff(swigCPtr, dOffset);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimNote.NoteFrameType getNoteFrameType() {
    OdDgDimNote.NoteFrameType ret = (OdDgDimNote.NoteFrameType)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteFrameType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteFrameType(OdDgDimNote.NoteFrameType iFrameType) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteFrameType(swigCPtr, (int)iFrameType);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getEnableNoteFrameScale() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getEnableNoteFrameScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setEnableNoteFrameScale(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setEnableNoteFrameScale(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimNote.NoteAttachmentDirection getNoteHorizontalAttachmentLeaderDirection() {
    OdDgDimNote.NoteAttachmentDirection ret = (OdDgDimNote.NoteAttachmentDirection)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteHorizontalAttachmentLeaderDirection(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteHorizontalAttachmentLeaderDirection(OdDgDimNote.NoteAttachmentDirection iDirection) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteHorizontalAttachmentLeaderDirection(swigCPtr, (int)iDirection);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimNote.NoteEditAbout getNoteEditAbout() {
    OdDgDimNote.NoteEditAbout ret = (OdDgDimNote.NoteEditAbout)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteEditAbout(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteEditAbout(OdDgDimNote.NoteEditAbout iEditAbout) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteEditAbout(swigCPtr, (int)iEditAbout);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimNote.NoteAttachmentAlignment getNoteLeftAttachmentAlignment() {
    OdDgDimNote.NoteAttachmentAlignment ret = (OdDgDimNote.NoteAttachmentAlignment)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteLeftAttachmentAlignment(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteLeftAttachmentAlignment(OdDgDimNote.NoteAttachmentAlignment iAlignment) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteLeftAttachmentAlignment(swigCPtr, (int)iAlignment);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgDimNote.NoteAttachmentAlignment getNoteRightAttachmentAlignment() {
    OdDgDimNote.NoteAttachmentAlignment ret = (OdDgDimNote.NoteAttachmentAlignment)TG_DbPINVOKE.OdDgDimensionInfoLinkage_getNoteRightAttachmentAlignment(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNoteRightAttachmentAlignment(OdDgDimNote.NoteAttachmentAlignment iAlignment) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setNoteRightAttachmentAlignment(swigCPtr, (int)iAlignment);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseExtendDimLineUnderText() {
    bool ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getUseExtendDimLineUnderText(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseExtendDimLineUnderText(bool bSetFlag) {
    TG_DbPINVOKE.OdDgDimensionInfoLinkage_setUseExtendDimLineUnderText(swigCPtr, bSetFlag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  protected static string getRealClassName(IntPtr /*SIMPLETYPE*/ ptr) {
    string ret = TG_DbPINVOKE.OdDgDimensionInfoLinkage_getRealClassName(ptr /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
}
 
}