OdDgReferenceAttachmentHeader.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 OdDgReferenceAttachmentHeader : OdDgElement {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDgReferenceAttachmentHeader(IntPtr cPtr, bool cMemoryOwn) : base(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDgReferenceAttachmentHeader 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_OdDgReferenceAttachmentHeader(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.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_getElementSubType(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public static OdDgReferenceAttachmentHeader cast(OdRxObject pObj) {//  OdSmartPtr<OdDgReferenceAttachmentHeader>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_cast(OdRxObject.getCPtr(pObj));
 
          OdDgReferenceAttachmentHeader ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgReferenceAttachmentHeader)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgReferenceAttachmentHeader),ptr, true));
                ret = (OdDgReferenceAttachmentHeader)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgReferenceAttachmentHeader),ptr, false);
          }
          else
          {
                  ret = (OdDgReferenceAttachmentHeader)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgReferenceAttachmentHeader),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.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public new static OdDgReferenceAttachmentHeader createObject() {//  OdSmartPtr<OdDgReferenceAttachmentHeader>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_createObject();
 
          OdDgReferenceAttachmentHeader ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgReferenceAttachmentHeader)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgReferenceAttachmentHeader),ptr, true));
                ret = (OdDgReferenceAttachmentHeader)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgReferenceAttachmentHeader),ptr, false);
          }
          else
          {
                  ret = (OdDgReferenceAttachmentHeader)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgReferenceAttachmentHeader),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public String getFileName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getFileName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setFileName(String filename) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setFileName(swigCPtr, filename);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getFullFileName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getFullFileName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setFullFileName(String filename) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setFullFileName(swigCPtr, filename);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getModelName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getModelName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setModelName(String name) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setModelName(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getLogicalName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLogicalName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setLogicalName(String name) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLogicalName(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getDescription() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDescription(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setDescription(String description) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDescription(swigCPtr, description);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getRevisionName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getRevisionName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setRevisionName(String name) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setRevisionName(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getExtractionModelName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getExtractionModelName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setExtractionModelName(String name) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setExtractionModelName(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public String getNamedGroupName() {
  string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getNamedGroupName(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setNamedGroupName(String name) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setNamedGroupName(swigCPtr, name);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getFileNumber() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getFileNumber(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setFileNumber(UInt32 val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setFileNumber(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt32 getPriority() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPriority(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setPriority(UInt32 val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPriority(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt16 getBaseNestDepth() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getBaseNestDepth(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setBaseNestDepth(UInt16 val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setBaseNestDepth(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public UInt16 getNestDepth() { 
// test csout
 /*SIMPLETYPE*/
     UInt16 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getNestDepth(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setNestDepth(UInt16 val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setNestDepth(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getReferenceOrigin() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getReferenceOrigin(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setReferenceOrigin(OdGePoint3d origin) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setReferenceOrigin(swigCPtr, OdGePoint3d.getCPtr(origin));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getMasterOrigin() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getMasterOrigin(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setMasterOrigin(OdGePoint3d origin) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setMasterOrigin(swigCPtr, OdGePoint3d.getCPtr(origin));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeMatrix3d getTransformation() {
    OdGeMatrix3d ret = new OdGeMatrix3d(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getTransformation(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setTransformation(OdGeMatrix3d rotation) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setTransformation(swigCPtr, OdGeMatrix3d.getCPtr(rotation));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getScale() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setScale(double scale) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setScale(swigCPtr, scale);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getEntireScale() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getEntireScale(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public double getZFront() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getZFront(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setZFront(double val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setZFront(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getZBack() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getZBack(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setZBack(double val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setZBack(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getCameraPosition() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getCameraPosition(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCameraPosition(OdGePoint3d pos) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setCameraPosition(swigCPtr, OdGePoint3d.getCPtr(pos));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getCameraFocalLength() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getCameraFocalLength(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setCameraFocalLength(double val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setCameraFocalLength(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override void copyFieldReferencesForWBlockClone(OdDgFiler pFiler) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_copyFieldReferencesForWBlockClone(swigCPtr, OdDgFiler.getCPtr(pFiler));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdResult subErase(bool erasing) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subErase(swigCPtr, erasing);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public UInt32 getClipPointsCount() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getClipPointsCount(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setClipPointsCount(UInt32 count) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipPointsCount(swigCPtr, count /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint2d getClipPoint(UInt32 index) {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getClipPoint(swigCPtr, index /*SIMPLETYPE*/), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setClipPoint(UInt32 index, OdGePoint2d point) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipPoint(swigCPtr, index /*SIMPLETYPE*/, OdGePoint2d.getCPtr(point));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void addClipPoint(OdGePoint2d point) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_addClipPoint(swigCPtr, OdGePoint2d.getCPtr(point));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void deleteClipPoint(UInt32 index) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_deleteClipPoint(swigCPtr, index /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getClipRotationMatrix(OdGeMatrix3d matRotation) {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getClipRotationMatrix(swigCPtr, OdGeMatrix3d.getCPtr(matRotation));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setClipRotationMatrix(OdGeMatrix3d matRotation, bool bRemoveRotation) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipRotationMatrix__SWIG_0(swigCPtr, OdGeMatrix3d.getCPtr(matRotation), bRemoveRotation);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setClipRotationMatrix(OdGeMatrix3d matRotation) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipRotationMatrix__SWIG_1(swigCPtr, OdGeMatrix3d.getCPtr(matRotation));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public void setClipElement(OdDgElementId idClipElement) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipElement(swigCPtr, OdDgElementId.getCPtr(idClipElement));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getCoincidentFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getCoincidentFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setCoincidentFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setCoincidentFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getSnapLockFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getSnapLockFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setSnapLockFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setSnapLockFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLocateLockFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLocateLockFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLocateLockFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLocateLockFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getCompletePathInV7Flag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getCompletePathInV7Flag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setCompletePathInV7Flag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setCompletePathInV7Flag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getAnonymousFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getAnonymousFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setAnonymousFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setAnonymousFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getManipulateAsElementFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getManipulateAsElementFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setManipulateAsElementFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setManipulateAsElementFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getInactiveFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getInactiveFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setInactiveFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setInactiveFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getMissingFileFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getMissingFileFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setMissingFileFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setMissingFileFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getLevelOverride() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLevelOverride(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setLevelOverride(UInt32 val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLevelOverride(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDontDetachOnAllFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDontDetachOnAllFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDontDetachOnAllFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDontDetachOnAllFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getMetadataOnlyFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getMetadataOnlyFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setMetadataOnlyFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setMetadataOnlyFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDisplayFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDisplayFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDisplayFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDisplayFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLineStyleScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLineStyleScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLineStyleScaleFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLineStyleScaleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getHiddenLineFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getHiddenLineFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setHiddenLineFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setHiddenLineFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDisplayHiddenLinesFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDisplayHiddenLinesFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDisplayHiddenLinesFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDisplayHiddenLinesFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getRotateClippingFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getRotateClippingFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setRotateClippingFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setRotateClippingFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getExtendedRefFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getExtendedRefFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setExtendedRefFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setExtendedRefFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getClipBackFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getClipBackFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setClipBackFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipBackFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getClipFrontFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getClipFrontFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setClipFrontFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setClipFrontFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getCameraOnFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getCameraOnFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setCameraOnFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setCameraOnFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getTrueScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getTrueScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTrueScaleFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setTrueScaleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDisplayBoundaryFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDisplayBoundaryFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDisplayBoundaryFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDisplayBoundaryFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getLibraryRefFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLibraryRefFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLibraryRefFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLibraryRefFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDisplayRasterRefsFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDisplayRasterRefsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDisplayRasterRefsFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDisplayRasterRefsFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseAlternateFileFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getUseAlternateFileFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseAlternateFileFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setUseAlternateFileFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseLightsFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getUseLightsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseLightsFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setUseLightsFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getDoNotDisplayAsNestedFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getDoNotDisplayAsNestedFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setDoNotDisplayAsNestedFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setDoNotDisplayAsNestedFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual UInt32 getColorTableUsage() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getColorTableUsage(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setColorTableUsage(UInt32 val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setColorTableUsage(swigCPtr, val /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getViewportFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getViewportFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setViewportFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setViewportFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getScaleByStorageUnitsFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getScaleByStorageUnitsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setScaleByStorageUnitsFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setScaleByStorageUnitsFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getPrintColorAdjustmentFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPrintColorAdjustmentFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrintColorAdjustmentFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPrintColorAdjustmentFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseViewFlagsFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getUseViewFlagsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseViewFlagsFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setUseViewFlagsFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseLevelFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getUseLevelFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseLevelFlag(bool bSet) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setUseLevelFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getUseAnnotationScaleFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getUseAnnotationScaleFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setUseAnnotationScaleFlag(bool val) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setUseAnnotationScaleFlag(swigCPtr, val);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgReferenceAttachmentHeader.OdDgNewLevelDisplyMode getNewLevelDisplayMode() {
    OdDgReferenceAttachmentHeader.OdDgNewLevelDisplyMode ret = (OdDgReferenceAttachmentHeader.OdDgNewLevelDisplyMode)TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getNewLevelDisplayMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setNewLevelDisplayMode(OdDgReferenceAttachmentHeader.OdDgNewLevelDisplyMode uMode) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setNewLevelDisplayMode(swigCPtr, (int)uMode);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgReferenceAttachmentViewFlags getViewFlags(UInt32 uViewIndex) {
    OdDgReferenceAttachmentViewFlags ret = new OdDgReferenceAttachmentViewFlags(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getViewFlags(swigCPtr, uViewIndex /*SIMPLETYPE*/), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setViewFlags(UInt32 uViewIndex, OdDgReferenceAttachmentViewFlags viewFlags) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setViewFlags(swigCPtr, uViewIndex /*SIMPLETYPE*/, OdDgReferenceAttachmentViewFlags.getCPtr(viewFlags));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdRxObject getReferencedDatabase() {//  OdRxObjectPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getReferencedDatabase(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 OdDgModel getReferencedModel() {//  OdDgModelPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getReferencedModel(swigCPtr);
 
          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 void add(OdDgElement pElement) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_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 OdDgLevelTable getLevelTable(OpenMode openMode) {//  OdDgLevelTablePtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLevelTable__SWIG_0(swigCPtr, (int)openMode);
 
          OdDgLevelTable ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgLevelTable)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgLevelTable),ptr, true));
                ret = (OdDgLevelTable)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgLevelTable),ptr, false);
          }
          else
          {
                  ret = (OdDgLevelTable)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgLevelTable),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDgLevelTable getLevelTable() {//  OdDgLevelTablePtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLevelTable__SWIG_1(swigCPtr);
 
          OdDgLevelTable ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgLevelTable)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgLevelTable),ptr, true));
                ret = (OdDgLevelTable)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgLevelTable),ptr, false);
          }
          else
          {
                  ret = (OdDgLevelTable)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgLevelTable),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public override bool subWorldDraw(OdGiWorldDraw pWd) {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_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.OdDgReferenceAttachmentHeader_subViewportDraw(swigCPtr, OdGiViewportDraw.getCPtr(pVd));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override UInt32 subSetAttributes(OdGiDrawableTraits pTraits) { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subSetAttributes(swigCPtr, OdGiDrawableTraits.getCPtr(pTraits)); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void subHighlight(bool bDoIt, OdDgFullSubentPath pSubId, bool highlightAll) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subHighlight__SWIG_0(swigCPtr, bDoIt, OdDgFullSubentPath.getCPtr(pSubId), highlightAll);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void subHighlight(bool bDoIt, OdDgFullSubentPath pSubId) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subHighlight__SWIG_1(swigCPtr, bDoIt, OdDgFullSubentPath.getCPtr(pSubId));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void subHighlight(bool bDoIt) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subHighlight__SWIG_2(swigCPtr, bDoIt);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void subHighlight() {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subHighlight__SWIG_3(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public override OdRxObject clone() {//  OdRxObjectPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_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 OdDgReferenceAttachmentHeader.OdDgReferenceForeignUnits getForeignUnits() {
    OdDgReferenceAttachmentHeader.OdDgReferenceForeignUnits ret = (OdDgReferenceAttachmentHeader.OdDgReferenceForeignUnits)TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getForeignUnits(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setForeignUnits(OdDgReferenceAttachmentHeader.OdDgReferenceForeignUnits iUnits) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setForeignUnits(swigCPtr, (int)iUnits);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public static double getForeignUnitsScale(OdDgReferenceAttachmentHeader.OdDgReferenceForeignUnits iUnits) {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getForeignUnitsScale((int)iUnits);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public OdDgReferenceAttachmentHeader.OdDgLineStyleScaleMode getLineStyleScaleMode() {
    OdDgReferenceAttachmentHeader.OdDgLineStyleScaleMode ret = (OdDgReferenceAttachmentHeader.OdDgLineStyleScaleMode)TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLineStyleScaleMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setLineStyleScaleMode(OdDgReferenceAttachmentHeader.OdDgLineStyleScaleMode iMode) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLineStyleScaleMode(swigCPtr, (int)iMode);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdResult subGetGeomExtents(OdGeExtents3d extents) {
    OdResult ret = (OdResult)TG_DbPINVOKE.OdDgReferenceAttachmentHeader_subGetGeomExtents__SWIG_0(swigCPtr, OdGeExtents3d.getCPtr(extents));
    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.OdDgReferenceAttachmentHeader_subGetGeomExtents__SWIG_1(swigCPtr, OdDgElementId.getCPtr(idView), OdGeExtents3d.getCPtr(extents));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual UInt32 getLevelEntryId() { 
// test csout
 /*SIMPLETYPE*/
     UInt32 ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLevelEntryId(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void setLevelEntryId(UInt32 index) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLevelEntryId(swigCPtr, index /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgElementId getLevelId() {
    OdDgElementId ret = new OdDgElementId(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getLevelId(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setLevelId(OdDgElementId levelId, bool doSubents) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLevelId__SWIG_0(swigCPtr, OdDgElementId.getCPtr(levelId), doSubents);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void setLevelId(OdDgElementId levelId) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setLevelId__SWIG_1(swigCPtr, OdDgElementId.getCPtr(levelId));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void bindNamedView(UInt64 uIdView) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_bindNamedView(swigCPtr, uIdView /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void reload(bool bShowReference) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_reload__SWIG_0(swigCPtr, bShowReference);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void reload() {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_reload__SWIG_1(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void unload(bool bHideReference) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_unload__SWIG_0(swigCPtr, bHideReference);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void unload() {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_unload__SWIG_1(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool isSelfReference() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_isSelfReference(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool isRaster() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_isRaster(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdCmTransparency getTransparency() {
    OdCmTransparency ret = new OdCmTransparency(TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getTransparency(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setTransparency(OdCmTransparency cmTransparency) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setTransparency(swigCPtr, OdCmTransparency.getCPtr(cmTransparency));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdDgReferenceAttachmentHeader.OdDgXRefPaletteModificationMode getPaletteModificationMode() {
    OdDgReferenceAttachmentHeader.OdDgXRefPaletteModificationMode ret = (OdDgReferenceAttachmentHeader.OdDgXRefPaletteModificationMode)TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPaletteModificationMode(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPaletteModificationMode(OdDgReferenceAttachmentHeader.OdDgXRefPaletteModificationMode uMode) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPaletteModificationMode(swigCPtr, (int)uMode);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getPaletteValue() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPaletteValue(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPaletteValue(double dValue) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPaletteValue(swigCPtr, dValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getPaletteSaturation() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPaletteSaturation(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPaletteSaturation(double dSaturation) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPaletteSaturation(swigCPtr, dSaturation);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual double getPaletteHue() {
    double ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPaletteHue(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPaletteHue(double dHue) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPaletteHue(swigCPtr, dHue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getHueFixForAllColorsFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getHueFixForAllColorsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setHueFixForAllColorsFlag(bool bSet) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setHueFixForAllColorsFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual bool getPrintAdjustedColorsFlag() {
    bool ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_getPrintAdjustedColorsFlag(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void setPrintAdjustedColorsFlag(bool bSet) {
    TG_DbPINVOKE.OdDgReferenceAttachmentHeader_setPrintAdjustedColorsFlag(swigCPtr, bSet);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  protected static string getRealClassName(IntPtr ptr) {
    string ret = TG_DbPINVOKE.OdDgReferenceAttachmentHeader_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 OdDgNewLevelDisplyMode {
    kConfigVariable = 0,
    kAlways = 1,
    kNever = 2
  }
 
  public enum OdDgLineStyleScaleMode {
    kLSMaster = 0,
    kLSNone = 1,
    kLSMasterReference = 2,
    kLSReference = 3
  }
 
  public enum OdDgReferenceForeignUnits {
    kUnitsUndefined = 0,
    kSeedFileMasterUnits = 1,
    kSeedFileSubUnits = 2,
    kDesignCenterUnits = 3,
    kUnitsMicrometers = 4,
    kUnitsMillimeters = 5,
    kUnitsCentimeters = 6,
    kUnitsMeters = 7,
    kUnitsKilometers = 8,
    kUnitsMicroinches = 9,
    kUnitsMils = 10,
    kUnitsInches = 11,
    kUnitsFeet = 12,
    kUnitsYards = 13,
    kUnitsMiles = 14
  }
 
  public enum OdDgXRefPaletteModificationMode {
    kAdjusmentFactor = 0,
    kFixedValueAndSaturation = 1
  }
 
}
 
}