OdDgModel.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 OdDgModel : OdDgElement {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDgModel(IntPtr cPtr, bool cMemoryOwn) : base(TG_DbPINVOKE.OdDgModel_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDgModel 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_OdDgModel(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  public override OdDgElement.ElementTypes getElementType() {
    OdDgElement.ElementTypes ret = (OdDgElement.ElementTypes)TG_DbPINVOKE.OdDgModel_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.OdDgModel_getElementSubType(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public static OdDgModel cast(OdRxObject pObj) {//  OdSmartPtr<OdDgModel>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_cast(OdRxObject.getCPtr(pObj));
 
          OdDgModel ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgModel)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgModel),ptr, true));
                ret = (OdDgModel)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgModel),ptr, false);
          }
          else
          {
                  ret = (OdDgModel)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgModel),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.OdDgModel_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.OdDgModel_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.OdDgModel_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public new static OdDgModel createObject() {//  OdSmartPtr<OdDgModel>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createObject();
 
          OdDgModel ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgModel)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgModel),ptr, true));
                ret = (OdDgModel)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgModel),ptr, false);
          }
          else
          {
                  ret = (OdDgModel)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgModel),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public class StorageUnitDescription : global::System.IDisposable {
    private Object locker = new Object();
    private HandleRef swigCPtr;
    protected bool swigCMemOwn;
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public StorageUnitDescription(IntPtr cPtr, bool cMemoryOwn) {
      swigCMemOwn = cMemoryOwn;
      swigCPtr = new HandleRef(this, cPtr);
    }
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public static HandleRef getCPtr(StorageUnitDescription obj) {
      return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~StorageUnitDescription() {
      Dispose(false);
    }
  
    public void Dispose() {
      Dispose(true);
      global::System.GC.SuppressFinalize(this);
    }
  
    protected virtual void Dispose(bool disposing) {
      lock(this) {
        if (swigCPtr.Handle != global::System.IntPtr.Zero) {
          if (swigCMemOwn) {
            swigCMemOwn = false;
            TG_DbPINVOKE.delete_OdDgModel_StorageUnitDescription(swigCPtr); // NESTED_DTOR_CSHARP
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public OdDgModel.UnitBase m_base {
      set {
        TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_base_set(swigCPtr, (int)value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        OdDgModel.UnitBase ret = (OdDgModel.UnitBase)TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_base_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public OdDgModel.UnitSystem m_system {
      set {
        TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_system_set(swigCPtr, (int)value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        OdDgModel.UnitSystem ret = (OdDgModel.UnitSystem)TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_system_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public double m_numerator {
      set {
        TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_numerator_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        double ret = TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_numerator_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public double m_denominator {
      set {
        TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_denominator_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        double ret = TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_denominator_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public double m_uorPerStorageUnit {
      set {
        TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_uorPerStorageUnit_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        double ret = TG_DbPINVOKE.OdDgModel_StorageUnitDescription_m_uorPerStorageUnit_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public StorageUnitDescription() : this(TG_DbPINVOKE.new_OdDgModel_StorageUnitDescription(), true) {
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    }
  
  }
 
  public class UnitDescription : global::System.IDisposable {
    private Object locker = new Object();
    private HandleRef swigCPtr;
    protected bool swigCMemOwn;
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public UnitDescription(IntPtr cPtr, bool cMemoryOwn) {
      swigCMemOwn = cMemoryOwn;
      swigCPtr = new HandleRef(this, cPtr);
    }
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public static HandleRef getCPtr(UnitDescription obj) {
      return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~UnitDescription() {
      Dispose(false);
    }
  
    public void Dispose() {
      Dispose(true);
      global::System.GC.SuppressFinalize(this);
    }
  
    protected virtual void Dispose(bool disposing) {
      lock(this) {
        if (swigCPtr.Handle != global::System.IntPtr.Zero) {
          if (swigCMemOwn) {
            swigCMemOwn = false;
            TG_DbPINVOKE.delete_OdDgModel_UnitDescription(swigCPtr); // NESTED_DTOR_CSHARP
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public OdDgModel.UnitBase m_base {
      set {
        TG_DbPINVOKE.OdDgModel_UnitDescription_m_base_set(swigCPtr, (int)value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        OdDgModel.UnitBase ret = (OdDgModel.UnitBase)TG_DbPINVOKE.OdDgModel_UnitDescription_m_base_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public OdDgModel.UnitSystem m_system {
      set {
        TG_DbPINVOKE.OdDgModel_UnitDescription_m_system_set(swigCPtr, (int)value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        OdDgModel.UnitSystem ret = (OdDgModel.UnitSystem)TG_DbPINVOKE.OdDgModel_UnitDescription_m_system_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public double m_numerator {
      set {
        TG_DbPINVOKE.OdDgModel_UnitDescription_m_numerator_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        double ret = TG_DbPINVOKE.OdDgModel_UnitDescription_m_numerator_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public double m_denominator {
      set {
        TG_DbPINVOKE.OdDgModel_UnitDescription_m_denominator_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        double ret = TG_DbPINVOKE.OdDgModel_UnitDescription_m_denominator_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public String m_name {
      set { // OdString csvarin
        TG_DbPINVOKE.OdDgModel_UnitDescription_m_name_set(swigCPtr, value);
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
  
    get { // OdString csvarout
        string ret = TG_DbPINVOKE.OdDgModel_UnitDescription_m_name_get(swigCPtr);
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
  
    }
  
    public UnitDescription() : this(TG_DbPINVOKE.new_OdDgModel_UnitDescription__SWIG_0(), true) {
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    }
  
    public UnitDescription(OdDgModel.UnitDescription obj) : this(TG_DbPINVOKE.new_OdDgModel_UnitDescription__SWIG_1(OdDgModel.UnitDescription.getCPtr(obj)), true) {
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    }
  
    public OdDgModel.UnitDescription Assign(OdDgModel.UnitDescription obj) {
      OdDgModel.UnitDescription ret = new OdDgModel.UnitDescription(TG_DbPINVOKE.OdDgModel_UnitDescription_Assign(swigCPtr, OdDgModel.UnitDescription.getCPtr(obj)), false);
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    }
  
  }
 
  public OdDgElementId addElement(OdDgElement pElement) {
    OdDgElementId ret = new OdDgElementId(TG_DbPINVOKE.OdDgModel_addElement(swigCPtr, OdDgElement.getCPtr(pElement)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdDgElementIterator createGraphicsElementsIterator(bool atBeginning, bool skipDeleted) {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createGraphicsElementsIterator__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 createGraphicsElementsIterator(bool atBeginning) {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createGraphicsElementsIterator__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 createGraphicsElementsIterator() {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createGraphicsElementsIterator__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 OdDgElementIterator createControlElementsIterator(bool atBeginning, bool skipDeleted) {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createControlElementsIterator__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 createControlElementsIterator(bool atBeginning) {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createControlElementsIterator__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 createControlElementsIterator() {//  OdDgElementIteratorPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_createControlElementsIterator__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 UInt32 getEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgModel_getEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public override UInt32 subSetAttributes(OdGiDrawableTraits pTraits) { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgModel_subSetAttributes(swigCPtr, OdGiDrawableTraits.getCPtr(pTraits)); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public override bool subWorldDraw(OdGiWorldDraw pWd) {
    bool ret = TG_DbPINVOKE.OdDgModel_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.OdDgModel_subViewportDraw(swigCPtr, OdGiViewportDraw.getCPtr(pVd));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdResult subGetGeomExtents(OdGeExtents3d extent) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgModel_subGetGeomExtents__SWIG_0(swigCPtr, OdGeExtents3d.getCPtr(extent));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult subGetGeomExtents(OdDgElementId idView, OdGeExtents3d extents) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgModel_subGetGeomExtents__SWIG_1(swigCPtr, OdDgElementId.getCPtr(idView), OdGeExtents3d.getCPtr(extents));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void fitToView() {
    TG_DbPINVOKE.OdDgModel_fitToView(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.Type getType() {
    OdDgModel.Type ret = (OdDgModel.Type)TG_DbPINVOKE.OdDgModel_getType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setType(OdDgModel.Type val) {
    TG_DbPINVOKE.OdDgModel_setType(swigCPtr, (int)val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getName() {
  string ret = TG_DbPINVOKE.OdDgModel_getName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setName(String name) {
    TG_DbPINVOKE.OdDgModel_setName(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.OdDgUnitsFormat getWorkingUnitFormat() {
    OdDgModel.OdDgUnitsFormat ret = (OdDgModel.OdDgUnitsFormat)TG_DbPINVOKE.OdDgModel_getWorkingUnitFormat(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setWorkingUnitFormat(OdDgModel.OdDgUnitsFormat uFormat) {
    TG_DbPINVOKE.OdDgModel_setWorkingUnitFormat(swigCPtr, (int)uFormat);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.OdDgUnitsAccuracy getWorkingUnitAccuracy() {
    OdDgModel.OdDgUnitsAccuracy ret = (OdDgModel.OdDgUnitsAccuracy)TG_DbPINVOKE.OdDgModel_getWorkingUnitAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setWorkingUnitAccuracy(OdDgModel.OdDgUnitsAccuracy uAccuracy) {
    TG_DbPINVOKE.OdDgModel_setWorkingUnitAccuracy(swigCPtr, (int)uAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.OdDgAngleFormat getAngleFormat() {
    OdDgModel.OdDgAngleFormat ret = (OdDgModel.OdDgAngleFormat)TG_DbPINVOKE.OdDgModel_getAngleFormat(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAngleFormat(OdDgModel.OdDgAngleFormat uFormat) {
    TG_DbPINVOKE.OdDgModel_setAngleFormat(swigCPtr, (int)uFormat);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.OdDgAngleAccuracy getAngleAccuracy() {
    OdDgModel.OdDgAngleAccuracy ret = (OdDgModel.OdDgAngleAccuracy)TG_DbPINVOKE.OdDgModel_getAngleAccuracy(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAngleAccuracy(OdDgModel.OdDgAngleAccuracy uAccuracy) {
    TG_DbPINVOKE.OdDgModel_setAngleAccuracy(swigCPtr, (int)uAccuracy);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.OdDgAngleDirectionMode getAngleDirectionMode() {
    OdDgModel.OdDgAngleDirectionMode ret = (OdDgModel.OdDgAngleDirectionMode)TG_DbPINVOKE.OdDgModel_getAngleDirectionMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAngleDirectionMode(OdDgModel.OdDgAngleDirectionMode uMode) {
    TG_DbPINVOKE.OdDgModel_setAngleDirectionMode(swigCPtr, (int)uMode);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getAngleDirectionClockwiseFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getAngleDirectionClockwiseFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAngleDirectionClockwiseFlag(bool bSet) {
    TG_DbPINVOKE.OdDgModel_setAngleDirectionClockwiseFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getDescription() {
  string ret = TG_DbPINVOKE.OdDgModel_getDescription(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setDescription(String name) {
    TG_DbPINVOKE.OdDgModel_setDescription(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.AcsType getAcsType() {
    OdDgModel.AcsType ret = (OdDgModel.AcsType)TG_DbPINVOKE.OdDgModel_getAcsType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAcsType(OdDgModel.AcsType val) {
    TG_DbPINVOKE.OdDgModel_setAcsType(swigCPtr, (int)val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getAcsOrigin() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgModel_getAcsOrigin(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAcsOrigin(OdGePoint3d origin) {
    TG_DbPINVOKE.OdDgModel_setAcsOrigin(swigCPtr, OdGePoint3d.getCPtr(origin));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeMatrix3d getAcsRotation() {
    OdGeMatrix3d ret = new OdGeMatrix3d(TG_DbPINVOKE.OdDgModel_getAcsRotation(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAcsRotation(OdGeMatrix3d rotation) {
    TG_DbPINVOKE.OdDgModel_setAcsRotation(swigCPtr, OdGeMatrix3d.getCPtr(rotation));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgElementId getAcsElementId() {
    OdDgElementId ret = new OdDgElementId(TG_DbPINVOKE.OdDgModel_getAcsElementId(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAcsElementId(OdDgElementId id) {
    TG_DbPINVOKE.OdDgModel_setAcsElementId(swigCPtr, OdDgElementId.getCPtr(id));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getGlobalOrigin() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgModel_getGlobalOrigin(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGlobalOrigin(OdGePoint3d origin) {
    TG_DbPINVOKE.OdDgModel_setGlobalOrigin(swigCPtr, OdGePoint3d.getCPtr(origin));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getUnitLockFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getUnitLockFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setUnitLockFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setUnitLockFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getIsometricLockFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getIsometricLockFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setIsometricLockFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setIsometricLockFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt16 getIsometricPlane() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgModel_getIsometricPlane(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setIsometricPlane(UInt16 val) {
    TG_DbPINVOKE.OdDgModel_setIsometricPlane(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool changeDrawingOrderOfElements(OdDgElementIdArray arrRelatedElements, OdDgElementIdArray arrRelatingElements, OdDgChangeDrawingOrderMode uMode) {
    bool ret = TG_DbPINVOKE.OdDgModel_changeDrawingOrderOfElements(swigCPtr, OdDgElementIdArray.getCPtr(arrRelatedElements), OdDgElementIdArray.getCPtr(arrRelatingElements), (int)uMode);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool getGridLockFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getGridLockFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGridLockFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setGridLockFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getIsometricGridFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getIsometricGridFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setIsometricGridFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setIsometricGridFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getGridMaster() {
    double ret = TG_DbPINVOKE.OdDgModel_getGridMaster(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGridMaster(double dGridMaster) {
    TG_DbPINVOKE.OdDgModel_setGridMaster(swigCPtr, dGridMaster);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getGridReference() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgModel_getGridReference(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setGridReference(UInt32 uGridReference) {
    TG_DbPINVOKE.OdDgModel_setGridReference(swigCPtr, uGridReference /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getGridRatio() {
    double ret = TG_DbPINVOKE.OdDgModel_getGridRatio(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGridRatio(double dGridRatio) {
    TG_DbPINVOKE.OdDgModel_setGridRatio(swigCPtr, dGridRatio);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getGridAngle() {
    double ret = TG_DbPINVOKE.OdDgModel_getGridAngle(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGridAngle(double dGridAngle) {
    TG_DbPINVOKE.OdDgModel_setGridAngle(swigCPtr, dGridAngle);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint2d getGridBase() {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgModel_getGridBase(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGridBase(OdGePoint2d ptGridBase) {
    TG_DbPINVOKE.OdDgModel_setGridBase(swigCPtr, OdGePoint2d.getCPtr(ptGridBase));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.OdDgGridOrientationType getGridOrientation() {
    OdDgModel.OdDgGridOrientationType ret = (OdDgModel.OdDgGridOrientationType)TG_DbPINVOKE.OdDgModel_getGridOrientation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setGridOrientation(OdDgModel.OdDgGridOrientationType uOrientation) {
    TG_DbPINVOKE.OdDgModel_setGridOrientation(swigCPtr, (int)uOrientation);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getModelIs3dFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getModelIs3dFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setModelIs3dFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setModelIs3dFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getHiddenFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getHiddenFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setHiddenFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setHiddenFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override bool getLockedFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getLockedFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void setLockedFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setLockedFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getNotInCellListFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getNotInCellListFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setNotInCellListFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setNotInCellListFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getUseBackgroundColorFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getUseBackgroundColorFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setUseBackgroundColorFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setUseBackgroundColorFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getAnnotationLineScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getAnnotationLineScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAnnotationLineScaleFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setAnnotationLineScaleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getAnnotationCellFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getAnnotationCellFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAnnotationCellFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setAnnotationCellFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getAutoUpdateFieldsFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getAutoUpdateFieldsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setAutoUpdateFieldsFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setAutoUpdateFieldsFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getPropagateAnnotationScaleOffFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getPropagateAnnotationScaleOffFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setPropagateAnnotationScaleOffFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setPropagateAnnotationScaleOffFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getCompoundLineScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getCompoundLineScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCompoundLineScaleFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setCompoundLineScaleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getLastSaveTime() {
    double ret = TG_DbPINVOKE.OdDgModel_getLastSaveTime(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setLastSaveTime(double val) {
    TG_DbPINVOKE.OdDgModel_setLastSaveTime(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt16 getProperties() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgModel_getProperties(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setProperties(UInt16 val) {
    TG_DbPINVOKE.OdDgModel_setProperties(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Int32 getStyle() { 
// test csout
 /*SIMPLETYPE*/
     Int32 ret = TG_DbPINVOKE.OdDgModel_getStyle(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setStyle(Int32 val) {
    TG_DbPINVOKE.OdDgModel_setStyle(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getWeight() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgModel_getWeight(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setWeight(UInt32 val) {
    TG_DbPINVOKE.OdDgModel_setWeight(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getColorIndex() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgModel_getColorIndex(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setColorIndex(UInt32 val) {
    TG_DbPINVOKE.OdDgModel_setColorIndex(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.CellType getCellType() {
    OdDgModel.CellType ret = (OdDgModel.CellType)TG_DbPINVOKE.OdDgModel_getCellType(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCellType(OdDgModel.CellType val) {
    TG_DbPINVOKE.OdDgModel_setCellType(swigCPtr, (int)val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgGraphicsElement.Class getClass() {
    OdDgGraphicsElement.Class ret = (OdDgGraphicsElement.Class)TG_DbPINVOKE.OdDgModel_getClass(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setClass(OdDgGraphicsElement.Class newClass) {
    TG_DbPINVOKE.OdDgModel_setClass(swigCPtr, (int)newClass);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getSolidExtent() {
    double ret = TG_DbPINVOKE.OdDgModel_getSolidExtent(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setSolidExtent(double val) {
    TG_DbPINVOKE.OdDgModel_setSolidExtent(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getInsertionBase() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgModel_getInsertionBase(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setInsertionBase(OdGePoint3d base_) {
    TG_DbPINVOKE.OdDgModel_setInsertionBase(swigCPtr, OdGePoint3d.getCPtr(base_));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getLinestyleScale() {
    double ret = TG_DbPINVOKE.OdDgModel_getLinestyleScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setLinestyleScale(double val) {
    TG_DbPINVOKE.OdDgModel_setLinestyleScale(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getBackground() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgModel_getBackground(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setBackground(UInt32 val) {
    TG_DbPINVOKE.OdDgModel_setBackground(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.WorkingUnit getWorkingUnit() {
    OdDgModel.WorkingUnit ret = (OdDgModel.WorkingUnit)TG_DbPINVOKE.OdDgModel_getWorkingUnit(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setWorkingUnit(OdDgModel.WorkingUnit eUnit) {
    TG_DbPINVOKE.OdDgModel_setWorkingUnit(swigCPtr, (int)eUnit);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void getStorageUnit(OdDgModel.StorageUnitDescription description) {
    TG_DbPINVOKE.OdDgModel_getStorageUnit(swigCPtr, OdDgModel.StorageUnitDescription.getCPtr(description));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setStorageUnit(OdDgModel.StorageUnitDescription description) {
    TG_DbPINVOKE.OdDgModel_setStorageUnit(swigCPtr, OdDgModel.StorageUnitDescription.getCPtr(description));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void getMasterUnit(OdDgModel.UnitDescription description) {
    TG_DbPINVOKE.OdDgModel_getMasterUnit__SWIG_0(swigCPtr, OdDgModel.UnitDescription.getCPtr(description));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setMasterUnit(OdDgModel.UnitDescription description) {
    TG_DbPINVOKE.OdDgModel_setMasterUnit__SWIG_0(swigCPtr, OdDgModel.UnitDescription.getCPtr(description));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.UnitMeasure getMasterUnit() {
    OdDgModel.UnitMeasure ret = (OdDgModel.UnitMeasure)TG_DbPINVOKE.OdDgModel_getMasterUnit__SWIG_1(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setMasterUnit(OdDgModel.UnitMeasure eUnitMeasure) {
    TG_DbPINVOKE.OdDgModel_setMasterUnit__SWIG_1(swigCPtr, (int)eUnitMeasure);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void getSubUnit(OdDgModel.UnitDescription description) {
    TG_DbPINVOKE.OdDgModel_getSubUnit__SWIG_0(swigCPtr, OdDgModel.UnitDescription.getCPtr(description));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setSubUnit(OdDgModel.UnitDescription description) {
    TG_DbPINVOKE.OdDgModel_setSubUnit__SWIG_0(swigCPtr, OdDgModel.UnitDescription.getCPtr(description));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgModel.UnitMeasure getSubUnit() {
    OdDgModel.UnitMeasure ret = (OdDgModel.UnitMeasure)TG_DbPINVOKE.OdDgModel_getSubUnit__SWIG_1(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setSubUnit(OdDgModel.UnitMeasure eUnitMeasure) {
    TG_DbPINVOKE.OdDgModel_setSubUnit__SWIG_1(swigCPtr, (int)eUnitMeasure);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public static void fillUnitDescriptor(OdDgModel.UnitMeasure source, OdDgModel.UnitDescription result) {
    TG_DbPINVOKE.OdDgModel_fillUnitDescriptor((int)source, OdDgModel.UnitDescription.getCPtr(result));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public static void fillUnitMeasure(OdDgModel.UnitDescription description, out OdDgModel.UnitMeasure measure) {
    TG_DbPINVOKE.OdDgModel_fillUnitMeasure(OdDgModel.UnitDescription.getCPtr(description), out measure);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getMeasuresConversion(OdDgModel.WorkingUnit from, OdDgModel.WorkingUnit to) {
    double ret = TG_DbPINVOKE.OdDgModel_getMeasuresConversion(swigCPtr, (int)from, (int)to);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double convertUORsToWorkingUnits(double uorsDistance) {
    double ret = TG_DbPINVOKE.OdDgModel_convertUORsToWorkingUnits__SWIG_0(swigCPtr, uorsDistance);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double convertWorkingUnitsToUORs(double workingUnitsDistance) {
    double ret = TG_DbPINVOKE.OdDgModel_convertWorkingUnitsToUORs__SWIG_0(swigCPtr, workingUnitsDistance);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGePoint2d convertUORsToWorkingUnits(OdGePoint2d uorsPoint) {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgModel_convertUORsToWorkingUnits__SWIG_1(swigCPtr, OdGePoint2d.getCPtr(uorsPoint)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGePoint2d convertWorkingUnitsToUORs(OdGePoint2d workingUnitsPoint) {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgModel_convertWorkingUnitsToUORs__SWIG_1(swigCPtr, OdGePoint2d.getCPtr(workingUnitsPoint)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGePoint3d convertUORsToWorkingUnits(OdGePoint3d uorsPoint) {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgModel_convertUORsToWorkingUnits__SWIG_2(swigCPtr, OdGePoint3d.getCPtr(uorsPoint)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGePoint3d convertWorkingUnitsToUORs(OdGePoint3d workingUnitsPoint) {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgModel_convertWorkingUnitsToUORs__SWIG_2(swigCPtr, OdGePoint3d.getCPtr(workingUnitsPoint)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeVector2d convertUORsToWorkingUnits(OdGeVector2d uorsVector) {
    OdGeVector2d ret = new OdGeVector2d(TG_DbPINVOKE.OdDgModel_convertUORsToWorkingUnits__SWIG_3(swigCPtr, OdGeVector2d.getCPtr(uorsVector).Handle), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeVector2d convertWorkingUnitsToUORs(OdGeVector2d workingUnitsVector) {
    OdGeVector2d ret = new OdGeVector2d(TG_DbPINVOKE.OdDgModel_convertWorkingUnitsToUORs__SWIG_3(swigCPtr, OdGeVector2d.getCPtr(workingUnitsVector).Handle), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeVector3d convertUORsToWorkingUnits(OdGeVector3d uorsVector) {
    OdGeVector3d ret = new OdGeVector3d(TG_DbPINVOKE.OdDgModel_convertUORsToWorkingUnits__SWIG_4(swigCPtr, OdGeVector3d.getCPtr(uorsVector)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdGeVector3d convertWorkingUnitsToUORs(OdGeVector3d workingUnitsVector) {
    OdGeVector3d ret = new OdGeVector3d(TG_DbPINVOKE.OdDgModel_convertWorkingUnitsToUORs__SWIG_4(swigCPtr, OdGeVector3d.getCPtr(workingUnitsVector)), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual double getAnnotationScale() {
    double ret = TG_DbPINVOKE.OdDgModel_getAnnotationScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScale(double dScale) {
    TG_DbPINVOKE.OdDgModel_setAnnotationScale(swigCPtr, dScale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAnnotationScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgModel_getAnnotationScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnnotationScaleFlag(bool val) {
    TG_DbPINVOKE.OdDgModel_setAnnotationScaleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgGeoDataInfo getGeoData(OpenMode uMode) {//  OdDgGeoDataInfoPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_getGeoData__SWIG_0(swigCPtr, (int)uMode);
 
          OdDgGeoDataInfo ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgGeoDataInfo)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgGeoDataInfo),ptr, true));
                ret = (OdDgGeoDataInfo)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgGeoDataInfo),ptr, false);
          }
          else
          {
                  ret = (OdDgGeoDataInfo)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgGeoDataInfo),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual OdDgGeoDataInfo getGeoData() {//  OdDgGeoDataInfoPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_getGeoData__SWIG_1(swigCPtr);
 
          OdDgGeoDataInfo ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgGeoDataInfo)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgGeoDataInfo),ptr, true));
                ret = (OdDgGeoDataInfo)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgGeoDataInfo),ptr, false);
          }
          else
          {
                  ret = (OdDgGeoDataInfo)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgGeoDataInfo),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual void setGeoData(OdDgGeoDataInfo pGeoDataInfo, OdDgGeoDataReprojectionSettings reprojectionSettings, OdDgModel.OdDgGeoDataCoordinateSystemChangeAction uAction) {
    TG_DbPINVOKE.OdDgModel_setGeoData__SWIG_0(swigCPtr, OdDgGeoDataInfo.getCPtr(pGeoDataInfo), OdDgGeoDataReprojectionSettings.getCPtr(reprojectionSettings), (int)uAction);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setGeoData(OdDgGeoDataInfo pGeoDataInfo, OdDgGeoDataReprojectionSettings reprojectionSettings) {
    TG_DbPINVOKE.OdDgModel_setGeoData__SWIG_1(swigCPtr, OdDgGeoDataInfo.getCPtr(pGeoDataInfo), OdDgGeoDataReprojectionSettings.getCPtr(reprojectionSettings));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool isGlobalOriginEnabled() {
    bool ret = TG_DbPINVOKE.OdDgModel_isGlobalOriginEnabled(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void enableGlobalOriginUsage(bool bEnable) {
    TG_DbPINVOKE.OdDgModel_enableGlobalOriginUsage__SWIG_0(swigCPtr, bEnable);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void enableGlobalOriginUsage() {
    TG_DbPINVOKE.OdDgModel_enableGlobalOriginUsage__SWIG_1(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgElementId createViewGroup() {
    OdDgElementId ret = new OdDgElementId(TG_DbPINVOKE.OdDgModel_createViewGroup(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdDgElementId getViewGroup(bool bCreateIfNoViewGroupsAssigned) {
    OdDgElementId ret = new OdDgElementId(TG_DbPINVOKE.OdDgModel_getViewGroup__SWIG_0(swigCPtr, bCreateIfNoViewGroupsAssigned), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdDgElementId getViewGroup() {
    OdDgElementId ret = new OdDgElementId(TG_DbPINVOKE.OdDgModel_getViewGroup__SWIG_1(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override void dgnIn(OdDgFiler pFiler) {
    TG_DbPINVOKE.OdDgModel_dgnIn(swigCPtr, OdDgFiler.getCPtr(pFiler));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void dgnOut(OdDgFiler pFiler) {
    TG_DbPINVOKE.OdDgModel_dgnOut(swigCPtr, OdDgFiler.getCPtr(pFiler));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool merge(OdDgModel pModel, OdGeMatrix3d matTransform, DuplicateRecordCloning uDuplicateRecordCloning) {
    bool ret = TG_DbPINVOKE.OdDgModel_merge__SWIG_0(swigCPtr, OdDgModel.getCPtr(pModel), OdGeMatrix3d.getCPtr(matTransform), (int)uDuplicateRecordCloning);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool merge(OdDgModel pModel, OdGeMatrix3d matTransform) {
    bool ret = TG_DbPINVOKE.OdDgModel_merge__SWIG_1(swigCPtr, OdDgModel.getCPtr(pModel), OdGeMatrix3d.getCPtr(matTransform));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool merge(OdDgModel pModel) {
    bool ret = TG_DbPINVOKE.OdDgModel_merge__SWIG_2(swigCPtr, OdDgModel.getCPtr(pModel));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool bind(OdDgReferenceAttachmentHeader pXRef, OdDgElementId idView, DuplicateRecordCloning uDuplicateRecordCloning, bool bApplyReferenceColor, bool bApplyClipData, bool bBindToCellHeader) {
    bool ret = TG_DbPINVOKE.OdDgModel_bind__SWIG_0(swigCPtr, OdDgReferenceAttachmentHeader.getCPtr(pXRef), OdDgElementId.getCPtr(idView), (int)uDuplicateRecordCloning, bApplyReferenceColor, bApplyClipData, bBindToCellHeader);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool bind(OdDgReferenceAttachmentHeader pXRef, OdDgElementId idView, DuplicateRecordCloning uDuplicateRecordCloning, bool bApplyReferenceColor, bool bApplyClipData) {
    bool ret = TG_DbPINVOKE.OdDgModel_bind__SWIG_1(swigCPtr, OdDgReferenceAttachmentHeader.getCPtr(pXRef), OdDgElementId.getCPtr(idView), (int)uDuplicateRecordCloning, bApplyReferenceColor, bApplyClipData);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool bind(OdDgReferenceAttachmentHeader pXRef, OdDgElementId idView, DuplicateRecordCloning uDuplicateRecordCloning, bool bApplyReferenceColor) {
    bool ret = TG_DbPINVOKE.OdDgModel_bind__SWIG_2(swigCPtr, OdDgReferenceAttachmentHeader.getCPtr(pXRef), OdDgElementId.getCPtr(idView), (int)uDuplicateRecordCloning, bApplyReferenceColor);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool bind(OdDgReferenceAttachmentHeader pXRef, OdDgElementId idView, DuplicateRecordCloning uDuplicateRecordCloning) {
    bool ret = TG_DbPINVOKE.OdDgModel_bind__SWIG_3(swigCPtr, OdDgReferenceAttachmentHeader.getCPtr(pXRef), OdDgElementId.getCPtr(idView), (int)uDuplicateRecordCloning);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool bind(OdDgReferenceAttachmentHeader pXRef, OdDgElementId idView) {
    bool ret = TG_DbPINVOKE.OdDgModel_bind__SWIG_4(swigCPtr, OdDgReferenceAttachmentHeader.getCPtr(pXRef), OdDgElementId.getCPtr(idView));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool bind(OdDgReferenceAttachmentHeader pXRef) {
    bool ret = TG_DbPINVOKE.OdDgModel_bind__SWIG_5(swigCPtr, OdDgReferenceAttachmentHeader.getCPtr(pXRef));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public override OdResult subErase(bool erasing) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgModel_subErase(swigCPtr, erasing);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdDgElement subDeepClone(OdDgIdMapping ownerIdMap) {//  OdDgElementPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgModel_subDeepClone(swigCPtr, OdDgIdMapping.getCPtr(ownerIdMap));
 
          OdDgElement ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgElement)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElement),ptr, true));
                ret = (OdDgElement)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElement),ptr, false);
          }
          else
          {
                  ret = (OdDgElement)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgElement),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public override void subHandOverTo(OdDgElement pNewElement) {
    TG_DbPINVOKE.OdDgModel_subHandOverTo(swigCPtr, OdDgElement.getCPtr(pNewElement));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void subSwapIdWith(OdDgElementId otherId) {
    TG_DbPINVOKE.OdDgModel_subSwapIdWith(swigCPtr, OdDgElementId.getCPtr(otherId));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  protected static string getRealClassName(IntPtr ptr) {
    string ret = TG_DbPINVOKE.OdDgModel_getRealClassName(ptr /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
     public  virtual  void vb_gripStatus(Teigha.TG.OdDgElement.GripStat status) { this.gripStatus(status); }
  
     public  virtual  Teigha.Core.OdGiDrawable.DrawableType vb_drawableType() { return this.drawableType(); }
  
  public enum Type {
    kDesignModel = 0,
    kSheetModel = 1,
    kExtractionModel = 2,
    kDrawingModel = 3
  }
 
  public enum AcsType {
    kGeographic = 0,
    kRectangular = 1,
    kCylindrical = 2,
    kSpherical = 3,
    kMilitaryGrid = 4,
    kMilitaryGridWGS84 = 5
  }
 
  public enum WorkingUnit {
    kWuUnitOfResolution = 0,
    kWuStorageUnit = 1,
    kWuWorldUnit = 2,
    kWuMasterUnit = 3,
    kWuSubUnit = 4
  }
 
  public enum UnitBase {
    kNone = 0,
    kMeter = 1,
    kDegree = 2
  }
 
  public enum UnitSystem {
    kCustom = 0,
    kEnglish = 1,
    kMetric = 2
  }
 
  public enum OdDgGeoDataCoordinateSystemChangeAction {
    kNoAction = 0,
    kChangeStorageUnits = 1,
    kChangeMasterUnits = 2,
    kReprojectCoordSystem = 3
  }
 
  public enum UnitMeasure {
    kUndefinedMeasure,
    kMegameters,
    kKilometers,
    kMeters,
    kDecimeters,
    kCentimeters,
    kMillimeters,
    kMicrometers,
    kNanometers,
    kPicometers,
    kMiles,
    kYards,
    kFeet,
    kInches,
    kMils,
    kUSSurveyFeet,
    kMicroinches
  }
 
  public enum OdDgUnitsFormat {
    kMu_Su = 0,
    kMu = 1,
    kMu_Su_Pu = 2
  }
 
  public enum OdDgAngleFormat {
    kAngle_D = 1,
    kAngle_DM = 2,
    kAngle_DMS = 3,
    kAngle_Gradian = 4,
    kAngle_Radian = 5
  }
 
  public enum OdDgUnitsAccuracy {
    kAccuracyNone = 0,
    kAccuracyDecimal1 = 1,
    kAccuracyDecimal2 = 2,
    kAccuracyDecimal3 = 3,
    kAccuracyDecimal4 = 4,
    kAccuracyDecimal5 = 5,
    kAccuracyDecimal6 = 6,
    kAccuracyDecimal7 = 7,
    kAccuracyDecimal8 = 8,
    kAccuracyFractional2 = 9,
    kAccuracyFractional4 = 10,
    kAccuracyFractional8 = 11,
    kAccuracyFractional16 = 12,
    kAccuracyFractional32 = 13,
    kAccuracyFractional64 = 14,
    kAccuracyFractional128 = 15,
    kAccuracyFractional256 = 16,
    kAccuracyExponential1 = 17,
    kAccuracyExponential2 = 18,
    kAccuracyExponential3 = 19,
    kAccuracyExponential4 = 20,
    kAccuracyExponential5 = 21,
    kAccuracyExponential6 = 22,
    kAccuracyExponential7 = 23,
    kAccuracyExponential8 = 24
  }
 
  public enum OdDgAngleDirectionMode {
    kAzimut = 1,
    kBearing = 2
  }
 
  public enum OdDgAngleAccuracy {
    kAngleAccuracy0 = 0x00,
    kAngleAccuracy1 = 0x01,
    kAngleAccuracy2 = 0x02,
    kAngleAccuracy3 = 0x03,
    kAngleAccuracy4 = 0x04,
    kAngleAccuracy5 = 0x05,
    kAngleAccuracy6 = 0x06,
    kAngleAccuracy7 = 0x07,
    kAngleAccuracy8 = 0x08
  }
 
  public enum CellType {
    kNormalGraphics = 0,
    kMenu = 3,
    kPoint = 7,
    kParametric = 8
  }
 
  public enum OdDgGridOrientationType {
    kView = 0,
    kTop = 1,
    kRight = 2,
    kFront = 3,
    kACS = 4
  }
 
}
 
}