OdDgTextNode2d.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 OdDgTextNode2d : OdDgGraphicsElement, OdDgTextStyleOverrideFlags, OdDgTextExtendedProperties {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDgTextNode2d(IntPtr cPtr, bool cMemoryOwn) : base(TG_DbPINVOKE.OdDgTextNode2d_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDgTextNode2d 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_OdDgTextNode2d(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  global::System.Runtime.InteropServices.HandleRef OdDgTextStyleOverrideFlags.GetInterfaceCPtr() {
    return new global::System.Runtime.InteropServices.HandleRef(this, TG_DbPINVOKE.OdDgTextNode2d_OdDgTextStyleOverrideFlags_GetInterfaceCPtr(swigCPtr.Handle));
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  global::System.Runtime.InteropServices.HandleRef OdDgTextExtendedProperties.GetInterfaceCPtr() {
    return new global::System.Runtime.InteropServices.HandleRef(this, TG_DbPINVOKE.OdDgTextNode2d_OdDgTextExtendedProperties_GetInterfaceCPtr(swigCPtr.Handle));
  }
 
  public override OdDgElement.ElementTypes getElementType() {
    OdDgElement.ElementTypes ret = (OdDgElement.ElementTypes)TG_DbPINVOKE.OdDgTextNode2d_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.OdDgTextNode2d_getElementSubType(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public static OdDgTextNode2d cast(OdRxObject pObj) {//  OdSmartPtr<OdDgTextNode2d>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgTextNode2d_cast(OdRxObject.getCPtr(pObj));
 
          OdDgTextNode2d ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgTextNode2d)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgTextNode2d),ptr, true));
                ret = (OdDgTextNode2d)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgTextNode2d),ptr, false);
          }
          else
          {
                  ret = (OdDgTextNode2d)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgTextNode2d),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.OdDgTextNode2d_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.OdDgTextNode2d_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.OdDgTextNode2d_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public new static OdDgTextNode2d createObject() {//  OdSmartPtr<OdDgTextNode2d>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgTextNode2d_createObject();
 
          OdDgTextNode2d ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgTextNode2d)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgTextNode2d),ptr, true));
                ret = (OdDgTextNode2d)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgTextNode2d),ptr, false);
          }
          else
          {
                  ret = (OdDgTextNode2d)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgTextNode2d),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public double getLineSpacing() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getLineSpacing(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setLineSpacing(double spacing) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineSpacing(swigCPtr, spacing);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getFirstLineIndentation() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getFirstLineIndentation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setFirstLineIndentation(double dValue) {
    TG_DbPINVOKE.OdDgTextNode2d_setFirstLineIndentation(swigCPtr, dValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getParagraphIndentation() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getParagraphIndentation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setParagraphIndentation(double dValue) {
    TG_DbPINVOKE.OdDgTextNode2d_setParagraphIndentation(swigCPtr, dValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeDoubleArray getTabStopArray() {
// csout array 
  OdGeDoubleArray res = new OdGeDoubleArray(TG_DbPINVOKE.OdDgTextNode2d_getTabStopArray(swigCPtr),false); 
  
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return res;
}
 
  public void setTabStopArray(OdGeDoubleArray arrTabStop) {
    TG_DbPINVOKE.OdDgTextNode2d_setTabStopArray(swigCPtr, OdGeDoubleArray.getCPtr(arrTabStop));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getDefaultTabStep() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getDefaultTabStep(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdDgTextExtendedProperties_OdDgSpecialSymbol_Array getTextNodeStartSpecialSymbols() {
// csout array 
  OdDgTextExtendedProperties_OdDgSpecialSymbol_Array res = new OdDgTextExtendedProperties_OdDgSpecialSymbol_Array(TG_DbPINVOKE.OdDgTextNode2d_getTextNodeStartSpecialSymbols(swigCPtr),false); 
  
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return res;
}
 
  public void setTextNodeStartSpecialSymbols(OdDgTextExtendedProperties_OdDgSpecialSymbol_Array arrSymbols) {
    TG_DbPINVOKE.OdDgTextNode2d_setTextNodeStartSpecialSymbols(swigCPtr, OdDgTextExtendedProperties_OdDgSpecialSymbol_Array.getCPtr(arrSymbols));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getFontEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getFontEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setFontEntryId(UInt32 fontId) {
    TG_DbPINVOKE.OdDgTextNode2d_setFontEntryId(swigCPtr, fontId /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt16 getMaxLength() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgTextNode2d_getMaxLength(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setMaxLength(UInt16 length) {
    TG_DbPINVOKE.OdDgTextNode2d_setMaxLength(swigCPtr, length /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public TextJustification getJustification() {
    TextJustification ret = (TextJustification)TG_DbPINVOKE.OdDgTextNode2d_getJustification(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setJustification(TextJustification justification) {
    TG_DbPINVOKE.OdDgTextNode2d_setJustification(swigCPtr, (int)justification);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getTextNodeNumber() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getTextNodeNumber(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setTextNodeNumber(UInt32 number) {
    TG_DbPINVOKE.OdDgTextNode2d_setTextNodeNumber(swigCPtr, number /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void add(OdDgElement pElement) {
    TG_DbPINVOKE.OdDgTextNode2d_add(swigCPtr, OdDgElement.getCPtr(pElement));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgElementIterator createIterator(bool atBeginning, bool skipDeleted) {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgTextNode2d_createIterator__SWIG_0(swigCPtr, atBeginning, skipDeleted);
 
          OdDgElementIterator ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, true));
                ret = (OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, false);
          }
          else
          {
                  ret = (OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDgElementIterator createIterator(bool atBeginning) {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgTextNode2d_createIterator__SWIG_1(swigCPtr, atBeginning);
 
          OdDgElementIterator ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, true));
                ret = (OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, false);
          }
          else
          {
                  ret = (OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDgElementIterator createIterator() {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgTextNode2d_createIterator__SWIG_2(swigCPtr);
 
          OdDgElementIterator ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, true));
                ret = (OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, false);
          }
          else
          {
                  ret = (OdDgElementIterator)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElementIterator),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void recalculateTextNode() {
    TG_DbPINVOKE.OdDgTextNode2d_recalculateTextNode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAnnotationScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getAnnotationScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet, double dAnnotationScale, bool bRescaleGeometry, bool doSubents) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScaleFlag__SWIG_0(swigCPtr, bSet, dAnnotationScale, bRescaleGeometry, doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet, double dAnnotationScale, bool bRescaleGeometry) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScaleFlag__SWIG_1(swigCPtr, bSet, dAnnotationScale, bRescaleGeometry);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet, double dAnnotationScale) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScaleFlag__SWIG_2(swigCPtr, bSet, dAnnotationScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScaleFlag(bool bSet) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScaleFlag__SWIG_3(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getAnnotationScale() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getAnnotationScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScale(double dScale, bool bRescaleGeometry, bool doSubents) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScale__SWIG_0(swigCPtr, dScale, bRescaleGeometry, doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScale(double dScale, bool bRescaleGeometry) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScale__SWIG_1(swigCPtr, dScale, bRescaleGeometry);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setAnnotationScale(double dScale) {
    TG_DbPINVOKE.OdDgTextNode2d_setAnnotationScale__SWIG_2(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override bool subWorldDraw(OdGiWorldDraw pWd) {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_subWorldDraw(swigCPtr, OdGiWorldDraw.getCPtr(pWd));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void subViewportDraw(OdGiViewportDraw pVd) {
    TG_DbPINVOKE.OdDgTextNode2d_subViewportDraw(swigCPtr, OdGiViewportDraw.getCPtr(pVd));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdResult subGetGeomExtents(OdGeExtents3d extents) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgTextNode2d_subGetGeomExtents__SWIG_0(swigCPtr, OdGeExtents3d.getCPtr(extents));
    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.OdDgTextNode2d_subGetGeomExtents__SWIG_1(swigCPtr, OdDgElementId.getCPtr(idView), OdGeExtents3d.getCPtr(extents));
    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.OdDgTextNode2d_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 virtual OdResult subExplode(OdRxObjectPtrArray entitySet) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgTextNode2d_subExplode(swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void copyFrom(OdRxObject pSource) {
    TG_DbPINVOKE.OdDgTextNode2d_copyFrom(swigCPtr, OdRxObject.getCPtr(pSource));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void transformTextNodeSettings(OdGeMatrix3d matTransform) {
    TG_DbPINVOKE.OdDgTextNode2d_transformTextNodeSettings(swigCPtr, OdGeMatrix3d.getCPtr(matTransform));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getRotation() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getRotation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setRotation(double angle) {
    TG_DbPINVOKE.OdDgTextNode2d_setRotation(swigCPtr, angle);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint2d getOrigin() {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgTextNode2d_getOrigin(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setOrigin(OdGePoint2d point) {
    TG_DbPINVOKE.OdDgTextNode2d_setOrigin(swigCPtr, OdGePoint2d.getCPtr(point));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void getBoundingPoints(OdGePoint2dArray boundingPoints) {
    TG_DbPINVOKE.OdDgTextNode2d_getBoundingPoints(swigCPtr, OdGePoint2dArray.getCPtr(boundingPoints).Handle);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getInterCharSpacingFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getInterCharSpacingFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setInterCharSpacingFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setInterCharSpacingFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getFixedWidthSpacingFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getFixedWidthSpacingFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFixedWidthSpacingFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setFixedWidthSpacingFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSlantFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getSlantFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSlantFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setSlantFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getVerticalFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getVerticalFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setVerticalFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setVerticalFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getRightToLeftFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getRightToLeftFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setRightToLeftFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setRightToLeftFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getReverseMlineFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getReverseMlineFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setReverseMlineFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setReverseMlineFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getKerningFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getKerningFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setKerningFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setKerningFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOffsetFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOffsetFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOffsetFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOffsetFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getCodepageFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getCodepageFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setCodepageFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setCodepageFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getShxBigFontFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getShxBigFontFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setShxBigFontFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setShxBigFontFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBgColorFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBgColorFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBgColorFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBgColorFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSubscriptFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getSubscriptFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSubscriptFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setSubscriptFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSuperscriptFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getSuperscriptFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSuperscriptFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setSuperscriptFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getExTextFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getExTextFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setExTextFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setExTextFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getTextStyleFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getTextStyleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTextStyleFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setTextStyleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBoldFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBoldFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBoldFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBoldFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineStyleFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineStyleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineStyleFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineStyleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineStyleFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineStyleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineStyleFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineStyleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getStyleOverridesFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getStyleOverridesFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setStyleOverridesFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setStyleOverridesFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getWordWrapTextNodeFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getWordWrapTextNodeFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setWordWrapTextNodeFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setWordWrapTextNodeFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getFullJustificationFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getFullJustificationFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFullJustificationFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setFullJustificationFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getColorFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getColorFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setColorFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setColorFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAcadInterCharSpacingFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getAcadInterCharSpacingFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAcadInterCharSpacingFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setAcadInterCharSpacingFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackwardsFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackwardsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackwardsFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackwardsFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUpsidedownFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUpsidedownFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUpsidedownFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUpsidedownFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAcadFittedTextFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getAcadFittedTextFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAcadFittedTextFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setAcadFittedTextFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUpsideDownFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUpsideDownFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUpsideDownFlag(bool bSet) {
    TG_DbPINVOKE.OdDgTextNode2d_setUpsideDownFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgTextExtendedPropertiesImpl.OdDgTextExtendedProperties_LineSpacingType getLineSpacingType() {
    OdDgTextExtendedPropertiesImpl.OdDgTextExtendedProperties_LineSpacingType ret = (OdDgTextExtendedPropertiesImpl.OdDgTextExtendedProperties_LineSpacingType)TG_DbPINVOKE.OdDgTextNode2d_getLineSpacingType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineSpacingType(OdDgTextExtendedPropertiesImpl.OdDgTextExtendedProperties_LineSpacingType uType) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineSpacingType(swigCPtr, (int)uType);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte getStackedFractionAlign() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TG_DbPINVOKE.OdDgTextNode2d_getStackedFractionAlign(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setStackedFractionAlign(byte var) {
    TG_DbPINVOKE.OdDgTextNode2d_setStackedFractionAlign(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte getStackedFractionSection() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TG_DbPINVOKE.OdDgTextNode2d_getStackedFractionSection(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setStackedFractionSection(byte var) {
    TG_DbPINVOKE.OdDgTextNode2d_setStackedFractionSection(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte getStackedFractionType() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TG_DbPINVOKE.OdDgTextNode2d_getStackedFractionType(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setStackedFractionType(byte var) {
    TG_DbPINVOKE.OdDgTextNode2d_setStackedFractionType(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getSlant() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getSlant(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSlant(double var) {
    TG_DbPINVOKE.OdDgTextNode2d_setSlant(swigCPtr, var);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getUnderlineSpacing() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineSpacing(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineSpacing(double var) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineSpacing(swigCPtr, var);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdGePoint2d getLineOffset() {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgTextNode2d_getLineOffset(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineOffset(OdGePoint2d var) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineOffset(swigCPtr, OdGePoint2d.getCPtr(var));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getCodePage() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getCodePage(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setCodePage(UInt32 var) {
    TG_DbPINVOKE.OdDgTextNode2d_setCodePage(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getShxBigFontEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getShxBigFontEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setShxBigFontEntryId(UInt32 var) {
    TG_DbPINVOKE.OdDgTextNode2d_setShxBigFontEntryId(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getBackgroundLineStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundLineStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getBackgroundLineWeight() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundLineWeight(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getBackgroundColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getBackgroundFillColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundFillColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual OdGePoint2d getBackgroundBorder() {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgTextNode2d_getBackgroundBorder(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual double getOverlineSpacing() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineSpacing(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineSpacing(double var) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineSpacing(swigCPtr, var);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getTextStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getTextStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setTextStyleEntryId(UInt32 var) {
    TG_DbPINVOKE.OdDgTextNode2d_setTextStyleEntryId(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getUnderlineColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getUnderlineLineStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineLineStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getUnderlineLineWeight() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineLineWeight(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getOverlineColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getOverlineLineStyleEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineLineStyleEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual UInt32 getOverlineLineWeight() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineLineWeight(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual double getTextnodeWordWrapLength() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getTextnodeWordWrapLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTextnodeWordWrapLength(double var) {
    TG_DbPINVOKE.OdDgTextNode2d_setTextnodeWordWrapLength(swigCPtr, var);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual byte getCrCount() { 
// test csout
 /*SIMPLETYPE*/
     byte ret = TG_DbPINVOKE.OdDgTextNode2d_getCrCount(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setCrCount(byte var) {
    TG_DbPINVOKE.OdDgTextNode2d_setCrCount(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override UInt32 getColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgTextNode2d_getColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public override void setColorIndex(UInt32 var, bool doSubents) {
    TG_DbPINVOKE.OdDgTextNode2d_setColorIndex__SWIG_0(swigCPtr, var /*SIMPLETYPE*/, doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void setColorIndex(UInt32 var) {
    TG_DbPINVOKE.OdDgTextNode2d_setColorIndex__SWIG_1(swigCPtr, var /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getFontNumberOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getFontNumberOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFontNumberOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setFontNumberOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getShxBigFontOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getShxBigFontOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setShxBigFontOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setShxBigFontOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getWidthOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getWidthOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setWidthOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setWidthOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getHeightOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getHeightOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setHeightOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setHeightOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSlantOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getSlantOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSlantOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setSlantOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLineSpacingOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getLineSpacingOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineSpacingOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineSpacingOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLineCharSpacingOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getLineCharSpacingOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineCharSpacingOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineCharSpacingOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineOffsetOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineOffsetOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineOffsetOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineOffsetOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineOffsetOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineOffsetOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineOffsetOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineOffsetOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getJustificationOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getJustificationOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setJustificationOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setJustificationOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getNodeJustificationOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getNodeJustificationOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNodeJustificationOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setNodeJustificationOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLineLengthOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getLineLengthOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineLengthOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineLengthOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDirectionOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getDirectionOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDirectionOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setDirectionOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getItalicsOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getItalicsOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setItalicsOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setItalicsOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBoldOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBoldOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBoldOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBoldOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSuperscriptOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getSuperscriptOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSuperscriptOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setSuperscriptOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSubscriptOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getSubscriptOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSubscriptOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setSubscriptOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getFixedSpacingOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getFixedSpacingOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFixedSpacingOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setFixedSpacingOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackgroundOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackgroundOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackgroundOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackgroundStyleOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundStyleOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackgroundStyleOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackgroundStyleOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackgroundWeightOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundWeightOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackgroundWeightOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackgroundWeightOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackgroundColorOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundColorOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackgroundColorOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackgroundColorOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackgroundFillColorOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundFillColorOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackgroundFillColorOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackgroundFillColorOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackgroundBorderOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackgroundBorderOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackgroundBorderOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackgroundBorderOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineStyleOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineStyleOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineStyleOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineStyleOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineWeightOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineWeightOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineWeightOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineWeightOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineColorOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineColorOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineColorOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineColorOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineStyleOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineStyleOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineStyleOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineStyleOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineWeightOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineWeightOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineWeightOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineWeightOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineColorOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineColorOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineColorOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineColorOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLineOffsetOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getLineOffsetOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineOffsetOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineOffsetOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getFractionsOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getFractionsOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFractionsOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setFractionsOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getOverlineStyleFlagOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getOverlineStyleFlagOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setOverlineStyleFlagOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineStyleFlagOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUnderlineStyleFlagOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUnderlineStyleFlagOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUnderlineStyleFlagOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineStyleFlagOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getColorOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getColorOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setColorOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setColorOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getWidthFactorOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getWidthFactorOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setWidthFactorOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setWidthFactorOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getColorFlagOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getColorFlagOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setColorFlagOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setColorFlagOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getFullJustificationOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getFullJustificationOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setFullJustificationOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setFullJustificationOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLineSpacingTypeOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getLineSpacingTypeOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineSpacingTypeOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setLineSpacingTypeOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getBackwardsOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getBackwardsOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setBackwardsOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackwardsOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUpsidedownOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getUpsidedownOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUpsidedownOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setUpsidedownOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAcadInterCharSpacingOverrideFlag() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getAcadInterCharSpacingOverrideFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAcadInterCharSpacingOverrideFlag(bool val) {
    TG_DbPINVOKE.OdDgTextNode2d_setAcadInterCharSpacingOverrideFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getLengthMultiplier() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getLengthMultiplier(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLengthMultiplier(double length) {
    TG_DbPINVOKE.OdDgTextNode2d_setLengthMultiplier(swigCPtr, length);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getHeightMultiplier() {
    double ret = TG_DbPINVOKE.OdDgTextNode2d_getHeightMultiplier(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setHeightMultiplier(double height) {
    TG_DbPINVOKE.OdDgTextNode2d_setHeightMultiplier(swigCPtr, height);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setOverlineStyle(UInt32 dOverlineColorIndex, UInt32 dOverlineLineStyleEntryId, UInt32 dOverlineLineWeight) {
    TG_DbPINVOKE.OdDgTextNode2d_setOverlineStyle(swigCPtr, dOverlineColorIndex /*SIMPLETYPE*/, dOverlineLineStyleEntryId /*SIMPLETYPE*/, dOverlineLineWeight /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setUnderlineStyle(UInt32 dUnderlineColorIndex, UInt32 dUnderlineLineStyleEntryId, UInt32 dUnderlineLineWeight) {
    TG_DbPINVOKE.OdDgTextNode2d_setUnderlineStyle(swigCPtr, dUnderlineColorIndex /*SIMPLETYPE*/, dUnderlineLineStyleEntryId /*SIMPLETYPE*/, dUnderlineLineWeight /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setBackground(UInt32 backgroundStyle, UInt32 backgroundWeight, UInt32 backgroundColor, UInt32 backgroundFillColor, OdGePoint2d backgroundBorder) {
    TG_DbPINVOKE.OdDgTextNode2d_setBackground(swigCPtr, backgroundStyle /*SIMPLETYPE*/, backgroundWeight /*SIMPLETYPE*/, backgroundColor /*SIMPLETYPE*/, backgroundFillColor /*SIMPLETYPE*/, OdGePoint2d.getCPtr(backgroundBorder));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void getSpacing(out double var, out OdDgTextExtendedPropertiesImpl.OdDgTextExtendedProperties_Spacing flag) {
    TG_DbPINVOKE.OdDgTextNode2d_getSpacing(swigCPtr, out var, out flag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setSpacing(double var, OdDgTextExtendedPropertiesImpl.OdDgTextExtendedProperties_Spacing flag) {
    TG_DbPINVOKE.OdDgTextNode2d_setSpacing(swigCPtr, var, flag);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool applyTextStyle(OdDgElementId idTextStyle, bool bActiveModelUnitsForNonDBRO, double dActualUORsToMasterScale) {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_applyTextStyle__SWIG_0(swigCPtr, OdDgElementId.getCPtr(idTextStyle), bActiveModelUnitsForNonDBRO, dActualUORsToMasterScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool applyTextStyle(OdDgElementId idTextStyle, bool bActiveModelUnitsForNonDBRO) {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_applyTextStyle__SWIG_1(swigCPtr, OdDgElementId.getCPtr(idTextStyle), bActiveModelUnitsForNonDBRO);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool applyTextStyle(OdDgElementId idTextStyle) {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_applyTextStyle__SWIG_2(swigCPtr, OdDgElementId.getCPtr(idTextStyle));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void subSetDatabaseDefaults(OdDgDatabase pDb, bool doSubents) {
    TG_DbPINVOKE.OdDgTextNode2d_subSetDatabaseDefaults(swigCPtr, OdDgDatabase.getCPtr(pDb), doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getItalics() {
    bool ret = TG_DbPINVOKE.OdDgTextNode2d_getItalics(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setItalics(bool bItalics) {
    TG_DbPINVOKE.OdDgTextNode2d_setItalics(swigCPtr, bItalics);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  protected static string getRealClassName(IntPtr ptr) {
    string ret = TG_DbPINVOKE.OdDgTextNode2d_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(); }
  
}
 
}