CFxAPI.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 PCAD_DOT_NET {
 
using System; 
using System.Runtime.InteropServices; 
using Teigha.Core;
using Teigha.TD;
 
public class CFxAPI : global::System.IDisposable {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  protected bool swigCMemOwn;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public CFxAPI(IntPtr cPtr, bool cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = new HandleRef(this, cPtr);
  }
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public static HandleRef getCPtr(CFxAPI obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }
 
  ~CFxAPI() {
    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;
          PCADGlobalsPINVOKE.delete_CFxAPI(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
    }
  }
 
  public virtual int fdt_regappA(string applic_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_regappA(swigCPtr, applic_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_regappW(string applic_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_regappW(swigCPtr, applic_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_registerA(string extfunc, string cfunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_registerA(swigCPtr, extfunc, cfunc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_registerW(string extfunc, string cfunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_registerW(swigCPtr, extfunc, cfunc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_register_paramA(string extfunc, string cfunc, SWIGTYPE_p_uintptr_t param) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_register_paramA(swigCPtr, extfunc, cfunc, SWIGTYPE_p_uintptr_t.getCPtr(param));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_register_paramW(string extfunc, string cfunc, SWIGTYPE_p_uintptr_t param) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_register_paramW(swigCPtr, extfunc, cfunc, SWIGTYPE_p_uintptr_t.getCPtr(param));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_register_funcA(string extfunc, SWIGTYPE_p_f___int cfunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_register_funcA(swigCPtr, extfunc, SWIGTYPE_p_f___int.getCPtr(cfunc));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_register_funcW(string extfunc, SWIGTYPE_p_f___int cfunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_register_funcW(swigCPtr, extfunc, SWIGTYPE_p_f___int.getCPtr(cfunc));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_unregisterA(string extfunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_unregisterA(swigCPtr, extfunc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_unregisterW(string extfunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_unregisterW(swigCPtr, extfunc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcfgA(string App_ProfileStringName, string App_ProfileStringValue, int App_ProfileStringLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcfgA(swigCPtr, App_ProfileStringName, App_ProfileStringValue, App_ProfileStringLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcfgW(string App_ProfileStringName, string App_ProfileStringValue, int App_ProfileStringLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcfgW(swigCPtr, App_ProfileStringName, App_ProfileStringValue, App_ProfileStringLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setcfgA(string Profile_name, string Profile_value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setcfgA(swigCPtr, Profile_name, Profile_value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setcfgW(string Profile_name, string Profile_value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setcfgW(swigCPtr, Profile_name, Profile_value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_loadA(string lisp_file) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_loadA(swigCPtr, lisp_file);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_loadW(string lisp_file) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_loadW(swigCPtr, lisp_file);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_xloadA(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xloadA(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_xloadW(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xloadW(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_xunloadA(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xunloadA(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_xunloadW(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xunloadW(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA fdt_getargsA() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_getargsA(swigCPtr);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_getargsW() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_getargsW(swigCPtr);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retint(int value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retint(swigCPtr, value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retreal(double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retreal(swigCPtr, value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retpoint(double[] /*DOUBLE_FIXED_ARRAY*/ point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retpoint(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retnil() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retnil(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_rett() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_rett(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retvoid() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retvoid(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retstrA(string string_) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retstrA(swigCPtr, string_);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retstrW(string string_) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retstrW(swigCPtr, string_);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retname(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retname(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_retlistA(fdt_resbufA rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retlistA(swigCPtr, fdt_resbufA.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retlistW(fdt_resbufW rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retlistW(swigCPtr, fdt_resbufW.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retvalA(fdt_resbufA value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retvalA(swigCPtr, fdt_resbufA.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_retvalW(fdt_resbufW value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_retvalW(swigCPtr, fdt_resbufW.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_invokeA(fdt_resbufA arguments, SWIGTYPE_p_p_fdt_resbufA rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_invokeA(swigCPtr, fdt_resbufA.getCPtr(arguments), SWIGTYPE_p_p_fdt_resbufA.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_invokeW(fdt_resbufW arguments, SWIGTYPE_p_p_fdt_resbufW rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_invokeW(swigCPtr, fdt_resbufW.getCPtr(arguments), SWIGTYPE_p_p_fdt_resbufW.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_invoke_lispA(string LISPExpr, SWIGTYPE_p_p_fdt_resbufA evalresrb) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_invoke_lispA(swigCPtr, LISPExpr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(evalresrb));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_invoke_lispW(string LISPExpr, SWIGTYPE_p_p_fdt_resbufW evalresrb) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_invoke_lispW(swigCPtr, LISPExpr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(evalresrb));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA fdt_loadedA() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_loadedA(swigCPtr);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_loadedW() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_loadedW(swigCPtr);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_drxloadA(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_drxloadA(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_drxloadW(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_drxloadW(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_drxunloadA(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_drxunloadA(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_drxunloadW(string fdt_app) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_drxunloadW(swigCPtr, fdt_app);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getsymA(string varname, SWIGTYPE_p_p_fdt_resbufA value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getsymA(swigCPtr, varname, SWIGTYPE_p_p_fdt_resbufA.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getsymW(string varname, SWIGTYPE_p_p_fdt_resbufW value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getsymW(swigCPtr, varname, SWIGTYPE_p_p_fdt_resbufW.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_putsymA(string sym_name, fdt_resbufA value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_putsymA(swigCPtr, sym_name, fdt_resbufA.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_putsymW(string sym_name, fdt_resbufW value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_putsymW(swigCPtr, sym_name, fdt_resbufW.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getininameA(string lpszIniName, int iIniNameLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getininameA(swigCPtr, lpszIniName, iIniNameLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getininameW(string lpszIniName, int iIniNameLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getininameW(swigCPtr, lpszIniName, iIniNameLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palgetnameslistA(SWIGTYPE_p_p_fdt_resbufA ListOfPaletteNames) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palgetnameslistA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(ListOfPaletteNames));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palgetnameslistW(SWIGTYPE_p_p_fdt_resbufW ListOfPaletteNames) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palgetnameslistW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(ListOfPaletteNames));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palloadA(string palfilename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palloadA(swigCPtr, palfilename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palloadW(string palfilename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palloadW(swigCPtr, palfilename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palunloadA(string palname) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palunloadA(swigCPtr, palname);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palunloadW(string palname) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palunloadW(swigCPtr, palname);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palshowA(string palname) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palshowA(swigCPtr, palname);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palshowW(string palname) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palshowW(swigCPtr, palname);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palhideA(string palname) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palhideA(swigCPtr, palname);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palhideW(string palname) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palhideW(swigCPtr, palname);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_palopendlg() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_palopendlg(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixgetnameslistA(SWIGTYPE_p_p_fdt_resbufA toolbars) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixgetnameslistA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(toolbars));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixgetnameslistW(SWIGTYPE_p_p_fdt_resbufW toolbars) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixgetnameslistW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(toolbars));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbaraddA(string toolbar, int index) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbaraddA__SWIG_0(swigCPtr, toolbar, index);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbaraddA(string toolbar) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbaraddA__SWIG_1(swigCPtr, toolbar);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbaraddW(string toolbar, int index) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbaraddW__SWIG_0(swigCPtr, toolbar, index);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbaraddW(string toolbar) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbaraddW__SWIG_1(swigCPtr, toolbar);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbarremoveA(string toolbar) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbarremoveA(swigCPtr, toolbar);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbarremoveW(string toolbar) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbarremoveW(swigCPtr, toolbar);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbarstategetA(string toolbar, out int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbarstategetA(swigCPtr, toolbar, out state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbarstategetW(string toolbar, out int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbarstategetW(swigCPtr, toolbar, out state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbarstatesetA(string toolbar, int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbarstatesetA(swigCPtr, toolbar, state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixtoolbarstatesetW(string toolbar, int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixtoolbarstatesetW(swigCPtr, toolbar, state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarstategetA(string toolbar, out int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarstategetA(swigCPtr, toolbar, out state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarstategetW(string toolbar, out int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarstategetW(swigCPtr, toolbar, out state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarstatesetA(string toolbar, int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarstatesetA(swigCPtr, toolbar, state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarstatesetW(string toolbar, int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarstatesetW(swigCPtr, toolbar, state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixstategetA(out int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixstategetA(swigCPtr, out state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixstategetW(out int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixstategetW(swigCPtr, out state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixstatesetA(int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixstatesetA(swigCPtr, state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarmatrixstatesetW(int state) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarmatrixstatesetW(swigCPtr, state);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_all_toolbars_visibleA(bool visible) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_all_toolbars_visibleA(swigCPtr, visible);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_all_toolbars_visibleW(bool visible) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_all_toolbars_visibleW(swigCPtr, visible);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbar_existsA(string toolbar, bool /*SIMPLETYPE*/ exists) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbar_existsA(swigCPtr, toolbar, exists /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbar_existsW(string toolbar, bool /*SIMPLETYPE*/ exists) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbar_existsW(swigCPtr, toolbar, exists /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarstateA(string toolbar, int state, int x, int y, int number_of_rows, int index_in_toolmatrix) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarstateA(swigCPtr, toolbar, state, x, y, number_of_rows, index_in_toolmatrix);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toolbarstateW(string toolbar, int state, int x, int y, int number_of_rows, int index_in_toolmatrix) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toolbarstateW(swigCPtr, toolbar, state, x, y, number_of_rows, index_in_toolmatrix);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_ssgetfirstA(SWIGTYPE_p_p_fdt_resbufA gripset, SWIGTYPE_p_p_fdt_resbufA pickset) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssgetfirstA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(gripset), SWIGTYPE_p_p_fdt_resbufA.getCPtr(pickset));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_ssgetfirstW(SWIGTYPE_p_p_fdt_resbufW gripset, SWIGTYPE_p_p_fdt_resbufW pickset) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssgetfirstW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(gripset), SWIGTYPE_p_p_fdt_resbufW.getCPtr(pickset));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_sssetfirst(ref UInt64[] /*OUT_ARRAY*/ pickset, ref UInt64[] /*OUT_ARRAY*/ unused) {
IntPtr p_pickset=Teigha.Core.Helpers.MarshalUInt64FixedArray(pickset);
IntPtr p_unused=Teigha.Core.Helpers.MarshalUInt64FixedArray(unused);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_sssetfirst(swigCPtr, p_pickset, p_unused);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
pickset = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_pickset); Marshal.FreeCoTaskMem(p_pickset);
unused = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_unused); Marshal.FreeCoTaskMem(p_unused);
    }
  }
 
  public virtual int fdt_alertA(string lpszMessage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_alertA(swigCPtr, lpszMessage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_alertW(string lpszMessage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_alertW(swigCPtr, lpszMessage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_failA(string lpszErrorText) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_failA(swigCPtr, lpszErrorText);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void fdt_failW(string lpszErrorText) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_failW(swigCPtr, lpszErrorText);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual fdt_resbufA fdt_newrbA(int value) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_newrbA(swigCPtr, value);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_newrbW(int value) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_newrbW(swigCPtr, value);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_copyresbufA(fdt_resbufA source_rb, SWIGTYPE_p_p_fdt_resbufA target_rb) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_copyresbufA(swigCPtr, fdt_resbufA.getCPtr(source_rb), SWIGTYPE_p_p_fdt_resbufA.getCPtr(target_rb));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_copyresbufW(fdt_resbufW source_rb, SWIGTYPE_p_p_fdt_resbufW target_rb) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_copyresbufW(swigCPtr, fdt_resbufW.getCPtr(source_rb), SWIGTYPE_p_p_fdt_resbufW.getCPtr(target_rb));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_relrbA(fdt_resbufA rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_relrbA(swigCPtr, fdt_resbufA.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_relrbW(fdt_resbufW rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_relrbW(swigCPtr, fdt_resbufW.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_cmdA(fdt_resbufA rb_cmd) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_cmdA(swigCPtr, fdt_resbufA.getCPtr(rb_cmd));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_cmdW(fdt_resbufW rb_cmd) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_cmdW(swigCPtr, fdt_resbufW.getCPtr(rb_cmd));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_initdialog(int show_dlg) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_initdialog(swigCPtr, show_dlg);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_actcmdA(string command_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_actcmdA(swigCPtr, command_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_actcmdW(string command_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_actcmdW(swigCPtr, command_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delcmdA(string command_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delcmdA(swigCPtr, command_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delcmdW(string command_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delcmdW(swigCPtr, command_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcnameA(string Cmd_Name, char[] /*SIMPLE_REFARRAY*/ Primary_Cmd_Name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcnameA(swigCPtr, Cmd_Name, Primary_Cmd_Name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcnameW(string Cmd_Name, SWIGTYPE_p_p_wchar_t Primary_Cmd_Name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcnameW(swigCPtr, Cmd_Name, SWIGTYPE_p_p_wchar_t.getCPtr(Primary_Cmd_Name));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_snvalidA(string Symbol_Name, int Flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_snvalidA(swigCPtr, Symbol_Name, Flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_snvalidW(string Symbol_Name, int Flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_snvalidW(swigCPtr, Symbol_Name, Flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_fgetenvA(string path_kword, string path) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_fgetenvA(swigCPtr, path_kword, path);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_fgetenvW(string path_kword, string path) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_fgetenvW(swigCPtr, path_kword, path);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getenvA(string szVarname, string szIni_section, string szIni_file, int length, string szResult) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getenvA(swigCPtr, szVarname, szIni_section, szIni_file, length, szResult);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getenvW(string szVarname, string szIni_section, string szIni_file, int length, string szResult) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getenvW(swigCPtr, szVarname, szIni_section, szIni_file, length, szResult);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setenvA(string szVarname, string szValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setenvA(swigCPtr, szVarname, szValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setenvW(string szVarname, string szValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setenvW(swigCPtr, szVarname, szValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual string fdt_strmallocA(int length) {
    string ret = PCADGlobalsPINVOKE.CFxAPI_fdt_strmallocA(swigCPtr, length);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_strfreeA(string string_) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_strfreeA(swigCPtr, string_);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void fdt_strfreeW(string string_) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_strfreeW(swigCPtr, string_);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual IntPtr fdt_malloc(uint length) { 
// test csout
 /*SIMPLETYPE*/
     IntPtr ret = PCADGlobalsPINVOKE.CFxAPI_fdt_malloc(swigCPtr, length); 
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual void fdt_free(IntPtr buffer) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_free(swigCPtr, buffer);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual int fdt_isalpha(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isalpha(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isupper(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isupper(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_islower(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_islower(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isdigit(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isdigit(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isxdigit(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isxdigit(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isspace(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isspace(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_ispunct(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ispunct(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isalnum(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isalnum(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isprint(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isprint(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isgraph(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isgraph(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_iscntrl(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_iscntrl(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_toupper(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_toupper(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tolower(int character) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tolower(swigCPtr, character);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdti_notify(int iReason, string lpszMassage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdti_notify(swigCPtr, iReason, lpszMassage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdti_notify_short(int iReason, int iCode) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdti_notify_short(swigCPtr, iReason, iCode);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setvarA(string lpszSysVar, fdt_resbufA pValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setvarA(swigCPtr, lpszSysVar, fdt_resbufA.getCPtr(pValue));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setvarW(string lpszSysVar, fdt_resbufW pValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setvarW(swigCPtr, lpszSysVar, fdt_resbufW.getCPtr(pValue));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getvarA(string lpszSysVar, fdt_resbufA pValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getvarA(swigCPtr, lpszSysVar, fdt_resbufA.getCPtr(pValue));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getvarW(string lpszSysVar, fdt_resbufW pValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getvarW(swigCPtr, lpszSysVar, fdt_resbufW.getCPtr(pValue));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_cvunitA(double value, string source_unit, string target_unit, out double result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_cvunitA(swigCPtr, value, source_unit, target_unit, out result);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_cvunitW(double value, string source_unit, string target_unit, out double result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_cvunitW(swigCPtr, value, source_unit, target_unit, out result);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_angtosA(double value, int format, int precision, string string_, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_angtosA(swigCPtr, value, format, precision, string_, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_angtosW(double value, int format, int precision, string string_, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_angtosW(swigCPtr, value, format, precision, string_, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_rtosA(double value, int format, int precision, string string_, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_rtosA(swigCPtr, value, format, precision, string_, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_rtosW(double value, int format, int precision, string string_, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_rtosW(swigCPtr, value, format, precision, string_, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_angtofA(string string_, int format, out double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_angtofA(swigCPtr, string_, format, out value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_angtofW(string string_, int format, out double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_angtofW(swigCPtr, string_, format, out value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_distofA(string string_, int format, out double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_distofA(swigCPtr, string_, format, out value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_distofW(string string_, int format, out double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_distofW(swigCPtr, string_, format, out value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_atofA(string string_, out double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_atofA(swigCPtr, string_, out value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_atofW(string string_, out double value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_atofW(swigCPtr, string_, out value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_wcmatchA(string strSource, string strPattern) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_wcmatchA(swigCPtr, strSource, strPattern);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_wcmatchW(string strSource, string strPattern) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_wcmatchW(swigCPtr, strSource, strPattern);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_promptA(string lpszPrompt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_promptA(swigCPtr, lpszPrompt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_promptW(string lpszPrompt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_promptW(swigCPtr, lpszPrompt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_graphscr() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_graphscr(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_textscr() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_textscr(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_textpage() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_textpage(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_cleartextscr() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_cleartextscr(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_activate_progress_barA(string lpszMessage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_activate_progress_barA(swigCPtr, lpszMessage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_activate_progress_barW(string lpszMessage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_activate_progress_barW(swigCPtr, lpszMessage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_hide_progress_bar() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_hide_progress_bar(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_set_progress_state(int iProgress) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_set_progress_state(swigCPtr, iProgress);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_selcheck(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_selcheck(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_ssgetA(string mode, IntPtr /*SIMPLETYPE*/ point1, double[] /*DOUBLE_FIXED_ARRAY*/ pt2, fdt_resbufA filter, ref UInt64[] /*OUT_ARRAY*/ sname) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssgetA(swigCPtr, mode, point1 /*SIMPLETYPE*/, pt2 /*DOUBLE_FIXED_ARRAY*/, fdt_resbufA.getCPtr(filter), p_sname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_ssgetW(string mode, IntPtr /*SIMPLETYPE*/ point1, double[] /*DOUBLE_FIXED_ARRAY*/ pt2, fdt_resbufW filter, ref UInt64[] /*OUT_ARRAY*/ sname) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssgetW(swigCPtr, mode, point1 /*SIMPLETYPE*/, pt2 /*DOUBLE_FIXED_ARRAY*/, fdt_resbufW.getCPtr(filter), p_sname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_ssfree(ref UInt64[] /*OUT_ARRAY*/ sname) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssfree(swigCPtr, p_sname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_sslength(ref UInt64[] /*OUT_ARRAY*/ sname, out int length) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_sslength(swigCPtr, p_sname, out length);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_ssadd(ref UInt64[] /*OUT_ARRAY*/ ename, ref UInt64[] /*OUT_ARRAY*/ selset, ref UInt64[] /*OUT_ARRAY*/ sresult, bool check_owner) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
IntPtr p_selset=Teigha.Core.Helpers.MarshalUInt64FixedArray(selset);
IntPtr p_sresult=Teigha.Core.Helpers.MarshalUInt64FixedArray(sresult);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssadd__SWIG_0(swigCPtr, p_ename, p_selset, p_sresult, check_owner);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
selset = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_selset); Marshal.FreeCoTaskMem(p_selset);
sresult = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sresult); Marshal.FreeCoTaskMem(p_sresult);
    }
  }
 
  public virtual int fdt_ssadd(ref UInt64[] /*OUT_ARRAY*/ ename, ref UInt64[] /*OUT_ARRAY*/ selset, ref UInt64[] /*OUT_ARRAY*/ sresult) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
IntPtr p_selset=Teigha.Core.Helpers.MarshalUInt64FixedArray(selset);
IntPtr p_sresult=Teigha.Core.Helpers.MarshalUInt64FixedArray(sresult);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssadd__SWIG_1(swigCPtr, p_ename, p_selset, p_sresult);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
selset = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_selset); Marshal.FreeCoTaskMem(p_selset);
sresult = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sresult); Marshal.FreeCoTaskMem(p_sresult);
    }
  }
 
  public virtual int fdt_ssname(ref UInt64[] /*OUT_ARRAY*/ sname, int n, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssname(swigCPtr, p_sname, n, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_ssnamexA(SWIGTYPE_p_p_fdt_resbufA rbpp, ref UInt64[] /*OUT_ARRAY*/ ss, int i, uint flags) {
IntPtr p_ss=Teigha.Core.Helpers.MarshalUInt64FixedArray(ss);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssnamexA__SWIG_0(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(rbpp), p_ss, i, flags);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ss = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ss); Marshal.FreeCoTaskMem(p_ss);
    }
  }
 
  public virtual int fdt_ssnamexA(SWIGTYPE_p_p_fdt_resbufA rbpp, ref UInt64[] /*OUT_ARRAY*/ ss, int i) {
IntPtr p_ss=Teigha.Core.Helpers.MarshalUInt64FixedArray(ss);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssnamexA__SWIG_1(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(rbpp), p_ss, i);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ss = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ss); Marshal.FreeCoTaskMem(p_ss);
    }
  }
 
  public virtual int fdt_ssnamexW(SWIGTYPE_p_p_fdt_resbufW rbpp, ref UInt64[] /*OUT_ARRAY*/ ss, int i, uint flags) {
IntPtr p_ss=Teigha.Core.Helpers.MarshalUInt64FixedArray(ss);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssnamexW__SWIG_0(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(rbpp), p_ss, i, flags);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ss = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ss); Marshal.FreeCoTaskMem(p_ss);
    }
  }
 
  public virtual int fdt_ssnamexW(SWIGTYPE_p_p_fdt_resbufW rbpp, ref UInt64[] /*OUT_ARRAY*/ ss, int i) {
IntPtr p_ss=Teigha.Core.Helpers.MarshalUInt64FixedArray(ss);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssnamexW__SWIG_1(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(rbpp), p_ss, i);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ss = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ss); Marshal.FreeCoTaskMem(p_ss);
    }
  }
 
  public virtual int fdt_ssdbnr(ref UInt64[] /*OUT_ARRAY*/ sname, out int nDbNo) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssdbnr(swigCPtr, p_sname, out nDbNo);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_ssmemb(ref UInt64[] /*OUT_ARRAY*/ sname, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssmemb(swigCPtr, p_sname, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_ssdel(ref UInt64[] /*OUT_ARRAY*/ ename, ref UInt64[] /*OUT_ARRAY*/ sname) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssdel(swigCPtr, p_ename, p_sname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_ssdel_all(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ssdel_all(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_xformss(ref UInt64[] /*OUT_ARRAY*/ sname, SWIGTYPE_p_a_4__double matrix) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xformss(swigCPtr, p_sname, SWIGTYPE_p_a_4__double.getCPtr(matrix));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_norm_dxfcode(int dxf_code) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_norm_dxfcode(swigCPtr, dxf_code);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdti_ssinc(ref UInt64[] /*OUT_ARRAY*/ sname) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdti_ssinc(swigCPtr, p_sname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_entnext(ref UInt64[] /*OUT_ARRAY*/ ename, ref UInt64[] /*OUT_ARRAY*/ next_ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
IntPtr p_next_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(next_ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entnext(swigCPtr, p_ename, p_next_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
next_ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_next_ename); Marshal.FreeCoTaskMem(p_next_ename);
    }
  }
 
  public virtual int fdt_entpos(fdt_pos position, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entpos(swigCPtr, (int)position, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entlast(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entlast(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entdel(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entdel(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_entgetA(ref UInt64[] /*OUT_ARRAY*/ ename, bool openErased) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetA__SWIG_0(swigCPtr, p_ename, openErased);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_entgetA(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetA__SWIG_1(swigCPtr, p_ename);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufW fdt_entgetW(ref UInt64[] /*OUT_ARRAY*/ ename, bool openErased) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetW__SWIG_0(swigCPtr, p_ename, openErased);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufW fdt_entgetW(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetW__SWIG_1(swigCPtr, p_ename);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_entgetxA(ref UInt64[] /*OUT_ARRAY*/ ename, fdt_resbufA applic_name, bool openErased) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetxA__SWIG_0(swigCPtr, p_ename, fdt_resbufA.getCPtr(applic_name), openErased);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_entgetxA(ref UInt64[] /*OUT_ARRAY*/ ename, fdt_resbufA applic_name) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetxA__SWIG_1(swigCPtr, p_ename, fdt_resbufA.getCPtr(applic_name));
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufW fdt_entgetxW(ref UInt64[] /*OUT_ARRAY*/ ename, fdt_resbufW applic_name, bool openErased) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetxW__SWIG_0(swigCPtr, p_ename, fdt_resbufW.getCPtr(applic_name), openErased);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufW fdt_entgetxW(ref UInt64[] /*OUT_ARRAY*/ ename, fdt_resbufW applic_name) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entgetxW__SWIG_1(swigCPtr, p_ename, fdt_resbufW.getCPtr(applic_name));
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entmodA(fdt_resbufA rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmodA(swigCPtr, fdt_resbufA.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entmodW(fdt_resbufW rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmodW(swigCPtr, fdt_resbufW.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entmakeA(fdt_resbufA rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmakeA(swigCPtr, fdt_resbufA.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entmakeW(fdt_resbufW rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmakeW(swigCPtr, fdt_resbufW.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entmakexA(fdt_resbufA rbuffer, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmakexA(swigCPtr, fdt_resbufA.getCPtr(rbuffer), p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entmakexW(fdt_resbufW rbuffer, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmakexW(swigCPtr, fdt_resbufW.getCPtr(rbuffer), p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entupd(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entupd(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entcheck(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entcheck(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entselA(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entselA(swigCPtr, prompt, p_ename, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entselW(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entselW(swigCPtr, prompt, p_ename, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_nentselA(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt, SWIGTYPE_p_a_4__double matrix, SWIGTYPE_p_p_fdt_resbufA refents) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_nentselA(swigCPtr, prompt, p_ename, point_rslt /*DOUBLE_FIXED_ARRAY*/, SWIGTYPE_p_a_4__double.getCPtr(matrix), SWIGTYPE_p_p_fdt_resbufA.getCPtr(refents));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_nentselW(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt, SWIGTYPE_p_a_4__double matrix, SWIGTYPE_p_p_fdt_resbufW refents) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_nentselW(swigCPtr, prompt, p_ename, point_rslt /*DOUBLE_FIXED_ARRAY*/, SWIGTYPE_p_a_4__double.getCPtr(matrix), SWIGTYPE_p_p_fdt_resbufW.getCPtr(refents));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_nentselpA(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt, int flag, SWIGTYPE_p_a_4__double matrix, SWIGTYPE_p_p_fdt_resbufA refents) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_nentselpA(swigCPtr, prompt, p_ename, point_rslt /*DOUBLE_FIXED_ARRAY*/, flag, SWIGTYPE_p_a_4__double.getCPtr(matrix), SWIGTYPE_p_p_fdt_resbufA.getCPtr(refents));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_nentselpW(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt, int flag, SWIGTYPE_p_a_4__double matrix, SWIGTYPE_p_p_fdt_resbufW refents) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_nentselpW(swigCPtr, prompt, p_ename, point_rslt /*DOUBLE_FIXED_ARRAY*/, flag, SWIGTYPE_p_a_4__double.getCPtr(matrix), SWIGTYPE_p_p_fdt_resbufW.getCPtr(refents));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_nentselpexA(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt, int flag, SWIGTYPE_p_a_4__double matrix, SWIGTYPE_p_p_fdt_resbufA refents, uint transSpaceFlag, out int gsmarker) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_nentselpexA(swigCPtr, prompt, p_ename, point_rslt /*DOUBLE_FIXED_ARRAY*/, flag, SWIGTYPE_p_a_4__double.getCPtr(matrix), SWIGTYPE_p_p_fdt_resbufA.getCPtr(refents), transSpaceFlag, out gsmarker);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_nentselpexW(string prompt, ref UInt64[] /*OUT_ARRAY*/ ename, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt, int flag, SWIGTYPE_p_a_4__double matrix, SWIGTYPE_p_p_fdt_resbufW refents, uint transSpaceFlag, out int gsmarker) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_nentselpexW(swigCPtr, prompt, p_ename, point_rslt /*DOUBLE_FIXED_ARRAY*/, flag, SWIGTYPE_p_a_4__double.getCPtr(matrix), SWIGTYPE_p_p_fdt_resbufW.getCPtr(refents), transSpaceFlag, out gsmarker);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_hatch(ref UInt64[] /*OUT_ARRAY*/ sname, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_hatch(swigCPtr, p_sname, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_tblnextA(string tbl_type, int flag) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_tblnextA(swigCPtr, tbl_type, flag);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_tblnextW(string tbl_type, int flag) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_tblnextW(swigCPtr, tbl_type, flag);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA fdt_tblsearchA(string tbl_type, string item_name, int setnext) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_tblsearchA(swigCPtr, tbl_type, item_name, setnext);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_tblsearchW(string tbl_type, string item_name, int setnext) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_tblsearchW(swigCPtr, tbl_type, item_name, setnext);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblobjnameA(string tbl_type, string item_name, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblobjnameA(swigCPtr, tbl_type, item_name, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_tblobjnameW(string tbl_type, string item_name, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblobjnameW(swigCPtr, tbl_type, item_name, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_tblmodA(fdt_resbufA tbl_record) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblmodA(swigCPtr, fdt_resbufA.getCPtr(tbl_record));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblmodW(fdt_resbufW tbl_record) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblmodW(swigCPtr, fdt_resbufW.getCPtr(tbl_record));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblmakeA(fdt_resbufA tbl_record) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblmakeA(swigCPtr, fdt_resbufA.getCPtr(tbl_record));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblmakeW(fdt_resbufW tbl_record) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblmakeW(swigCPtr, fdt_resbufW.getCPtr(tbl_record));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblsetA(string tbl_type, string item_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblsetA(swigCPtr, tbl_type, item_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblsetW(string tbl_type, string item_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblsetW(swigCPtr, tbl_type, item_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblrenA(string tbl_type, string old_name, string new_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblrenA(swigCPtr, tbl_type, old_name, new_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblrenW(string tbl_type, string old_name, string new_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblrenW(swigCPtr, tbl_type, old_name, new_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tbldelA(string tbl_type, string item_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tbldelA(swigCPtr, tbl_type, item_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tbldelW(string tbl_type, string item_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tbldelW(swigCPtr, tbl_type, item_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblpurgeA(string tbl_type, int flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblpurgeA(swigCPtr, tbl_type, flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblpurgeW(string tbl_type, int flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblpurgeW(swigCPtr, tbl_type, flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblcheckrefA(string tbl_type, string item_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblcheckrefA(swigCPtr, tbl_type, item_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tblcheckrefW(string tbl_type, string item_name) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tblcheckrefW(swigCPtr, tbl_type, item_name);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_inters(double[] /*DOUBLE_FIXED_ARRAY*/ from_pt1, double[] /*DOUBLE_FIXED_ARRAY*/ to_pt1, double[] /*DOUBLE_FIXED_ARRAY*/ from_pt2, double[] /*DOUBLE_FIXED_ARRAY*/ to_pt2, int flag, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_inters(swigCPtr, from_pt1 /*DOUBLE_FIXED_ARRAY*/, to_pt1 /*DOUBLE_FIXED_ARRAY*/, from_pt2 /*DOUBLE_FIXED_ARRAY*/, to_pt2 /*DOUBLE_FIXED_ARRAY*/, flag, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual double fdt_angle(double[] /*DOUBLE_FIXED_ARRAY*/ point1, double[] /*DOUBLE_FIXED_ARRAY*/ point2) {
    double ret = PCADGlobalsPINVOKE.CFxAPI_fdt_angle(swigCPtr, point1 /*DOUBLE_FIXED_ARRAY*/, point2 /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual double fdt_distance(double[] /*DOUBLE_FIXED_ARRAY*/ point1, double[] /*DOUBLE_FIXED_ARRAY*/ point2) {
    double ret = PCADGlobalsPINVOKE.CFxAPI_fdt_distance(swigCPtr, point1 /*DOUBLE_FIXED_ARRAY*/, point2 /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_polar(double[] /*DOUBLE_FIXED_ARRAY*/ point, double angle, double distance, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_polar(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, angle, distance, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual int fdt_initgetA(int value, string keywords) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_initgetA(swigCPtr, value, keywords);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_initgetW(int value, string keywords) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_initgetW(swigCPtr, value, keywords);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getangleA(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, out double angle_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getangleA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, out angle_rslt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getangleW(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, out double angle_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getangleW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, out angle_rslt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcornerA(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcornerA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcornerW(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcornerW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getdistA(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, out double distance) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getdistA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, out distance);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getdistW(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, out double distance) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getdistW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, out distance);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getorientA(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, out double orientation) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getorientA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, out orientation);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getorientW(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, out double orientation) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getorientW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, out orientation);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getpointA(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getpointA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getpointW(double[] /*DOUBLE_FIXED_ARRAY*/ point, string prompt, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getpointW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, prompt, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getintA(string prompt, out int int_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getintA(swigCPtr, prompt, out int_rslt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getintW(string prompt, out int int_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getintW(swigCPtr, prompt, out int_rslt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getkwordA(string prompt, string keyword, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getkwordA(swigCPtr, prompt, keyword, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getkwordW(string prompt, string keyword, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getkwordW(swigCPtr, prompt, keyword, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getrealA(string prompt, out double real_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getrealA(swigCPtr, prompt, out real_rslt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getrealW(string prompt, out double real_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getrealW(swigCPtr, prompt, out real_rslt);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getinputA(string keyword, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getinputA(swigCPtr, keyword, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getinputW(string keyword, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getinputW(swigCPtr, keyword, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getstringA(int flag, string prompt, string string_rslt, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getstringA(swigCPtr, flag, prompt, string_rslt, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getstringW(int flag, string prompt, string string_rslt, uint iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getstringW(swigCPtr, flag, prompt, string_rslt, iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_setosnapinactive() {
    PCADGlobalsPINVOKE.CFxAPI_fdt_setosnapinactive(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual int fdt_usrbrk() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_usrbrk(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_menucmdA(string pString) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_menucmdA(swigCPtr, pString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_menucmdW(string pString) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_menucmdW(swigCPtr, pString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_findfileA(string lpszFilename, string lpszResultFilename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_findfileA(swigCPtr, lpszFilename, lpszResultFilename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_findfileW(string lpszFilename, string lpszResultFilename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_findfileW(swigCPtr, lpszFilename, lpszResultFilename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getfiledA(string lpszTitle, string lpszDefault, string lpszExtension, int flags, fdt_resbufA pResultFilename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getfiledA(swigCPtr, lpszTitle, lpszDefault, lpszExtension, flags, fdt_resbufA.getCPtr(pResultFilename));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getfiledW(string lpszTitle, string lpszDefault, string lpszExtension, int flags, fdt_resbufW pResultFilename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getfiledW(swigCPtr, lpszTitle, lpszDefault, lpszExtension, flags, fdt_resbufW.getCPtr(pResultFilename));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_handentA(string handle, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_handentA(swigCPtr, handle, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_handentW(string handle, ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_handentW(swigCPtr, handle, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_transA(double[] /*DOUBLE_FIXED_ARRAY*/ point, fdt_resbufA origin_cs, fdt_resbufA target_cs, int disp_mode, double[] /*DOUBLE_FIXED_ARRAY*/ rslt_point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_transA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, fdt_resbufA.getCPtr(origin_cs), fdt_resbufA.getCPtr(target_cs), disp_mode, rslt_point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_transW(double[] /*DOUBLE_FIXED_ARRAY*/ point, fdt_resbufW origin_cs, fdt_resbufW target_cs, int disp_mode, double[] /*DOUBLE_FIXED_ARRAY*/ rslt_point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_transW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, fdt_resbufW.getCPtr(origin_cs), fdt_resbufW.getCPtr(target_cs), disp_mode, rslt_point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_redraw(ref UInt64[] /*OUT_ARRAY*/ ename, int mode) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_redraw(swigCPtr, p_ename, mode);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_regen() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_regen(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grreadA(int flag, out int type, fdt_resbufA result, bool bTrack) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grreadA__SWIG_0(swigCPtr, flag, out type, fdt_resbufA.getCPtr(result), bTrack);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grreadA(int flag, out int type, fdt_resbufA result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grreadA__SWIG_1(swigCPtr, flag, out type, fdt_resbufA.getCPtr(result));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grreadW(int flag, out int type, fdt_resbufW result, bool bTrack) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grreadW__SWIG_0(swigCPtr, flag, out type, fdt_resbufW.getCPtr(result), bTrack);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grreadW(int flag, out int type, fdt_resbufW result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grreadW__SWIG_1(swigCPtr, flag, out type, fdt_resbufW.getCPtr(result));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_capture_grread() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_capture_grread(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_release_grread() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_release_grread(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grdraw(double[] /*DOUBLE_FIXED_ARRAY*/ point1, double[] /*DOUBLE_FIXED_ARRAY*/ point2, int color, int flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grdraw(swigCPtr, point1 /*DOUBLE_FIXED_ARRAY*/, point2 /*DOUBLE_FIXED_ARRAY*/, color, flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grvecsA(fdt_resbufA vlist, SWIGTYPE_p_a_4__double matrix) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grvecsA(swigCPtr, fdt_resbufA.getCPtr(vlist), SWIGTYPE_p_a_4__double.getCPtr(matrix));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grvecsW(fdt_resbufW vlist, SWIGTYPE_p_a_4__double matrix) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grvecsW(swigCPtr, fdt_resbufW.getCPtr(vlist), SWIGTYPE_p_a_4__double.getCPtr(matrix));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grtextA(string string_, out int pBox, out int pHighlight) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grtextA__SWIG_0(swigCPtr, string_, out pBox, out pHighlight);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grtextA(string string_, out int pBox) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grtextA__SWIG_1(swigCPtr, string_, out pBox);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grtextA(string string_) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grtextA__SWIG_2(swigCPtr, string_);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grtextW(string string_, out int pBox, out int pHighlight) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grtextW__SWIG_0(swigCPtr, string_, out pBox, out pHighlight);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grtextW(string string_, out int pBox) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grtextW__SWIG_1(swigCPtr, string_, out pBox);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grtextW(string string_) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grtextW__SWIG_2(swigCPtr, string_);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_grclear() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_grclear(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_osnapA(double[] /*DOUBLE_FIXED_ARRAY*/ point, string osnap_key, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_osnapA(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, osnap_key, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_osnapW(double[] /*DOUBLE_FIXED_ARRAY*/ point, string osnap_key, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_osnapW(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, osnap_key, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_osnap_mode(double[] /*DOUBLE_FIXED_ARRAY*/ point, int osmode_flag, double[] /*DOUBLE_FIXED_ARRAY*/ point_rslt) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_osnap_mode(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/, osmode_flag, point_rslt /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getsnapmodeA(string osnap_key, out short osmode_flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getsnapmodeA(swigCPtr, osnap_key, out osmode_flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getsnapmodeW(string osnap_key, out short osmode_flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getsnapmodeW(swigCPtr, osnap_key, out osmode_flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_appinters(double[] /*DOUBLE_FIXED_ARRAY*/ pt1, double[] /*DOUBLE_FIXED_ARRAY*/ pt2, double[] /*DOUBLE_FIXED_ARRAY*/ result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_appinters(swigCPtr, pt1 /*DOUBLE_FIXED_ARRAY*/, pt2 /*DOUBLE_FIXED_ARRAY*/, result /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_textboxA(fdt_resbufA descr_buffer, double[] /*DOUBLE_FIXED_ARRAY*/ corner1, double[] /*DOUBLE_FIXED_ARRAY*/ corner2) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_textboxA(swigCPtr, fdt_resbufA.getCPtr(descr_buffer), corner1 /*DOUBLE_FIXED_ARRAY*/, corner2 /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_textboxW(fdt_resbufW descr_buffer, double[] /*DOUBLE_FIXED_ARRAY*/ corner1, double[] /*DOUBLE_FIXED_ARRAY*/ corner2) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_textboxW(swigCPtr, fdt_resbufW.getCPtr(descr_buffer), corner1 /*DOUBLE_FIXED_ARRAY*/, corner2 /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcurr_mousepos(double[] /*DOUBLE_FIXED_ARRAY*/ point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcurr_mousepos(swigCPtr, point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_draggenA(ref UInt64[] /*OUT_ARRAY*/ sname, string prompt, int cursor, SWIGTYPE_p_f_a_3__double_a_4__a_4__double__int scanfunc, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_draggenA(swigCPtr, p_sname, prompt, cursor, SWIGTYPE_p_f_a_3__double_a_4__a_4__double__int.getCPtr(scanfunc), point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_draggenW(ref UInt64[] /*OUT_ARRAY*/ sname, string prompt, int cursor, SWIGTYPE_p_f_a_3__double_a_4__a_4__double__int scanfunc, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_draggenW(swigCPtr, p_sname, prompt, cursor, SWIGTYPE_p_f_a_3__double_a_4__a_4__double__int.getCPtr(scanfunc), point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public virtual int fdt_init_dragmodeA(int mode, fdt_resbufA params_) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_init_dragmodeA(swigCPtr, mode, fdt_resbufA.getCPtr(params_));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_init_dragmodeW(int mode, fdt_resbufW params_) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_init_dragmodeW(swigCPtr, mode, fdt_resbufW.getCPtr(params_));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_exit_dragmode() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_exit_dragmode(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_vportsA(SWIGTYPE_p_p_fdt_resbufA viewport_list) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_vportsA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(viewport_list));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_vportsW(SWIGTYPE_p_p_fdt_resbufW viewport_list) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_vportsW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(viewport_list));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tabletinfoA(fdt_tablet_recA tab_info) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tabletinfoA(swigCPtr, fdt_tablet_recA.getCPtr(tab_info));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_tabletinfoW(fdt_tablet_recW tab_info) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_tabletinfoW(swigCPtr, fdt_tablet_recW.getCPtr(tab_info));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxnewA(string filename, string template_filename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxnewA(swigCPtr, filename, template_filename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxnewW(string filename, string template_filename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxnewW(swigCPtr, filename, template_filename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxrnewA(string filename, string template_filename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxrnewA(swigCPtr, filename, template_filename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxrnewW(string filename, string template_filename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxrnewW(swigCPtr, filename, template_filename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxopenA(string filename, int ro_flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxopenA(swigCPtr, filename, ro_flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxopenW(string filename, int ro_flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxopenW(swigCPtr, filename, ro_flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxropenA(string filename, int ro_flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxropenA(swigCPtr, filename, ro_flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxropenW(string filename, int ro_flag) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxropenW(swigCPtr, filename, ro_flag);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxsave() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxsave(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxsaveasA(string filename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxsaveasA(swigCPtr, filename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxsaveasW(string filename) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxsaveasW(swigCPtr, filename);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxclose(int save_mode) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxclose(swigCPtr, save_mode);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxclosevport() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxclosevport(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxnamesA(SWIGTYPE_p_p_fdt_resbufA names) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxnamesA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(names));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_flxnamesW(SWIGTYPE_p_p_fdt_resbufW names) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_flxnamesW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(names));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getflxinfoA(string FileName, FDT_FLX_INFOA FileInfo, UInt32 /*SIMPLETYPE*/ BMPSize, SWIGTYPE_p_HGLOBAL BMPHandle) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getflxinfoA(swigCPtr, FileName, FDT_FLX_INFOA.getCPtr(FileInfo), BMPSize /*SIMPLETYPE*/, SWIGTYPE_p_HGLOBAL.getCPtr(BMPHandle));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getflxinfoW(string FileName, FDT_FLX_INFOW FileInfo, UInt32 /*SIMPLETYPE*/ BMPSize, SWIGTYPE_p_HGLOBAL BMPHandle) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getflxinfoW(swigCPtr, FileName, FDT_FLX_INFOW.getCPtr(FileInfo), BMPSize /*SIMPLETYPE*/, SWIGTYPE_p_HGLOBAL.getCPtr(BMPHandle));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setflxinfoA(string FileName, FDT_FLX_INFOA FileInfo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setflxinfoA(swigCPtr, FileName, FDT_FLX_INFOA.getCPtr(FileInfo));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setflxinfoW(string FileName, FDT_FLX_INFOW FileInfo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setflxinfoW(swigCPtr, FileName, FDT_FLX_INFOW.getCPtr(FileInfo));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getpreviewbitmapA(string FileName, SWIGTYPE_p_FxBitmap PrevBitmap, SWIGTYPE_p_FxPalette BmpPalette) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getpreviewbitmapA(swigCPtr, FileName, SWIGTYPE_p_FxBitmap.getCPtr(PrevBitmap), SWIGTYPE_p_FxPalette.getCPtr(BmpPalette));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getpreviewbitmapW(string FileName, SWIGTYPE_p_FxBitmap PrevBitmap, SWIGTYPE_p_FxPalette BmpPalette) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getpreviewbitmapW(swigCPtr, FileName, SWIGTYPE_p_FxBitmap.getCPtr(PrevBitmap), SWIGTYPE_p_FxPalette.getCPtr(BmpPalette));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcolorindex(IntPtr /*SIMPLETYPE*/ parent_window, int default_value, int mode_flag, out int int_result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcolorindex(swigCPtr, parent_window /*SIMPLETYPE*/, default_value, mode_flag, out int_result);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getbackgroundcolorref(SWIGTYPE_p_FxColorRef colorref) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getbackgroundcolorref(swigCPtr, SWIGTYPE_p_FxColorRef.getCPtr(colorref));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcolorref(int colorindex, SWIGTYPE_p_FxColorRef colorref) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcolorref(swigCPtr, colorindex, SWIGTYPE_p_FxColorRef.getCPtr(colorref));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setcolorref(int colorindex, SWIGTYPE_p_FxColorRef new_colorref, SWIGTYPE_p_FxColorRef old_colorref) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setcolorref(swigCPtr, colorindex, SWIGTYPE_p_FxColorRef.getCPtr(new_colorref), SWIGTYPE_p_FxColorRef.getCPtr(old_colorref));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getdesktopcolor(short iDescElement, out short iColorIndex) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getdesktopcolor(swigCPtr, iDescElement, out iColorIndex);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setdesktopcolor(short iDescElement, short iColorIndex) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setdesktopcolor(swigCPtr, iDescElement, iColorIndex);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual uint fdt_getrgb(int colorIndex) {
    uint ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getrgb(swigCPtr, colorIndex);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getactivedocumentA(SWIGTYPE_p_p_fdt_resbufA data) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getactivedocumentA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(data));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getactivedocumentW(SWIGTYPE_p_p_fdt_resbufW data) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getactivedocumentW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(data));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_set3dview(int nDbNo, int nWndNo, double[] /*DOUBLE_FIXED_ARRAY*/ ZDir, double[] /*DOUBLE_FIXED_ARRAY*/ XDir, double[] /*DOUBLE_FIXED_ARRAY*/ Center_Point, double Height) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_set3dview(swigCPtr, nDbNo, nWndNo, ZDir /*DOUBLE_FIXED_ARRAY*/, XDir /*DOUBLE_FIXED_ARRAY*/, Center_Point /*DOUBLE_FIXED_ARRAY*/, Height);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setviewA(fdt_resbufA View_deflist, int Vport_id) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setviewA(swigCPtr, fdt_resbufA.getCPtr(View_deflist), Vport_id);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setviewW(fdt_resbufW View_deflist, int Vport_id) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setviewW(swigCPtr, fdt_resbufW.getCPtr(View_deflist), Vport_id);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getactvport(out short nDbNo, out short nVpNo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getactvport(swigCPtr, out nDbNo, out nVpNo);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setactvport(short nDbNo, short nVpNo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setactvport(swigCPtr, nDbNo, nVpNo);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_zoomext(short nDbNo, short nVpNo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_zoomext(swigCPtr, nDbNo, nVpNo);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_gethandle(out IntPtr /*SIMPLETYPE*/ frame_hwnd, out IntPtr /*SIMPLETYPE*/ client_hwnd) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_gethandle(swigCPtr, out frame_hwnd, out client_hwnd);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_compfontA(string source_file, string target_file) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_compfontA(swigCPtr, source_file, target_file);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_compfontW(string source_file, string target_file) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_compfontW(swigCPtr, source_file, target_file);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setcursor(short nDbNo, cursordef cursor_style) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setcursor(swigCPtr, nDbNo, cursordef.getCPtr(cursor_style));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getcursor(short nDbNo, cursordef cursor_style) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getcursor(swigCPtr, nDbNo, cursordef.getCPtr(cursor_style));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_poly2bspline(ref UInt64[] /*OUT_ARRAY*/ ename, int steps) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_poly2bspline(swigCPtr, p_ename, steps);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_bspline2poly(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_bspline2poly(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_poly2catrom_2d(ref UInt64[] /*OUT_ARRAY*/ ename, int steps, double tension) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_poly2catrom_2d(swigCPtr, p_ename, steps, tension);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_catrom2poly_2d(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_catrom2poly_2d(swigCPtr, p_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_inputA(string Prompt, int FilterFlag) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_inputA(swigCPtr, Prompt, FilterFlag);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_inputW(string Prompt, int FilterFlag) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_inputW(swigCPtr, Prompt, FilterFlag);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_boundingbox(ref UInt64[] /*OUT_ARRAY*/ name, double[] /*DOUBLE_FIXED_ARRAY*/ min, double[] /*DOUBLE_FIXED_ARRAY*/ max) {
IntPtr p_name=Teigha.Core.Helpers.MarshalUInt64FixedArray(name);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_boundingbox(swigCPtr, p_name, min /*DOUBLE_FIXED_ARRAY*/, max /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
name = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_name); Marshal.FreeCoTaskMem(p_name);
    }
  }
 
  public virtual int fdt_pcontour(ref UInt64[] /*OUT_ARRAY*/ ssname, int mode, double[] /*DOUBLE_FIXED_ARRAY*/ inner_pnt, ref UInt64[] /*OUT_ARRAY*/ resname) {
IntPtr p_ssname=Teigha.Core.Helpers.MarshalUInt64FixedArray(ssname);
IntPtr p_resname=Teigha.Core.Helpers.MarshalUInt64FixedArray(resname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_pcontour(swigCPtr, p_ssname, mode, inner_pnt /*DOUBLE_FIXED_ARRAY*/, p_resname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ssname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ssname); Marshal.FreeCoTaskMem(p_ssname);
resname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_resname); Marshal.FreeCoTaskMem(p_resname);
    }
  }
 
  public virtual int fdt_wmfoutA(string szFileName, int nDbNo, int nWndNo, char Mode, double[] /*DOUBLE_FIXED_ARRAY*/ PntMin, double[] /*DOUBLE_FIXED_ARRAY*/ PntMax, int nGroundColor, int nEntityColor) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_wmfoutA(swigCPtr, szFileName, nDbNo, nWndNo, Mode, PntMin /*DOUBLE_FIXED_ARRAY*/, PntMax /*DOUBLE_FIXED_ARRAY*/, nGroundColor, nEntityColor);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_wmfoutW(string szFileName, int nDbNo, int nWndNo, char Mode, double[] /*DOUBLE_FIXED_ARRAY*/ PntMin, double[] /*DOUBLE_FIXED_ARRAY*/ PntMax, int nGroundColor, int nEntityColor) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_wmfoutW(swigCPtr, szFileName, nDbNo, nWndNo, Mode, PntMin /*DOUBLE_FIXED_ARRAY*/, PntMax /*DOUBLE_FIXED_ARRAY*/, nGroundColor, nEntityColor);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setselecthookA(SWIGTYPE_p_f_a_2__q_const__uintptr_t__int fnSelHook, string lpszAppName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setselecthookA(swigCPtr, SWIGTYPE_p_f_a_2__q_const__uintptr_t__int.getCPtr(fnSelHook), lpszAppName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setselecthookW(SWIGTYPE_p_f_a_2__q_const__uintptr_t__int fnSelHook, string lpszAppName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setselecthookW(swigCPtr, SWIGTYPE_p_f_a_2__q_const__uintptr_t__int.getCPtr(fnSelHook), lpszAppName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setselecthookex(SWIGTYPE_p_f_a_2__uintptr_t__int fnSelHook, SWIGTYPE_p_p_f_a_2__uintptr_t__int fnOldProc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setselecthookex(swigCPtr, SWIGTYPE_p_f_a_2__uintptr_t__int.getCPtr(fnSelHook), SWIGTYPE_p_p_f_a_2__uintptr_t__int.getCPtr(fnOldProc));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delselecthook(SWIGTYPE_p_f_a_2__q_const__uintptr_t__int fnSelHook) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delselecthook(swigCPtr, SWIGTYPE_p_f_a_2__q_const__uintptr_t__int.getCPtr(fnSelHook));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delselecthookex() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delselecthookex(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_purgeselecthooklist() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_purgeselecthooklist(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setmousehook(SWIGTYPE_p_f_int_a_3__q_const__double_a_3__q_const__double__int fnMouseHook, short MouseButton) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setmousehook(swigCPtr, SWIGTYPE_p_f_int_a_3__q_const__double_a_3__q_const__double__int.getCPtr(fnMouseHook), MouseButton);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delmousehook() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delmousehook(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setdbmodhookA(SWIGTYPE_p_f_a_2__q_const__uintptr_t__int fnDbModHook, string lpszAppName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setdbmodhookA(swigCPtr, SWIGTYPE_p_f_a_2__q_const__uintptr_t__int.getCPtr(fnDbModHook), lpszAppName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setdbmodhookW(SWIGTYPE_p_f_a_2__q_const__uintptr_t__int fnDbModHook, string lpszAppName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setdbmodhookW(swigCPtr, SWIGTYPE_p_f_a_2__q_const__uintptr_t__int.getCPtr(fnDbModHook), lpszAppName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_deldbmodhook(SWIGTYPE_p_f_a_2__q_const__uintptr_t__int fnDbModHook) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_deldbmodhook(swigCPtr, SWIGTYPE_p_f_a_2__q_const__uintptr_t__int.getCPtr(fnDbModHook));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_purgedbmodhooklist() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_purgedbmodhooklist(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entnext_dbhook(ref UInt64[] /*OUT_ARRAY*/ ename, ref UInt64[] /*OUT_ARRAY*/ next_ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
IntPtr p_next_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(next_ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entnext_dbhook(swigCPtr, p_ename, p_next_ename);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
next_ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_next_ename); Marshal.FreeCoTaskMem(p_next_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_entget_dbhookA(ref UInt64[] /*OUT_ARRAY*/ ename, bool openErased) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entget_dbhookA__SWIG_0(swigCPtr, p_ename, openErased);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufA fdt_entget_dbhookA(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entget_dbhookA__SWIG_1(swigCPtr, p_ename);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufW fdt_entget_dbhookW(ref UInt64[] /*OUT_ARRAY*/ ename, bool openErased) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entget_dbhookW__SWIG_0(swigCPtr, p_ename, openErased);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual fdt_resbufW fdt_entget_dbhookW(ref UInt64[] /*OUT_ARRAY*/ ename) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_entget_dbhookW__SWIG_1(swigCPtr, p_ename);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_entmod_dbhookA(fdt_resbufA rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmod_dbhookA(swigCPtr, fdt_resbufA.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entmod_dbhookW(fdt_resbufW rbuffer) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmod_dbhookW(swigCPtr, fdt_resbufW.getCPtr(rbuffer));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_entmod_type() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_entmod_type(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isselecthook() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isselecthook(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_isdbmodhook() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_isdbmodhook(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_ismousehook() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_ismousehook(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setfunhelpA(string szName, string szHelpFile, string szHelpTopic) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setfunhelpA(swigCPtr, szName, szHelpFile, szHelpTopic);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setfunhelpW(string szName, string szHelpFile, string szHelpTopic) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setfunhelpW(swigCPtr, szName, szHelpFile, szHelpTopic);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_addimage2libA(string szLibName, string szImageString, string szImagePath, ushort wType) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_addimage2libA(swigCPtr, szLibName, szImageString, szImagePath, wType);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_addimage2libW(string szLibName, string szImageString, string szImagePath, ushort wType) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_addimage2libW(swigCPtr, szLibName, szImageString, szImagePath, wType);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual ushort fdt_getimagetypeA(string szLibName, string szImageString) {
    ushort ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getimagetypeA(swigCPtr, szLibName, szImageString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual ushort fdt_getimagetypeW(string szLibName, string szImageString) {
    ushort ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getimagetypeW(swigCPtr, szLibName, szImageString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delimagefromlibA(string szLibName, string szImageString) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delimagefromlibA(swigCPtr, szLibName, szImageString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_delimagefromlibW(string szLibName, string szImageString) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_delimagefromlibW(swigCPtr, szLibName, szImageString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_remove(ref UInt64[] /*OUT_ARRAY*/ ssname) {
IntPtr p_ssname=Teigha.Core.Helpers.MarshalUInt64FixedArray(ssname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_remove(swigCPtr, p_ssname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ssname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ssname); Marshal.FreeCoTaskMem(p_ssname);
    }
  }
 
  public virtual int fdt_removeall() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_removeall(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_remdelall() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_remdelall(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setpreselect(ref UInt64[] /*OUT_ARRAY*/ selset) {
IntPtr p_selset=Teigha.Core.Helpers.MarshalUInt64FixedArray(selset);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setpreselect(swigCPtr, p_selset);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
selset = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_selset); Marshal.FreeCoTaskMem(p_selset);
    }
  }
 
  public virtual int fdt_getprofileslistA(string CurrentProfileName, SWIGTYPE_p_p_fdt_resbufA ListOfProfiles, uint size) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getprofileslistA(swigCPtr, CurrentProfileName, SWIGTYPE_p_p_fdt_resbufA.getCPtr(ListOfProfiles), size);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getprofileslistW(string CurrentProfileName, SWIGTYPE_p_p_fdt_resbufW ListOfProfiles, uint size) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getprofileslistW(swigCPtr, CurrentProfileName, SWIGTYPE_p_p_fdt_resbufW.getCPtr(ListOfProfiles), size);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_genout(ref UInt64[] /*OUT_ARRAY*/ ename, short mode, IntPtr /*SIMPLETYPE*/ UserData, SWIGTYPE_p_f_p_FDT_GENOUTREC_p_void__short CallBackFunction) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_genout(swigCPtr, p_ename, mode, UserData /*SIMPLETYPE*/, SWIGTYPE_p_f_p_FDT_GENOUTREC_p_void__short.getCPtr(CallBackFunction));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual int fdt_genout_enamesA(SWIGTYPE_p_p_fdt_resbufA rb) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_genout_enamesA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(rb));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_genout_enamesW(SWIGTYPE_p_p_fdt_resbufW rb) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_genout_enamesW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(rb));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual IntPtr fdt_AddUserImage(WORLDPOINT LowerLeft, WORLDPOINT UpperRight, int iSpace, SWIGTYPE_p_f_p_void_HDC_devpoint_devpoint_worldpoint_worldpoint_worldpoint_worldpoint_int_int_p_void__void pImageProc, IntPtr /*SIMPLETYPE*/ pUser) { 
// test csout
 /*SIMPLETYPE*/
     IntPtr ret = PCADGlobalsPINVOKE.CFxAPI_fdt_AddUserImage(swigCPtr, WORLDPOINT.getCPtr(LowerLeft), WORLDPOINT.getCPtr(UpperRight), iSpace, SWIGTYPE_p_f_p_void_HDC_devpoint_devpoint_worldpoint_worldpoint_worldpoint_worldpoint_int_int_p_void__void.getCPtr(pImageProc), pUser /*SIMPLETYPE*/); 
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual int fdt_DeleteUserImage(IntPtr /*SIMPLETYPE*/ hImage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_DeleteUserImage(swigCPtr, hImage /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_SetRedrawHook(SWIGTYPE_p_f_short_short_short_short__int arg0, short arg1) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_SetRedrawHook(swigCPtr, SWIGTYPE_p_f_short_short_short_short__int.getCPtr(arg0), arg1);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_DelRedrawHook(short arg0) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_DelRedrawHook(swigCPtr, arg0);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual int fdt_GetVportExtInfo(short arg0, short arg1, fdt_VPORT_EXT_INFO arg2) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_GetVportExtInfo(swigCPtr, arg0, arg1, fdt_VPORT_EXT_INFO.getCPtr(arg2));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_SetPrintHook(SWIGTYPE_p_f_p_PRINTREC__int PrintHook) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_SetPrintHook(swigCPtr, SWIGTYPE_p_f_p_PRINTREC__int.getCPtr(PrintHook));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_DelPrintHook() {
    PCADGlobalsPINVOKE.CFxAPI_fdt_DelPrintHook(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual int fdt_GetPrintExtInfo(PRINT_EXT_INFO PrintExtInfo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_GetPrintExtInfo(swigCPtr, PRINT_EXT_INFO.getCPtr(PrintExtInfo));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_Vcs2PrinterPnt(double arg0, double arg1, out int arg2, out int arg3) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_Vcs2PrinterPnt(swigCPtr, arg0, arg1, out arg2, out arg3);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_GetLastViewportEntId() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_GetLastViewportEntId(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getconfstringA(string lpAppName, string lpKeyName, string lpDefault, string lpReturnedString, uint nSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getconfstringA(swigCPtr, lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getconfstringW(string lpAppName, string lpKeyName, string lpDefault, string lpReturnedString, uint nSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getconfstringW(swigCPtr, lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getconfintA(string lpAppName, string lpKeyName, int nDefault) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getconfintA(swigCPtr, lpAppName, lpKeyName, nDefault);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getconfintW(string lpAppName, string lpKeyName, int nDefault) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getconfintW(swigCPtr, lpAppName, lpKeyName, nDefault);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setconfstringA(string lpAppName, string lpKeyName, string lpString) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setconfstringA(swigCPtr, lpAppName, lpKeyName, lpString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setconfstringW(string lpAppName, string lpKeyName, string lpString) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setconfstringW(swigCPtr, lpAppName, lpKeyName, lpString);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setconfintA(string lpAppName, string lpKeyName, int nValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setconfintA(swigCPtr, lpAppName, lpKeyName, nValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setconfintW(string lpAppName, string lpKeyName, int nValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setconfintW(swigCPtr, lpAppName, lpKeyName, nValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_registry_deleteA(string lpKey, string lpName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_deleteA(swigCPtr, lpKey, lpName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_registry_deleteW(string lpKey, string lpName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_deleteW(swigCPtr, lpKey, lpName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA fdt_registry_descendentsA(string lpKey, short values) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_descendentsA(swigCPtr, lpKey, values);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_registry_descendentsW(string lpKey, short values) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_descendentsW(swigCPtr, lpKey, values);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA fdt_registry_readA(string lpKey, string lpName) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_readA(swigCPtr, lpKey, lpName);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW fdt_registry_readW(string lpKey, string lpName) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_readW(swigCPtr, lpKey, lpName);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_registry_writeA(string lpKey, string lpName, string lpValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_writeA(swigCPtr, lpKey, lpName, lpValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_registry_writeW(string lpKey, string lpName, string lpValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_registry_writeW(swigCPtr, lpKey, lpName, lpValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_deleteA(string lpFile) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_deleteA(swigCPtr, lpFile);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_deleteW(string lpFile) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_deleteW(swigCPtr, lpFile);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_copyA(string lpSource, string lpDest, int iAppend, out int iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_copyA(swigCPtr, lpSource, lpDest, iAppend, out iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_copyW(string lpSource, string lpDest, int iAppend, out int iSize) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_copyW(swigCPtr, lpSource, lpDest, iAppend, out iSize);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_renameA(string lpSource, string lpDest) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_renameA(swigCPtr, lpSource, lpDest);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_renameW(string lpSource, string lpDest) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_renameW(swigCPtr, lpSource, lpDest);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_sizeA(string lpFile, int[] lpValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_sizeA(swigCPtr, lpFile, lpValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_sizeW(string lpfile, int[] lpValue) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_sizeW(swigCPtr, lpfile, lpValue);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_systimeA(string lpFile, out int iYear, out int iMonth, out int iWeekDay, out int iMonthDay, out int iHour, out int iMinute, out int iSecond, out int iMilliSecond) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_systimeA(swigCPtr, lpFile, out iYear, out iMonth, out iWeekDay, out iMonthDay, out iHour, out iMinute, out iSecond, out iMilliSecond);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_systimeW(string lpfile, out int iYear, out int iMonth, out int iWeekDay, out int iMonthDay, out int iHour, out int iMinute, out int iSecond, out int iMilliSecond) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_systimeW(swigCPtr, lpfile, out iYear, out iMonth, out iWeekDay, out iMonthDay, out iHour, out iMinute, out iSecond, out iMilliSecond);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_directory_pA(string lpFile) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_directory_pA(swigCPtr, lpFile);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_file_directory_pW(string lpFile) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_file_directory_pW(swigCPtr, lpFile);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_directory_filesA(string lpDirectory, string lpFilter, int mode, SWIGTYPE_p_p_fdt_resbufA lpResult) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_directory_filesA(swigCPtr, lpDirectory, lpFilter, mode, SWIGTYPE_p_p_fdt_resbufA.getCPtr(lpResult));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_directory_filesW(string lpDirectory, string lpFilter, int mode, SWIGTYPE_p_p_fdt_resbufW lpResult) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_directory_filesW(swigCPtr, lpDirectory, lpFilter, mode, SWIGTYPE_p_p_fdt_resbufW.getCPtr(lpResult));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_directoryA(string lpFile, string lpDir, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_directoryA(swigCPtr, lpFile, lpDir, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_directoryW(string lpFile, string lpDir, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_directoryW(swigCPtr, lpFile, lpDir, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_baseA(string lpFile, string lpDir, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_baseA(swigCPtr, lpFile, lpDir, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_baseW(string lpFile, string lpDir, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_baseW(swigCPtr, lpFile, lpDir, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_extensionA(string lpFile, string lpDir, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_extensionA(swigCPtr, lpFile, lpDir, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_extensionW(string lpFile, string lpDir, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_extensionW(swigCPtr, lpFile, lpDir, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_mktempA(string lpPattern, string lpDirectory, string lpExt, string lpFile, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_mktempA(swigCPtr, lpPattern, lpDirectory, lpExt, lpFile, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_filename_mktempW(string lpPattern, string lpDirectory, string lpExt, string lpFile, int iCount) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_filename_mktempW(swigCPtr, lpPattern, lpDirectory, lpExt, lpFile, iCount);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_dictionary_addA(ref UInt64[] /*OUT_ARRAY*/ dict, string lpName, ref UInt64[] /*OUT_ARRAY*/ object_) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
IntPtr p_object_=Teigha.Core.Helpers.MarshalUInt64FixedArray(object_);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_addA(swigCPtr, p_dict, lpName, p_object_);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
object_ = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_object_); Marshal.FreeCoTaskMem(p_object_);
    }
  }
 
  public virtual int fdt_dictionary_addW(ref UInt64[] /*OUT_ARRAY*/ dict, string lpName, ref UInt64[] /*OUT_ARRAY*/ object_) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
IntPtr p_object_=Teigha.Core.Helpers.MarshalUInt64FixedArray(object_);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_addW(swigCPtr, p_dict, lpName, p_object_);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
object_ = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_object_); Marshal.FreeCoTaskMem(p_object_);
    }
  }
 
  public virtual int fdt_dictionary_deleteA(ref UInt64[] /*OUT_ARRAY*/ dict, string lpName, ref UInt64[] /*OUT_ARRAY*/ object_) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
IntPtr p_object_=Teigha.Core.Helpers.MarshalUInt64FixedArray(object_);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_deleteA(swigCPtr, p_dict, lpName, p_object_);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
object_ = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_object_); Marshal.FreeCoTaskMem(p_object_);
    }
  }
 
  public virtual int fdt_dictionary_deleteW(ref UInt64[] /*OUT_ARRAY*/ dict, string lpName, ref UInt64[] /*OUT_ARRAY*/ object_) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
IntPtr p_object_=Teigha.Core.Helpers.MarshalUInt64FixedArray(object_);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_deleteW(swigCPtr, p_dict, lpName, p_object_);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
object_ = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_object_); Marshal.FreeCoTaskMem(p_object_);
    }
  }
 
  public virtual fdt_resbufA fdt_dictionary_nextA(ref UInt64[] /*OUT_ARRAY*/ dict, int flag) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_nextA(swigCPtr, p_dict, flag);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual fdt_resbufW fdt_dictionary_nextW(ref UInt64[] /*OUT_ARRAY*/ dict, int flag) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_nextW(swigCPtr, p_dict, flag);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual fdt_resbufA fdt_dictionary_searchA(ref UInt64[] /*OUT_ARRAY*/ dict, string lpName, int iSetNext) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_searchA(swigCPtr, p_dict, lpName, iSetNext);
      fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual fdt_resbufW fdt_dictionary_searchW(ref UInt64[] /*OUT_ARRAY*/ dict, string lpName, int iSetNext) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_searchW(swigCPtr, p_dict, lpName, iSetNext);
      fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual int fdt_dictionary_renameA(ref UInt64[] /*OUT_ARRAY*/ dict, string lpNameOld, string lpNameNew) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_renameA(swigCPtr, p_dict, lpNameOld, lpNameNew);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual int fdt_dictionary_renameW(ref UInt64[] /*OUT_ARRAY*/ dict, string lpNameOld, string lpNameNew) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_dictionary_renameW(swigCPtr, p_dict, lpNameOld, lpNameNew);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual int fdt_namedobjdict(ref UInt64[] /*OUT_ARRAY*/ dict) {
IntPtr p_dict=Teigha.Core.Helpers.MarshalUInt64FixedArray(dict);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_namedobjdict(swigCPtr, p_dict);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
dict = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_dict); Marshal.FreeCoTaskMem(p_dict);
    }
  }
 
  public virtual int fdt_curve_getarea(ref UInt64[] /*OUT_ARRAY*/ curve, out double value) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getarea(swigCPtr, p_curve, out value);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getclosestpointto(ref UInt64[] /*OUT_ARRAY*/ curve, double[] /*DOUBLE_FIXED_ARRAY*/ point, int iExtend, double[] /*DOUBLE_FIXED_ARRAY*/ retvalue) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getclosestpointto(swigCPtr, p_curve, point /*DOUBLE_FIXED_ARRAY*/, iExtend, retvalue /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getclosestpointtoprojection(ref UInt64[] /*OUT_ARRAY*/ curve, double[] /*DOUBLE_FIXED_ARRAY*/ point, double[] /*DOUBLE_FIXED_ARRAY*/ normal, int iExtend, double[] /*DOUBLE_FIXED_ARRAY*/ retvalue) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getclosestpointtoprojection(swigCPtr, p_curve, point /*DOUBLE_FIXED_ARRAY*/, normal /*DOUBLE_FIXED_ARRAY*/, iExtend, retvalue /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getdistatparam(ref UInt64[] /*OUT_ARRAY*/ curve, double param, out double value) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getdistatparam(swigCPtr, p_curve, param, out value);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getdistatpoint(ref UInt64[] /*OUT_ARRAY*/ curve, double[] /*DOUBLE_FIXED_ARRAY*/ point, out double value) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getdistatpoint(swigCPtr, p_curve, point /*DOUBLE_FIXED_ARRAY*/, out value);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getendparam(ref UInt64[] /*OUT_ARRAY*/ curve, out double param) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getendparam(swigCPtr, p_curve, out param);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getendpoint(ref UInt64[] /*OUT_ARRAY*/ curve, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getendpoint(swigCPtr, p_curve, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getstartparam(ref UInt64[] /*OUT_ARRAY*/ curve, out double param) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getstartparam(swigCPtr, p_curve, out param);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getstartpoint(ref UInt64[] /*OUT_ARRAY*/ curve, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getstartpoint(swigCPtr, p_curve, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getparamatdist(ref UInt64[] /*OUT_ARRAY*/ curve, double dist, out double param) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getparamatdist(swigCPtr, p_curve, dist, out param);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getpointatdist(ref UInt64[] /*OUT_ARRAY*/ curve, double dist, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getpointatdist(swigCPtr, p_curve, dist, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getpointatparam(ref UInt64[] /*OUT_ARRAY*/ curve, double param, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getpointatparam(swigCPtr, p_curve, param, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getparamatpoint(ref UInt64[] /*OUT_ARRAY*/ curve, double[] /*DOUBLE_FIXED_ARRAY*/ point, out double param) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getparamatpoint(swigCPtr, p_curve, point /*DOUBLE_FIXED_ARRAY*/, out param);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getfirstderiv(ref UInt64[] /*OUT_ARRAY*/ curve, double param, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getfirstderiv(swigCPtr, p_curve, param, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_getsecondderiv(ref UInt64[] /*OUT_ARRAY*/ curve, double param, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_getsecondderiv(swigCPtr, p_curve, param, point /*DOUBLE_FIXED_ARRAY*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_isclosed(ref UInt64[] /*OUT_ARRAY*/ curve, out int iBool) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_isclosed(swigCPtr, p_curve, out iBool);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_isperiodic(ref UInt64[] /*OUT_ARRAY*/ curve, out int iBool) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_isperiodic(swigCPtr, p_curve, out iBool);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_curve_isplanar(ref UInt64[] /*OUT_ARRAY*/ curve, out int iBool) {
IntPtr p_curve=Teigha.Core.Helpers.MarshalUInt64FixedArray(curve);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_curve_isplanar(swigCPtr, p_curve, out iBool);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
curve = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_curve); Marshal.FreeCoTaskMem(p_curve);
    }
  }
 
  public virtual int fdt_translateA(string context, string string_, string result, uint size) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_translateA(swigCPtr, context, string_, result, size);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_translateW(string context, string string_, string result, uint size) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_translateW(swigCPtr, context, string_, result, size);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_xdsizeW(fdt_resbufW rbuffer, out int size) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xdsizeW(swigCPtr, fdt_resbufW.getCPtr(rbuffer), out size);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_xdsizeA(fdt_resbufA rbuffer, out int size) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_xdsizeA(swigCPtr, fdt_resbufA.getCPtr(rbuffer), out size);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogLoadA(string dlg_file, out int dlg_id) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogLoadA(swigCPtr, dlg_file, out dlg_id);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogLoadW(string dlg_file, out int dlg_id) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogLoadW(swigCPtr, dlg_file, out dlg_id);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogUnload(int dlg_id) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogUnload(swigCPtr, dlg_id);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogNewA(string dlg_name, int dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetA_p_void__void def_callback, SWIGTYPE_p_p_void hdlg) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogNewA(swigCPtr, dlg_name, dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetA_p_void__void.getCPtr(def_callback), SWIGTYPE_p_p_void.getCPtr(hdlg));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogNewW(string dlg_name, int dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetW_p_void__void def_callback, SWIGTYPE_p_p_void hdlg) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogNewW(swigCPtr, dlg_name, dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetW_p_void__void.getCPtr(def_callback), SWIGTYPE_p_p_void.getCPtr(hdlg));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogNewPositionedA(string dlg_name, int dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetA_p_void__void def_callback, int x, int y, SWIGTYPE_p_p_void hdlg) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogNewPositionedA(swigCPtr, dlg_name, dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetA_p_void__void.getCPtr(def_callback), x, y, SWIGTYPE_p_p_void.getCPtr(hdlg));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogNewPositionedW(string dlg_name, int dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetW_p_void__void def_callback, int x, int y, SWIGTYPE_p_p_void hdlg) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogNewPositionedW(swigCPtr, dlg_name, dlg_id, SWIGTYPE_p_f_p_dlg_callback_packetW_p_void__void.getCPtr(def_callback), x, y, SWIGTYPE_p_p_void.getCPtr(hdlg));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogStart(IntPtr /*SIMPLETYPE*/ hdlg, out int status, SWIGTYPE_p_f_p_void_p_void__void init_dialog_callback) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogStart(swigCPtr, hdlg /*SIMPLETYPE*/, out status, SWIGTYPE_p_f_p_void_p_void__void.getCPtr(init_dialog_callback));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogDone(IntPtr /*SIMPLETYPE*/ hdlg, int status) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogDone(swigCPtr, hdlg /*SIMPLETYPE*/, status);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogDonePositioned(IntPtr /*SIMPLETYPE*/ hdlg, int status, out int x_result, out int y_result) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogDonePositioned(swigCPtr, hdlg /*SIMPLETYPE*/, status, out x_result, out y_result);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_DialogTerm() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_DialogTerm(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileActionA(IntPtr /*SIMPLETYPE*/ hdlg, string key, SWIGTYPE_p_f_p_dlg_callback_packetA_p_void__void tilefunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileActionA(swigCPtr, hdlg /*SIMPLETYPE*/, key, SWIGTYPE_p_f_p_dlg_callback_packetA_p_void__void.getCPtr(tilefunc));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileActionW(IntPtr /*SIMPLETYPE*/ hdlg, string key, SWIGTYPE_p_f_p_dlg_callback_packetW_p_void__void tilefunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileActionW(swigCPtr, hdlg /*SIMPLETYPE*/, key, SWIGTYPE_p_f_p_dlg_callback_packetW_p_void__void.getCPtr(tilefunc));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileSetA(IntPtr /*SIMPLETYPE*/ hdlg, string key, string value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileSetA(swigCPtr, hdlg /*SIMPLETYPE*/, key, value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileSetW(IntPtr /*SIMPLETYPE*/ hdlg, string key, string value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileSetW(swigCPtr, hdlg /*SIMPLETYPE*/, key, value);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileGetA(IntPtr /*SIMPLETYPE*/ hdlg, string key, string value, int maxlen) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileGetA(swigCPtr, hdlg /*SIMPLETYPE*/, key, value, maxlen);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileGetW(IntPtr /*SIMPLETYPE*/ hdlg, string key, string value, int maxlen) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileGetW(swigCPtr, hdlg /*SIMPLETYPE*/, key, value, maxlen);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileClientDataA(IntPtr /*SIMPLETYPE*/ hdlg, string key, IntPtr /*SIMPLETYPE*/ clientdata) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileClientDataA(swigCPtr, hdlg /*SIMPLETYPE*/, key, clientdata /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileClientDataW(IntPtr /*SIMPLETYPE*/ hdlg, string key, IntPtr /*SIMPLETYPE*/ clientdata) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileClientDataW(swigCPtr, hdlg /*SIMPLETYPE*/, key, clientdata /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileModeA(IntPtr /*SIMPLETYPE*/ hdlg, string key, short mode) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileModeA(swigCPtr, hdlg /*SIMPLETYPE*/, key, mode);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileModeW(IntPtr /*SIMPLETYPE*/ hdlg, string key, short mode) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileModeW(swigCPtr, hdlg /*SIMPLETYPE*/, key, mode);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileDimensionsA(IntPtr /*SIMPLETYPE*/ hdlg, string key, out short cx, out short cy) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileDimensionsA(swigCPtr, hdlg /*SIMPLETYPE*/, key, out cx, out cy);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileDimensionsW(IntPtr /*SIMPLETYPE*/ hdlg, string key, out short cx, out short cy) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileDimensionsW(swigCPtr, hdlg /*SIMPLETYPE*/, key, out cx, out cy);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileSetFontA(IntPtr /*SIMPLETYPE*/ hdlg, string key, short font) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileSetFontA(swigCPtr, hdlg /*SIMPLETYPE*/, key, font);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_TileSetFontW(IntPtr /*SIMPLETYPE*/ hdlg, string key, short font) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_TileSetFontW(swigCPtr, hdlg /*SIMPLETYPE*/, key, font);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListStartA(IntPtr /*SIMPLETYPE*/ hdlg, string key, short operation, short index) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListStartA(swigCPtr, hdlg /*SIMPLETYPE*/, key, operation, index);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListStartW(IntPtr /*SIMPLETYPE*/ hdlg, string key, short operation, short index) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListStartW(swigCPtr, hdlg /*SIMPLETYPE*/, key, operation, index);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListAddA(string item) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListAddA(swigCPtr, item);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListAddW(string item) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListAddW(swigCPtr, item);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListGetA(out int nPos, string szBuffer, int maxlen) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListGetA(swigCPtr, out nPos, szBuffer, maxlen);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListGetW(out int nPos, string szBuffer, int maxlen) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListGetW(swigCPtr, out nPos, szBuffer, maxlen);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListEnd() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListEnd(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListSetTabStopsA(IntPtr /*SIMPLETYPE*/ hdlg, string key, string tabstops) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListSetTabStopsA(swigCPtr, hdlg /*SIMPLETYPE*/, key, tabstops);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListSetTabStopsW(IntPtr /*SIMPLETYPE*/ hdlg, string key, string tabstops) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListSetTabStopsW(swigCPtr, hdlg /*SIMPLETYPE*/, key, tabstops);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListSetColumnWidthA(IntPtr /*SIMPLETYPE*/ hdlg, string key, string columnwidth) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListSetColumnWidthA(swigCPtr, hdlg /*SIMPLETYPE*/, key, columnwidth);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ListSetColumnWidthW(IntPtr /*SIMPLETYPE*/ hdlg, string key, string columnwidth) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ListSetColumnWidthW(swigCPtr, hdlg /*SIMPLETYPE*/, key, columnwidth);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_SliderGetA(IntPtr /*SIMPLETYPE*/ hdlg, string key, out int nCurPos, out int nMinPos, out int nMaxPos, out int nSmallInc, out int nBigInc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_SliderGetA(swigCPtr, hdlg /*SIMPLETYPE*/, key, out nCurPos, out nMinPos, out nMaxPos, out nSmallInc, out nBigInc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_SliderGetW(IntPtr /*SIMPLETYPE*/ hdlg, string key, out int nCurPos, out int nMinPos, out int nMaxPos, out int nSmallInc, out int nBigInc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_SliderGetW(swigCPtr, hdlg /*SIMPLETYPE*/, key, out nCurPos, out nMinPos, out nMaxPos, out nSmallInc, out nBigInc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_SliderSetA(IntPtr /*SIMPLETYPE*/ hdlg, string key, int nCurPos, int nMinPos, int nMaxPos, int nSmallInc, int nBigInc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_SliderSetA(swigCPtr, hdlg /*SIMPLETYPE*/, key, nCurPos, nMinPos, nMaxPos, nSmallInc, nBigInc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_SliderSetW(IntPtr /*SIMPLETYPE*/ hdlg, string key, int nCurPos, int nMinPos, int nMaxPos, int nSmallInc, int nBigInc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_SliderSetW(swigCPtr, hdlg /*SIMPLETYPE*/, key, nCurPos, nMinPos, nMaxPos, nSmallInc, nBigInc);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageStartA(IntPtr /*SIMPLETYPE*/ hdlg, string key) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageStartA(swigCPtr, hdlg /*SIMPLETYPE*/, key);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageStartW(IntPtr /*SIMPLETYPE*/ hdlg, string key) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageStartW(swigCPtr, hdlg /*SIMPLETYPE*/, key);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageEnd() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageEnd(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageVector(short x1, short y1, short x2, short y2, short color) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageVector(swigCPtr, x1, y1, x2, y2, color);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageFill(short x1, short y1, short x2, short y2, short color) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageFill(swigCPtr, x1, y1, x2, y2, color);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageBmpA(short x1, short y1, short x2, short y2, string szBmpPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageBmpA(swigCPtr, x1, y1, x2, y2, szBmpPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageBmpW(short x1, short y1, short x2, short y2, string szBmpPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageBmpW(swigCPtr, x1, y1, x2, y2, szBmpPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImagePreviewBmpA(short x1, short y1, short x2, short y2, string szDrawingPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImagePreviewBmpA(swigCPtr, x1, y1, x2, y2, szDrawingPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImagePreviewBmpW(short x1, short y1, short x2, short y2, string szDrawingPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImagePreviewBmpW(swigCPtr, x1, y1, x2, y2, szDrawingPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageWmfA(short x1, short y1, short x2, short y2, string szWmfPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageWmfA(swigCPtr, x1, y1, x2, y2, szWmfPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageWmfW(short x1, short y1, short x2, short y2, string szWmfPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageWmfW(swigCPtr, x1, y1, x2, y2, szWmfPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageSlideA(short x1, short y1, short x2, short y2, string szDrawingPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageSlideA(swigCPtr, x1, y1, x2, y2, szDrawingPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageSlideW(short x1, short y1, short x2, short y2, string szDrawingPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageSlideW(swigCPtr, x1, y1, x2, y2, szDrawingPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageLibraryA(short x1, short y1, short x2, short y2, string szImageName, string szLibPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageLibraryA(swigCPtr, x1, y1, x2, y2, szImageName, szLibPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dlg_ImageLibraryW(short x1, short y1, short x2, short y2, string szImageName, string szLibPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dlg_ImageLibraryW(swigCPtr, x1, y1, x2, y2, szImageName, szLibPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_new_dialogA(string szDialogName, int nDialogFileID, IntPtr /*SIMPLETYPE*/ pfnDef_Callback, SWIGTYPE_p_p__dcl_hdlg hDialog) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_new_dialogA(swigCPtr, szDialogName, nDialogFileID, pfnDef_Callback /*SIMPLETYPE*/, SWIGTYPE_p_p__dcl_hdlg.getCPtr(hDialog));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_new_dialogW(string szDialogName, int nDialogFileID, IntPtr /*SIMPLETYPE*/ pfnDef_Callback, SWIGTYPE_p_p__dcl_hdlg hDialog) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_new_dialogW(swigCPtr, szDialogName, nDialogFileID, pfnDef_Callback /*SIMPLETYPE*/, SWIGTYPE_p_p__dcl_hdlg.getCPtr(hDialog));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_load_dialogA(string szFileToLoad, out int nDialogFileID) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_load_dialogA(swigCPtr, szFileToLoad, out nDialogFileID);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_load_dialogW(string szFileToLoad, out int nDialogFileID) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_load_dialogW(swigCPtr, szFileToLoad, out nDialogFileID);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_unload_dialog(int nDialogFileID) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_unload_dialog(swigCPtr, nDialogFileID);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_start_dialog(SWIGTYPE_p__dcl_hdlg hDialog, out int nMessage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_start_dialog(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), out nMessage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_done_dialog(SWIGTYPE_p__dcl_hdlg hDialog, int nMessage) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_done_dialog(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), nMessage);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_new_positioned_dialogA(string szDialogName, int nDialogFileID, IntPtr /*SIMPLETYPE*/ pfnDef_Callback, int nXPos, int nYPos, SWIGTYPE_p_p__dcl_hdlg hDialog) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_new_positioned_dialogA(swigCPtr, szDialogName, nDialogFileID, pfnDef_Callback /*SIMPLETYPE*/, nXPos, nYPos, SWIGTYPE_p_p__dcl_hdlg.getCPtr(hDialog));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_new_positioned_dialogW(string szDialogName, int nDialogFileID, IntPtr /*SIMPLETYPE*/ pfnDef_Callback, int nXPos, int nYPos, SWIGTYPE_p_p__dcl_hdlg hDialog) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_new_positioned_dialogW(swigCPtr, szDialogName, nDialogFileID, pfnDef_Callback /*SIMPLETYPE*/, nXPos, nYPos, SWIGTYPE_p_p__dcl_hdlg.getCPtr(hDialog));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_done_positioned_dialog(SWIGTYPE_p__dcl_hdlg hDialog, int nMessage, out int nXPos, out int nYPos) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_done_positioned_dialog(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), nMessage, out nXPos, out nYPos);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_term_dialog() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_term_dialog(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_start_listA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, int nChangeAddNew, int nWhichItem) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_start_listA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, nChangeAddNew, nWhichItem);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_start_listW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, int nChangeAddNew, int nWhichItem) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_start_listW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, nChangeAddNew, nWhichItem);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_add_listA(string szAddToList) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_add_listA(swigCPtr, szAddToList);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_add_listW(string szAddToList) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_add_listW(swigCPtr, szAddToList);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_list_stringA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szListString, int nStringLength, int nWhichItem) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_list_stringA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szListString, nStringLength, nWhichItem);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_list_stringW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szListString, int nStringLength, int nWhichItem) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_list_stringW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szListString, nStringLength, nWhichItem);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_end_list() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_end_list(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_attrA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szAttribName, string szAttribInfo, int lInfoMaxLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_attrA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szAttribName, szAttribInfo, lInfoMaxLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_attrW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szAttribName, string szAttribInfo, int lInfoMaxLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_attrW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szAttribName, szAttribInfo, lInfoMaxLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_attr_stringA(SWIGTYPE_p__dcl_htile hControl, string szAttribName, string szAttribInfo, int lInfoMaxLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_attr_stringA(swigCPtr, SWIGTYPE_p__dcl_htile.getCPtr(hControl), szAttribName, szAttribInfo, lInfoMaxLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_attr_stringW(SWIGTYPE_p__dcl_htile hControl, string szAttribName, string szAttribInfo, int lInfoMaxLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_attr_stringW(swigCPtr, SWIGTYPE_p__dcl_htile.getCPtr(hControl), szAttribName, szAttribInfo, lInfoMaxLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_tileA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szControlInfo, int lInfoMaxLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_tileA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szControlInfo, lInfoMaxLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_tileW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szControlInfo, int lInfoMaxLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_tileW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szControlInfo, lInfoMaxLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_set_tileA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szControlInfo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_set_tileA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szControlInfo);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_set_tileW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, string szControlInfo) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_set_tileW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, szControlInfo);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_action_tileA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, IntPtr /*SIMPLETYPE*/ pfnControlFunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_action_tileA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, pfnControlFunc /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_action_tileW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, IntPtr /*SIMPLETYPE*/ pfnControlFunc) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_action_tileW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, pfnControlFunc /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_mode_tileA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, int nTileState) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_mode_tileA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, nTileState);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_mode_tileW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, int nTileState) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_mode_tileW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, nTileState);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_dimensions_tileA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, out int nWidthLess1, out int nHeightLess1) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_dimensions_tileA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, out nWidthLess1, out nHeightLess1);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_dimensions_tileW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, out int nWidthLess1, out int nHeightLess1) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_dimensions_tileW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, out nWidthLess1, out nHeightLess1);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_start_imageA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_start_imageA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_start_imageW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_start_imageW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_fill_image(int nULCornerX, int nULCornerY, int nWidthLess1, int nHeightLess1, int nColor) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_fill_image(swigCPtr, nULCornerX, nULCornerY, nWidthLess1, nHeightLess1, nColor);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_slide_imageA(int nULCornerX, int nULCornerY, int nWidthLess1, int nHeightLess1, string szSnapshotName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_slide_imageA(swigCPtr, nULCornerX, nULCornerY, nWidthLess1, nHeightLess1, szSnapshotName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_slide_imageW(int nULCornerX, int nULCornerY, int nWidthLess1, int nHeightLess1, string szSnapshotName) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_slide_imageW(swigCPtr, nULCornerX, nULCornerY, nWidthLess1, nHeightLess1, szSnapshotName);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_vector_image(int nXVectStart, int nYVectStart, int nXVectEnd, int nYVectEnd, int nColor) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_vector_image(swigCPtr, nXVectStart, nYVectStart, nXVectEnd, nYVectEnd, nColor);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_end_image() {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_end_image(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_client_data_tileA(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, IntPtr /*SIMPLETYPE*/ pApplicationData) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_client_data_tileA(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, pApplicationData /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_client_data_tileW(SWIGTYPE_p__dcl_hdlg hDialog, string szControlKey, IntPtr /*SIMPLETYPE*/ pApplicationData) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_client_data_tileW(swigCPtr, SWIGTYPE_p__dcl_hdlg.getCPtr(hDialog), szControlKey, pApplicationData /*SIMPLETYPE*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_tile_keyA(SWIGTYPE_p__dcl_htile hTile, string szControlKey, int lControlKeyLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_tile_keyA(swigCPtr, SWIGTYPE_p__dcl_htile.getCPtr(hTile), szControlKey, lControlKeyLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int dcl_get_tile_keyW(SWIGTYPE_p__dcl_htile hTile, string szControlKey, int lControlKeyLength) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_dcl_get_tile_keyW(swigCPtr, SWIGTYPE_p__dcl_htile.getCPtr(hTile), szControlKey, lControlKeyLength);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void fdt_push_resource_handle(SWIGTYPE_p_HINSTANCE hInst) {
    PCADGlobalsPINVOKE.CFxAPI_fdt_push_resource_handle(swigCPtr, SWIGTYPE_p_HINSTANCE.getCPtr(hInst));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void fdt_pop_resource_handle() {
    PCADGlobalsPINVOKE.CFxAPI_fdt_pop_resource_handle(swigCPtr);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual int fdt_install_modeless_hook(SWIGTYPE_p_HWND hWnd, SWIGTYPE_p_HINSTANCE hInst) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_install_modeless_hook(swigCPtr, SWIGTYPE_p_HWND.getCPtr(hWnd), SWIGTYPE_p_HINSTANCE.getCPtr(hInst));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_uninstall_modeless_hook(SWIGTYPE_p_HWND hWnd) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_uninstall_modeless_hook(swigCPtr, SWIGTYPE_p_HWND.getCPtr(hWnd));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_add_support_pathA(string szSupportPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_add_support_pathA(swigCPtr, szSupportPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_add_support_pathW(string szSupportPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_add_support_pathW(swigCPtr, szSupportPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_remove_support_pathA(string szSupportPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_remove_support_pathA(swigCPtr, szSupportPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_remove_support_pathW(string szSupportPath) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_remove_support_pathW(swigCPtr, szSupportPath);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_loaded_appsA(int mode, SWIGTYPE_p_p_fdt_resbufA modules_list) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_loaded_appsA(swigCPtr, mode, SWIGTYPE_p_p_fdt_resbufA.getCPtr(modules_list));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_loaded_appsW(int mode, SWIGTYPE_p_p_fdt_resbufW modules_list) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_loaded_appsW(swigCPtr, mode, SWIGTYPE_p_p_fdt_resbufW.getCPtr(modules_list));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getprinterlistA(SWIGTYPE_p_p_fdt_resbufA printerList) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getprinterlistA(swigCPtr, SWIGTYPE_p_p_fdt_resbufA.getCPtr(printerList));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getprinterlistW(SWIGTYPE_p_p_fdt_resbufW printerList) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getprinterlistW(swigCPtr, SWIGTYPE_p_p_fdt_resbufW.getCPtr(printerList));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getprinterpapersizesA(string printer, SWIGTYPE_p_p_fdt_resbufA paperSizes) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getprinterpapersizesA(swigCPtr, printer, SWIGTYPE_p_p_fdt_resbufA.getCPtr(paperSizes));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getprinterpapersizesW(string printer, SWIGTYPE_p_p_fdt_resbufW paperSizes) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getprinterpapersizesW(swigCPtr, printer, SWIGTYPE_p_p_fdt_resbufW.getCPtr(paperSizes));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getresourceimageA(string filename, SWIGTYPE_p_HBITMAP image) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getresourceimageA(swigCPtr, filename, SWIGTYPE_p_HBITMAP.getCPtr(image));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getresourceimageW(string filename, SWIGTYPE_p_HBITMAP image) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getresourceimageW(swigCPtr, filename, SWIGTYPE_p_HBITMAP.getCPtr(image));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getpreferenceA(string group, string name_pref, SWIGTYPE_p_p_fdt_resbufA value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getpreferenceA(swigCPtr, group, name_pref, SWIGTYPE_p_p_fdt_resbufA.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_getpreferenceW(string group, string name_pref, SWIGTYPE_p_p_fdt_resbufW value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_getpreferenceW(swigCPtr, group, name_pref, SWIGTYPE_p_p_fdt_resbufW.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setpreferenceA(string group, string name_pref, fdt_resbufA value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setpreferenceA(swigCPtr, group, name_pref, fdt_resbufA.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int fdt_setpreferenceW(string group, string name_pref, fdt_resbufW value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_fdt_setpreferenceW(swigCPtr, group, name_pref, fdt_resbufW.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetADSName(OdDbObjectId id, ref UInt64[] /*OUT_ARRAY*/ name) {
IntPtr p_name=Teigha.Core.Helpers.MarshalUInt64FixedArray(name);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_GetADSName(OdDbObjectId.getCPtr(id), p_name);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
name = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_name); Marshal.FreeCoTaskMem(p_name);
    }
  }
 
  public static int GetObjectId(ref UInt64[] /*OUT_ARRAY*/ name, OdDbObjectId id) {
IntPtr p_name=Teigha.Core.Helpers.MarshalUInt64FixedArray(name);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_GetObjectId(p_name, OdDbObjectId.getCPtr(id));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
name = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_name); Marshal.FreeCoTaskMem(p_name);
    }
  }
 
  public static int GetSSName(CFxSelectionSet pSS, ref UInt64[] /*OUT_ARRAY*/ sname) {
IntPtr p_sname=Teigha.Core.Helpers.MarshalUInt64FixedArray(sname);
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_GetSSName(CFxSelectionSet.getCPtr(pSS), p_sname);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
sname = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_sname); Marshal.FreeCoTaskMem(p_sname);
    }
  }
 
  public static CFxSelectionSet GetSSPtr(ref UInt64[] /*OUT_ARRAY*/ name) {
IntPtr p_name=Teigha.Core.Helpers.MarshalUInt64FixedArray(name);
    try {
      global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_GetSSPtr(p_name);
      CFxSelectionSet ret = (cPtr == global::System.IntPtr.Zero) ? null : new CFxSelectionSet(cPtr, false);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
name = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_name); Marshal.FreeCoTaskMem(p_name);
    }
  }
 
  public static int GetPoint3D(double[] /*DOUBLE_FIXED_ARRAY*/ point, OdGePoint3d gePoint) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetPoint3D__SWIG_0(point /*DOUBLE_FIXED_ARRAY*/, OdGePoint3d.getCPtr(gePoint));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetPoint3D(double[] /*DOUBLE_FIXED_ARRAY*/ point, OdGeVector3d gePoint) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetPoint3D__SWIG_1(point /*DOUBLE_FIXED_ARRAY*/, OdGeVector3d.getCPtr(gePoint));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetPointFDT(OdGePoint3d gePoint, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetPointFDT__SWIG_0(OdGePoint3d.getCPtr(gePoint), point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetPointFDT(OdGeVector3d gePoint, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetPointFDT__SWIG_1(OdGeVector3d.getCPtr(gePoint), point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetPointFDT(OdGePoint2d gePoint, double[] /*DOUBLE_FIXED_ARRAY*/ point) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetPointFDT__SWIG_2(OdGePoint2d.getCPtr(gePoint), point /*DOUBLE_FIXED_ARRAY*/);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetMatrix3D(SWIGTYPE_p_a_4__double matrix, OdGeMatrix3d geMatrix) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetMatrix3D(SWIGTYPE_p_a_4__double.getCPtr(matrix), OdGeMatrix3d.getCPtr(geMatrix));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public static int GetMatrixFDT(OdGeMatrix3d geMatrix, SWIGTYPE_p_a_4__double matrix) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetMatrixFDT(OdGeMatrix3d.getCPtr(geMatrix), SWIGTYPE_p_a_4__double.getCPtr(matrix));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int GetResBufFDTW(OdResBuf pRB, SWIGTYPE_p_p_fdt_resbufW pRBResult, bool bAddXData, bool bAddMinus3) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetResBufFDTW(swigCPtr, OdResBuf.getCPtr(pRB), SWIGTYPE_p_p_fdt_resbufW.getCPtr(pRBResult), bAddXData, bAddMinus3);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int GetResBufDDW(fdt_resbufW rbuffer, ref OdResBuf /*OUT_PARAM for SMARTPTR*/ pRBResult, int iDepth) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pRBResult = pRBResult == null ? IntPtr.Zero : OdResBuf.getCPtr(pRBResult).Handle; 
 IntPtr saved_pRBResult = tmp_pRBResult; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_GetResBufDDW__SWIG_0(swigCPtr, fdt_resbufW.getCPtr(rbuffer), ref tmp_pRBResult /*OUT_PARAM for SMARTPTR*/, iDepth);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pRBResult == IntPtr.Zero) pRBResult = null; 
 if(tmp_pRBResult != IntPtr.Zero && tmp_pRBResult != saved_pRBResult) 
 { 
 MemoryTransaction mTrans_pRBResult = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pRBResult != null)
 mTrans_pRBResult.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdResBuf>(typeof(OdResBuf), tmp_pRBResult, true)); 
 pRBResult = Teigha.Core.Helpers.odCreateObjectInternal<OdResBuf>(typeof(OdResBuf), tmp_pRBResult, mTrans_pRBResult == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual int GetResBufDDW(fdt_resbufW rbuffer, ref OdResBuf /*OUT_PARAM for SMARTPTR*/ pRBResult) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pRBResult = pRBResult == null ? IntPtr.Zero : OdResBuf.getCPtr(pRBResult).Handle; 
 IntPtr saved_pRBResult = tmp_pRBResult; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      int ret = PCADGlobalsPINVOKE.CFxAPI_GetResBufDDW__SWIG_1(swigCPtr, fdt_resbufW.getCPtr(rbuffer), ref tmp_pRBResult /*OUT_PARAM for SMARTPTR*/);
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pRBResult == IntPtr.Zero) pRBResult = null; 
 if(tmp_pRBResult != IntPtr.Zero && tmp_pRBResult != saved_pRBResult) 
 { 
 MemoryTransaction mTrans_pRBResult = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pRBResult != null)
 mTrans_pRBResult.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdResBuf>(typeof(OdResBuf), tmp_pRBResult, true)); 
 pRBResult = Teigha.Core.Helpers.odCreateObjectInternal<OdResBuf>(typeof(OdResBuf), tmp_pRBResult, mTrans_pRBResult == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public static int GetResBuf(fdt_resbufW pResBuf, int iType, SWIGTYPE_p_p_fdt_resbufW pRB) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_GetResBuf(fdt_resbufW.getCPtr(pResBuf), iType, SWIGTYPE_p_p_fdt_resbufW.getCPtr(pRB));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual int AddResBuf(fdt_resbufW pResBuf, int iType, fdt_u_valW value) {
    int ret = PCADGlobalsPINVOKE.CFxAPI_AddResBuf(swigCPtr, fdt_resbufW.getCPtr(pResBuf), iType, fdt_u_valW.getCPtr(value));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual CFxDocument GetFxDocument() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_GetFxDocument(swigCPtr);
    CFxDocument ret = (cPtr == global::System.IntPtr.Zero) ? null : new CFxDocument(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual CFxDatabase GetFxDatabase() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_GetFxDatabase__SWIG_0(swigCPtr);
    CFxDatabase ret = (cPtr == global::System.IntPtr.Zero) ? null : new CFxDatabase(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual CFxUserIO GetUserIO() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_GetUserIO__SWIG_0(swigCPtr);
    CFxUserIO ret = (cPtr == global::System.IntPtr.Zero) ? null : new CFxUserIO(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual CFxView GetActiveFxView() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_GetActiveFxView(swigCPtr);
    CFxView ret = (cPtr == global::System.IntPtr.Zero) ? null : new CFxView(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool CheckFilter(ref UInt64[] /*OUT_ARRAY*/ ename, fdt_resbufW entmask) {
IntPtr p_ename=Teigha.Core.Helpers.MarshalUInt64FixedArray(ename);
    try {
      bool ret = PCADGlobalsPINVOKE.CFxAPI_CheckFilter(swigCPtr, p_ename, fdt_resbufW.getCPtr(entmask));
      if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
ename = Teigha.Core.Helpers.UnMarshalUInt64FixedArray(p_ename); Marshal.FreeCoTaskMem(p_ename);
    }
  }
 
  public virtual SWIGTYPE_p_CFxImages GetFXImages() {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_GetFXImages(swigCPtr);
    SWIGTYPE_p_CFxImages ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_CFxImages(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW ConvertToW(fdt_resbufA rbuffer, int iDepth) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_ConvertToW__SWIG_0(swigCPtr, fdt_resbufA.getCPtr(rbuffer), iDepth);
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufW ConvertToW(fdt_resbufA rbuffer) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_ConvertToW__SWIG_1(swigCPtr, fdt_resbufA.getCPtr(rbuffer));
    fdt_resbufW ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufW(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA ConvertToA(fdt_resbufW rbuffer, int iDepth) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_ConvertToA__SWIG_0(swigCPtr, fdt_resbufW.getCPtr(rbuffer), iDepth);
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual fdt_resbufA ConvertToA(fdt_resbufW rbuffer) {
    global::System.IntPtr cPtr = PCADGlobalsPINVOKE.CFxAPI_ConvertToA__SWIG_1(swigCPtr, fdt_resbufW.getCPtr(rbuffer));
    fdt_resbufA ret = (cPtr == global::System.IntPtr.Zero) ? null : new fdt_resbufA(cPtr, false);
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void ConvertToW(fdt_resbufA rbufferA, fdt_resbufW rbufferW) {
    PCADGlobalsPINVOKE.CFxAPI_ConvertToW__SWIG_2(swigCPtr, fdt_resbufA.getCPtr(rbufferA), fdt_resbufW.getCPtr(rbufferW));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void ConvertToA(fdt_resbufW rbufferW, fdt_resbufA rbufferA) {
    PCADGlobalsPINVOKE.CFxAPI_ConvertToA__SWIG_2(swigCPtr, fdt_resbufW.getCPtr(rbufferW), fdt_resbufA.getCPtr(rbufferA));
    if (PCADGlobalsPINVOKE.SWIGPendingException.Pending) throw PCADGlobalsPINVOKE.SWIGPendingException.Retrieve();
  }
 
}
 
}