Dario Sassi
8765 lines
404 KiB
VB.net
8765 lines
404 KiB
VB.net
'----------------------------------------------------------------------------
|
|
' EgalTech 2014-2015
|
|
'----------------------------------------------------------------------------
|
|
' File : EgtInterface.vb Data : 30.06.15 Versione : 1.6f4
|
|
' Contenuto : Modulo EgtInterface (interfaccia verso il motore EgalTech).
|
|
'
|
|
'
|
|
'
|
|
' Modifiche : 04.11.14 DS Creazione modulo.
|
|
' 30.06.15 DS Unificati 32 e 64 bit in AnyCPU.
|
|
'
|
|
'----------------------------------------------------------------------------
|
|
|
|
Imports System.Runtime.InteropServices
|
|
|
|
Public Module EgtInterface
|
|
|
|
Structure Vector3d
|
|
' Membri
|
|
Dim x, y, z As Double
|
|
' Costruttori
|
|
Sub New(ByVal dX As Double, ByVal dY As Double, ByVal dZ As Double)
|
|
x = dX
|
|
y = dY
|
|
z = dZ
|
|
End Sub
|
|
Sub New(ByRef VtV As Vector3d)
|
|
x = VtV.x
|
|
y = VtV.y
|
|
z = VtV.z
|
|
End Sub
|
|
' Calcolatori da componenti polari / sferici
|
|
Shared Function FromSpherical(ByVal dLen As Double, ByVal dAngVertDeg As Double, ByVal dAngOrizzDeg As Double) As Vector3d
|
|
Dim dAngVertRad As Double = dAngVertDeg * Math.PI / 180
|
|
Dim dAngOrizzRad As Double = dAngOrizzDeg * Math.PI / 180
|
|
Dim dSinAngVert As Double = Math.Sin(dAngVertRad)
|
|
Dim vtV As New Vector3d(dLen * dSinAngVert * Math.Cos(dAngOrizzRad),
|
|
dLen * dSinAngVert * Math.Sin(dAngOrizzRad),
|
|
dLen * Math.Cos(dAngVertRad))
|
|
Return vtV
|
|
End Function
|
|
Shared Function FromPolar(ByVal dLen As Double, ByVal dAngOrizzDeg As Double) As Vector3d
|
|
Dim dAngOrizzRad As Double = dAngOrizzDeg * Math.PI / 180
|
|
Dim vtV As New Vector3d(dLen * Math.Cos(dAngOrizzRad),
|
|
dLen * Math.Sin(dAngOrizzRad),
|
|
0)
|
|
Return vtV
|
|
End Function
|
|
' Vettore opposto
|
|
Shared Operator -(ByVal VtV1 As Vector3d) As Vector3d
|
|
Dim vtV As New Vector3d(-VtV1.x, -VtV1.y, -VtV1.z)
|
|
Return vtV
|
|
End Operator
|
|
' Somma
|
|
Shared Operator +(ByVal VtV1 As Vector3d, ByVal VtV2 As Vector3d) As Vector3d
|
|
Dim vtV As New Vector3d(VtV1.x + VtV2.x, VtV1.y + VtV2.y, VtV1.z + VtV2.z)
|
|
Return vtV
|
|
End Operator
|
|
' Sottrazione
|
|
Shared Operator -(ByVal VtV1 As Vector3d, ByVal VtV2 As Vector3d) As Vector3d
|
|
Dim vtV As New Vector3d(VtV1.x - VtV2.x, VtV1.y - VtV2.y, VtV1.z - VtV2.z)
|
|
Return vtV
|
|
End Operator
|
|
' Prodotto con un numero
|
|
Shared Operator *(ByVal dNum As Double, ByVal VtV2 As Vector3d) As Vector3d
|
|
Dim vtV As New Vector3d(dNum * VtV2.x, dNum * VtV2.y, dNum * VtV2.z)
|
|
Return vtV
|
|
End Operator
|
|
Shared Operator *(ByVal VtV1 As Vector3d, ByVal dNum As Double) As Vector3d
|
|
Dim vtV As New Vector3d(dNum * VtV1.x, dNum * VtV1.y, dNum * VtV1.z)
|
|
Return vtV
|
|
End Operator
|
|
' Divisione per un numero
|
|
Shared Operator /(ByVal VtV1 As Vector3d, ByVal dDiv As Double) As Vector3d
|
|
Dim dMul As Double = 1 / dDiv
|
|
Dim vtV As New Vector3d(dMul * VtV1.x, dMul * VtV1.y, dMul * VtV1.z)
|
|
Return vtV
|
|
End Operator
|
|
' Prodotto scalare
|
|
Shared Operator *(ByVal VtV1 As Vector3d, ByVal VtV2 As Vector3d) As Double
|
|
Return (VtV1.x * VtV2.x + VtV1.y * VtV2.y + VtV1.z * VtV2.z)
|
|
End Operator
|
|
' Prodotto scalare nel piano XY
|
|
Shared Function ScalarXY(ByVal VtV1 As Vector3d, ByVal VtV2 As Vector3d) As Double
|
|
Return (VtV1.x * VtV2.x + VtV1.y * VtV2.y)
|
|
End Function
|
|
' Prodotto vettoriale
|
|
Shared Operator ^(ByVal VtV1 As Vector3d, ByVal VtV2 As Vector3d) As Vector3d
|
|
Dim vtV As New Vector3d(VtV1.y * VtV2.z - VtV1.z * VtV2.y,
|
|
VtV1.z * VtV2.x - VtV1.x * VtV2.z,
|
|
VtV1.x * VtV2.y - VtV1.y * VtV2.x)
|
|
Return vtV
|
|
End Operator
|
|
' Prodotto vettoriale nel piano XY
|
|
Shared Function CrossXY(ByVal VtV1 As Vector3d, ByVal VtV2 As Vector3d) As Double
|
|
Return (VtV1.x * VtV2.y - VtV1.y * VtV2.x)
|
|
End Function
|
|
' Quadrato della lunghezza
|
|
Function SqLen() As Double
|
|
Return (x * x + y * y + z * z)
|
|
End Function
|
|
' Quadrato della lunghezza nelpiano XY
|
|
Function SqLenXY() As Double
|
|
Return (x * x + y * y)
|
|
End Function
|
|
' Lunghezza
|
|
Function Len() As Double
|
|
Return Math.Sqrt(x * x + y * y + z * z)
|
|
End Function
|
|
' Lunghezza nel piano XY
|
|
Function LenXY() As Double
|
|
Return Math.Sqrt(x * x + y * y)
|
|
End Function
|
|
' Verifica di vettore quasi nullo
|
|
Function IsSmall() As Boolean
|
|
Return ((x * x + y * y + z * z) < EPS_SMALL * EPS_SMALL)
|
|
End Function
|
|
' Normalizzazione
|
|
Function Normalize(Optional ByVal dEps As Double = EPS_SMALL) As Boolean
|
|
Return EgtVectorNormalize(x, y, z, dEps)
|
|
End Function
|
|
' Ritorna la rappresentazione in coordinate sferiche
|
|
Sub ToSpherical(ByRef dLen As Double, ByRef dAngVertDeg As Double, ByRef dAngOrizzDeg As Double)
|
|
' lunghezza
|
|
dLen = Len()
|
|
' angoli
|
|
' se vettore nullo
|
|
If dLen < EPS_ZERO Then
|
|
dAngVertDeg = 0
|
|
dAngOrizzDeg = 0
|
|
' se diretto come Z
|
|
ElseIf Math.Abs(x) < EPS_ZERO And Math.Abs(y) < EPS_ZERO Then
|
|
dAngVertDeg = If(z > 0, 0, 180)
|
|
dAngOrizzDeg = 0
|
|
' se altrimenti nel piano XY
|
|
ElseIf Math.Abs(z) < EPS_ZERO Then
|
|
dAngVertDeg = 90
|
|
dAngOrizzDeg = Math.Atan2(y, x) * 180 / Math.PI
|
|
If dAngOrizzDeg < 0 Then
|
|
dAngOrizzDeg += 360
|
|
End If
|
|
' caso generico
|
|
Else
|
|
dAngVertDeg = Math.Acos(z / dLen) * 180 / Math.PI
|
|
dAngOrizzDeg = Math.Atan2(y, x) * 180 / Math.PI
|
|
If dAngOrizzDeg < 0 Then
|
|
dAngOrizzDeg += 360
|
|
End If
|
|
End If
|
|
End Sub
|
|
' Rotazione
|
|
Function Rotate(ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
Return EgtVectorRotate(x, y, z, VtAx, dAngRotDeg)
|
|
End Function
|
|
' Scalatura
|
|
Function Scale(ByRef frRef As Frame3d, ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
Return EgtVectorScale(x, y, z, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(),
|
|
dCoeffX, dCoeffY, dCoeffZ)
|
|
End Function
|
|
' Mirror
|
|
Function Mirror(ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtVectorMirror(x, y, z, VtNorm)
|
|
End Function
|
|
' Shear
|
|
Function Shear(ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
Return EgtVectorShear(x, y, z, VtNorm, VtDir, dCoeff)
|
|
End Function
|
|
' Cambio di riferimento : dal riferimento al globale
|
|
Function ToGlob(ByRef frRef As Frame3d) As Boolean
|
|
If frRef.IsValid Then
|
|
Return EgtVectorToGlob(x, y, z, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal globale al riferimento
|
|
Function ToLoc(ByRef frRef As Frame3d) As Boolean
|
|
If frRef.IsValid Then
|
|
Return EgtVectorToLoc(x, y, z, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal primo riferimento al secondo
|
|
Function LocToLoc(ByRef frSou As Frame3d, ByRef frDest As Frame3d) As Boolean
|
|
If frSou.IsValid And frDest.IsValid Then
|
|
Return EgtVectorLocToLoc(x, y, z,
|
|
frSou.Orig(), frSou.VersX(), frSou.VersY(), frSou.VersZ(),
|
|
frDest.Orig(), frDest.VersX(), frDest.VersY(), frDest.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Restituisce vettore in globale partendo da espressione nel riferimento dell'oggetto
|
|
Function Glob(ByVal nId As Integer) As Vector3d
|
|
Dim vtV As New Vector3d(x, y, z)
|
|
EgtVectorToIdGlob(vtV, nId)
|
|
Return vtV
|
|
End Function
|
|
' Restituisce vettore nel riferimento dell'oggetto partendo da espressione in globale
|
|
Function Loc(ByVal nId As Integer) As Vector3d
|
|
Dim vtV As New Vector3d(x, y, z)
|
|
EgtVectorToIdLoc(vtV, nId)
|
|
Return vtV
|
|
End Function
|
|
' Restituisce vettore nel riferimento del 2°oggetto partendo da espressione nel riferimento del 1° oggetto
|
|
Function LocLoc(ByVal nIdSou As Integer, ByVal nIdDest As Integer) As Vector3d
|
|
Dim vtV As New Vector3d(x, y, z)
|
|
If EgtVectorToIdGlob(vtV, nIdSou) And EgtVectorToIdLoc(vtV, nIdDest) Then
|
|
Return vtV
|
|
Else
|
|
Return Me
|
|
End If
|
|
End Function
|
|
' vettore nullo
|
|
Shared Function NULL() As Vector3d
|
|
Return New Vector3d(0, 0, 0)
|
|
End Function
|
|
' Versore Asse X
|
|
Shared Function X_AX() As Vector3d
|
|
Return New Vector3d(1, 0, 0)
|
|
End Function
|
|
' Versore Asse Y
|
|
Shared Function Y_AX() As Vector3d
|
|
Return New Vector3d(0, 1, 0)
|
|
End Function
|
|
' Versore Asse Z
|
|
Shared Function Z_AX() As Vector3d
|
|
Return New Vector3d(0, 0, 1)
|
|
End Function
|
|
End Structure
|
|
|
|
Structure Point3d
|
|
' Membri
|
|
Dim x, y, z As Double
|
|
' Costruttori
|
|
Sub New(ByVal dX As Double, ByVal dY As Double, ByVal dZ As Double)
|
|
x = dX
|
|
y = dY
|
|
z = dZ
|
|
End Sub
|
|
Sub New(ByRef PtP As Point3d)
|
|
x = PtP.x
|
|
y = PtP.y
|
|
z = PtP.z
|
|
End Sub
|
|
' Somma di un punto e un vettore
|
|
Shared Operator +(ByVal PtP1 As Point3d, ByVal VtV2 As Vector3d) As Point3d
|
|
Dim ptP As New Point3d(PtP1.x + VtV2.x, PtP1.y + VtV2.y, PtP1.z + VtV2.z)
|
|
Return ptP
|
|
End Operator
|
|
Shared Operator +(ByVal VtV1 As Vector3d, ByVal PtP2 As Point3d) As Point3d
|
|
Dim ptP As New Point3d(VtV1.x + PtP2.x, VtV1.y + PtP2.y, VtV1.z + PtP2.z)
|
|
Return ptP
|
|
End Operator
|
|
' Differenza di due punti (produce un vettore)
|
|
Shared Operator -(ByVal PtP1 As Point3d, ByVal PtP2 As Point3d) As Vector3d
|
|
Dim vtV As New Vector3d(PtP1.x - PtP2.x, PtP1.y - PtP2.y, PtP1.z - PtP2.z)
|
|
Return vtV
|
|
End Operator
|
|
' Media pesata di due punti (con 0 è il primo, con 1 il secondo, con 0.5 il medio, ...)
|
|
Shared Function Media(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, Optional ByVal dCoeff As Double = 0.5) As Point3d
|
|
Dim ptMedia As New Point3d((1 - dCoeff) * ptP1.x + dCoeff * ptP2.x,
|
|
(1 - dCoeff) * ptP1.y + dCoeff * ptP2.y,
|
|
(1 - dCoeff) * ptP1.z + dCoeff * ptP2.z)
|
|
Return ptMedia
|
|
End Function
|
|
' Quadrato della distanza
|
|
Shared Function SqDist(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d) As Double
|
|
Return (ptP2 - ptP1).SqLen()
|
|
End Function
|
|
' Quadrato della distanza nel piano XY
|
|
Shared Function SqDistXY(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d) As Double
|
|
Return (ptP2 - ptP1).SqLenXY()
|
|
End Function
|
|
' Distanza
|
|
Shared Function Dist(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d) As Double
|
|
Return (ptP2 - ptP1).Len()
|
|
End Function
|
|
' Distanza nel piano XY
|
|
Shared Function DistXY(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d) As Double
|
|
Return (ptP2 - ptP1).LenXY()
|
|
End Function
|
|
' Sono lo stesso punto approssimativamente
|
|
Shared Function SameApprox(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d) As Boolean
|
|
Return (ptP2 - ptP1).SqLen() < EPS_SMALL * EPS_SMALL
|
|
End Function
|
|
' Traslazione
|
|
Function Move(ByRef VtMove As Vector3d) As Boolean
|
|
Return EgtPointTranslate(x, y, z, VtMove)
|
|
End Function
|
|
' Rotazione
|
|
Function Rotate(ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
Return EgtPointRotate(x, y, z, PtAx, VtAx, dAngRotDeg)
|
|
End Function
|
|
' Scalatura
|
|
Function Scale(ByRef frRef As Frame3d, ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
Return EgtPointScale(x, y, z, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(),
|
|
dCoeffX, dCoeffY, dCoeffZ)
|
|
End Function
|
|
' Mirror
|
|
Function Mirror(ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtPointMirror(x, y, z, PtOn, VtNorm)
|
|
End Function
|
|
' Shear
|
|
Function Shear(ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
Return EgtPointShear(x, y, z, PtOn, VtNorm, VtDir, dCoeff)
|
|
End Function
|
|
' Cambio di riferimento : dal riferimento al globale
|
|
Function ToGlob(ByRef frRef As Frame3d) As Boolean
|
|
If frRef.IsValid Then
|
|
Return EgtPointToGlob(x, y, z, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal globale al riferimento
|
|
Function ToLoc(ByRef frRef As Frame3d) As Boolean
|
|
If frRef.IsValid Then
|
|
Return EgtPointToLoc(x, y, z, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal primo riferimento al secondo
|
|
Function LocToLoc(ByRef frSou As Frame3d, ByRef frDest As Frame3d) As Boolean
|
|
If frSou.IsValid And frDest.IsValid Then
|
|
Return EgtPointLocToLoc(x, y, z,
|
|
frSou.Orig(), frSou.VersX(), frSou.VersY(), frSou.VersZ(),
|
|
frDest.Orig(), frDest.VersX(), frDest.VersY(), frDest.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Restituisce punto in globale partendo da espressione nel riferimento dell'oggetto
|
|
Function Glob(ByVal nId As Integer) As Point3d
|
|
Dim ptP As New Point3d(x, y, z)
|
|
EgtPointToIdGlob(ptP, nId)
|
|
Return ptP
|
|
End Function
|
|
' Restituisce punto nel riferimento dell'oggetto partendo da espressione in globale
|
|
Function Loc(ByVal nId As Integer) As Point3d
|
|
Dim ptP As New Point3d(x, y, z)
|
|
EgtPointToIdLoc(ptP, nId)
|
|
Return ptP
|
|
End Function
|
|
' Restituisce punto nel riferimento del 2°oggetto partendo da espressione nel riferimento del 1° oggetto
|
|
Function LocLoc(ByVal nIdSou As Integer, ByVal nIdDest As Integer) As Point3d
|
|
Dim ptP As New Point3d(x, y, z)
|
|
If EgtPointToIdGlob(ptP, nIdSou) And EgtPointToIdLoc(ptP, nIdDest) Then
|
|
Return ptP
|
|
Else
|
|
Return Me
|
|
End If
|
|
End Function
|
|
' Punto Origine
|
|
Shared Function ORIG() As Point3d
|
|
Return New Point3d(0, 0, 0)
|
|
End Function
|
|
End Structure
|
|
|
|
Class Frame3d
|
|
' Membri
|
|
Private PtOrig As Point3d
|
|
Private VtDirX, VtDirY, VtDirZ As Vector3d
|
|
Private bOk As Boolean
|
|
' Costruttori
|
|
Sub New()
|
|
PtOrig = Point3d.ORIG
|
|
VtDirX = Vector3d.X_AX
|
|
VtDirY = Vector3d.Y_AX
|
|
VtDirZ = Vector3d.Z_AX
|
|
bOk = True
|
|
End Sub
|
|
Sub New(ByRef PtOri As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d)
|
|
PtOrig = PtOri
|
|
VtDirX = VtX
|
|
VtDirY = VtY
|
|
VtDirZ = VtZ
|
|
bOk = VtDirX.Normalize() And VtDirY.Normalize() And VtDirZ.Normalize() And Verify()
|
|
End Sub
|
|
Sub New(ByRef PtOri As Point3d)
|
|
PtOrig = PtOri
|
|
VtDirX = Vector3d.X_AX
|
|
VtDirY = Vector3d.Y_AX
|
|
VtDirZ = Vector3d.Z_AX
|
|
bOk = True
|
|
End Sub
|
|
Sub New(ByRef frFrame As Frame3d)
|
|
PtOrig = frFrame.Orig()
|
|
VtDirX = frFrame.VersX()
|
|
VtDirY = frFrame.VersY()
|
|
VtDirZ = frFrame.VersZ()
|
|
bOk = True
|
|
End Sub
|
|
' Inizializzatori
|
|
Public Function Setup(ByRef PtOri As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
PtOrig = PtOri
|
|
VtDirX = VtX
|
|
VtDirY = VtY
|
|
VtDirZ = VtZ
|
|
bOk = VtDirX.Normalize() And VtDirY.Normalize() And VtDirZ.Normalize() And Verify()
|
|
Return bOk
|
|
End Function
|
|
Public Function Setup(ByRef PtOri As Point3d) As Boolean
|
|
PtOrig = PtOri
|
|
VtDirX = Vector3d.X_AX
|
|
VtDirY = Vector3d.Y_AX
|
|
VtDirZ = Vector3d.Z_AX
|
|
bOk = True
|
|
Return bOk
|
|
End Function
|
|
Public Function Setup(ByRef PtOri As Point3d, ByRef PtOnX As Point3d, ByRef PtNearY As Point3d) As Boolean
|
|
Return EgtFrameFrom3Points(PtOri, PtOnX, PtNearY, PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End Function
|
|
Public Function Setup(ByRef PtOri As Point3d, ByRef VtZ As Vector3d) As Boolean
|
|
Return EgtFrameOCS(PtOri, VtZ, PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End Function
|
|
' Cambio origine
|
|
Public Function ChangeOrigin(ByRef PtOri As Point3d) As Boolean
|
|
PtOrig = PtOri
|
|
Return True
|
|
End Function
|
|
' Verifica
|
|
Private Function Verify() As Boolean
|
|
' verifica della ortogonalità dei versori e del senso destrorso
|
|
Dim dOrtXY As Double = VtDirX * VtDirY
|
|
Dim dOrtYZ As Double = VtDirY * VtDirZ
|
|
Dim dOrtZX As Double = VtDirZ * VtDirX
|
|
Dim vtTmp As Vector3d = VtDirX ^ VtDirY
|
|
Dim dRight As Double = vtTmp * VtDirZ
|
|
If Math.Abs(dOrtXY) > EPS_ZERO Or
|
|
Math.Abs(dOrtYZ) > EPS_ZERO Or
|
|
Math.Abs(dOrtZX) > EPS_ZERO Or
|
|
dRight < EPS_ZERO Then
|
|
Return False
|
|
Else
|
|
Return True
|
|
End If
|
|
End Function
|
|
Public Function IsValid() As Boolean
|
|
Return bOk
|
|
End Function
|
|
' Restituzione componenti
|
|
Function Orig() As Point3d
|
|
Return PtOrig
|
|
End Function
|
|
Function VersX() As Vector3d
|
|
Return VtDirX
|
|
End Function
|
|
Function VersY() As Vector3d
|
|
Return VtDirY
|
|
End Function
|
|
Function VersZ() As Vector3d
|
|
Return VtDirZ
|
|
End Function
|
|
' Traslazione
|
|
Function Move(ByRef VtMove As Vector3d) As Boolean
|
|
If bOk Then
|
|
Return EgtFrameTranslate(PtOrig, VtDirX, VtDirY, VtDirZ, VtMove)
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Rotazione
|
|
Function Rotate(ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
If bOk Then
|
|
Return EgtFrameRotate(PtOrig, VtDirX, VtDirY, VtDirZ, PtAx, VtAx, dAngRotDeg)
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal riferimento al globale
|
|
Function ToGlob(ByRef frRef As Frame3d) As Boolean
|
|
If bOk And frRef.IsValid Then
|
|
Return EgtFrameToGlob(PtOrig, VtDirX, VtDirY, VtDirZ,
|
|
frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal globale al riferimento
|
|
Function ToLoc(ByRef frRef As Frame3d) As Boolean
|
|
If bOk And frRef.IsValid Then
|
|
Return EgtFrameToLoc(PtOrig, VtDirX, VtDirY, VtDirZ,
|
|
frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Cambio di riferimento : dal primo riferimento al secondo
|
|
Function LocToLoc(ByRef frSou As Frame3d, ByRef frDest As Frame3d) As Boolean
|
|
If frSou.IsValid And frDest.IsValid Then
|
|
Return EgtFrameLocToLoc(PtOrig, VtDirX, VtDirY, VtDirZ,
|
|
frSou.Orig(), frSou.VersX(), frSou.VersY(), frSou.VersZ(),
|
|
frDest.Orig(), frDest.VersX(), frDest.VersY(), frDest.VersZ())
|
|
Else
|
|
Return False
|
|
End If
|
|
End Function
|
|
' Riferimento Globale o Identità
|
|
Shared Function GLOB() As Frame3d
|
|
Return New Frame3d
|
|
End Function
|
|
End Class
|
|
|
|
Structure Color3d
|
|
' Membri
|
|
Dim R, G, B, A As Integer
|
|
' Costruttori
|
|
Sub New(ByVal nRed As Integer, ByVal nGreen As Integer, ByVal nBlue As Integer, Optional ByVal nAlpha As Integer = 100)
|
|
R = nRed
|
|
G = nGreen
|
|
B = nBlue
|
|
A = nAlpha
|
|
End Sub
|
|
Sub New(ByRef colSou As Color3d)
|
|
R = colSou.R
|
|
G = colSou.G
|
|
B = colSou.B
|
|
A = colSou.A
|
|
End Sub
|
|
' Inizializzatori
|
|
Sub Setup(ByVal nRed As Integer, ByVal nGreen As Integer, ByVal nBlue As Integer, Optional ByVal nAlpha As Integer = 100)
|
|
R = nRed
|
|
G = nGreen
|
|
B = nBlue
|
|
A = nAlpha
|
|
End Sub
|
|
' Conversione a System.Drawing.Color
|
|
Function ToColor() As System.Drawing.Color
|
|
Return System.Drawing.Color.FromArgb(A * 255 / 100, R, G, B)
|
|
End Function
|
|
' Conversione da System.Drawing.Color
|
|
Sub FromColor(ByVal SysCol As System.Drawing.Color)
|
|
R = SysCol.R
|
|
G = SysCol.G
|
|
B = SysCol.B
|
|
A = SysCol.A * 100 / 255
|
|
End Sub
|
|
End Structure
|
|
|
|
#If DEBUG Then
|
|
Const EgtIntDll32 As String = "EgtInterfaceD32.dll"
|
|
Const EgtIntDll64 As String = "EgtInterfaceD64.dll"
|
|
#Else
|
|
Const EgtIntDll32 As String = "EgtInterfaceR32.dll"
|
|
Const EgtIntDll64 As String = "EgtInterfaceR64.dll"
|
|
#End If
|
|
|
|
|
|
'---------- General ------------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInit")>
|
|
Private Function EgtInit_32(ByVal nDebug As Integer, ByVal sLogFile As String, Optional ByVal sLogMsg As String = "") As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInit")>
|
|
Private Function EgtInit_64(ByVal nDebug As Integer, ByVal sLogFile As String, Optional ByVal sLogMsg As String = "") As Boolean
|
|
End Function
|
|
Public Function EgtInit(ByVal nDebug As Integer, ByVal sLogFile As String, Optional ByVal sLogMsg As String = "") As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInit_32(nDebug, sLogFile, sLogMsg)
|
|
Else
|
|
Return EgtInit_64(nDebug, sLogFile, sLogMsg)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExit")>
|
|
Private Function EgtExit_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExit")>
|
|
Private Function EgtExit_64() As Boolean
|
|
End Function
|
|
Public Function EgtExit() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExit_32()
|
|
Else
|
|
Return EgtExit_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetKey")>
|
|
Private Function EgtSetKey_32(ByVal sKey As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetKey")>
|
|
Private Function EgtSetKey_64(ByVal sKey As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetKey(ByVal sKey As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetKey_32(sKey)
|
|
Else
|
|
Return EgtSetKey_64(sKey)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetFont")>
|
|
Private Function EgtSetFont_32(ByVal sNfeFontDir As String, ByVal sDefaultFont As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetFont")>
|
|
Private Function EgtSetFont_64(ByVal sNfeFontDir As String, ByVal sDefaultFont As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetFont(ByVal sNfeFontDir As String, ByVal sDefaultFont As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetFont_32(sNfeFontDir, sDefaultFont)
|
|
Else
|
|
Return EgtSetFont_64(sNfeFontDir, sDefaultFont)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNfeFontDir")>
|
|
Private Function EgtGetNfeFontDir_32(ByRef psNfeFontDir As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNfeFontDir")>
|
|
Private Function EgtGetNfeFontDir_64(ByRef psNfeFontDir As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetNfeFontDir(ByRef sNfeFontDir As String) As Boolean
|
|
Dim psNfeFontDir As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetNfeFontDir_32(psNfeFontDir)
|
|
Else
|
|
bOk = EgtGetNfeFontDir_64(psNfeFontDir)
|
|
End If
|
|
If bOk Then
|
|
sNfeFontDir = Marshal.PtrToStringUni(psNfeFontDir)
|
|
EgtFreeMemory(psNfeFontDir)
|
|
Else
|
|
sNfeFontDir = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetDefaultFont")>
|
|
Private Function EgtGetDefaultFont_32(ByRef psDefaultFont As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetDefaultFont")>
|
|
Private Function EgtGetDefaultFont_64(ByRef psDefaultFont As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetDefaultFont(ByRef sDefaultFont As String) As Boolean
|
|
Dim psDefaultFont As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetDefaultFont_32(psDefaultFont)
|
|
Else
|
|
bOk = EgtGetDefaultFont_64(psDefaultFont)
|
|
End If
|
|
If bOk Then
|
|
sDefaultFont = Marshal.PtrToStringUni(psDefaultFont)
|
|
EgtFreeMemory(psDefaultFont)
|
|
Else
|
|
sDefaultFont = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetLuaLibs")>
|
|
Private Function EgtSetLuaLibs_32(ByVal sLuaLibsDir As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetLuaLibs")>
|
|
Private Function EgtSetLuaLibs_64(ByVal sLuaLibsDir As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetLuaLibs(ByVal sLuaLibsDir As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetLuaLibs_32(sLuaLibsDir)
|
|
Else
|
|
Return EgtSetLuaLibs_64(sLuaLibsDir)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCommandLogger")>
|
|
Private Function EgtSetCommandLogger_32(ByVal sLogFile As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCommandLogger")>
|
|
Private Function EgtSetCommandLogger_64(ByVal sLogFile As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetCommandLogger(ByVal sLogFile As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCommandLogger_32(sLogFile)
|
|
Else
|
|
Return EgtSetCommandLogger_64(sLogFile)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtEnableCommandLogger")>
|
|
Private Sub EgtEnableCommandLogger_32()
|
|
End Sub
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtEnableCommandLogger")>
|
|
Private Sub EgtEnableCommandLogger_64()
|
|
End Sub
|
|
Public Sub EgtEnableCommandLogger()
|
|
If IntPtr.Size = 4 Then
|
|
EgtEnableCommandLogger_32()
|
|
Else
|
|
EgtEnableCommandLogger_64()
|
|
End If
|
|
End Sub
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDisableCommandLogger")>
|
|
Private Sub EgtDisableCommandLogger_32()
|
|
End Sub
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDisableCommandLogger")>
|
|
Private Sub EgtDisableCommandLogger_64()
|
|
End Sub
|
|
Public Sub EgtDisableCommandLogger()
|
|
If IntPtr.Size = 4 Then
|
|
EgtDisableCommandLogger_32()
|
|
Else
|
|
EgtDisableCommandLogger_64()
|
|
End If
|
|
End Sub
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetVersionInfo")>
|
|
Private Function EgtGetVersionInfo_32(ByRef psVerInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetVersionInfo")>
|
|
Private Function EgtGetVersionInfo_64(ByRef psVerInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetVersionInfo(ByRef sVerInfo As String) As Boolean
|
|
Dim psVerInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetVersionInfo_32(psVerInfo)
|
|
Else
|
|
bOk = EgtGetVersionInfo_64(psVerInfo)
|
|
End If
|
|
If bOk Then
|
|
sVerInfo = Marshal.PtrToStringUni(psVerInfo)
|
|
EgtFreeMemory(psVerInfo)
|
|
Else
|
|
sVerInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetKeyInfo")>
|
|
Private Function EgtGetKeyInfo_32(ByRef psKeyInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetKeyInfo")>
|
|
Private Function EgtGetKeyInfo_64(ByRef psKeyInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetKeyInfo(ByRef sKeyInfo As String) As Boolean
|
|
Dim psKeyInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetKeyInfo_32(psKeyInfo)
|
|
Else
|
|
bOk = EgtGetKeyInfo_64(psKeyInfo)
|
|
End If
|
|
If bOk Then
|
|
sKeyInfo = Marshal.PtrToStringUni(psKeyInfo)
|
|
EgtFreeMemory(psKeyInfo)
|
|
Else
|
|
sKeyInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOsInfo")>
|
|
Private Function EgtGetOsInfo_32(ByRef psOsInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOsInfo")>
|
|
Private Function EgtGetOsInfo_64(ByRef psOsInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetOsInfo(ByRef sOsInfo As String) As Boolean
|
|
Dim psOsInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetOsInfo_32(psOsInfo)
|
|
Else
|
|
bOk = EgtGetOsInfo_64(psOsInfo)
|
|
End If
|
|
If bOk Then
|
|
sOsInfo = Marshal.PtrToStringUni(psOsInfo)
|
|
EgtFreeMemory(psOsInfo)
|
|
Else
|
|
sOsInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCpuInfo")>
|
|
Private Function EgtGetCpuInfo_32(ByRef psCpuInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCpuInfo")>
|
|
Private Function EgtGetCpuInfo_64(ByRef psCpuInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetCpuInfo(ByRef sCpuInfo As String) As Boolean
|
|
Dim psCpuInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetCpuInfo_32(psCpuInfo)
|
|
Else
|
|
bOk = EgtGetCpuInfo_64(psCpuInfo)
|
|
End If
|
|
If bOk Then
|
|
sCpuInfo = Marshal.PtrToStringUni(psCpuInfo)
|
|
EgtFreeMemory(psCpuInfo)
|
|
Else
|
|
sCpuInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMemoryInfo")>
|
|
Private Function EgtGetMemoryInfo_32(ByRef psMemInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMemoryInfo")>
|
|
Private Function EgtGetMemoryInfo_64(ByRef psMemInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetMemoryInfo(ByRef sMemInfo As String) As Boolean
|
|
Dim psMemInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetMemoryInfo_32(psMemInfo)
|
|
Else
|
|
bOk = EgtGetMemoryInfo_64(psMemInfo)
|
|
End If
|
|
If bOk Then
|
|
sMemInfo = Marshal.PtrToStringUni(psMemInfo)
|
|
EgtFreeMemory(psMemInfo)
|
|
Else
|
|
sMemInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFreeMemory")>
|
|
Private Function EgtFreeMemory_32(ByVal sB As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFreeMemory")>
|
|
Private Function EgtFreeMemory_64(ByVal sB As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtFreeMemory(ByVal sB As IntPtr) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFreeMemory_32(sB)
|
|
Else
|
|
Return EgtFreeMemory_64(sB)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtOutLog")>
|
|
Private Function EgtOutLog_32(ByVal sMsg As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtOutLog")>
|
|
Private Function EgtOutLog_64(ByVal sMsg As String) As Boolean
|
|
End Function
|
|
Public Function EgtOutLog(ByVal sMsg As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtOutLog_32(sMsg)
|
|
Else
|
|
Return EgtOutLog_64(sMsg)
|
|
End If
|
|
End Function
|
|
|
|
Public Delegate Function ProcessEventsCallback(ByVal nProg As Integer, ByVal nPause As Integer) As Integer
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetProcessEvents")>
|
|
Private Function EgtSetProcessEvents_32(ByVal Callback As ProcessEventsCallback) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetProcessEvents")>
|
|
Private Function EgtSetProcessEvents_64(ByVal Callback As ProcessEventsCallback) As Boolean
|
|
End Function
|
|
Public Function EgtSetProcessEvents(ByVal Callback As ProcessEventsCallback) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetProcessEvents_32(Callback)
|
|
Else
|
|
Return EgtSetProcessEvents_64(Callback)
|
|
End If
|
|
End Function
|
|
|
|
Public Delegate Function OutTextCallback(ByRef psText As IntPtr) As Boolean
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetOutText")>
|
|
Private Function EgtSetOutText_32(ByVal Callback As OutTextCallback) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetOutText")>
|
|
Private Function EgtSetOutText_64(ByVal Callback As OutTextCallback) As Boolean
|
|
End Function
|
|
Public Function EgtSetOutText(ByVal Callback As OutTextCallback) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetOutText_32(Callback)
|
|
Else
|
|
Return EgtSetOutText_64(Callback)
|
|
End If
|
|
End Function
|
|
|
|
'---------- UiUnits ------------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetUiUnits")>
|
|
Private Function EgtSetUiUnits_32(ByVal bMM As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetUiUnits")>
|
|
Private Function EgtSetUiUnits_64(ByVal bMM As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetUiUnits(ByVal bMM As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetUiUnits_32(bMM)
|
|
Else
|
|
Return EgtSetUiUnits_64(bMM)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtUiUnitsAreMM")>
|
|
Private Function EgtUiUnitsAreMM_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtUiUnitsAreMM")>
|
|
Private Function EgtUiUnitsAreMM_64() As Boolean
|
|
End Function
|
|
Public Function EgtUiUnitsAreMM() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtUiUnitsAreMM_32()
|
|
Else
|
|
Return EgtUiUnitsAreMM_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFromUiUnits")>
|
|
Private Function EgtFromUiUnits_32(ByVal dVal As Double) As Double
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFromUiUnits")>
|
|
Private Function EgtFromUiUnits_64(ByVal dVal As Double) As Double
|
|
End Function
|
|
Public Function EgtFromUiUnits(ByVal dVal As Double) As Double
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFromUiUnits_32(dVal)
|
|
Else
|
|
Return EgtFromUiUnits_64(dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtToUiUnits")>
|
|
Private Function EgtToUiUnits_32(ByVal dVal As Double) As Double
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtToUiUnits")>
|
|
Private Function EgtToUiUnits_64(ByVal dVal As Double) As Double
|
|
End Function
|
|
Public Function EgtToUiUnits(ByVal dVal As Double) As Double
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtToUiUnits_32(dVal)
|
|
Else
|
|
Return EgtToUiUnits_64(dVal)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb -------------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitContext")>
|
|
Private Function EgtInitContext_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitContext")>
|
|
Private Function EgtInitContext_64() As Integer
|
|
End Function
|
|
Public Function EgtInitContext() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInitContext_32()
|
|
Else
|
|
Return EgtInitContext_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeleteContext")>
|
|
Private Function EgtDeleteContext_32(ByVal nCtx As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeleteContext")>
|
|
Private Function EgtDeleteContext_64(ByVal nCtx As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtDeleteContext(ByVal nCtx As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDeleteContext_32(nCtx)
|
|
Else
|
|
Return EgtDeleteContext_64(nCtx)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrentContext")>
|
|
Private Function EgtSetCurrentContext_32(ByVal nCtx As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrentContext")>
|
|
Private Function EgtSetCurrentContext_64(ByVal nCtx As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetCurrentContext(ByVal nCtx As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCurrentContext_32(nCtx)
|
|
Else
|
|
Return EgtSetCurrentContext_64(nCtx)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetCurrentContext")>
|
|
Private Function EgtResetCurrentContext_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetCurrentContext")>
|
|
Private Function EgtResetCurrentContext_64() As Boolean
|
|
End Function
|
|
Public Function EgtResetCurrentContext() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetCurrentContext_32()
|
|
Else
|
|
Return EgtResetCurrentContext_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrentContext")>
|
|
Private Function EgtGetCurrentContext_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrentContext")>
|
|
Private Function EgtGetCurrentContext_64() As Integer
|
|
End Function
|
|
Public Function EgtGetCurrentContext() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCurrentContext_32()
|
|
Else
|
|
Return EgtGetCurrentContext_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetDefaultMaterial")>
|
|
Private Function EgtSetDefaultMaterial_32(ByRef DefCol As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetDefaultMaterial")>
|
|
Private Function EgtSetDefaultMaterial_64(ByRef DefCol As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetDefaultMaterial(ByRef DefCol As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetDefaultMaterial_32(DefCol)
|
|
Else
|
|
Return EgtSetDefaultMaterial_64(DefCol)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridFrame")>
|
|
Private Function EgtSetGridFrame_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridFrame")>
|
|
Private Function EgtSetGridFrame_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetGridFrame(ByRef frRef As Frame3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGridFrame_32(frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
Else
|
|
Return EgtSetGridFrame_64(frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ())
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGridFrame")>
|
|
Private Function EgtGetGridFrame_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGridFrame")>
|
|
Private Function EgtGetGridFrame_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetGridFrame() As Frame3d
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetGridFrame_32(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
bOk = EgtGetGridFrame_64(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
If Not bOk Then
|
|
Dim frRef As New Frame3d
|
|
Return frRef
|
|
Else
|
|
Dim frRef As New Frame3d(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Return frRef
|
|
End If
|
|
End Function
|
|
|
|
Public Function EgtGetGridOrigin() As Point3d
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
If IntPtr.Size = 4 Then
|
|
EgtGetGridFrame_32(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
EgtGetGridFrame_64(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
Return PtOrig
|
|
End Function
|
|
|
|
Public Function EgtGetGridVersX() As Vector3d
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
If IntPtr.Size = 4 Then
|
|
EgtGetGridFrame_32(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
EgtGetGridFrame_64(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
Return VtDirX
|
|
End Function
|
|
|
|
Public Function EgtGetGridVersY() As Vector3d
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
If IntPtr.Size = 4 Then
|
|
EgtGetGridFrame_32(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
EgtGetGridFrame_64(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
Return VtDirY
|
|
End Function
|
|
|
|
Public Function EgtGetGridVersZ() As Vector3d
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
If IntPtr.Size = 4 Then
|
|
EgtGetGridFrame_32(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
EgtGetGridFrame_64(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
Return VtDirZ
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrFilePath")>
|
|
Private Function EgtSetCurrFilePath_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrFilePath")>
|
|
Private Function EgtSetCurrFilePath_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetCurrFilePath(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCurrFilePath_32(sFilePath)
|
|
Else
|
|
Return EgtSetCurrFilePath_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrFilePath")>
|
|
Private Function EgtGetCurrFilePath_32(ByRef psFilePath As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrFilePath")>
|
|
Private Function EgtGetCurrFilePath_64(ByRef psFilePath As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetCurrFilePath(ByRef sFilePath As String) As Boolean
|
|
Dim psFilePath As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetCurrFilePath_32(psFilePath)
|
|
Else
|
|
bOk = EgtGetCurrFilePath_64(psFilePath)
|
|
End If
|
|
If bOk Then
|
|
sFilePath = Marshal.PtrToStringUni(psFilePath)
|
|
EgtFreeMemory(psFilePath)
|
|
Else
|
|
sFilePath = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtEnableModified")>
|
|
Private Function EgtEnableModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtEnableModified")>
|
|
Private Function EgtEnableModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtEnableModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtEnableModified_32()
|
|
Else
|
|
Return EgtEnableModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDisableModified")>
|
|
Private Function EgtDisableModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDisableModified")>
|
|
Private Function EgtDisableModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtDisableModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDisableModified_32()
|
|
Else
|
|
Return EgtDisableModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetModified")>
|
|
Private Function EgtSetModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetModified")>
|
|
Private Function EgtSetModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtSetModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetModified_32()
|
|
Else
|
|
Return EgtSetModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetModified")>
|
|
Private Function EgtResetModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetModified")>
|
|
Private Function EgtResetModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtResetModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetModified_32()
|
|
Else
|
|
Return EgtResetModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetModified")>
|
|
Private Function EgtGetModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetModified")>
|
|
Private Function EgtGetModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtGetModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetModified_32()
|
|
Else
|
|
Return EgtGetModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtNewFile")>
|
|
Private Function EgtNewFile_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtNewFile")>
|
|
Private Function EgtNewFile_64() As Boolean
|
|
End Function
|
|
Public Function EgtNewFile() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtNewFile_32()
|
|
Else
|
|
Return EgtNewFile_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtOpenFile")>
|
|
Private Function EgtOpenFile_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtOpenFile")>
|
|
Private Function EgtOpenFile_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtOpenFile(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtOpenFile_32(sFilePath)
|
|
Else
|
|
Return EgtOpenFile_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInsertFile")>
|
|
Private Function EgtInsertFile_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInsertFile")>
|
|
Private Function EgtInsertFile_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtInsertFile(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInsertFile_32(sFilePath)
|
|
Else
|
|
Return EgtInsertFile_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSaveFile")>
|
|
Private Function EgtSaveFile_32(ByVal sFilePath As String, ByVal nFlag As NGE) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSaveFile")>
|
|
Private Function EgtSaveFile_64(ByVal sFilePath As String, ByVal nFlag As NGE) As Boolean
|
|
End Function
|
|
Public Function EgtSaveFile(ByVal sFilePath As String, ByVal nFlag As NGE) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSaveFile_32(sFilePath, nFlag)
|
|
Else
|
|
Return EgtSaveFile_64(sFilePath, nFlag)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSaveObjToFile")>
|
|
Private Function EgtSaveObjToFile_32(ByVal nId As Integer, ByVal sFilePath As String, ByVal nFlag As NGE) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSaveObjToFile")>
|
|
Private Function EgtSaveObjToFile_64(ByVal nId As Integer, ByVal sFilePath As String, ByVal nFlag As NGE) As Boolean
|
|
End Function
|
|
Public Function EgtSaveObjToFile(ByVal nId As Integer, ByVal sFilePath As String, ByVal nFlag As NGE) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSaveObjToFile_32(nId, sFilePath, nFlag)
|
|
Else
|
|
Return EgtSaveObjToFile_64(nId, sFilePath, nFlag)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Exchange -----------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFileType")>
|
|
Private Function EgtGetFileType_32(ByVal sFilePath As String) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFileType")>
|
|
Private Function EgtGetFileType_64(ByVal sFilePath As String) As Integer
|
|
End Function
|
|
Public Function EgtGetFileType(ByVal sFilePath As String) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFileType_32(sFilePath)
|
|
Else
|
|
Return EgtGetFileType_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportDxf")>
|
|
Private Function EgtImportDxf_32(ByVal sFilePath As String, ByVal dScaleFactor As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportDxf")>
|
|
Private Function EgtImportDxf_64(ByVal sFilePath As String, ByVal dScaleFactor As Double) As Boolean
|
|
End Function
|
|
Public Function EgtImportDxf(ByVal sFilePath As String, ByVal dScaleFactor As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtImportDxf_32(sFilePath, dScaleFactor)
|
|
Else
|
|
Return EgtImportDxf_64(sFilePath, dScaleFactor)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportStl")>
|
|
Private Function EgtImportStl_32(ByVal sFilePath As String, ByVal dScaleFactor As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportStl")>
|
|
Private Function EgtImportStl_64(ByVal sFilePath As String, ByVal dScaleFactor As Double) As Boolean
|
|
End Function
|
|
Public Function EgtImportStl(ByVal sFilePath As String, ByVal dScaleFactor As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtImportStl_32(sFilePath, dScaleFactor)
|
|
Else
|
|
Return EgtImportStl_64(sFilePath, dScaleFactor)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportCnc")>
|
|
Private Function EgtImportCnc_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportCnc")>
|
|
Private Function EgtImportCnc_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtImportCnc(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtImportCnc_32(sFilePath)
|
|
Else
|
|
Return EgtImportCnc_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportCsf")>
|
|
Private Function EgtImportCsf_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportCsf")>
|
|
Private Function EgtImportCsf_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtImportCsf(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtImportCsf_32(sFilePath)
|
|
Else
|
|
Return EgtImportCsf_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportBtl")>
|
|
Private Function EgtImportBtl_32(ByVal sFilePath As String, ByVal bFlatPos As Boolean, ByVal bSpecialTrim As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtImportBtl")>
|
|
Private Function EgtImportBtl_64(ByVal sFilePath As String, ByVal bFlatPos As Boolean, ByVal bSpecialTrim As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtImportBtl(ByVal sFilePath As String, ByVal bFlatPos As Boolean, ByVal bSpecialTrim As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtImportBtl_32(sFilePath, bFlatPos, bSpecialTrim)
|
|
Else
|
|
Return EgtImportBtl_64(sFilePath, bFlatPos, bSpecialTrim)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExportDxf")>
|
|
Private Function EgtExportDxf_32(ByVal nId As Integer, ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExportDxf")>
|
|
Private Function EgtExportDxf_64(ByVal nId As Integer, ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtExportDxf(ByVal nId As Integer, ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExportDxf_32(nId, sFilePath)
|
|
Else
|
|
Return EgtExportDxf_64(nId, sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExportStl")>
|
|
Private Function EgtExportStl_32(ByVal nId As Integer, ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExportStl")>
|
|
Private Function EgtExportStl_64(ByVal nId As Integer, ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtExportStl(ByVal nId As Integer, ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExportStl_32(nId, sFilePath)
|
|
Else
|
|
Return EgtExportStl_64(nId, sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Tsc Executor -------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitTscExec")>
|
|
Private Function EgtInitTscExec_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitTscExec")>
|
|
Private Function EgtInitTscExec_64() As Boolean
|
|
End Function
|
|
Public Function EgtInitTscExec() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInitTscExec_32()
|
|
Else
|
|
Return EgtInitTscExec_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTscExecFile")>
|
|
Private Function EgtTscExecFile_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTscExecFile")>
|
|
Private Function EgtTscExecFile_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtTscExecFile(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTscExecFile_32(sFilePath)
|
|
Else
|
|
Return EgtTscExecFile_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTscExecLine")>
|
|
Private Function EgtTscExecLine_32(ByVal sLine As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTscExecLine")>
|
|
Private Function EgtTscExecLine_64(ByVal sLine As String) As Boolean
|
|
End Function
|
|
Public Function EgtTscExecLine(ByVal sLine As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTscExecLine_32(sLine)
|
|
Else
|
|
Return EgtTscExecLine_64(sLine)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- LUA Executor -------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaCreateGlobTable")>
|
|
Private Function EgtLuaCreateGlobTable_32(ByVal sVar As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaCreateGlobTable")>
|
|
Private Function EgtLuaCreateGlobTable_64(ByVal sVar As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaCreateGlobTable(ByVal sVar As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaCreateGlobTable_32(sVar)
|
|
Else
|
|
Return EgtLuaCreateGlobTable_64(sVar)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobBoolVar")>
|
|
Private Function EgtLuaSetGlobBoolVar_32(ByVal sVar As String, ByVal bVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobBoolVar")>
|
|
Private Function EgtLuaSetGlobBoolVar_64(ByVal sVar As String, ByVal bVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtLuaSetGlobBoolVar(ByVal sVar As String, ByVal bVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaSetGlobBoolVar_32(sVar, bVal)
|
|
Else
|
|
Return EgtLuaSetGlobBoolVar_64(sVar, bVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobIntVar")>
|
|
Private Function EgtLuaSetGlobIntVar_32(ByVal sVar As String, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobIntVar")>
|
|
Private Function EgtLuaSetGlobIntVar_64(ByVal sVar As String, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtLuaSetGlobIntVar(ByVal sVar As String, ByVal nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaSetGlobIntVar_32(sVar, nVal)
|
|
Else
|
|
Return EgtLuaSetGlobIntVar_64(sVar, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobNumVar")>
|
|
Private Function EgtLuaSetGlobNumVar_32(ByVal sVar As String, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobNumVar")>
|
|
Private Function EgtLuaSetGlobNumVar_64(ByVal sVar As String, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtLuaSetGlobNumVar(ByVal sVar As String, ByVal dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaSetGlobNumVar_32(sVar, dVal)
|
|
Else
|
|
Return EgtLuaSetGlobNumVar_64(sVar, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobStringVar")>
|
|
Private Function EgtLuaSetGlobStringVar_32(ByVal sVar As String, ByVal sVal As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaSetGlobStringVar")>
|
|
Private Function EgtLuaSetGlobStringVar_64(ByVal sVar As String, ByVal sVal As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaSetGlobStringVar(ByVal sVar As String, ByVal sVal As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaSetGlobStringVar_32(sVar, sVal)
|
|
Else
|
|
Return EgtLuaSetGlobStringVar_64(sVar, sVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobBoolVar")>
|
|
Private Function EgtLuaGetGlobBoolVar_32(ByVal sVar As String, ByRef bVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobBoolVar")>
|
|
Private Function EgtLuaGetGlobBoolVar_64(ByVal sVar As String, ByRef bVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtLuaGetGlobBoolVar(ByVal sVar As String, ByRef bVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaGetGlobBoolVar_32(sVar, bVal)
|
|
Else
|
|
Return EgtLuaGetGlobBoolVar_64(sVar, bVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobIntVar")>
|
|
Private Function EgtLuaGetGlobIntVar_32(ByVal sVar As String, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobIntVar")>
|
|
Private Function EgtLuaGetGlobIntVar_64(ByVal sVar As String, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtLuaGetGlobIntVar(ByVal sVar As String, ByRef nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaGetGlobIntVar_32(sVar, nVal)
|
|
Else
|
|
Return EgtLuaGetGlobIntVar_64(sVar, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobNumVar")>
|
|
Private Function EgtLuaGetGlobNumVar_32(ByVal sVar As String, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobNumVar")>
|
|
Private Function EgtLuaGetGlobNumVar_64(ByVal sVar As String, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtLuaGetGlobNumVar(ByVal sVar As String, ByRef dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaGetGlobNumVar_32(sVar, dVal)
|
|
Else
|
|
Return EgtLuaGetGlobNumVar_64(sVar, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobStringVar")>
|
|
Private Function EgtLuaGetGlobStringVar_32(ByVal sVar As String, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetGlobStringVar")>
|
|
Private Function EgtLuaGetGlobStringVar_64(ByVal sVar As String, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtLuaGetGlobStringVar(ByVal sVar As String, ByRef sVal As String) As Boolean
|
|
Dim psVal As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtLuaGetGlobStringVar_32(sVar, psVal)
|
|
Else
|
|
bOk = EgtLuaGetGlobStringVar_64(sVar, psVal)
|
|
End If
|
|
If bOk Then
|
|
sVal = Marshal.PtrToStringUni(psVal)
|
|
EgtFreeMemory(psVal)
|
|
Else
|
|
sVal = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaResetGlobVar")>
|
|
Private Function EgtLuaResetGlobVar_32(ByVal sVar As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaResetGlobVar")>
|
|
Private Function EgtLuaResetGlobVar_64(ByVal sVar As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaResetGlobVar(ByVal sVar As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaResetGlobVar_32(sVar)
|
|
Else
|
|
Return EgtLuaResetGlobVar_64(sVar)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaCallFunction")>
|
|
Private Function EgtLuaCallFunction_32(ByVal sFun As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaCallFunction")>
|
|
Private Function EgtLuaCallFunction_64(ByVal sFun As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaCallFunction(ByVal sFun As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaCallFunction_32(sFun)
|
|
Else
|
|
Return EgtLuaCallFunction_64(sFun)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaEvalNumExpr")>
|
|
Private Function EgtLuaEvalNumExpr_32(ByVal sLine As String, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaEvalNumExpr")>
|
|
Private Function EgtLuaEvalNumExpr_64(ByVal sLine As String, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtLuaEvalNumExpr(ByVal sLine As String, ByRef dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaEvalNumExpr_32(sLine, dVal)
|
|
Else
|
|
Return EgtLuaEvalNumExpr_64(sLine, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaEvalStringExpr")>
|
|
Private Function EgtLuaEvalStringExpr_32(ByVal sLine As String, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaEvalStringExpr")>
|
|
Private Function EgtLuaEvalStringExpr_64(ByVal sLine As String, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtLuaEvalStringExpr(ByVal sLine As String, ByRef sVal As String) As Boolean
|
|
Dim psVal As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtLuaEvalStringExpr_32(sLine, psVal)
|
|
Else
|
|
bOk = EgtLuaEvalStringExpr_64(sLine, psVal)
|
|
End If
|
|
If bOk Then
|
|
sVal = Marshal.PtrToStringUni(psVal)
|
|
EgtFreeMemory(psVal)
|
|
Else
|
|
sVal = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaExecLine")>
|
|
Private Function EgtLuaExecLine_32(ByVal sLine As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaExecLine")>
|
|
Private Function EgtLuaExecLine_64(ByVal sLine As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaExecLine(ByVal sLine As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaExecLine_32(sLine)
|
|
Else
|
|
Return EgtLuaExecLine_64(sLine)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaExecFile")>
|
|
Private Function EgtLuaExecFile_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaExecFile")>
|
|
Private Function EgtLuaExecFile_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaExecFile(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaExecFile_32(sFilePath)
|
|
Else
|
|
Return EgtLuaExecFile_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaRequire")>
|
|
Private Function EgtLuaRequire_32(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaRequire")>
|
|
Private Function EgtLuaRequire_64(ByVal sFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtLuaRequire(ByVal sFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLuaRequire_32(sFilePath)
|
|
Else
|
|
Return EgtLuaRequire_64(sFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetLastError")>
|
|
Private Function EgtLuaGetLastError_32(ByRef psError As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLuaGetLastError")>
|
|
Private Function EgtLuaGetLastError_64(ByRef psError As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtLuaGetLastError(ByRef sError As String) As Boolean
|
|
Dim psError As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtLuaGetLastError_32(psError)
|
|
Else
|
|
bOk = EgtLuaGetLastError_64(psError)
|
|
End If
|
|
If bOk Then
|
|
sError = Marshal.PtrToStringUni(psError)
|
|
EgtFreeMemory(psError)
|
|
Else
|
|
sError = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Objects Create ----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGroup")>
|
|
Private Function EgtCreateGroup_32(ByVal nParentId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGroup")>
|
|
Private Function EgtCreateGroup_64(ByVal nParentId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Integer
|
|
End Function
|
|
Public Function EgtCreateGroup(ByVal nParentId As Integer, ByRef frRef As Frame3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateGroup_32(nParentId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
Else
|
|
Return EgtCreateGroup_64(nParentId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
End If
|
|
End Function
|
|
Public Function EgtCreateGroup(ByVal nParentId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateGroup_32(nParentId, Point3d.ORIG(), Vector3d.X_AX, Vector3d.Y_AX, Vector3d.Z_AX, GDB_RT.LOC)
|
|
Else
|
|
Return EgtCreateGroup_64(nParentId, Point3d.ORIG(), Vector3d.X_AX, Vector3d.Y_AX, Vector3d.Z_AX, GDB_RT.LOC)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGeoPoint")>
|
|
Private Function EgtCreateGeoPoint_32(ByVal nParentId As Integer,
|
|
ByRef PtP As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGeoPoint")>
|
|
Private Function EgtCreateGeoPoint_64(ByVal nParentId As Integer,
|
|
ByRef PtP As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateGeoPoint(ByVal nParentId As Integer,
|
|
ByRef PtP As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateGeoPoint_32(nParentId, PtP, nRefType)
|
|
Else
|
|
Return EgtCreateGeoPoint_64(nParentId, PtP, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGeoVector")>
|
|
Private Function EgtCreateGeoVector_32(ByVal nParentId As Integer,
|
|
ByRef vtV As Vector3d, ByRef PtB As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGeoVector")>
|
|
Private Function EgtCreateGeoVector_64(ByVal nParentId As Integer,
|
|
ByRef vtV As Vector3d, ByRef PtB As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateGeoVector(ByVal nParentId As Integer,
|
|
ByRef vtV As Vector3d, ByRef PtB As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateGeoVector_32(nParentId, vtV, PtB, nRefType)
|
|
Else
|
|
Return EgtCreateGeoVector_64(nParentId, vtV, PtB, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGeoFrame")>
|
|
Private Function EgtCreateGeoFrame_32(ByVal nParentId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateGeoFrame")>
|
|
Private Function EgtCreateGeoFrame_64(ByVal nParentId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Integer
|
|
End Function
|
|
Public Function EgtCreateGeoFrame(ByVal nParentId As Integer, ByRef frRef As Frame3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateGeoFrame_32(nParentId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
Else
|
|
Return EgtCreateGeoFrame_64(nParentId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLine")>
|
|
Private Function EgtCreateLine_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLine")>
|
|
Private Function EgtCreateLine_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateLine(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateLine_32(nParentId, PtStart, PtEnd, nRefType)
|
|
Else
|
|
Return EgtCreateLine_64(nParentId, PtStart, PtEnd, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLineEx")>
|
|
Private Function EgtCreateLineEx_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByVal nSepS As SEP, ByVal nIdS As Integer,
|
|
ByRef PtEnd As Point3d, ByVal nSepE As SEP, ByVal nIdE As Integer, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLineEx")>
|
|
Private Function EgtCreateLineEx_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByVal nSepS As SEP, ByVal nIdS As Integer,
|
|
ByRef PtEnd As Point3d, ByVal nSepE As SEP, ByVal nIdE As Integer, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateLineEx(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByVal nSepS As SEP, ByVal nIdS As Integer,
|
|
ByRef PtEnd As Point3d, ByVal nSepE As SEP, ByVal nIdE As Integer, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateLineEx_32(nParentId, PtStart, nSepS, nIdS, PtEnd, nSepE, nIdE, nRefType)
|
|
Else
|
|
Return EgtCreateLineEx_64(nParentId, PtStart, nSepS, nIdS, PtEnd, nSepE, nIdE, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLinePDL")>
|
|
Private Function EgtCreateLinePDL_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByVal dDirDeg As Double, ByVal dLen As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLinePDL")>
|
|
Private Function EgtCreateLinePDL_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByVal dDirDeg As Double, ByVal dLen As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateLinePDL(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByVal dDirDeg As Double, ByVal dLen As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateLinePDL_32(nParentId, PtStart, dDirDeg, dLen, nRefType)
|
|
Else
|
|
Return EgtCreateLinePDL_64(nParentId, PtStart, dDirDeg, dLen, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLinePVL")>
|
|
Private Function EgtCreateLinePVL_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef VtDir As Vector3d, ByVal dLen As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateLinePVL")>
|
|
Private Function EgtCreateLinePVL_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef VtDir As Vector3d, ByVal dLen As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateLinePVL(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef VtDir As Vector3d, ByVal dLen As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateLinePVL_32(nParentId, PtStart, VtDir, dLen, nRefType)
|
|
Else
|
|
Return EgtCreateLinePVL_64(nParentId, PtStart, VtDir, dLen, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCircle")>
|
|
Private Function EgtCreateCircle_32(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByVal dRad As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCircle")>
|
|
Private Function EgtCreateCircle_64(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByVal dRad As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateCircle(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByVal dRad As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateCircle_32(nParentId, PtCen, dRad, nRefType)
|
|
Else
|
|
Return EgtCreateCircle_64(nParentId, PtCen, dRad, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCircleCP")>
|
|
Private Function EgtCreateCircleCP_32(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCircleCP")>
|
|
Private Function EgtCreateCircleCP_64(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateCircleCP(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateCircleCP_32(nParentId, PtCen, PtOn, nRefType)
|
|
Else
|
|
Return EgtCreateCircleCP_64(nParentId, PtCen, PtOn, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCircleCPEx")>
|
|
Private Function EgtCreateCircleCPEx_32(ByVal nParentId As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtOn As Point3d, ByVal nSepO As SEP, ByVal nIdO As Integer,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCircleCPEx")>
|
|
Private Function EgtCreateCircleCPEx_64(ByVal nParentId As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtOn As Point3d, ByVal nSepO As SEP, ByVal nIdO As Integer,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateCircleCPEx(ByVal nParentId As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtOn As Point3d, ByVal nSepO As SEP, ByVal nIdO As Integer,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateCircleCPEx_32(nParentId, PtCen, PtOn, nSepO, nIdO, nRefType)
|
|
Else
|
|
Return EgtCreateCircleCPEx_64(nParentId, PtCen, PtOn, nSepO, nIdO, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc3P")>
|
|
Private Function EgtCreateArc3P_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtMid As Point3d, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc3P")>
|
|
Private Function EgtCreateArc3P_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtMid As Point3d, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateArc3P(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtMid As Point3d, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateArc3P_32(nParentId, PtStart, PtMid, PtEnd, nRefType)
|
|
Else
|
|
Return EgtCreateArc3P_64(nParentId, PtStart, PtMid, PtEnd, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArcC2P")>
|
|
Private Function EgtCreateArcC2P_32(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArcC2P")>
|
|
Private Function EgtCreateArcC2P_64(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateArcC2P(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateArcC2P_32(nParentId, PtCen, PtStart, PtEnd, nRefType)
|
|
Else
|
|
Return EgtCreateArcC2P_64(nParentId, PtCen, PtStart, PtEnd, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArcC2PEx")>
|
|
Private Function EgtCreateArcC2PEx_32(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtStart As Point3d, ByVal nSepS As SEP, ByVal nIdS As Integer,
|
|
ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArcC2PEx")>
|
|
Private Function EgtCreateArcC2PEx_64(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtStart As Point3d, ByVal nSepS As SEP, ByVal nIdS As Integer,
|
|
ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateArcC2PEx(ByVal nParentId As Integer,
|
|
ByRef PtCen As Point3d, ByRef PtStart As Point3d, ByVal nSepS As SEP, ByVal nIdS As Integer,
|
|
ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateArcC2PEx_32(nParentId, PtCen, PtStart, nSepS, nIdS, PtEnd, nRefType)
|
|
Else
|
|
Return EgtCreateArcC2PEx_64(nParentId, PtCen, PtStart, nSepS, nIdS, PtEnd, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc2PD")>
|
|
Private Function EgtCreateArc2PD_32(ByVal nParentId As Integer, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
ByVal dDirSDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc2PD")>
|
|
Private Function EgtCreateArc2PD_64(ByVal nParentId As Integer, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
ByVal dDirSDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateArc2PD(ByVal nParentId As Integer, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
ByVal dDirSDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateArc2PD_32(nParentId, PtStart, PtEnd, dDirSDeg, nRefType)
|
|
Else
|
|
Return EgtCreateArc2PD_64(nParentId, PtStart, PtEnd, dDirSDeg, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc2PDEx")>
|
|
Private Function EgtCreateArc2PDEx_32(ByVal nParentId As Integer, ByRef PtStart As Point3d,
|
|
ByRef PtEnd As Point3d, ByVal nSepE As SEP, ByVal nIdE As Integer,
|
|
ByVal dDirSDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc2PDEx")>
|
|
Private Function EgtCreateArc2PDEx_64(ByVal nParentId As Integer, ByRef PtStart As Point3d,
|
|
ByRef PtEnd As Point3d, ByVal nSepE As SEP, ByVal nIdE As Integer,
|
|
ByVal dDirSDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateArc2PDEx(ByVal nParentId As Integer, ByRef PtStart As Point3d,
|
|
ByRef PtEnd As Point3d, ByVal nSepE As SEP, ByVal nIdE As Integer,
|
|
ByVal dDirSDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateArc2PDEx_32(nParentId, PtStart, PtEnd, nSepE, nIdE, dDirSDeg, nRefType)
|
|
Else
|
|
Return EgtCreateArc2PDEx_64(nParentId, PtStart, PtEnd, nSepE, nIdE, dDirSDeg, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc2PV")>
|
|
Private Function EgtCreateArc2PV_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtEnd As Point3d, ByRef VtDirS As Vector3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateArc2PV")>
|
|
Private Function EgtCreateArc2PV_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtEnd As Point3d, ByRef VtDirS As Vector3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateArc2PV(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtEnd As Point3d, ByRef VtDirS As Vector3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateArc2PV_32(nParentId, PtStart, PtEnd, VtDirS, nRefType)
|
|
Else
|
|
Return EgtCreateArc2PV_64(nParentId, PtStart, PtEnd, VtDirS, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateBiArc")>
|
|
Private Function EgtCreateBiArc_32(ByVal nParentId As Integer, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
ByVal dDirSDeg As Double, ByVal dDirEDeg As Double, ByVal dPar As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateBiArc")>
|
|
Private Function EgtCreateBiArc_64(ByVal nParentId As Integer, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
ByVal dDirSDeg As Double, ByVal dDirEDeg As Double, ByVal dPar As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateBiArc(ByVal nParentId As Integer, ByRef PtStart As Point3d, ByRef PtEnd As Point3d,
|
|
ByVal dDirSDeg As Double, ByVal dDirEDeg As Double, ByVal dPar As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateBiArc_32(nParentId, PtStart, PtEnd, dDirSDeg, dDirEDeg, dPar, nRefType)
|
|
Else
|
|
Return EgtCreateBiArc_64(nParentId, PtStart, PtEnd, dDirSDeg, dDirEDeg, dPar, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCurveFillet")>
|
|
Private Function EgtCreateCurveFillet_32(ByVal nParentId As Integer, ByVal nCrv1 As Integer, ByRef PtNear1 As Point3d,
|
|
ByVal nCrv2 As Integer, ByRef PtNear2 As Point3d,
|
|
ByVal dRad As Double, ByVal bTrimExt As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCurveFillet")>
|
|
Private Function EgtCreateCurveFillet_64(ByVal nParentId As Integer, ByVal nCrv1 As Integer, ByRef PtNear1 As Point3d,
|
|
ByVal nCrv2 As Integer, ByRef PtNear2 As Point3d,
|
|
ByVal dRad As Double, ByVal bTrimExt As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateCurveFillet(ByVal nParentId As Integer, ByVal nCrv1 As Integer, ByRef PtNear1 As Point3d,
|
|
ByVal nCrv2 As Integer, ByRef PtNear2 As Point3d,
|
|
ByVal dRad As Double, ByVal bTrimExt As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateCurveFillet_32(nParentId, nCrv1, PtNear1, nCrv2, PtNear2, dRad, bTrimExt, nRefType)
|
|
Else
|
|
Return EgtCreateCurveFillet_64(nParentId, nCrv1, PtNear1, nCrv2, PtNear2, dRad, bTrimExt, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCurveChamfer")>
|
|
Private Function EgtCreateCurveChamfer_32(ByVal nParentId As Integer, ByVal nCrv1 As Integer, ByRef PtNear1 As Point3d,
|
|
ByVal nCrv2 As Integer, ByRef PtNear2 As Point3d,
|
|
ByVal dDist As Double, ByVal bTrimExt As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCurveChamfer")>
|
|
Private Function EgtCreateCurveChamfer_64(ByVal nParentId As Integer, ByVal nCrv1 As Integer, ByRef PtNear1 As Point3d,
|
|
ByVal nCrv2 As Integer, ByRef PtNear2 As Point3d,
|
|
ByVal dDist As Double, ByVal bTrimExt As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateCurveChamfer(ByVal nParentId As Integer, ByVal nCrv1 As Integer, ByRef PtNear1 As Point3d,
|
|
ByVal nCrv2 As Integer, ByRef PtNear2 As Point3d,
|
|
ByVal dDist As Double, ByVal bTrimExt As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateCurveChamfer_32(nParentId, nCrv1, PtNear1, nCrv2, PtNear2, dDist, bTrimExt, nRefType)
|
|
Else
|
|
Return EgtCreateCurveChamfer_64(nParentId, nCrv1, PtNear1, nCrv2, PtNear2, dDist, bTrimExt, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCurveCompoByChain")>
|
|
Private Function EgtCreateCurveCompoByChain_32(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef PtNearStart As Point3d, ByVal bCrvErase As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateCurveCompoByChain")>
|
|
Private Function EgtCreateCurveCompoByChain_64(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef PtNearStart As Point3d, ByVal bCrvErase As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateCurveCompoByChain(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef PtNearStart As Point3d, ByVal bCrvErase As Boolean, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateCurveCompoByChain_32(nParentId, nNumCrv, nCrvId, PtNearStart, bCrvErase, nRefType)
|
|
Else
|
|
Return EgtCreateCurveCompoByChain_64(nParentId, nNumCrv, nCrvId, PtNearStart, bCrvErase, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateRectangle2P")>
|
|
Private Function EgtCreateRectangle2P_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtCross As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateRectangle2P")>
|
|
Private Function EgtCreateRectangle2P_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtCross As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateRectangle2P(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtCross As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateRectangle2P_32(nParentId, PtStart, PtCross, nRefType)
|
|
Else
|
|
Return EgtCreateRectangle2P_64(nParentId, PtStart, PtCross, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateRectangle3P")>
|
|
Private Function EgtCreateRectangle3P_32(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtCross As Point3d,
|
|
ByRef PtDir As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateRectangle3P")>
|
|
Private Function EgtCreateRectangle3P_64(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtCross As Point3d,
|
|
ByRef PtDir As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateRectangle3P(ByVal nParentId As Integer,
|
|
ByRef PtStart As Point3d, ByRef PtCross As Point3d,
|
|
ByRef PtDir As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateRectangle3P_32(nParentId, PtStart, PtCross, PtDir, nRefType)
|
|
Else
|
|
Return EgtCreateRectangle3P_64(nParentId, PtStart, PtCross, PtDir, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreatePolygonFromRadius")>
|
|
Private Function EgtCreatePolygonFromRadius_32(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtCorn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreatePolygonFromRadius")>
|
|
Private Function EgtCreatePolygonFromRadius_64(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtCorn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreatePolygonFromRadius(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtCorn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreatePolygonFromRadius_32(nParentId, nNumSides, PtCen, PtCorn, nRefType)
|
|
Else
|
|
Return EgtCreatePolygonFromRadius_64(nParentId, nNumSides, PtCen, PtCorn, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreatePolygonFromApothem")>
|
|
Private Function EgtCreatePolygonFromApothem_32(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtMid As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreatePolygonFromApothem")>
|
|
Private Function EgtCreatePolygonFromApothem_64(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtMid As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreatePolygonFromApothem(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtCen As Point3d,
|
|
ByRef PtMid As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreatePolygonFromApothem_32(nParentId, nNumSides, PtCen, PtMid, nRefType)
|
|
Else
|
|
Return EgtCreatePolygonFromApothem_64(nParentId, nNumSides, PtCen, PtMid, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreatePolygonFromSide")>
|
|
Private Function EgtCreatePolygonFromSide_32(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtStart As Point3d,
|
|
ByRef PtFin As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreatePolygonFromSide")>
|
|
Private Function EgtCreatePolygonFromSide_64(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtStart As Point3d,
|
|
ByRef PtFin As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreatePolygonFromSide(ByVal nParentId As Integer, ByVal nNumSides As Integer, ByRef PtStart As Point3d,
|
|
ByRef PtFin As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreatePolygonFromSide_32(nParentId, nNumSides, PtStart, PtFin, nRefType)
|
|
Else
|
|
Return EgtCreatePolygonFromSide_64(nParentId, nNumSides, PtStart, PtFin, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfFrRectangle")>
|
|
Private Function EgtCreateSurfFrRectangle_32(ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfFrRectangle")>
|
|
Private Function EgtCreateSurfFrRectangle_64(ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfFrRectangle(ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfFrRectangle_32(nParentId, ptMin, ptMax, nRefType)
|
|
Else
|
|
Return EgtCreateSurfFrRectangle_64(nParentId, ptMin, ptMax, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfFlatRegion")>
|
|
Private Function EgtCreateSurfFlatRegion_32(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfFlatRegion")>
|
|
Private Function EgtCreateSurfFlatRegion_64(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfFlatRegion(ByVal nParentId As Integer, ByVal nCrvId() As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfFlatRegion_32(nParentId, nCrvId.Length(), nCrvId)
|
|
Else
|
|
Return EgtCreateSurfFlatRegion_64(nParentId, nCrvId.Length(), nCrvId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmBBox")>
|
|
Private Function EgtCreateSurfTmBBox_32(ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmBBox")>
|
|
Private Function EgtCreateSurfTmBBox_64(ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmBBox(ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmBBox_32(nParentId, ptMin, ptMax, nRefType)
|
|
Else
|
|
Return EgtCreateSurfTmBBox_64(nParentId, ptMin, ptMax, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByFlatContour")>
|
|
Private Function EgtCreateSurfTmByFlatContour_32(ByVal nParentId As Integer, ByVal nCrvId As Integer, ByVal dLinTol As Double) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByFlatContour")>
|
|
Private Function EgtCreateSurfTmByFlatContour_64(ByVal nParentId As Integer, ByVal nCrvId As Integer, ByVal dLinTol As Double) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByFlatContour(ByVal nParentId As Integer, ByVal nCrvId As Integer, ByVal dLinTol As Double) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByFlatContour_32(nParentId, nCrvId, dLinTol)
|
|
Else
|
|
Return EgtCreateSurfTmByFlatContour_64(nParentId, nCrvId, dLinTol)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByRegion")>
|
|
Private Function EgtCreateSurfTmByRegion_32(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer, ByVal dLinTol As Double) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByRegion")>
|
|
Private Function EgtCreateSurfTmByRegion_64(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer, ByVal dLinTol As Double) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByRegion(ByVal nParentId As Integer, ByVal nCrvId() As Integer, ByVal dLinTol As Double) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByRegion_32(nParentId, nCrvId.Length(), nCrvId, dLinTol)
|
|
Else
|
|
Return EgtCreateSurfTmByRegion_64(nParentId, nCrvId.Length(), nCrvId, dLinTol)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByExtrusion")>
|
|
Private Function EgtCreateSurfTmByExtrusion_32(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef VtExtr As Vector3d, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByExtrusion")>
|
|
Private Function EgtCreateSurfTmByExtrusion_64(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef VtExtr As Vector3d, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByExtrusion(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef VtExtr As Vector3d, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByExtrusion_32(nParentId, nNumCrv, nCrvId, VtExtr, dLinTol, nRefType)
|
|
Else
|
|
Return EgtCreateSurfTmByExtrusion_64(nParentId, nNumCrv, nCrvId, VtExtr, dLinTol, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByRegionExtrusion")>
|
|
Private Function EgtCreateSurfTmByRegionExtrusion_32(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef VtExtr As Vector3d, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByRegionExtrusion")>
|
|
Private Function EgtCreateSurfTmByRegionExtrusion_64(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef VtExtr As Vector3d, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByRegionExtrusion(ByVal nParentId As Integer, ByVal nNumCrv As Integer, ByVal nCrvId() As Integer,
|
|
ByRef VtExtr As Vector3d, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByRegionExtrusion_32(nParentId, nNumCrv, nCrvId, VtExtr, dLinTol, nRefType)
|
|
Else
|
|
Return EgtCreateSurfTmByRegionExtrusion_64(nParentId, nNumCrv, nCrvId, VtExtr, dLinTol, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByRevolve")>
|
|
Private Function EgtCreateSurfTmByRevolve_32(ByVal nParentId As Integer, ByVal nCrvId As Integer,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d,
|
|
ByVal bCapEnds As Boolean, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByRevolve")>
|
|
Private Function EgtCreateSurfTmByRevolve_64(ByVal nParentId As Integer, ByVal nCrvId As Integer,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d,
|
|
ByVal bCapEnds As Boolean, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByRevolve(ByVal nParentId As Integer, ByVal nCrvId As Integer,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d,
|
|
ByVal bCapEnds As Boolean, ByVal dLinTol As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByRevolve_32(nParentId, nCrvId, PtAx, VtAx, bCapEnds, dLinTol, nRefType)
|
|
Else
|
|
Return EgtCreateSurfTmByRevolve_64(nParentId, nCrvId, PtAx, VtAx, bCapEnds, dLinTol, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByScrewing")>
|
|
Private Function EgtCreateSurfTmByScrewing_32(ByVal nParentId As Integer, ByVal nCrvId As Integer,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d,
|
|
ByVal dAngRotDeg As Double, ByVal dMove As Double,
|
|
ByVal dLinTol As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByScrewing")>
|
|
Private Function EgtCreateSurfTmByScrewing_64(ByVal nParentId As Integer, ByVal nCrvId As Integer,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d,
|
|
ByVal dAngRotDeg As Double, ByVal dMove As Double,
|
|
ByVal dLinTol As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByScrewing(ByVal nParentId As Integer, ByVal nCrvId As Integer,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d,
|
|
ByVal dAngRotDeg As Double, ByVal dMove As Double,
|
|
ByVal dLinTol As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByScrewing_32(nParentId, nCrvId, PtAx, VtAx, dAngRotDeg, dMove, dLinTol, nRefType)
|
|
Else
|
|
Return EgtCreateSurfTmByScrewing_64(nParentId, nCrvId, PtAx, VtAx, dAngRotDeg, dMove, dLinTol, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmRuled")>
|
|
Private Function EgtCreateSurfTmRuled_32(ByVal nParentId As Integer, ByVal nCrvId1 As Integer, ByVal nCrvId2 As Integer, ByVal dLinTol As Double) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmRuled")>
|
|
Private Function EgtCreateSurfTmRuled_64(ByVal nParentId As Integer, ByVal nCrvId1 As Integer, ByVal nCrvId2 As Integer, ByVal dLinTol As Double) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmRuled(ByVal nParentId As Integer, ByVal nCrvId1 As Integer, ByVal nCrvId2 As Integer, ByVal dLinTol As Double) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmRuled_32(nParentId, nCrvId1, nCrvId2, dLinTol)
|
|
Else
|
|
Return EgtCreateSurfTmRuled_64(nParentId, nCrvId1, nCrvId2, dLinTol)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByTriangles")>
|
|
Private Function EgtCreateSurfTmByTriangles_32(ByVal nParentId As Integer, ByVal nNumSrf As Integer, ByVal nSrfId() As Integer, ByVal bSrfErase As Boolean) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByTriangles")>
|
|
Private Function EgtCreateSurfTmByTriangles_64(ByVal nParentId As Integer, ByVal nNumSrf As Integer, ByVal nSrfId() As Integer, ByVal bSrfErase As Boolean) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmByTriangles(ByVal nParentId As Integer, ByVal nNumSrf As Integer, ByVal nSrfId() As Integer, ByVal bSrfErase As Boolean) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmByTriangles_32(nParentId, nNumSrf, nSrfId, bSrfErase)
|
|
Else
|
|
Return EgtCreateSurfTmByTriangles_64(nParentId, nNumSrf, nSrfId, bSrfErase)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByTriangles")>
|
|
Private Function EgtCreateSurfTmBySewing_32(ByVal nParentId As Integer, ByVal nNumSrf As Integer, ByVal nSrfId() As Integer, ByVal bSrfErase As Boolean) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateSurfTmByTriangles")>
|
|
Private Function EgtCreateSurfTmBySewing_64(ByVal nParentId As Integer, ByVal nNumSrf As Integer, ByVal nSrfId() As Integer, ByVal bSrfErase As Boolean) As Integer
|
|
End Function
|
|
Public Function EgtCreateSurfTmBySewing(ByVal nParentId As Integer, ByVal nNumSrf As Integer, ByVal nSrfId() As Integer, ByVal bSrfErase As Boolean) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateSurfTmBySewing_32(nParentId, nNumSrf, nSrfId, bSrfErase)
|
|
Else
|
|
Return EgtCreateSurfTmBySewing_64(nParentId, nNumSrf, nSrfId, bSrfErase)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateText")>
|
|
Private Function EgtCreateText_32(ByVal nParentId As Integer, ByRef ptP As Point3d,
|
|
ByVal sText As String, ByVal dH As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateText")>
|
|
Private Function EgtCreateText_64(ByVal nParentId As Integer, ByRef ptP As Point3d,
|
|
ByVal sText As String, ByVal dH As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateText(ByVal nParentId As Integer, ByRef ptP As Point3d,
|
|
ByVal sText As String, ByVal dH As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateText_32(nParentId, ptP, sText, dH, nRefType)
|
|
Else
|
|
Return EgtCreateText_64(nParentId, ptP, sText, dH, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateTextEx")>
|
|
Private Function EgtCreateTextEx_32(ByVal nParentId As Integer, ByRef ptP As Point3d, ByVal dAngRotDeg As Double,
|
|
ByVal sText As String, ByVal sFont As String, ByVal bItalic As Boolean, ByVal dH As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateTextEx")>
|
|
Private Function EgtCreateTextEx_64(ByVal nParentId As Integer, ByRef ptP As Point3d, ByVal dAngRotDeg As Double,
|
|
ByVal sText As String, ByVal sFont As String, ByVal bItalic As Boolean, ByVal dH As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateTextEx(ByVal nParentId As Integer, ByRef ptP As Point3d, ByVal dAngRotDeg As Double,
|
|
ByVal sText As String, ByVal sFont As String, ByVal bItalic As Boolean, ByVal dH As Double,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateTextEx_32(nParentId, ptP, dAngRotDeg, sText, sFont, bItalic, dH, nRefType)
|
|
Else
|
|
Return EgtCreateTextEx_64(nParentId, ptP, dAngRotDeg, sText, sFont, bItalic, dH, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateTextAdv")>
|
|
Private Function EgtCreateTextAdv_32(ByVal nParentId As Integer, ByRef ptP As Point3d, ByVal dAngRotDeg As Double,
|
|
ByVal sText As String, ByVal sFont As String, ByVal nW As Integer, ByVal bItalic As Boolean,
|
|
ByVal dH As Double, ByVal dRat As Double, ByVal dAddAdv As Double, ByVal nInsPos As Integer,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateTextAdv")>
|
|
Private Function EgtCreateTextAdv_64(ByVal nParentId As Integer, ByRef ptP As Point3d, ByVal dAngRotDeg As Double,
|
|
ByVal sText As String, ByVal sFont As String, ByVal nW As Integer, ByVal bItalic As Boolean,
|
|
ByVal dH As Double, ByVal dRat As Double, ByVal dAddAdv As Double, ByVal nInsPos As Integer,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtCreateTextAdv(ByVal nParentId As Integer, ByRef ptP As Point3d, ByVal dAngRotDeg As Double,
|
|
ByVal sText As String, ByVal sFont As String, ByVal nW As Integer, ByVal bItalic As Boolean,
|
|
ByVal dH As Double, ByVal dRat As Double, ByVal dAddAdv As Double, ByVal nInsPos As Integer,
|
|
Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateTextAdv_32(nParentId, ptP, dAngRotDeg, sText, sFont, nW, bItalic, dH, dRat, dAddAdv, nInsPos, nRefType)
|
|
Else
|
|
Return EgtCreateTextAdv_64(nParentId, ptP, dAngRotDeg, sText, sFont, nW, bItalic, dH, dRat, dAddAdv, nInsPos, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Objects Modify ----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeGroupFrame")>
|
|
Private Function EgtChangeGroupFrame_32(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeGroupFrame")>
|
|
Private Function EgtChangeGroupFrame_64(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Boolean
|
|
End Function
|
|
Public Function EgtChangeGroupFrame(ByVal nId As Integer, ByRef frRef As Frame3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtChangeGroupFrame_32(nId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
Else
|
|
Return EgtChangeGroupFrame_64(nId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeVectorBase")>
|
|
Private Function EgtChangeVectorBase_32(ByVal nId As Integer, ByRef PtBase As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeVectorBase")>
|
|
Private Function EgtChangeVectorBase_64(ByVal nId As Integer, ByRef PtBase As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtChangeVectorBase(ByVal nId As Integer, ByRef PtBase As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtChangeVectorBase_32(nId, PtBase, nRefType)
|
|
Else
|
|
Return EgtChangeVectorBase_64(nId, PtBase, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFlipText")>
|
|
Private Function EgtFlipText_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFlipText")>
|
|
Private Function EgtFlipText_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtFlipText(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFlipText_32(nId)
|
|
Else
|
|
Return EgtFlipText_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMirrorText")>
|
|
Private Function EgtMirrorText_32(ByVal nId As Integer, ByVal bOnL As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMirrorText")>
|
|
Private Function EgtMirrorText_64(ByVal nId As Integer, ByVal bOnL As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtMirrorText(ByVal nId As Integer, ByVal bOnL As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMirrorText_32(nId, bOnL)
|
|
Else
|
|
Return EgtMirrorText_64(nId, bOnL)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExplodeText")>
|
|
Private Function EgtExplodeText_32(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExplodeText")>
|
|
Private Function EgtExplodeText_64(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
Public Function EgtExplodeText(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExplodeText_32(nId, nCount)
|
|
Else
|
|
Return EgtExplodeText_64(nId, nCount)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Curves Modify -----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInvertCurve")>
|
|
Private Function EgtInvertCurve_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInvertCurve")>
|
|
Private Function EgtInvertCurve_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtInvertCurve(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInvertCurve_32(nId)
|
|
Else
|
|
Return EgtInvertCurve_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtOffsetCurve")>
|
|
Private Function EgtOffsetCurve_32(ByVal nId As Integer, ByVal dDist As Double, ByVal nType As OFF_TYPE) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtOffsetCurve")>
|
|
Private Function EgtOffsetCurve_64(ByVal nId As Integer, ByVal dDist As Double, ByVal nType As OFF_TYPE) As Boolean
|
|
End Function
|
|
Public Function EgtOffsetCurve(ByVal nId As Integer, ByVal dDist As Double, ByVal nType As OFF_TYPE) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtOffsetCurve_32(nId, dDist, nType)
|
|
Else
|
|
Return EgtOffsetCurve_64(nId, dDist, nType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtOffsetCurveAdv")>
|
|
Private Function EgtOffsetCurveAdv_32(ByVal nId As Integer, ByVal dDist As Double, ByVal nType As OFF_TYPE, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtOffsetCurveAdv")>
|
|
Private Function EgtOffsetCurveAdv_64(ByVal nId As Integer, ByVal dDist As Double, ByVal nType As OFF_TYPE, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
Public Function EgtOffsetCurveAdv(ByVal nId As Integer, ByVal dDist As Double, ByVal nType As OFF_TYPE, ByRef nCount As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtOffsetCurveAdv_32(nId, dDist, nType, nCount)
|
|
Else
|
|
Return EgtOffsetCurveAdv_64(nId, dDist, nType, nCount)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtApproxCurve")>
|
|
Private Function EgtApproxCurve_32(ByVal nId As Integer, ByVal nApprType As Integer, ByVal dLinTol As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtApproxCurve")>
|
|
Private Function EgtApproxCurve_64(ByVal nId As Integer, ByVal nApprType As Integer, ByVal dLinTol As Double) As Boolean
|
|
End Function
|
|
Public Function EgtApproxCurve(ByVal nId As Integer, ByVal nApprType As Integer, ByVal dLinTol As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtApproxCurve_32(nId, nApprType, dLinTol)
|
|
Else
|
|
Return EgtApproxCurve_64(nId, nApprType, dLinTol)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeClosedCurveStartPoint")>
|
|
Private Function EgtChangeClosedCurveStartPoint_32(ByVal nId As Integer, ByRef PtStart As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeClosedCurveStartPoint")>
|
|
Private Function EgtChangeClosedCurveStartPoint_64(ByVal nId As Integer, ByRef PtStart As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtChangeClosedCurveStartPoint(ByVal nId As Integer, ByRef PtStart As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtChangeClosedCurveStartPoint_32(nId, PtStart, nRefType)
|
|
Else
|
|
Return EgtChangeClosedCurveStartPoint_64(nId, PtStart, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveStartPoint")>
|
|
Private Function EgtModifyCurveStartPoint_32(ByVal nId As Integer, ByRef PtStart As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveStartPoint")>
|
|
Private Function EgtModifyCurveStartPoint_64(ByVal nId As Integer, ByRef PtStart As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtModifyCurveStartPoint(ByVal nId As Integer, ByRef PtStart As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyCurveStartPoint_32(nId, PtStart, nRefType)
|
|
Else
|
|
Return EgtModifyCurveStartPoint_64(nId, PtStart, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveEndPoint")>
|
|
Private Function EgtModifyCurveEndPoint_32(ByVal nId As Integer, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveEndPoint")>
|
|
Private Function EgtModifyCurveEndPoint_64(ByVal nId As Integer, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtModifyCurveEndPoint(ByVal nId As Integer, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyCurveEndPoint_32(nId, PtEnd, nRefType)
|
|
Else
|
|
Return EgtModifyCurveEndPoint_64(nId, PtEnd, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveExtrusion")>
|
|
Private Function EgtModifyCurveExtrusion_32(ByVal nId As Integer, ByRef VtExtr As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveExtrusion")>
|
|
Private Function EgtModifyCurveExtrusion_64(ByVal nId As Integer, ByRef VtExtr As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtModifyCurveExtrusion(ByVal nId As Integer, ByRef VtExtr As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyCurveExtrusion_32(nId, VtExtr, nRefType)
|
|
Else
|
|
Return EgtModifyCurveExtrusion_64(nId, VtExtr, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveThickness")>
|
|
Private Function EgtModifyCurveThickness_32(ByVal nId As Integer, ByVal dTh As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCurveThickness")>
|
|
Private Function EgtModifyCurveThickness_64(ByVal nId As Integer, ByVal dTh As Double) As Boolean
|
|
End Function
|
|
Public Function EgtModifyCurveThickness(ByVal nId As Integer, ByVal dTh As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyCurveThickness_32(nId, dTh)
|
|
Else
|
|
Return EgtModifyCurveThickness_64(nId, dTh)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExtendCurveStartByLen")>
|
|
Private Function EgtExtendCurveStartByLen_32(ByVal nId As Integer, ByVal dLen As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExtendCurveStartByLen")>
|
|
Private Function EgtExtendCurveStartByLen_64(ByVal nId As Integer, ByVal dLen As Double) As Boolean
|
|
End Function
|
|
Public Function EgtExtendCurveStartByLen(ByVal nId As Integer, ByVal dLen As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExtendCurveStartByLen_32(nId, dLen)
|
|
Else
|
|
Return EgtExtendCurveStartByLen_64(nId, dLen)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExtendCurveEndByLen")>
|
|
Private Function EgtExtendCurveEndByLen_32(ByVal nId As Integer, ByVal dLen As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExtendCurveEndByLen")>
|
|
Private Function EgtExtendCurveEndByLen_64(ByVal nId As Integer, ByVal dLen As Double) As Boolean
|
|
End Function
|
|
Public Function EgtExtendCurveEndByLen(ByVal nId As Integer, ByVal dLen As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExtendCurveEndByLen_32(nId, dLen)
|
|
Else
|
|
Return EgtExtendCurveEndByLen_64(nId, dLen)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTrimExtendCurveByLen")>
|
|
Private Function EgtTrimExtendCurveByLen_32(ByVal nId As Integer, ByVal dLen As Double, ByRef PtNear As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTrimExtendCurveByLen")>
|
|
Private Function EgtTrimExtendCurveByLen_64(ByVal nId As Integer, ByVal dLen As Double, ByRef PtNear As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtTrimExtendCurveByLen(ByVal nId As Integer, ByVal dLen As Double, ByRef PtNear As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTrimExtendCurveByLen_32(nId, dLen, PtNear, nRefType)
|
|
Else
|
|
Return EgtTrimExtendCurveByLen_64(nId, dLen, PtNear, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSplitCurve")>
|
|
Private Function EgtSplitCurve_32(ByVal nId As Integer, ByVal nParts As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSplitCurve")>
|
|
Private Function EgtSplitCurve_64(ByVal nId As Integer, ByVal nParts As Integer) As Integer
|
|
End Function
|
|
Public Function EgtSplitCurve(ByVal nId As Integer, ByVal nParts As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSplitCurve_32(nId, nParts)
|
|
Else
|
|
Return EgtSplitCurve_64(nId, nParts)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSplitCurveAtPoint")>
|
|
Private Function EgtSplitCurveAtPoint_32(ByVal nId As Integer, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSplitCurveAtPoint")>
|
|
Private Function EgtSplitCurveAtPoint_64(ByVal nId As Integer, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
End Function
|
|
Public Function EgtSplitCurveAtPoint(ByVal nId As Integer, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSplitCurveAtPoint_32(nId, PtOn, nRefType)
|
|
Else
|
|
Return EgtSplitCurveAtPoint_64(nId, PtOn, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCircleCP")>
|
|
Private Function EgtModifyCircleCP_32(ByVal nId As Integer, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyCircleCP")>
|
|
Private Function EgtModifyCircleCP_64(ByVal nId As Integer, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtModifyCircleCP(ByVal nId As Integer, ByRef PtOn As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyCircleCP_32(nId, PtOn, nRefType)
|
|
Else
|
|
Return EgtModifyCircleCP_64(nId, PtOn, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyArcRadius")>
|
|
Private Function EgtModifyArcRadius_32(ByVal nId As Integer, ByVal dRad As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyArcRadius")>
|
|
Private Function EgtModifyArcRadius_64(ByVal nId As Integer, ByVal dRad As Double) As Boolean
|
|
End Function
|
|
Public Function EgtModifyArcRadius(ByVal nId As Integer, ByVal dRad As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyArcRadius_32(nId, dRad)
|
|
Else
|
|
Return EgtModifyArcRadius_64(nId, dRad)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyArcC2P")>
|
|
Private Function EgtModifyArcC2P_32(ByVal nId As Integer, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyArcC2P")>
|
|
Private Function EgtModifyArcC2P_64(ByVal nId As Integer, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtModifyArcC2P(ByVal nId As Integer, ByRef PtEnd As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyArcC2P_32(nId, PtEnd, nRefType)
|
|
Else
|
|
Return EgtModifyArcC2P_64(nId, PtEnd, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyArc3P")>
|
|
Private Function EgtModifyArc3P_32(ByVal nId As Integer, ByRef PtMid As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyArc3P")>
|
|
Private Function EgtModifyArc3P_64(ByVal nId As Integer, ByRef PtMid As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtModifyArc3P(ByVal nId As Integer, ByRef PtMid As Point3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyArc3P_32(nId, PtMid, nRefType)
|
|
Else
|
|
Return EgtModifyArc3P_64(nId, PtMid, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExplodeCurveCompo")>
|
|
Private Function EgtExplodeCurveCompo_32(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExplodeCurveCompo")>
|
|
Private Function EgtExplodeCurveCompo_64(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
Public Function EgtExplodeCurveCompo(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExplodeCurveCompo_32(nId, nCount)
|
|
Else
|
|
Return EgtExplodeCurveCompo_64(nId, nCount)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMergeCurvesInCurveCompo")>
|
|
Private Function EgtMergeCurvesInCurveCompo_32(ByVal nId As Integer, ByVal dLinTol As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMergeCurvesInCurveCompo")>
|
|
Private Function EgtMergeCurvesInCurveCompo_64(ByVal nId As Integer, ByVal dLinTol As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMergeCurvesInCurveCompo(ByVal nId As Integer, ByVal dLinTol As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMergeCurvesInCurveCompo_32(nId, dLinTol)
|
|
Else
|
|
Return EgtMergeCurvesInCurveCompo_64(nId, dLinTol)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Surfaces Modify ---------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInvertSurface")>
|
|
Private Function EgtInvertSurface_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInvertSurface")>
|
|
Private Function EgtInvertSurface_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtInvertSurface(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInvertSurface_32(nId)
|
|
Else
|
|
Return EgtInvertSurface_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExplodeSurface")>
|
|
Private Function EgtExplodeSurface_32(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExplodeSurface")>
|
|
Private Function EgtExplodeSurface_64(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
End Function
|
|
Public Function EgtExplodeSurface(ByVal nId As Integer, ByRef nCount As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExplodeSurface_32(nId, nCount)
|
|
Else
|
|
Return EgtExplodeSurface_64(nId, nCount)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Parts & Layers ----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsPart")>
|
|
Private Function EgtIsPart_32(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsPart")>
|
|
Private Function EgtIsPart_64(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtIsPart(ByVal nPartId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtIsPart_32(nPartId)
|
|
Else
|
|
Return EgtIsPart_64(nPartId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsLayer")>
|
|
Private Function EgtIsLayer_32(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsLayer")>
|
|
Private Function EgtIsLayer_64(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtIsLayer(ByVal nLayerId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtIsLayer_32(nLayerId)
|
|
Else
|
|
Return EgtIsLayer_64(nLayerId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrPart")>
|
|
Private Function EgtGetCurrPart_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrPart")>
|
|
Private Function EgtGetCurrPart_64() As Integer
|
|
End Function
|
|
Public Function EgtGetCurrPart() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCurrPart_32()
|
|
Else
|
|
Return EgtGetCurrPart_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrLayer")>
|
|
Private Function EgtGetCurrLayer_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrLayer")>
|
|
Private Function EgtGetCurrLayer_64() As Integer
|
|
End Function
|
|
Public Function EgtGetCurrLayer() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCurrLayer_32()
|
|
Else
|
|
Return EgtGetCurrLayer_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrPartLayer")>
|
|
Private Function EgtSetCurrPartLayer_32(ByVal nPartId As Integer, ByVal nLayerId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrPartLayer")>
|
|
Private Function EgtSetCurrPartLayer_64(ByVal nPartId As Integer, ByVal nLayerId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtSetCurrPartLayer(ByVal nPartId As Integer, ByVal nLayerId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCurrPartLayer_32(nPartId, nLayerId)
|
|
Else
|
|
Return EgtSetCurrPartLayer_64(nPartId, nLayerId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetCurrPartLayer")>
|
|
Private Function EgtResetCurrPartLayer_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetCurrPartLayer")>
|
|
Private Function EgtResetCurrPartLayer_64() As Integer
|
|
End Function
|
|
Public Function EgtResetCurrPartLayer() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetCurrPartLayer_32()
|
|
Else
|
|
Return EgtResetCurrPartLayer_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstPart")>
|
|
Private Function EgtGetFirstPart_32(Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstPart")>
|
|
Private Function EgtGetFirstPart_64(Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetFirstPart(Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstPart_32(bOnlyVisible)
|
|
Else
|
|
Return EgtGetFirstPart_64(bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextPart")>
|
|
Private Function EgtGetNextPart_32(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextPart")>
|
|
Private Function EgtGetNextPart_64(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetNextPart(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextPart_32(nPartId, bOnlyVisible)
|
|
Else
|
|
Return EgtGetNextPart_64(nPartId, bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastPart")>
|
|
Private Function EgtGetLastPart_32(Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastPart")>
|
|
Private Function EgtGetLastPart_64(Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetLastPart(Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastPart_32(bOnlyVisible)
|
|
Else
|
|
Return EgtGetLastPart_64(bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevPart")>
|
|
Private Function EgtGetPrevPart_32(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevPart")>
|
|
Private Function EgtGetPrevPart_64(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetPrevPart(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPrevPart_32(nPartId, bOnlyVisible)
|
|
Else
|
|
Return EgtGetPrevPart_64(nPartId, bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstLayer")>
|
|
Private Function EgtGetFirstLayer_32(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstLayer")>
|
|
Private Function EgtGetFirstLayer_64(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetFirstLayer(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstLayer_32(nPartId, bOnlyVisible)
|
|
Else
|
|
Return EgtGetFirstLayer_64(nPartId, bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextLayer")>
|
|
Private Function EgtGetNextLayer_32(ByVal nLayerId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextLayer")>
|
|
Private Function EgtGetNextLayer_64(ByVal nLayerId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetNextLayer(ByVal nLayerId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextLayer_32(nLayerId, bOnlyVisible)
|
|
Else
|
|
Return EgtGetNextLayer_64(nLayerId, bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastLayer")>
|
|
Private Function EgtGetLastLayer_32(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastLayer")>
|
|
Private Function EgtGetlastLayer_64(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetLastLayer(ByVal nPartId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastLayer_32(nPartId, bOnlyVisible)
|
|
Else
|
|
Return EgtGetlastLayer_64(nPartId, bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevLayer")>
|
|
Private Function EgtGetPrevLayer_32(ByVal nLayerId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevLayer")>
|
|
Private Function EgtGetPrevLayer_64(ByVal nLayerId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
End Function
|
|
Public Function EgtGetPrevLayer(ByVal nLayerId As Integer, Optional ByVal bOnlyVisible As Boolean = False) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPrevLayer_32(nLayerId, bOnlyVisible)
|
|
Else
|
|
Return EgtGetPrevLayer_64(nLayerId, bOnlyVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtEraseEmptyParts")>
|
|
Private Function EgtEraseEmptyParts_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtEraseEmptyParts")>
|
|
Private Function EgtEraseEmptyParts_64() As Boolean
|
|
End Function
|
|
Public Function EgtEraseEmptyParts() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtEraseEmptyParts_32()
|
|
Else
|
|
Return EgtEraseEmptyParts_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectPartObjs")>
|
|
Private Function EgtSelectPartObjs_32(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectPartObjs")>
|
|
Private Function EgtSelectPartObjs_64(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSelectPartObjs(ByVal nPartId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelectPartObjs_32(nPartId)
|
|
Else
|
|
Return EgtSelectPartObjs_64(nPartId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectPartObjs")>
|
|
Private Function EgtDeselectPartObjs_32(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectPartObjs")>
|
|
Private Function EgtDeselectPartObjs_64(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtDeselectPartObjs(ByVal nPartId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDeselectPartObjs_32(nPartId)
|
|
Else
|
|
Return EgtDeselectPartObjs_64(nPartId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectLayerObjs")>
|
|
Private Function EgtSelectLayerObjs_32(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectLayerObjs")>
|
|
Private Function EgtSelectLayerObjs_64(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSelectLayerObjs(ByVal nLayerId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelectLayerObjs_32(nLayerId)
|
|
Else
|
|
Return EgtSelectLayerObjs_64(nLayerId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectLayerObjs")>
|
|
Private Function EgtDeselectLayerObjs_32(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectLayerObjs")>
|
|
Private Function EgtDeselectLayerObjs_64(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtDeselectLayerObjs(ByVal nLayerId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDeselectLayerObjs_32(nLayerId)
|
|
Else
|
|
Return EgtDeselectLayerObjs_64(nLayerId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectPathObjs")>
|
|
Private Function EgtSelectPathObjs_32(ByVal nId As Integer, ByVal bHaltOnFork As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectPathObjs")>
|
|
Private Function EgtSelectPathObjs_64(ByVal nId As Integer, ByVal bHaltOnFork As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSelectPathObjs(ByVal nId As Integer, ByVal bHaltOnFork As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelectPathObjs_32(nId, bHaltOnFork)
|
|
Else
|
|
Return EgtSelectPathObjs_64(nId, bHaltOnFork)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Objects -----------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExistsObj")>
|
|
Private Function EgtExistsObj_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExistsObj")>
|
|
Private Function EgtExistsObj_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtExistsObj(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExistsObj_32(nId)
|
|
Else
|
|
Return EgtExistsObj_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetParent")>
|
|
Private Function EgtGetParent_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetParent")>
|
|
Private Function EgtGetParent_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetParent(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetParent_32(nId)
|
|
Else
|
|
Return EgtGetParent_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGroupGlobFrame")>
|
|
Private Function EgtGetGroupGlobFrame_32(ByVal nId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGroupGlobFrame")>
|
|
Private Function EgtGetGroupGlobFrame_64(ByVal nId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetGroupGlobFrame(ByVal nId As Integer, ByRef frGRef As Frame3d) As Boolean
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetGroupGlobFrame_32(nId, PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
bOk = EgtGetGroupGlobFrame_64(nId, PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
If Not bOk Then
|
|
Return False
|
|
Else
|
|
Return frGRef.Setup(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGroupObjs")>
|
|
Private Function EgtGetGroupObjs_32(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGroupObjs")>
|
|
Private Function EgtGetGroupObjs_64(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetGroupObjs(ByVal nGroupId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetGroupObjs_32(nGroupId)
|
|
Else
|
|
Return EgtGetGroupObjs_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstInGroup")>
|
|
Private Function EgtGetFirstInGroup_32(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstInGroup")>
|
|
Private Function EgtGetFirstInGroup_64(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetFirstInGroup(ByVal nGroupId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstInGroup_32(nGroupId)
|
|
Else
|
|
Return EgtGetFirstInGroup_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNext")>
|
|
Private Function EgtGetNext_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNext")>
|
|
Private Function EgtGetNext_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetNext(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNext_32(nId)
|
|
Else
|
|
Return EgtGetNext_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastInGroup")>
|
|
Private Function EgtGetLastInGroup_32(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastInGroup")>
|
|
Private Function EgtGetLastInGroup_64(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetLastInGroup(ByVal nGroupId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastInGroup_32(nGroupId)
|
|
Else
|
|
Return EgtGetLastInGroup_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrev")>
|
|
Private Function EgtGetPrev_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrev")>
|
|
Private Function EgtGetPrev_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetPrev(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPrev_32(nId)
|
|
Else
|
|
Return EgtGetPrev_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstGroupInGroup")>
|
|
Private Function EgtGetFirstGroupInGroup_32(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstGroupInGroup")>
|
|
Private Function EgtGetFirstGroupInGroup_64(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetFirstGroupInGroup(ByVal nGroupId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstGroupInGroup_32(nGroupId)
|
|
Else
|
|
Return EgtGetFirstGroupInGroup_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextGroup")>
|
|
Private Function EgtGetNextGroup_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextGroup")>
|
|
Private Function EgtGetNextGroup_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetNextGroup(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextGroup_32(nId)
|
|
Else
|
|
Return EgtGetNextGroup_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastGroupInGroup")>
|
|
Private Function EgtGetLastGroupInGroup_32(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastGroupInGroup")>
|
|
Private Function EgtGetLastGroupInGroup_64(ByVal nGroupId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetLastGroupInGroup(ByVal nGroupId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastGroupInGroup_32(nGroupId)
|
|
Else
|
|
Return EgtGetLastGroupInGroup_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevGroup")>
|
|
Private Function EgtGetPrevGroup_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevGroup")>
|
|
Private Function EgtGetPrevGroup_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetPrevGroup(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPrevGroup_32(nId)
|
|
Else
|
|
Return EgtGetPrevGroup_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstNameInGroup")>
|
|
Private Function EgtGetFirstNameInGroup_32(ByVal nGroupId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstNameInGroup")>
|
|
Private Function EgtGetFirstNameInGroup_64(ByVal nGroupId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
Public Function EgtGetFirstNameInGroup(ByVal nGroupId As Integer, ByVal sName As String) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstNameInGroup_32(nGroupId, sName)
|
|
Else
|
|
Return EgtGetFirstNameInGroup_64(nGroupId, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextName")>
|
|
Private Function EgtGetNextName_32(ByVal nId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextName")>
|
|
Private Function EgtGetNextName_64(ByVal nId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
Public Function EgtGetNextName(ByVal nId As Integer, ByVal sName As String) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextName_32(nId, sName)
|
|
Else
|
|
Return EgtGetNextName_64(nId, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastNameInGroup")>
|
|
Private Function EgtGetLastNameInGroup_32(ByVal nGroupId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastNameInGroup")>
|
|
Private Function EgtGetLastNameInGroup_64(ByVal nGroupId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
Public Function EgtGetLastNameInGroup(ByVal nGroupId As Integer, ByVal sName As String) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastNameInGroup_32(nGroupId, sName)
|
|
Else
|
|
Return EgtGetLastNameInGroup_64(nGroupId, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevName")>
|
|
Private Function EgtGetPrevName_32(ByVal nId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevName")>
|
|
Private Function EgtGetPrevName_64(ByVal nId As Integer, ByVal sName As String) As Integer
|
|
End Function
|
|
Public Function EgtGetPrevName(ByVal nId As Integer, ByVal sName As String) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPrevName_32(nId, sName)
|
|
Else
|
|
Return EgtGetPrevName_64(nId, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetBBox")>
|
|
Private Function EgtGetBBox_32(ByVal nId As Integer, ByVal nFlag As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetBBox")>
|
|
Private Function EgtGetBBox_64(ByVal nId As Integer, ByVal nFlag As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetBBox(ByVal nId As Integer, ByVal nFlag As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetBBox_32(nId, nFlag, PtMin, PtMax)
|
|
Else
|
|
Return EgtGetBBox_64(nId, nFlag, PtMin, PtMax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetBBoxGlob")>
|
|
Private Function EgtGetBBoxGlob_32(ByVal nId As Integer, ByVal nFlag As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetBBoxGlob")>
|
|
Private Function EgtGetBBoxGlob_64(ByVal nId As Integer, ByVal nFlag As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetBBoxGlob(ByVal nId As Integer, ByVal nFlag As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetBBoxGlob_32(nId, nFlag, PtMin, PtMax)
|
|
Else
|
|
Return EgtGetBBoxGlob_64(nId, nFlag, PtMin, PtMax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCopy")>
|
|
Private Function EgtCopy_32(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCopy")>
|
|
Private Function EgtCopy_64(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
Public Function EgtCopy(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCopy_32(nId, nRefId, nSonBeforeAfter)
|
|
Else
|
|
Return EgtCopy_64(nId, nRefId, nSonBeforeAfter)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCopyGlob")>
|
|
Private Function EgtCopyGlob_32(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCopyGlob")>
|
|
Private Function EgtCopyGlob_64(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
Public Function EgtCopyGlob(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCopyGlob_32(nId, nRefId, nSonBeforeAfter)
|
|
Else
|
|
Return EgtCopyGlob_64(nId, nRefId, nSonBeforeAfter)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRelocate")>
|
|
Private Function EgtRelocate_32(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRelocate")>
|
|
Private Function EgtRelocate_64(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
Public Function EgtRelocate(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRelocate_32(nId, nRefId, nSonBeforeAfter)
|
|
Else
|
|
Return EgtRelocate_64(nId, nRefId, nSonBeforeAfter)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRelocateGlob")>
|
|
Private Function EgtRelocateGlob_32(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRelocateGlob")>
|
|
Private Function EgtRelocateGlob_64(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
End Function
|
|
Public Function EgtRelocateGlob(ByVal nId As Integer, ByVal nRefId As Integer, Optional ByVal nSonBeforeAfter As GDB_POS = GDB_POS.LAST_SON) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRelocateGlob_32(nId, nRefId, nSonBeforeAfter)
|
|
Else
|
|
Return EgtRelocateGlob_64(nId, nRefId, nSonBeforeAfter)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtErase")>
|
|
Private Function EgtErase_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtErase")>
|
|
Private Function EgtErase_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtErase(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtErase_32(nId)
|
|
Else
|
|
Return EgtErase_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtEmptyGroup")>
|
|
Private Function EgtEmptyGroup_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtEmptyGroup")>
|
|
Private Function EgtEmptyGroup_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtEmptyGroup(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtEmptyGroup_32(nId)
|
|
Else
|
|
Return EgtEmptyGroup_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetType")>
|
|
Private Function EgtGetType_32(ByVal nId As Integer) As GDB_TY
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetType")>
|
|
Private Function EgtGetType_64(ByVal nId As Integer) As GDB_TY
|
|
End Function
|
|
Public Function EgtGetType(ByVal nId As Integer) As GDB_TY
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetType_32(nId)
|
|
Else
|
|
Return EgtGetType_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTitle")>
|
|
Private Function EgtGetTitle_32(ByVal nId As Integer, ByRef psTitle As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTitle")>
|
|
Private Function EgtGetTitle_64(ByVal nId As Integer, ByRef psTitle As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetTitle(ByVal nId As Integer, ByRef sTitle As String) As Boolean
|
|
Dim psTitle As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetTitle_32(nId, psTitle)
|
|
Else
|
|
bOk = EgtGetTitle_64(nId, psTitle)
|
|
End If
|
|
If bOk Then
|
|
sTitle = Marshal.PtrToStringUni(psTitle)
|
|
EgtFreeMemory(psTitle)
|
|
Else
|
|
sTitle = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGroupDump")>
|
|
Private Function EgtGroupDump_32(ByVal nId As Integer, ByRef psDump As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGroupDump")>
|
|
Private Function EgtGroupDump_64(ByVal nId As Integer, ByRef psDump As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGroupDump(ByVal nId As Integer, ByRef sDump As String) As Boolean
|
|
Dim psDump As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGroupDump_32(nId, psDump)
|
|
Else
|
|
bOk = EgtGroupDump_64(nId, psDump)
|
|
End If
|
|
If bOk Then
|
|
sDump = Marshal.PtrToStringUni(psDump)
|
|
EgtFreeMemory(psDump)
|
|
Else
|
|
sDump = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGeoObjDump")>
|
|
Private Function EgtGeoObjDump_32(ByVal nId As Integer, ByRef psDump As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGeoObjDump")>
|
|
Private Function EgtGeoObjDump_64(ByVal nId As Integer, ByRef psDump As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGeoObjDump(ByVal nId As Integer, ByRef sDump As String) As Boolean
|
|
Dim psDump As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGeoObjDump_32(nId, psDump)
|
|
Else
|
|
bOk = EgtGeoObjDump_64(nId, psDump)
|
|
End If
|
|
If bOk Then
|
|
sDump = Marshal.PtrToStringUni(psDump)
|
|
EgtFreeMemory(psDump)
|
|
Else
|
|
sDump = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Obj Attributes ----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetLevel")>
|
|
Private Function EgtSetLevel_32(ByVal nId As Integer, ByVal nLevel As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetLevel")>
|
|
Private Function EgtSetLevel_64(ByVal nId As Integer, ByVal nLevel As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetLevel(ByVal nId As Integer, ByVal nLevel As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetLevel_32(nId, nLevel)
|
|
Else
|
|
Return EgtSetLevel_64(nId, nLevel)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRevertLevel")>
|
|
Private Function EgtRevertLevel_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRevertLevel")>
|
|
Private Function EgtRevertLevel_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRevertLevel(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRevertLevel_32(nId)
|
|
Else
|
|
Return EgtRevertLevel_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLevel")>
|
|
Private Function EgtGetLevel_32(ByVal nId As Integer, ByRef nLevel As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLevel")>
|
|
Private Function EgtGetLevel_64(ByVal nId As Integer, ByRef nLevel As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetLevel(ByVal nId As Integer, ByRef nLevel As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLevel_32(nId, nLevel)
|
|
Else
|
|
Return EgtGetLevel_64(nId, nLevel)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcLevel")>
|
|
Private Function EgtGetCalcLevel_32(ByVal nId As Integer, ByRef nLevel As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcLevel")>
|
|
Private Function EgtGetCalcLevel_64(ByVal nId As Integer, ByRef nLevel As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcLevel(ByVal nId As Integer, ByRef nLevel As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcLevel_32(nId, nLevel)
|
|
Else
|
|
Return EgtGetCalcLevel_64(nId, nLevel)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMode")>
|
|
Private Function EgtSetMode_32(ByVal nId As Integer, ByVal nMode As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMode")>
|
|
Private Function EgtSetMode_64(ByVal nId As Integer, ByVal nMode As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetMode(ByVal nId As Integer, ByVal nMode As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetMode_32(nId, nMode)
|
|
Else
|
|
Return EgtSetMode_64(nId, nMode)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRevertMode")>
|
|
Private Function EgtRevertMode_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRevertMode")>
|
|
Private Function EgtRevertMode_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRevertMode(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRevertMode_32(nId)
|
|
Else
|
|
Return EgtRevertMode_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMode")>
|
|
Private Function EgtGetMode_32(ByVal nId As Integer, ByRef nMode As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMode")>
|
|
Private Function EgtGetMode_64(ByVal nId As Integer, ByRef nMode As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetMode(ByVal nId As Integer, ByRef nMode As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetMode_32(nId, nMode)
|
|
Else
|
|
Return EgtGetMode_64(nId, nMode)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcMode")>
|
|
Private Function EgtGetCalcMode_32(ByVal nId As Integer, ByRef nMode As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcMode")>
|
|
Private Function EgtGetCalcMode_64(ByVal nId As Integer, ByRef nMode As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcMode(ByVal nId As Integer, ByRef nMode As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcMode_32(nId, nMode)
|
|
Else
|
|
Return EgtGetCalcMode_64(nId, nMode)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetStatus")>
|
|
Private Function EgtSetStatus_32(ByVal nId As Integer, ByVal nStat As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetStatus")>
|
|
Private Function EgtSetStatus_64(ByVal nId As Integer, ByVal nStat As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetStatus(ByVal nId As Integer, ByVal nStat As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetStatus_32(nId, nStat)
|
|
Else
|
|
Return EgtSetStatus_64(nId, nStat)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRevertStatus")>
|
|
Private Function EgtRevertStatus_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRevertStatus")>
|
|
Private Function EgtRevertStatus_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRevertStatus(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRevertStatus_32(nId)
|
|
Else
|
|
Return EgtRevertStatus_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetStatus")>
|
|
Private Function EgtGetStatus_32(ByVal nId As Integer, ByRef nStat As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetStatus")>
|
|
Private Function EgtGetStatus_64(ByVal nId As Integer, ByRef nStat As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetStatus(ByVal nId As Integer, ByRef nStat As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetStatus_32(nId, nStat)
|
|
Else
|
|
Return EgtGetStatus_64(nId, nStat)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcStatus")>
|
|
Private Function EgtGetCalcStatus_32(ByVal nId As Integer, ByRef nStat As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcStatus")>
|
|
Private Function EgtGetCalcStatus_64(ByVal nId As Integer, ByRef nStat As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcStatus(ByVal nId As Integer, ByRef nStat As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcStatus_32(nId, nStat)
|
|
Else
|
|
Return EgtGetCalcStatus_64(nId, nStat)
|
|
End If
|
|
End Function
|
|
|
|
Public Function EgtIsVisibleObj(ByVal nId As Integer) As Boolean
|
|
Dim nStat As GDB_ST = GDB_ST.ON_
|
|
Return EgtGetCalcStatus(nId, nStat) AndAlso nStat <> GDB_ST.OFF
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMark")>
|
|
Private Function EgtSetMark_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMark")>
|
|
Private Function EgtSetMark_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetMark(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetMark_32(nId)
|
|
Else
|
|
Return EgtSetMark_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetMark")>
|
|
Private Function EgtResetMark_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetMark")>
|
|
Private Function EgtResetMark_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtResetMark(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetMark_32(nId)
|
|
Else
|
|
Return EgtResetMark_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMark")>
|
|
Private Function EgtGetMark_32(ByVal nId As Integer, ByRef bMark As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMark")>
|
|
Private Function EgtGetMark_64(ByVal nId As Integer, ByRef bMark As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtGetMark(ByVal nId As Integer, ByRef bMark As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetMark_32(nId, bMark)
|
|
Else
|
|
Return EgtGetMark_64(nId, bMark)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcMark")>
|
|
Private Function EgtGetCalcMark_32(ByVal nId As Integer, ByRef bMark As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcMark")>
|
|
Private Function EgtGetCalcMark_64(ByVal nId As Integer, ByRef bMark As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcMark(ByVal nId As Integer, ByRef bMark As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcMark_32(nId, bMark)
|
|
Else
|
|
Return EgtGetCalcMark_64(nId, bMark)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetColor")>
|
|
Private Function EgtSetColor_32(ByVal nId As Integer, ByRef ColObj As Color3d, Optional ByVal bSetAlpha As Boolean = True) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetColor")>
|
|
Private Function EgtSetColor_64(ByVal nId As Integer, ByRef ColObj As Color3d, Optional ByVal bSetAlpha As Boolean = True) As Boolean
|
|
End Function
|
|
Public Function EgtSetColor(ByVal nId As Integer, ByRef ColObj As Color3d, Optional ByVal bSetAlpha As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetColor_32(nId, ColObj, bSetAlpha)
|
|
Else
|
|
Return EgtSetColor_64(nId, ColObj, bSetAlpha)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAlpha")>
|
|
Private Function EgtSetAlpha_32(ByVal nId As Integer, ByVal nAlpha As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAlpha")>
|
|
Private Function EgtSetAlpha_64(ByVal nId As Integer, ByVal nAlpha As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetAlpha(ByVal nId As Integer, ByVal nAlpha As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetAlpha_32(nId, nAlpha)
|
|
Else
|
|
Return EgtSetAlpha_64(nId, nAlpha)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetColor")>
|
|
Private Function EgtResetColor_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetColor")>
|
|
Private Function EgtResetColor_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtResetColor(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetColor_32(nId)
|
|
Else
|
|
Return EgtResetColor_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetColor")>
|
|
Private Function EgtGetColor_32(ByVal nId As Integer, ByRef ColObj As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetColor")>
|
|
Private Function EgtGetColor_64(ByVal nId As Integer, ByRef ColObj As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetColor(ByVal nId As Integer, ByRef ColObj As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetColor_32(nId, ColObj)
|
|
Else
|
|
Return EgtGetColor_64(nId, ColObj)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcColor")>
|
|
Private Function EgtGetCalcColor_32(ByVal nId As Integer, ByRef ColObj As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcColor")>
|
|
Private Function EgtGetCalcColor_64(ByVal nId As Integer, ByRef ColObj As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcColor(ByVal nId As Integer, ByRef ColObj As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcColor_32(nId, ColObj)
|
|
Else
|
|
Return EgtGetCalcColor_64(nId, ColObj)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetName")>
|
|
Private Function EgtSetName_32(ByVal nId As Integer, ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetName")>
|
|
Private Function EgtSetName_64(ByVal nId As Integer, ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetName(ByVal nId As Integer, ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetName_32(nId, sName)
|
|
Else
|
|
Return EgtSetName_64(nId, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetName")>
|
|
Private Function EgtGetName_32(ByVal nId As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetName")>
|
|
Private Function EgtGetName_64(ByVal nId As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetName(ByVal nId As Integer, ByRef sName As String) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetName_32(nId, psName)
|
|
Else
|
|
bOk = EgtGetName_64(nId, psName)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExistsName")>
|
|
Private Function EgtExistsName_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExistsName")>
|
|
Private Function EgtExistsName_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtExistsName(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExistsName_32(nId)
|
|
Else
|
|
Return EgtExistsName_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveName")>
|
|
Private Function EgtRemoveName_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveName")>
|
|
Private Function EgtRemoveName_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRemoveName(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveName_32(nId)
|
|
Else
|
|
Return EgtRemoveName_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetInfo")>
|
|
Private Function EgtSetInfo_32(ByVal nId As Integer, ByVal sKey As String, ByVal sInfo As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetInfo")>
|
|
Private Function EgtSetInfo_64(ByVal nId As Integer, ByVal sKey As String, ByVal sInfo As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetInfo(ByVal nId As Integer, ByVal sKey As String, ByVal sInfo As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetInfo_32(nId, sKey, sInfo)
|
|
Else
|
|
Return EgtSetInfo_64(nId, sKey, sInfo)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetInfoFrame")>
|
|
Private Function EgtSetInfoFrame_32(ByVal nId As Integer, ByVal sKey As String, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetInfoFrame")>
|
|
Private Function EgtSetInfoFrame_64(ByVal nId As Integer, ByVal sKey As String, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetInfo(ByVal nId As Integer, ByVal sKey As String, ByVal Frame As Frame3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetInfoFrame_32(nId, sKey, Frame.Orig(), Frame.VersX(), Frame.VersY(), Frame.VersZ())
|
|
Else
|
|
Return EgtSetInfoFrame_64(nId, sKey, Frame.Orig(), Frame.VersX(), Frame.VersY(), Frame.VersZ())
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfo")>
|
|
Private Function EgtGetInfo_32(ByVal nId As Integer, ByVal sKey As String, ByRef psInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfo")>
|
|
Private Function EgtGetInfo_64(ByVal nId As Integer, ByVal sKey As String, ByRef psInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetInfo(ByVal nId As Integer, ByVal sKey As String, ByRef sInfo As String) As Boolean
|
|
Dim psInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetInfo_32(nId, sKey, psInfo)
|
|
Else
|
|
bOk = EgtGetInfo_64(nId, sKey, psInfo)
|
|
End If
|
|
If bOk Then
|
|
sInfo = Marshal.PtrToStringUni(psInfo)
|
|
EgtFreeMemory(psInfo)
|
|
Else
|
|
sInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfoInt")>
|
|
Private Function EgtGetInfoInt_32(ByVal nId As Integer, ByVal sKey As String, ByRef nInfo As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfoInt")>
|
|
Private Function EgtGetInfoInt_64(ByVal nId As Integer, ByVal sKey As String, ByRef nInfo As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetInfo(ByVal nId As Integer, ByVal sKey As String, ByRef nInfo As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetInfoInt_32(nId, sKey, nInfo)
|
|
Else
|
|
Return EgtGetInfoInt_64(nId, sKey, nInfo)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfoDouble")>
|
|
Private Function EgtGetInfoDouble_32(ByVal nId As Integer, ByVal sKey As String, ByRef dInfo As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfoDouble")>
|
|
Private Function EgtGetInfoDouble_64(ByVal nId As Integer, ByVal sKey As String, ByRef dInfo As Double) As Boolean
|
|
End Function
|
|
Public Function EgtGetInfo(ByVal nId As Integer, ByVal sKey As String, ByRef dInfo As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetInfoDouble_32(nId, sKey, dInfo)
|
|
Else
|
|
Return EgtGetInfoDouble_64(nId, sKey, dInfo)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfoFrame")>
|
|
Private Function EgtGetInfoFrame_32(ByVal nId As Integer, ByVal sKey As String, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetInfoFrame")>
|
|
Private Function EgtGetInfoFrame_64(ByVal nId As Integer, ByVal sKey As String, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetInfo(ByVal nId As Integer, ByVal sKey As String, ByRef Frame As Frame3d) As Boolean
|
|
Dim ptOri As Point3d
|
|
Dim vtX As Vector3d
|
|
Dim vtY As Vector3d
|
|
Dim vtZ As Vector3d
|
|
If IntPtr.Size = 4 Then
|
|
If Not EgtGetInfoFrame_32(nId, sKey, ptOri, vtX, vtY, vtZ) Then
|
|
Return False
|
|
End If
|
|
Else
|
|
If Not EgtGetInfoFrame_64(nId, sKey, ptOri, vtX, vtY, vtZ) Then
|
|
Return False
|
|
End If
|
|
End If
|
|
Return Frame.Setup(ptOri, vtX, vtY, vtZ)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtExistsInfo")>
|
|
Private Function EgtExistsInfo_32(ByVal nId As Integer, ByVal sKey As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtExistsInfo")>
|
|
Private Function EgtExistsInfo_64(ByVal nId As Integer, ByVal sKey As String) As Boolean
|
|
End Function
|
|
Public Function EgtExistsInfo(ByVal nId As Integer, ByVal sKey As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtExistsInfo_32(nId, sKey)
|
|
Else
|
|
Return EgtExistsInfo_64(nId, sKey)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveInfo")>
|
|
Private Function EgtRemoveInfo_32(ByVal nId As Integer, ByVal sKey As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveInfo")>
|
|
Private Function EgtRemoveInfo_64(ByVal nId As Integer, ByVal sKey As String) As Boolean
|
|
End Function
|
|
Public Function EgtRemoveInfo(ByVal nId As Integer, ByVal sKey As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveInfo_32(nId, sKey)
|
|
Else
|
|
Return EgtRemoveInfo_64(nId, sKey)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetTextureName")>
|
|
Private Function EgtSetTextureName_32(ByVal nId As Integer, ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetTextureName")>
|
|
Private Function EgtSetTextureName_64(ByVal nId As Integer, ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetTextureName(ByVal nId As Integer, ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetTextureName_32(nId, sName)
|
|
Else
|
|
Return EgtSetTextureName_64(nId, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetTextureFrame")>
|
|
Private Function EgtSetTextureFrame_32(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetTextureFrame")>
|
|
Private Function EgtSetTextureFrame_64(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d, ByVal nRefType As GDB_RT) As Boolean
|
|
End Function
|
|
Public Function EgtSetTextureFrame(ByVal nId As Integer, ByRef frRef As Frame3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetTextureFrame_32(nId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
Else
|
|
Return EgtSetTextureFrame_64(nId, frRef.Orig(), frRef.VersX(), frRef.VersY(), frRef.VersZ(), nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveTextureData")>
|
|
Private Function EgtRemoveTextureData_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveTextureData")>
|
|
Private Function EgtRemoveTextureData_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRemoveTextureData(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveTextureData_32(nId)
|
|
Else
|
|
Return EgtRemoveTextureData_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTextureName")>
|
|
Private Function EgtGetTextureName_32(ByVal nId As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTextureName")>
|
|
Private Function EgtGetTextureName_64(ByVal nId As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetTextureName(ByVal nId As Integer, ByRef sName As String) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetTextureName_32(nId, psName)
|
|
Else
|
|
bOk = EgtGetTextureName_64(nId, psName)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTextureFrame")>
|
|
Private Function EgtGetTextureFrame_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTextureFrame")>
|
|
Private Function EgtGetTextureFrame_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetTextureFrame(ByVal nId As Integer, ByVal nRefId As Integer, ByRef frRef As Frame3d) As Boolean
|
|
Dim ptOri As Point3d
|
|
Dim vtX As Vector3d
|
|
Dim vtY As Vector3d
|
|
Dim vtZ As Vector3d
|
|
If IntPtr.Size = 4 Then
|
|
If Not EgtGetTextureFrame_32(nId, nRefId, ptOri, vtX, vtY, vtZ) Then
|
|
Return False
|
|
End If
|
|
Else
|
|
If Not EgtGetTextureFrame_64(nId, nRefId, ptOri, vtX, vtY, vtZ) Then
|
|
Return False
|
|
End If
|
|
End If
|
|
Return frRef.Setup(ptOri, vtX, vtY, vtZ)
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Obj Selection -----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectObj")>
|
|
Private Function EgtSelectObj_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectObj")>
|
|
Private Function EgtSelectObj_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSelectObj(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelectObj_32(nId)
|
|
Else
|
|
Return EgtSelectObj_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectObj")>
|
|
Private Function EgtDeselectObj_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectObj")>
|
|
Private Function EgtDeselectObj_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtDeselectObj(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDeselectObj_32(nId)
|
|
Else
|
|
Return EgtDeselectObj_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectAll")>
|
|
Private Function EgtSelectAll_32(Optional ByVal bOnlyIfVisible As Boolean = False) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectAll")>
|
|
Private Function EgtSelectAll_64(Optional ByVal bOnlyIfVisible As Boolean = False) As Boolean
|
|
End Function
|
|
Public Function EgtSelectAll(Optional ByVal bOnlyIfVisible As Boolean = False) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelectAll_32(bOnlyIfVisible)
|
|
Else
|
|
Return EgtSelectAll_64(bOnlyIfVisible)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectAll")>
|
|
Private Function EgtDeselectAll_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectAll")>
|
|
Private Function EgtDeselectAll_64() As Boolean
|
|
End Function
|
|
Public Function EgtDeselectAll() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDeselectAll_32()
|
|
Else
|
|
Return EgtDeselectAll_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectGroupObjs")>
|
|
Private Function EgtSelectGroupObjs_32(ByVal nGroupId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelectGroupObjs")>
|
|
Private Function EgtSelectGroupObjs_64(ByVal nGroupId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSelectGroupObjs(ByVal nGroupId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelectGroupObjs_32(nGroupId)
|
|
Else
|
|
Return EgtSelectGroupObjs_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectGroupObjs")>
|
|
Private Function EgtDeselectGroupObjs_32(ByVal nGroupId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDeselectGroupObjs")>
|
|
Private Function EgtDeselectGroupObjs_64(ByVal nGroupId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtDeselectGroupObjs(ByVal nGroupId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDeselectGroupObjs_32(nGroupId)
|
|
Else
|
|
Return EgtDeselectGroupObjs_64(nGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsSelectedObj")>
|
|
Private Function EgtIsSelectedObj_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsSelectedObj")>
|
|
Private Function EgtIsSelectedObj_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtIsSelectedObj(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtIsSelectedObj_32(nId)
|
|
Else
|
|
Return EgtIsSelectedObj_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetSelectedObjCount")>
|
|
Private Function EgtGetSelectedObjCount_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetSelectedObjCount")>
|
|
Private Function EgtGetSelectedObjCount_64() As Integer
|
|
End Function
|
|
Public Function EgtGetSelectedObjCount() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetSelectedObjCount_32()
|
|
Else
|
|
Return EgtGetSelectedObjCount_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstSelectedObj")>
|
|
Private Function EgtGetFirstSelectedObj_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstSelectedObj")>
|
|
Private Function EgtGetFirstSelectedObj_64() As Integer
|
|
End Function
|
|
Public Function EgtGetFirstSelectedObj() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstSelectedObj_32()
|
|
Else
|
|
Return EgtGetFirstSelectedObj_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextSelectedObj")>
|
|
Private Function EgtGetNextSelectedObj_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextSelectedObj")>
|
|
Private Function EgtGetNextSelectedObj_64() As Integer
|
|
End Function
|
|
Public Function EgtGetNextSelectedObj() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextSelectedObj_32()
|
|
Else
|
|
Return EgtGetNextSelectedObj_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastSelectedObj")>
|
|
Private Function EgtGetLastSelectedObj_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastSelectedObj")>
|
|
Private Function EgtGetLastSelectedObj_64() As Integer
|
|
End Function
|
|
Public Function EgtGetLastSelectedObj() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastSelectedObj_32()
|
|
Else
|
|
Return EgtGetLastSelectedObj_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevSelectedObj")>
|
|
Private Function EgtGetPrevSelectedObj_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPrevSelectedObj")>
|
|
Private Function EgtGetPrevSelectedObj_64() As Integer
|
|
End Function
|
|
Public Function EgtGetPrevSelectedObj() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPrevSelectedObj_32()
|
|
Else
|
|
Return EgtGetPrevSelectedObj_64()
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Obj Transform -----------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMove")>
|
|
Private Function EgtMove_32(ByVal nId As Integer, ByRef VtMove As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMove")>
|
|
Private Function EgtMove_64(ByVal nId As Integer, ByRef VtMove As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtMove(ByVal nId As Integer, ByRef VtMove As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMove_32(nId, VtMove, nRefType)
|
|
Else
|
|
Return EgtMove_64(nId, VtMove, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotate")>
|
|
Private Function EgtRotate_32(ByVal nId As Integer, ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotate")>
|
|
Private Function EgtRotate_64(ByVal nId As Integer, ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtRotate(ByVal nId As Integer, ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRotate_32(nId, PtAx, VtAx, dAngRotDeg, nRefType)
|
|
Else
|
|
Return EgtRotate_64(nId, PtAx, VtAx, dAngRotDeg, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtScale")>
|
|
Private Function EgtScale_32(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double, ByVal nRefType As GDB_RT) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtScale")>
|
|
Private Function EgtScale_64(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double, ByVal nRefType As GDB_RT) As Boolean
|
|
End Function
|
|
Public Function EgtScale(ByVal nId As Integer, ByVal Frame As Frame3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtScale_32(nId, Frame.Orig(), Frame.VersX(), Frame.VersY(), Frame.VersZ(), dCoeffX, dCoeffY, dCoeffZ, nRefType)
|
|
Else
|
|
Return EgtScale_64(nId, Frame.Orig(), Frame.VersX(), Frame.VersY(), Frame.VersZ(), dCoeffX, dCoeffY, dCoeffZ, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMirror")>
|
|
Private Function EgtMirror_32(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMirror")>
|
|
Private Function EgtMirror_64(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtMirror(ByVal nId As Integer, ByVal PtOn As Point3d, ByVal VtNorm As Vector3d, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMirror_32(nId, PtOn, VtNorm, nRefType)
|
|
Else
|
|
Return EgtMirror_64(nId, PtOn, VtNorm, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtShear")>
|
|
Private Function EgtShear_32(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d,
|
|
ByRef VtDir As Vector3d, ByVal dCoeff As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtShear")>
|
|
Private Function EgtShear_64(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d,
|
|
ByRef VtDir As Vector3d, ByVal dCoeff As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
End Function
|
|
Public Function EgtShear(ByVal nId As Integer, ByVal PtOn As Point3d, ByVal VtNorm As Vector3d,
|
|
ByVal VtDir As Vector3d, ByVal dCoeff As Double, Optional ByVal nRefType As GDB_RT = GDB_RT.LOC) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtShear_32(nId, PtOn, VtNorm, VtDir, dCoeff, nRefType)
|
|
Else
|
|
Return EgtShear_64(nId, PtOn, VtNorm, VtDir, dCoeff, nRefType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveGroup")>
|
|
Private Function EgtMoveGroup_32(ByVal nId As Integer, ByRef VtMove As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveGroup")>
|
|
Private Function EgtMoveGroup_64(ByVal nId As Integer, ByRef VtMove As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtMoveGroup(ByVal nId As Integer, ByVal VtMove As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveGroup_32(nId, VtMove)
|
|
Else
|
|
Return EgtMoveGroup_64(nId, VtMove)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotateGroup")>
|
|
Private Function EgtRotateGroup_32(ByVal nId As Integer, ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotateGroup")>
|
|
Private Function EgtRotateGroup_64(ByVal nId As Integer, ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
Public Function EgtRotateGroup(ByVal nId As Integer, ByVal PtAx As Point3d, ByVal VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRotateGroup_32(nId, PtAx, VtAx, dAngRotDeg)
|
|
Else
|
|
Return EgtRotateGroup_64(nId, PtAx, VtAx, dAngRotDeg)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtScaleGroup")>
|
|
Private Function EgtScaleGroup_32(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtScaleGroup")>
|
|
Private Function EgtScaleGroup_64(ByVal nId As Integer, ByRef PtOrig As Point3d,
|
|
ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
End Function
|
|
Public Function EgtScaleGroup(ByVal nId As Integer, ByVal Frame As Frame3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtScaleGroup_32(nId, Frame.Orig(), Frame.VersX(), Frame.VersY(), Frame.VersZ(), dCoeffX, dCoeffY, dCoeffZ)
|
|
Else
|
|
Return EgtScaleGroup_64(nId, Frame.Orig(), Frame.VersX(), Frame.VersY(), Frame.VersZ(), dCoeffX, dCoeffY, dCoeffZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMirrorGroup")>
|
|
Private Function EgtMirrorGroup_32(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMirrorGroup")>
|
|
Private Function EgtMirrorGroup_64(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtMirrorGroup(ByVal nId As Integer, ByVal PtOn As Point3d, ByVal VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMirrorGroup_32(nId, PtOn, VtNorm)
|
|
Else
|
|
Return EgtMirrorGroup_64(nId, PtOn, VtNorm)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtShearGroup")>
|
|
Private Function EgtShearGroup_32(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d,
|
|
ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtShearGroup")>
|
|
Private Function EgtShearGroup_64(ByVal nId As Integer, ByRef PtOn As Point3d, ByRef VtNorm As Vector3d,
|
|
ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
End Function
|
|
Public Function EgtShearGroup(ByVal nId As Integer, ByVal PtOn As Point3d, ByVal VtNorm As Vector3d,
|
|
ByVal VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtShearGroup_32(nId, PtOn, VtNorm, VtDir, dCoeff)
|
|
Else
|
|
Return EgtShearGroup_64(nId, PtOn, VtNorm, VtDir, dCoeff)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- GeomDb Snap Vector/Point/Frame -------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtStartPoint")>
|
|
Private Function EgtStartPoint_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtStartPoint")>
|
|
Private Function EgtStartPoint_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtStartPoint(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtStartPoint_32(nId, nRefId, PtP)
|
|
Else
|
|
Return EgtStartPoint_64(nId, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtStartPoint(ByVal nId As Integer, ByRef PtP As Point3d) As Boolean
|
|
Return EgtStartPoint(nId, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtEndPoint")>
|
|
Private Function EgtEndPoint_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtEndPoint")>
|
|
Private Function EgtEndPoint_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtEndPoint(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtEndPoint_32(nId, nRefId, PtP)
|
|
Else
|
|
Return EgtEndPoint_64(nId, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtEndPoint(ByVal nId As Integer, ByRef PtP As Point3d) As Boolean
|
|
Return EgtEndPoint(nId, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMidPoint")>
|
|
Private Function EgtMidPoint_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMidPoint")>
|
|
Private Function EgtMidPoint_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtMidPoint(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMidPoint_32(nId, nRefId, PtP)
|
|
Else
|
|
Return EgtMidPoint_64(nId, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtMidPoint(ByVal nId As Integer, ByRef PtP As Point3d) As Boolean
|
|
Return EgtMidPoint(nId, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCenterPoint")>
|
|
Private Function EgtCenterPoint_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCenterPoint")>
|
|
Private Function EgtCenterPoint_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtCenterPoint(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCenterPoint_32(nId, nRefId, PtP)
|
|
Else
|
|
Return EgtCenterPoint_64(nId, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtCenterPoint(ByVal nId As Integer, ByRef PtP As Point3d) As Boolean
|
|
Return EgtCenterPoint(nId, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCentroid")>
|
|
Private Function EgtCentroid_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCentroid")>
|
|
Private Function EgtCentroid_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtCentroid(ByVal nId As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCentroid_32(nId, nRefId, PtP)
|
|
Else
|
|
Return EgtCentroid_64(nId, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtCentroid(ByVal nId As Integer, ByRef PtP As Point3d) As Boolean
|
|
Return EgtCentroid(nId, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAtParamPoint")>
|
|
Private Function EgtAtParamPoint_32(ByVal nId As Integer, ByVal dU As Double, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAtParamPoint")>
|
|
Private Function EgtAtParamPoint_64(ByVal nId As Integer, ByVal dU As Double, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtAtParamPoint(ByVal nId As Integer, ByVal dU As Double, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAtParamPoint_32(nId, dU, nRefId, PtP)
|
|
Else
|
|
Return EgtAtParamPoint_64(nId, dU, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtAtParamPoint(ByVal nId As Integer, ByVal dU As Double, ByRef PtP As Point3d) As Boolean
|
|
Return EgtAtParamPoint(nId, dU, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtNearPoint")>
|
|
Private Function EgtNearPoint_32(ByVal nId As Integer, ByRef PtNear As Point3d, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtNearPoint")>
|
|
Private Function EgtNearPoint_64(ByVal nId As Integer, ByRef PtNear As Point3d, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtNearPoint(ByVal nId As Integer, ByRef PtNear As Point3d, ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtNearPoint_32(nId, PtNear, nRefId, PtP)
|
|
Else
|
|
Return EgtNearPoint_64(nId, PtNear, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtNearPoint(ByVal nId As Integer, ByRef PtNear As Point3d, ByRef PtP As Point3d) As Boolean
|
|
Return EgtNearPoint(nId, PtNear, nId, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtIntersectionPoint")>
|
|
Private Function EgtIntersectionPoint_32(ByVal nId1 As Integer, ByVal nId2 As Integer, ByRef PtNear As Point3d,
|
|
ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtIntersectionPoint")>
|
|
Private Function EgtIntersectionPoint_64(ByVal nId1 As Integer, ByVal nId2 As Integer, ByRef PtNear As Point3d,
|
|
ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtIntersectionPoint(ByVal nId1 As Integer, ByVal nId2 As Integer, ByRef PtNear As Point3d,
|
|
ByVal nRefId As Integer, ByRef PtP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtIntersectionPoint_32(nId1, nId2, PtNear, nRefId, PtP)
|
|
Else
|
|
Return EgtIntersectionPoint_64(nId1, nId2, PtNear, nRefId, PtP)
|
|
End If
|
|
End Function
|
|
Public Function EgtIntersectionPoint(ByVal nId1 As Integer, ByVal nId2 As Integer, ByRef PtNear As Point3d,
|
|
ByRef PtP As Point3d) As Boolean
|
|
Return EgtIntersectionPoint(nId1, nId2, PtNear, nId1, PtP)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtStartVector")>
|
|
Private Function EgtStartVector_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtStartVector")>
|
|
Private Function EgtStartVector_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtStartVector(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtStartVector_32(nId, nRefId, VtV)
|
|
Else
|
|
Return EgtStartVector_64(nId, nRefId, VtV)
|
|
End If
|
|
End Function
|
|
Public Function EgtStartVector(ByVal nId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
Return EgtStartVector(nId, nId, VtV)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtEndVector")>
|
|
Private Function EgtEndVector_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtEndVector")>
|
|
Private Function EgtEndVector_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtEndVector(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtEndVector_32(nId, nRefId, VtV)
|
|
Else
|
|
Return EgtEndVector_64(nId, nRefId, VtV)
|
|
End If
|
|
End Function
|
|
Public Function EgtEndVector(ByVal nId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
Return EgtEndVector(nId, nId, VtV)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMidVector")>
|
|
Private Function EgtMidVector_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMidVector")>
|
|
Private Function EgtMidVector_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtMidVector(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMidVector_32(nId, nRefId, VtV)
|
|
Else
|
|
Return EgtMidVector_64(nId, nRefId, VtV)
|
|
End If
|
|
End Function
|
|
Public Function EgtMidVector(ByVal nId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
Return EgtMidVector(nId, nId, VtV)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAtParamVector")>
|
|
Private Function EgtAtParamVector_32(ByVal nId As Integer, ByVal dU As Double, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAtParamVector")>
|
|
Private Function EgtAtParamVector_64(ByVal nId As Integer, ByVal dU As Double, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtAtParamVector(ByVal nId As Integer, ByVal dU As Double, ByVal nRefId As Integer, ByRef VtV As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAtParamVector_32(nId, dU, nRefId, VtV)
|
|
Else
|
|
Return EgtAtParamVector_64(nId, dU, nRefId, VtV)
|
|
End If
|
|
End Function
|
|
Public Function EgtAtParamVector(ByVal nId As Integer, ByVal dU As Double, ByRef VtV As Vector3d) As Boolean
|
|
Return EgtAtParamVector(nId, dU, nId, VtV)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrame")>
|
|
Private Function EgtFrame_32(ByVal nId As Integer, ByVal nRefId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrame")>
|
|
Private Function EgtFrame_64(ByVal nId As Integer, ByVal nRefId As Integer,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtFrame(ByVal nId As Integer, ByVal nRefId As Integer, ByRef frFrame As Frame3d) As Boolean
|
|
Dim PtOrig As Point3d
|
|
Dim VtDirX, VtDirY, VtDirZ As Vector3d
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtFrame_32(nId, nRefId, PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
Else
|
|
bOk = EgtFrame_64(nId, nRefId, PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
If Not bOk Then
|
|
frFrame = Frame3d.GLOB()
|
|
Return False
|
|
Else
|
|
Return frFrame.Setup(PtOrig, VtDirX, VtDirY, VtDirZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveDomain")>
|
|
Private Function EgtCurveDomain_32(ByVal nId As Integer, ByRef dStart As Double, ByRef dEnd As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveDomain")>
|
|
Private Function EgtCurveDomain_64(ByVal nId As Integer, ByRef dStart As Double, ByRef dEnd As Double) As Boolean
|
|
End Function
|
|
Public Function EgtCurveDomain(ByVal nId As Integer, ByRef dStart As Double, ByRef dEnd As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCurveDomain_32(nId, dStart, dEnd)
|
|
Else
|
|
Return EgtCurveDomain_64(nId, dStart, dEnd)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveLength")>
|
|
Private Function EgtCurveLength_32(ByVal nId As Integer, ByRef dLen As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveLength")>
|
|
Private Function EgtCurveLength_64(ByVal nId As Integer, ByRef dLen As Double) As Boolean
|
|
End Function
|
|
Public Function EgtCurveLength(ByVal nId As Integer, ByRef dLen As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCurveLength_32(nId, dLen)
|
|
Else
|
|
Return EgtCurveLength_64(nId, dLen)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveLengthAtPoint")>
|
|
Private Function EgtCurveLengthAtPoint_32(ByVal nId As Integer, ByRef ptOn As Point3d, ByVal dExtend As Double, ByRef dLen As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveLengthAtPoint")>
|
|
Private Function EgtCurveLengthAtPoint_64(ByVal nId As Integer, ByRef ptOn As Point3d, ByVal dExtend As Double, ByRef dLen As Double) As Boolean
|
|
End Function
|
|
Public Function EgtCurveLengthAtPoint(ByVal nId As Integer, ByRef ptOn As Point3d, ByVal dExtend As Double, ByRef dLen As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCurveLengthAtPoint_32(nId, ptOn, dExtend, dLen)
|
|
Else
|
|
Return EgtCurveLengthAtPoint_64(nId, ptOn, dExtend, dLen)
|
|
End If
|
|
End Function
|
|
Public Function EgtCurveLengthAtPoint(ByVal nId As Integer, ByVal ptOn As Point3d, ByRef dLen As Double) As Boolean
|
|
Return EgtCurveLengthAtPoint(nId, ptOn, 0, dLen)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveNearestExtremityToPoint")>
|
|
Private Function EgtCurveNearestExtremityToPoint_32(ByVal nId As Integer, ByRef ptP As Point3d, ByRef bStart As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveNearestExtremityToPoint")>
|
|
Private Function EgtCurveNearestExtremityToPoint_64(ByVal nId As Integer, ByRef ptP As Point3d, ByRef bStart As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtCurveNearestExtremityToPoint(ByVal nId As Integer, ByRef ptP As Point3d, ByRef bStart As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCurveNearestExtremityToPoint_32(nId, ptP, bStart)
|
|
Else
|
|
Return EgtCurveNearestExtremityToPoint_64(nId, ptP, bStart)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveExtrusion")>
|
|
Private Function EgtCurveExtrusion_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtExtr As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveExtrusion")>
|
|
Private Function EgtCurveExtrusion_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtExtr As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtCurveExtrusion(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtExtr As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCurveExtrusion_32(nId, nRefId, VtExtr)
|
|
Else
|
|
Return EgtCurveExtrusion_64(nId, nRefId, VtExtr)
|
|
End If
|
|
End Function
|
|
Public Function EgtCurveExtrusion(ByVal nId As Integer, ByRef VtExtr As Vector3d) As Boolean
|
|
Return EgtCurveExtrusion(nId, nId, VtExtr)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveThickness")>
|
|
Private Function EgtCurveThickness_32(ByVal nId As Integer, ByRef dThick As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCurveThickness")>
|
|
Private Function EgtCurveThickness_64(ByVal nId As Integer, ByRef dThick As Double) As Boolean
|
|
End Function
|
|
Public Function EgtCurveThickness(ByVal nId As Integer, ByRef dThick As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCurveThickness_32(nId, dThick)
|
|
Else
|
|
Return EgtCurveThickness_64(nId, dThick)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMinDistPointCurve")>
|
|
Private Function EgtGetMinDistPointCurve_32(ByRef ptP As Point3d, ByVal nId As Integer, ByRef dDist As Double, ByRef dU As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMinDistPointCurve")>
|
|
Private Function EgtGetMinDistPointCurve_64(ByRef ptP As Point3d, ByVal nId As Integer, ByRef dDist As Double, ByRef dU As Double) As Boolean
|
|
End Function
|
|
Public Function EgtGetMinDistPointCurve(ByRef ptP As Point3d, ByVal nId As Integer, ByRef dDist As Double, ByRef dU As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetMinDistPointCurve_32(ptP, nId, dDist, dU)
|
|
Else
|
|
Return EgtGetMinDistPointCurve_64(ptP, nId, dDist, dU)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMinDistPntSidePointCurve")>
|
|
Private Function EgtGetMinDistPntSidePointCurve_32(ByRef ptP As Point3d, ByVal nId As Integer, ByRef vtN As Vector3d,
|
|
ByRef dDist As Double, ByRef ptMin As Point3d, ByRef nSide As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMinDistPntSidePointCurve")>
|
|
Private Function EgtGetMinDistPntSidePointCurve_64(ByRef ptP As Point3d, ByVal nId As Integer, ByRef vtN As Vector3d,
|
|
ByRef dDist As Double, ByRef ptMin As Point3d, ByRef nSide As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetMinDistPntSidePointCurve(ByRef ptP As Point3d, ByVal nId As Integer, ByRef vtN As Vector3d,
|
|
ByRef dDist As Double, ByRef ptMin As Point3d, ByRef nSide As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetMinDistPntSidePointCurve_32(ptP, nId, vtN, dDist, ptMin, nSide)
|
|
Else
|
|
Return EgtGetMinDistPntSidePointCurve_64(ptP, nId, vtN, dDist, ptMin, nSide)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtArcNormVersor")>
|
|
Private Function EgtArcNormVersor_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtArcNormVersor")>
|
|
Private Function EgtArcNormVersor_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtArcNormVersor(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtArcNormVersor_32(nId, nRefId, VtNorm)
|
|
Else
|
|
Return EgtArcNormVersor_64(nId, nRefId, VtNorm)
|
|
End If
|
|
End Function
|
|
Public Function EgtArcNormVersor(ByVal nId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtArcNormVersor(nId, nId, VtNorm)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfFrNormVersor")>
|
|
Private Function EgtSurfFrNormVersor_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfFrNormVersor")>
|
|
Private Function EgtSurfFrNormVersor_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtSurfFrNormVersor(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSurfFrNormVersor_32(nId, nRefId, VtNorm)
|
|
Else
|
|
Return EgtSurfFrNormVersor_64(nId, nRefId, VtNorm)
|
|
End If
|
|
End Function
|
|
Public Function EgtSurfFrNormVersor(ByVal nId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtSurfFrNormVersor(nId, nId, VtNorm)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetFromTria")>
|
|
Private Function EgtSurfTmFacetFromTria_32(ByVal nId As Integer, ByVal nT As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetFromTria")>
|
|
Private Function EgtSurfTmFacetFromTria_64(ByVal nId As Integer, ByVal nT As Integer) As Integer
|
|
End Function
|
|
Public Function EgtSurfTmFacetFromTria(ByVal nId As Integer, ByVal nT As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSurfTmFacetFromTria_32(nId, nT)
|
|
Else
|
|
Return EgtSurfTmFacetFromTria_64(nId, nT)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetNearestEndPoint")>
|
|
Private Function EgtSurfTmFacetNearestEndPoint_32(ByVal nId As Integer, ByVal nF As Integer, ByRef PtNear As Point3d, ByVal nRefId As Integer,
|
|
ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetNearestEndPoint")>
|
|
Private Function EgtSurfTmFacetNearestEndPoint_64(ByVal nId As Integer, ByVal nF As Integer, ByRef PtNear As Point3d, ByVal nRefId As Integer,
|
|
ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtSurfTmFacetNearestEndPoint(ByVal nId As Integer, ByVal nF As Integer, ByRef PtNear As Point3d, ByVal nRefId As Integer,
|
|
ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSurfTmFacetNearestEndPoint_32(nId, nF, PtNear, nRefId, PtP, VtNorm)
|
|
Else
|
|
Return EgtSurfTmFacetNearestEndPoint_64(nId, nF, PtNear, nRefId, PtP, VtNorm)
|
|
End If
|
|
End Function
|
|
Public Function EgtSurfTmFacetNearestEndPoint(ByVal nId As Integer, ByVal nF As Integer, ByRef PtNear As Point3d,
|
|
ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtSurfTmFacetNearestEndPoint(nId, nF, PtNear, nId, PtP, VtNorm)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetCenter")>
|
|
Private Function EgtSurfTmFacetCenter_32(ByVal nId As Integer, ByVal nF As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetCenter")>
|
|
Private Function EgtSurfTmFacetCenter_64(ByVal nId As Integer, ByVal nF As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtSurfTmFacetCenter(ByVal nId As Integer, ByVal nF As Integer, ByVal nRefId As Integer, ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSurfTmFacetCenter_32(nId, nF, nRefId, PtP, VtNorm)
|
|
Else
|
|
Return EgtSurfTmFacetCenter_64(nId, nF, nRefId, PtP, VtNorm)
|
|
End If
|
|
End Function
|
|
Public Function EgtSurfTmFacetCenter(ByVal nId As Integer, ByVal nF As Integer, ByRef PtP As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtSurfTmFacetCenter(nId, nF, nId, PtP, VtNorm)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetNormVersor")>
|
|
Private Function EgtSurfTmFacetNormVersor_32(ByVal nId As Integer, ByVal nF As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSurfTmFacetNormVersor")>
|
|
Private Function EgtSurfTmFacetNormVersor_64(ByVal nId As Integer, ByVal nF As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtSurfTmFacetNormVersor(ByVal nId As Integer, ByVal nF As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSurfTmFacetNormVersor_32(nId, nF, nRefId, VtNorm)
|
|
Else
|
|
Return EgtSurfTmFacetNormVersor_64(nId, nF, nRefId, VtNorm)
|
|
End If
|
|
End Function
|
|
Public Function EgtSurfTmFacetNormVersor(ByVal nId As Integer, ByVal nF As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtSurfTmFacetNormVersor(nId, nF, nId, VtNorm)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTextNormVersor")>
|
|
Private Function EgtTextNormVersor_32(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTextNormVersor")>
|
|
Private Function EgtTextNormVersor_64(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtTextNormVersor(ByVal nId As Integer, ByVal nRefId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTextNormVersor_32(nId, nRefId, VtNorm)
|
|
Else
|
|
Return EgtTextNormVersor_64(nId, nRefId, VtNorm)
|
|
End If
|
|
End Function
|
|
Public Function EgtTextNormVersor(ByVal nId As Integer, ByRef VtNorm As Vector3d) As Boolean
|
|
Return EgtTextNormVersor(nId, nId, VtNorm)
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToIdGlob")>
|
|
Private Function EgtPointToIdGlob_32(ByRef PtP As Point3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToIdGlob")>
|
|
Private Function EgtPointToIdGlob_64(ByRef PtP As Point3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Private Function EgtPointToIdGlob(ByRef PtP As Point3d, ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointToIdGlob_32(PtP, nId)
|
|
Else
|
|
Return EgtPointToIdGlob_64(PtP, nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToIdLoc")>
|
|
Private Function EgtPointToIdLoc_32(ByRef PtP As Point3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToIdLoc")>
|
|
Private Function EgtPointToIdLoc_64(ByRef PtP As Point3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Private Function EgtPointToIdLoc(ByRef PtP As Point3d, ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointToIdLoc_32(PtP, nId)
|
|
Else
|
|
Return EgtPointToIdLoc_64(PtP, nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToIdGlob")>
|
|
Private Function EgtVectorToIdGlob_32(ByRef VtV As Vector3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToIdGlob")>
|
|
Private Function EgtVectorToIdGlob_64(ByRef VtV As Vector3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Private Function EgtVectorToIdGlob(ByRef VtV As Vector3d, ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorToIdGlob_32(VtV, nId)
|
|
Else
|
|
Return EgtVectorToIdGlob_64(VtV, nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToIdLoc")>
|
|
Private Function EgtVectorToIdLoc_32(ByRef VtV As Vector3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToIdLoc")>
|
|
Private Function EgtVectorToIdLoc_64(ByRef VtV As Vector3d, ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Private Function EgtVectorToIdLoc(ByRef VtV As Vector3d, ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorToIdLoc_32(VtV, nId)
|
|
Else
|
|
Return EgtVectorToIdLoc_64(VtV, nId)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Nestings -----------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateFlatParts")>
|
|
Private Function EgtCreateFlatParts_32(ByVal nType As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtCreateFlatParts")>
|
|
Private Function EgtCreateFlatParts_64(ByVal nType As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtCreateFlatParts(ByVal nType As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtCreateFlatParts_32(nType)
|
|
Else
|
|
Return EgtCreateFlatParts_64(nType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAdjustFlatPartLayer")>
|
|
Private Function EgtAdjustFlatPartLayer_32(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAdjustFlatPartLayer")>
|
|
Private Function EgtAdjustFlatPartLayer_64(ByVal nLayerId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtAdjustFlatPartLayer(ByVal nLayerId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAdjustFlatPartLayer_32(nLayerId)
|
|
Else
|
|
Return EgtAdjustFlatPartLayer_64(nLayerId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPackBoxCluster")>
|
|
Private Function EgtPackBoxCluster_32(ByVal vId As Integer(), ByVal nCount As Integer, ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPackBoxCluster")>
|
|
Private Function EgtPackBoxCluster_64(ByVal vId As Integer(), ByVal nCount As Integer, ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtPackBoxCluster(ByVal vId As Integer(), ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPackBoxCluster_32(vId, vId.Count(), dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp)
|
|
Else
|
|
Return EgtPackBoxCluster_64(vId, vId.Count(), dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp)
|
|
End If
|
|
End Function
|
|
Public Function EgtPackBox(ByVal nPartId As Integer, ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPackBoxCluster_32(vId, 1, dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp)
|
|
Else
|
|
Return EgtPackBoxCluster_64(vId, 1, dXmin, dYmin, dXmax, dYmax, dOffs, bBottomUp)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveBoxCluster")>
|
|
Private Function EgtMoveBoxCluster_32(ByVal vId As Integer(), ByVal nCount As Integer, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveBoxCluster")>
|
|
Private Function EgtMoveBoxCluster_64(ByVal vId As Integer(), ByVal nCount As Integer, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMoveBoxCluster(ByVal vId As Integer(), ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveBoxCluster_32(vId, vId.Count(), vtMove, dXmin, dYmin, dXmax, dYmax, dOffs)
|
|
Else
|
|
Return EgtMoveBoxCluster_64(vId, vId.Count(), vtMove, dXmin, dYmin, dXmax, dYmax, dOffs)
|
|
End If
|
|
End Function
|
|
Public Function EgtMoveBox(ByVal nPartId As Integer, ByRef vtMove As Vector3d, ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal dOffs As Double) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveBoxCluster_32(vId, 1, vtMove, dXmin, dYmin, dXmax, dYmax, dOffs)
|
|
Else
|
|
Return EgtMoveBoxCluster_64(vId, 1, vtMove, dXmin, dYmin, dXmax, dYmax, dOffs)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetClusterBBoxGlob")>
|
|
Private Function EgtGetClusterBBoxGlob_32(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetClusterBBoxGlob")>
|
|
Private Function EgtGetClusterBBoxGlob_64(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetClusterBBoxGlob(ByVal vId As Integer(),
|
|
ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetClusterBBoxGlob_32(vId, vId.Count(), PtMin, PtMax)
|
|
Else
|
|
Return EgtGetClusterBBoxGlob_64(vId, vId.Count(), PtMin, PtMax)
|
|
End If
|
|
End Function
|
|
Public Function EgtGetPartBBoxGlob(ByVal nPartId As Integer, ByRef PtMin As Point3d, ByRef PtMax As Point3d) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetClusterBBoxGlob_32(vId, 1, PtMin, PtMax)
|
|
Else
|
|
Return EgtGetClusterBBoxGlob_64(vId, 1, PtMin, PtMax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyPartCluster")>
|
|
Private Function EgtVerifyPartCluster_32(ByVal vId As Integer(), ByVal nCount As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyPartCluster")>
|
|
Private Function EgtVerifyPartCluster_64(ByVal vId As Integer(), ByVal nCount As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
Public Function EgtVerifyPartCluster(ByVal vId As Integer(), ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVerifyPartCluster_32(vId, vId.Count(), bReducedCut, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtVerifyPartCluster_64(vId, vId.Count(), bReducedCut, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
Public Function EgtVerifyPart(ByVal nPartId As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVerifyPartCluster_32(vId, 1, bReducedCut, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtVerifyPartCluster_64(vId, 1, bReducedCut, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPackPartCluster")>
|
|
Private Function EgtPackPartCluster_32(ByVal vId As Integer(), ByVal nCount As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPackPartCluster")>
|
|
Private Function EgtPackPartCluster_64(ByVal vId As Integer(), ByVal nCount As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtPackPartCluster(ByVal vId As Integer(), ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPackPartCluster_32(vId, vId.Count(), bReducedCut, dXmin, dYmin, dXmax, dYmax, bBottomUp)
|
|
Else
|
|
Return EgtPackPartCluster_64(vId, vId.Count(), bReducedCut, dXmin, dYmin, dXmax, dYmax, bBottomUp)
|
|
End If
|
|
End Function
|
|
Public Function EgtPackPart(ByVal nPartId As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double, ByVal bBottomUp As Boolean) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPackPartCluster_32(vId, 1, bReducedCut, dXmin, dYmin, dXmax, dYmax, bBottomUp)
|
|
Else
|
|
Return EgtPackPartCluster_64(vId, 1, bReducedCut, dXmin, dYmin, dXmax, dYmax, bBottomUp)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMovePartCluster")>
|
|
Private Function EgtMovePartCluster_32(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMovePartCluster")>
|
|
Private Function EgtMovePartCluster_64(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMovePartCluster(ByVal vId As Integer(),
|
|
ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMovePartCluster_32(vId, vId.Count(), bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtMovePartCluster_64(vId, vId.Count(), bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
Public Function EgtMovePart(ByVal nPartId As Integer, ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMovePartCluster_32(vId, 1, bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtMovePartCluster_64(vId, 1, bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotatePartCluster")>
|
|
Private Function EgtRotatePartCluster_32(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByRef ptCen As Point3d, ByRef dRotAngDeg As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotatePartCluster")>
|
|
Private Function EgtRotatePartCluster_64(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByRef ptCen As Point3d, ByRef dRotAngDeg As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
Public Function EgtRotatePartCluster(ByVal vId As Integer(),
|
|
ByVal bReducedCut As Boolean, ByVal ptCen As Point3d, ByRef dRotAngDeg As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRotatePartCluster_32(vId, vId.Count(), bReducedCut, ptCen, dRotAngDeg, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtRotatePartCluster_64(vId, vId.Count(), bReducedCut, ptCen, dRotAngDeg, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
Public Function EgtRotatePart(ByVal nPartId As Integer, ByVal bReducedCut As Boolean, ByVal ptCen As Point3d, ByRef dRotAngDeg As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRotatePartCluster_32(vId, 1, bReducedCut, ptCen, dRotAngDeg, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtRotatePartCluster_64(vId, 1, bReducedCut, ptCen, dRotAngDeg, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTgMovePartClusterOnCollision")>
|
|
Private Function EgtTgMovePartClusterOnCollision_32(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTgMovePartClusterOnCollision")>
|
|
Private Function EgtTgMovePartClusterOnCollision_64(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
End Function
|
|
Public Function EgtTgMovePartClusterOnCollision(ByVal vId As Integer(),
|
|
ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTgMovePartClusterOnCollision_32(vId, vId.Count(), bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtTgMovePartClusterOnCollision_64(vId, vId.Count(), bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
Public Function EgtTgMovePartOnCollision(ByVal nPartId As Integer, ByVal bReducedCut As Boolean, ByRef vtMove As Vector3d,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTgMovePartClusterOnCollision_32(vId, 1, bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
Else
|
|
Return EgtTgMovePartClusterOnCollision_64(vId, 1, bReducedCut, vtMove, dXmin, dYmin, dXmax, dYmax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAlignPartClusterOnCollision")>
|
|
Private Function EgtAlignPartClusterOnCollision_32(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAlignPartClusterOnCollision")>
|
|
Private Function EgtAlignPartClusterOnCollision_64(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtAlignPartClusterOnCollision(ByVal vId As Integer(),
|
|
ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAlignPartClusterOnCollision_32(vId, vId.Count(), bReducedCut, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
Else
|
|
Return EgtAlignPartClusterOnCollision_64(vId, vId.Count(), bReducedCut, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
End If
|
|
End Function
|
|
Public Function EgtAlignPartOnCollision(ByVal nPartId As Integer, ByVal bReducedCut As Boolean,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAlignPartClusterOnCollision_32(vId, 1, bReducedCut, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
Else
|
|
Return EgtAlignPartClusterOnCollision_64(vId, 1, bReducedCut, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveToSnapPointOnCollision")>
|
|
Private Function EgtMoveToSnapPointOnCollision_32(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByVal dMaxMove As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveToSnapPointOnCollision")>
|
|
Private Function EgtMoveToSnapPointOnCollision_64(ByVal vId As Integer(), ByVal nCount As Integer,
|
|
ByVal bReducedCut As Boolean, ByVal dMaxMove As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtMoveToSnapPointOnCollision(ByVal vId As Integer(),
|
|
ByVal bReducedCut As Boolean, ByVal dMaxMove As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveToSnapPointOnCollision_32(vId, vId.Count(), bReducedCut, dMaxMove, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
Else
|
|
Return EgtMoveToSnapPointOnCollision_64(vId, vId.Count(), bReducedCut, dMaxMove, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
End If
|
|
End Function
|
|
Public Function EgtMovePartToSnapPointOnCollision(ByVal nPartId As Integer, ByVal bReducedCut As Boolean, ByVal dMaxMove As Double,
|
|
ByVal dXmin As Double, ByVal dYmin As Double,
|
|
ByVal dXmax As Double, ByVal dYmax As Double,
|
|
ByRef bMoved As Boolean) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveToSnapPointOnCollision_32(vId, 1, bReducedCut, dMaxMove, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
Else
|
|
Return EgtMoveToSnapPointOnCollision_64(vId, 1, bReducedCut, dMaxMove, dXmin, dYmin, dXmax, dYmax, bMoved)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSaveCollInfo")>
|
|
Private Sub EgtSaveCollInfo_32()
|
|
End Sub
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSaveCollInfo")>
|
|
Private Sub EgtSaveCollInfo_64()
|
|
End Sub
|
|
Public Sub EgtSaveCollInfo()
|
|
If IntPtr.Size = 4 Then
|
|
EgtSaveCollInfo_32()
|
|
Else
|
|
EgtSaveCollInfo_64()
|
|
End If
|
|
End Sub
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRestoreCollInfo")>
|
|
Private Sub EgtRestoreCollInfo_32()
|
|
End Sub
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRestoreCollInfo")>
|
|
Private Sub EgtRestoreCollInfo_64()
|
|
End Sub
|
|
Public Sub EgtRestoreCollInfo()
|
|
If IntPtr.Size = 4 Then
|
|
EgtRestoreCollInfo_32()
|
|
Else
|
|
EgtRestoreCollInfo_64()
|
|
End If
|
|
End Sub
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPartClusterCenterGlob")>
|
|
Private Function EgtGetPartClusterCenterGlob_32(ByVal vId As Integer(), ByVal nCount As Integer, ByRef ptCen As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPartClusterCenterGlob")>
|
|
Private Function EgtGetPartClusterCenterGlob_64(ByVal vId As Integer(), ByVal nCount As Integer, ByRef ptCen As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetPartClusterCenterGlob(ByVal vId As Integer(), ByVal ptCen As Point3d, ByRef dRotAngDeg As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPartClusterCenterGlob_32(vId, vId.Count(), ptCen)
|
|
Else
|
|
Return EgtGetPartClusterCenterGlob_64(vId, vId.Count(), ptCen)
|
|
End If
|
|
End Function
|
|
Public Function EgtGetPartPartClusterCenterGlob(ByVal nPartId As Integer, ByRef ptCen As Point3d) As Boolean
|
|
Dim vId(0) As Integer
|
|
vId(0) = nPartId
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPartClusterCenterGlob_32(vId, 1, ptCen)
|
|
Else
|
|
Return EgtGetPartClusterCenterGlob_64(vId, 1, ptCen)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyMachining")>
|
|
Private Function EgtVerifyMachining_32(ByVal nId As Integer, ByRef nResult As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyMachining")>
|
|
Private Function EgtVerifyMachining_64(ByVal nId As Integer, ByRef nResult As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtVerifyMachining(ByVal nId As Integer, ByRef nResult As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVerifyMachining_32(nId, nResult)
|
|
Else
|
|
Return EgtVerifyMachining_64(nId, nResult)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyCutAsSplitting")>
|
|
Private Function EgtVerifyCutAsSplitting_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyCutAsSplitting")>
|
|
Private Function EgtVerifyCutAsSplitting_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtVerifyCutAsSplitting(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVerifyCutAsSplitting_32(nId)
|
|
Else
|
|
Return EgtVerifyCutAsSplitting_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Machinings ---------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitMachMgr")>
|
|
Private Function EgtInitMachMgr_32(ByVal sMachinesDir As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitMachMgr")>
|
|
Private Function EgtInitMachMgr_64(ByVal sMachinesDir As String) As Boolean
|
|
End Function
|
|
Public Function EgtInitMachMgr(ByVal sMachinesDir As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInitMachMgr_32(sMachinesDir)
|
|
Else
|
|
Return EgtInitMachMgr_64(sMachinesDir)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrMachine")>
|
|
Private Function EgtSetCurrMachine_32(ByVal sMachineName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrMachine")>
|
|
Private Function EgtSetCurrMachine_64(ByVal sMachineName As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetCurrMachine(ByVal sMachineName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCurrMachine_32(sMachineName)
|
|
Else
|
|
Return EgtSetCurrMachine_64(sMachineName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrMachineName")>
|
|
Private Function EgtGetCurrMachineName_32(ByRef psMachineName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCurrMachineName")>
|
|
Private Function EgtGetCurrMachineName_64(ByRef psMachineName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetCurrMachineName(ByRef sMachineName As String) As Boolean
|
|
Dim psMachineName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetCurrMachineName_32(psMachineName)
|
|
Else
|
|
bOk = EgtGetCurrMachineName_64(psMachineName)
|
|
End If
|
|
If bOk Then
|
|
sMachineName = Marshal.PtrToStringUni(psMachineName)
|
|
EgtFreeMemory(psMachineName)
|
|
Else
|
|
sMachineName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstMachGroup")>
|
|
Private Function EgtGetFirstMachGroup_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstMachGroup")>
|
|
Private Function EgtGetFirstMachGroup_64() As Integer
|
|
End Function
|
|
Public Function EgtGetFirstMachGroup() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstMachGroup_32()
|
|
Else
|
|
Return EgtGetFirstMachGroup_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextMachGroup")>
|
|
Private Function EgtGetNextMachGroup_32(ByVal nMGroupId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextMachGroup")>
|
|
Private Function EgtGetNextMachGroup_64(ByVal nMGroupId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetNextMachGroup(ByVal nMGroupId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextMachGroup_32(nMGroupId)
|
|
Else
|
|
Return EgtGetNextMachGroup_64(nMGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrMachGroup")>
|
|
Private Function EgtSetCurrMachGroup_32(ByVal nMGroupId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrMachGroup")>
|
|
Private Function EgtSetCurrMachGroup_64(ByVal nMGroupId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetCurrMachGroup(ByVal nMGroupId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCurrMachGroup_32(nMGroupId)
|
|
Else
|
|
Return EgtSetCurrMachGroup_64(nMGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddMachGroup")>
|
|
Private Function EgtAddMachGroup_32(ByVal sName As String, ByVal sMachineName As String) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddMachGroup")>
|
|
Private Function EgtAddMachGroup_64(ByVal sName As String, ByVal sMachineName As String) As Integer
|
|
End Function
|
|
Public Function EgtAddMachGroup(ByVal sName As String, ByVal sMachineName As String) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAddMachGroup_32(sName, sMachineName)
|
|
Else
|
|
Return EgtAddMachGroup_64(sName, sMachineName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveMachGroup")>
|
|
Private Function EgtRemoveMachGroup_32(ByVal nMGroupId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveMachGroup")>
|
|
Private Function EgtRemoveMachGroup_64(ByVal nMGroupId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRemoveMachGroup(ByVal nMGroupId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveMachGroup_32(nMGroupId)
|
|
Else
|
|
Return EgtRemoveMachGroup_64(nMGroupId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetRawPartCount")>
|
|
Private Function EgtGetRawPartCount_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetRawPartCount")>
|
|
Private Function EgtGetRawPartCount_64() As Integer
|
|
End Function
|
|
Public Function EgtGetRawPartCount() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetRawPartCount_32()
|
|
Else
|
|
Return EgtGetRawPartCount_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstRawPart")>
|
|
Private Function EgtGetFirstRawPart_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstRawPart")>
|
|
Private Function EgtGetFirstRawPart_64() As Integer
|
|
End Function
|
|
Public Function EgtGetFirstRawPart() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstRawPart_32()
|
|
Else
|
|
Return EgtGetFirstRawPart_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextRawPart")>
|
|
Private Function EgtGetNextRawPart_32(ByVal nRawId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextRawPart")>
|
|
Private Function EgtGetNextRawPart_64(ByVal nRawId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetNextRawPart(ByVal nRawId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextRawPart_32(nRawId)
|
|
Else
|
|
Return EgtGetNextRawPart_64(nRawId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddRawPart")>
|
|
Private Function EgtAddRawPart_32(ByRef ptOrig As Point3d, ByVal dLength As Double, ByVal dWidth As Double,
|
|
ByVal dHeight As Double, ByRef Color As Color3d) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddRawPart")>
|
|
Private Function EgtAddRawPart_64(ByRef ptOrig As Point3d, ByVal dLength As Double, ByVal dWidth As Double,
|
|
ByVal dHeight As Double, ByRef Color As Color3d) As Integer
|
|
End Function
|
|
Public Function EgtAddRawPart(ByRef ptOrig As Point3d, ByVal dLength As Double, ByVal dWidth As Double,
|
|
ByVal dHeight As Double, ByRef Color As Color3d) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAddRawPart_32(ptOrig, dLength, dWidth, dHeight, Color)
|
|
Else
|
|
Return EgtAddRawPart_64(ptOrig, dLength, dWidth, dHeight, Color)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyRawPart")>
|
|
Private Function EgtModifyRawPart_32(ByVal nRawId As Integer, ByRef ptOrig As Point3d, ByVal dLength As Double,
|
|
ByVal dWidth As Double, ByVal dHeight As Double, ByRef Color As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyRawPart")>
|
|
Private Function EgtModifyRawPart_64(ByVal nRawId As Integer, ByRef ptOrig As Point3d, ByVal dLength As Double,
|
|
ByVal dWidth As Double, ByVal dHeight As Double, ByRef Color As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtModifyRawPart(ByVal nRawId As Integer, ByRef ptOrig As Point3d, ByVal dLength As Double,
|
|
ByVal dWidth As Double, ByVal dHeight As Double, ByRef Color As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyRawPart_32(nRawId, ptOrig, dLength, dWidth, dHeight, Color)
|
|
Else
|
|
Return EgtModifyRawPart_64(nRawId, ptOrig, dLength, dWidth, dHeight, Color)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyRawPartSize")>
|
|
Private Function EgtModifyRawPartSize_32(ByVal nRawId As Integer, ByVal dLength As Double, ByVal dWidth As Double, ByVal dHeight As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyRawPartSize")>
|
|
Private Function EgtModifyRawPartSize_64(ByVal nRawId As Integer, ByVal dLength As Double, ByVal dWidth As Double, ByVal dHeight As Double) As Boolean
|
|
End Function
|
|
Public Function EgtModifyRawPartSize(ByVal nRawId As Integer, ByVal dLength As Double, ByVal dWidth As Double, ByVal dHeight As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyRawPartSize_32(nRawId, dLength, dWidth, dHeight)
|
|
Else
|
|
Return EgtModifyRawPartSize_64(nRawId, dLength, dWidth, dHeight)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyRawPartHeight")>
|
|
Private Function EgtModifyRawPartHeight_32(ByVal nRawId As Integer, ByVal dHeight As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtModifyRawPartHeight")>
|
|
Private Function EgtModifyRawPartHeight_64(ByVal nRawId As Integer, ByVal dHeight As Double) As Boolean
|
|
End Function
|
|
Public Function EgtModifyRawPartHeight(ByVal nRawId As Integer, ByVal dHeight As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtModifyRawPartHeight_32(nRawId, dHeight)
|
|
Else
|
|
Return EgtModifyRawPartHeight_64(nRawId, dHeight)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveRawPart")>
|
|
Private Function EgtRemoveRawPart_32(ByVal nRawId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveRawPart")>
|
|
Private Function EgtRemoveRawPart_64(ByVal nRawId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRemoveRawPart(ByVal nRawId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveRawPart_32(nRawId)
|
|
Else
|
|
Return EgtRemoveRawPart_64(nRawId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveToCornerRawPart")>
|
|
Private Function EgtMoveToCornerRawPart_32(ByVal nRawId As Integer, ByRef ptCorner As Point3d, ByVal nFlag As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveToCornerRawPart")>
|
|
Private Function EgtMoveToCornerRawPart_64(ByVal nRawId As Integer, ByRef ptCorner As Point3d, ByVal nFlag As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtMoveToCornerRawPart(ByVal nRawId As Integer, ByRef ptCorner As Point3d, ByVal nFlag As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveToCornerRawPart_32(nRawId, ptCorner, nFlag)
|
|
Else
|
|
Return EgtMoveToCornerRawPart_64(nRawId, ptCorner, nFlag)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveRawPart")>
|
|
Private Function EgtMoveRawPart_32(ByVal nRawId As Integer, ByRef vtMove As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMoveRawPart")>
|
|
Private Function EgtMoveRawPart_64(ByVal nRawId As Integer, ByRef vtMove As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtMoveRawPart(ByVal nRawId As Integer, ByRef vtMove As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMoveRawPart_32(nRawId, vtMove)
|
|
Else
|
|
Return EgtMoveRawPart_64(nRawId, vtMove)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPartInRawPartCount")>
|
|
Private Function EgtGetPartInRawPartCount_32(ByVal nRawId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPartInRawPartCount")>
|
|
Private Function EgtGetPartInRawPartCount_64(ByVal nRawId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetPartInRawPartCount(ByVal nRawId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPartInRawPartCount_32(nRawId)
|
|
Else
|
|
Return EgtGetPartInRawPartCount_64(nRawId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstPartInRawPart")>
|
|
Private Function EgtGetFirstPartInRawPart_32(ByVal nRawId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstPartInRawPart")>
|
|
Private Function EgtGetFirstPartInRawPart_64(ByVal nRawId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetFirstPartInRawPart(ByVal nRawId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstPartInRawPart_32(nRawId)
|
|
Else
|
|
Return EgtGetFirstPartInRawPart_64(nRawId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextPartInRawPart")>
|
|
Private Function EgtGetNextPartInRawPart_32(ByVal nPartId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextPartInRawPart")>
|
|
Private Function EgtGetNextPartInRawPart_64(ByVal nPartId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetNextPartInRawPart(ByVal nPartId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextPartInRawPart_32(nPartId)
|
|
Else
|
|
Return EgtGetNextPartInRawPart_64(nPartId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddPartToRawPart")>
|
|
Private Function EgtAddPartToRawPart_32(ByVal nPartId As Integer, ByRef ptPos As Point3d, ByVal nRawId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddPartToRawPart")>
|
|
Private Function EgtAddPartToRawPart_64(ByVal nPartId As Integer, ByRef ptPos As Point3d, ByVal nRawId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtAddPartToRawPart(ByVal nPartId As Integer, ByRef ptPos As Point3d, ByVal nRawId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAddPartToRawPart_32(nPartId, ptPos, nRawId)
|
|
Else
|
|
Return EgtAddPartToRawPart_64(nPartId, ptPos, nRawId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemovePartFromRawPart")>
|
|
Private Function EgtRemovePartFromRawPart_32(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemovePartFromRawPart")>
|
|
Private Function EgtRemovePartFromRawPart_64(ByVal nPartId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRemovePartFromRawPart(ByVal nPartId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemovePartFromRawPart_32(nPartId)
|
|
Else
|
|
Return EgtRemovePartFromRawPart_64(nPartId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetTable")>
|
|
Private Function EgtSetTable_32(ByVal sTable As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetTable")>
|
|
Private Function EgtSetTable_64(ByVal sTable As String) As Boolean
|
|
End Function
|
|
Public Function EgtSetTable(ByVal sTable As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetTable_32(sTable)
|
|
Else
|
|
Return EgtSetTable_64(sTable)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTableRef")>
|
|
Private Function EgtGetTableRef_32(ByVal nInd As Integer, ByRef ptPos As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTableRef")>
|
|
Private Function EgtGetTableRef_64(ByVal nInd As Integer, ByRef ptPos As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetTableRef(ByVal nInd As Integer, ByRef ptPos As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetTableRef_32(nInd, ptPos)
|
|
Else
|
|
Return EgtGetTableRef_64(nInd, ptPos)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTableArea")>
|
|
Private Function EgtGetTableArea_32(ByVal nInd As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTableArea")>
|
|
Private Function EgtGetTableArea_64(ByVal nInd As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetTableArea(ByVal nInd As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetTableArea_32(nInd, ptMin, ptMax)
|
|
Else
|
|
Return EgtGetTableArea_64(nInd, ptMin, ptMax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtShowOnlyTable")>
|
|
Private Function EgtShowOnlyTable_32(ByVal bVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtShowOnlyTable")>
|
|
Private Function EgtShowOnlyTable_64(ByVal bVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtShowOnlyTable(ByVal bVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtShowOnlyTable_32(bVal)
|
|
Else
|
|
Return EgtShowOnlyTable_64(bVal)
|
|
End If
|
|
End Function
|
|
|
|
' Tools Database
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetToolNewName")>
|
|
Private Function EgtTdbGetToolNewName_32(ByVal sName As String, ByRef psNewName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetToolNewName")>
|
|
Private Function EgtTdbGetToolNewName_64(ByVal sName As String, ByRef psNewName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetToolNewName(ByRef sName As String) As Boolean
|
|
Dim psNewName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtTdbGetToolNewName_32(sName, psNewName)
|
|
Else
|
|
bOk = EgtTdbGetToolNewName_64(sName, psNewName)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psNewName)
|
|
EgtFreeMemory(psNewName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbAddTool")>
|
|
Private Function EgtTdbAddTool_32(ByVal sName As String, ByVal nType As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbAddTool")>
|
|
Private Function EgtTdbAddTool_64(ByVal sName As String, ByVal nType As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtTdbAddTool(ByVal sName As String, ByVal nType As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbAddTool_32(sName, nType)
|
|
Else
|
|
Return EgtTdbAddTool_64(sName, nType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbCopyTool")>
|
|
Private Function EgtTdbCopyTool_32(ByVal sSource As String, ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbCopyTool")>
|
|
Private Function EgtTdbCopyTool_64(ByVal sSource As String, ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtTdbCopyTool(ByVal sSource As String, ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbCopyTool_32(sSource, sName)
|
|
Else
|
|
Return EgtTdbCopyTool_64(sSource, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbRemoveTool")>
|
|
Private Function EgtTdbRemoveTool_32(ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbRemoveTool")>
|
|
Private Function EgtTdbRemoveTool_64(ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtTdbRemoveTool(ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbRemoveTool_32(sName)
|
|
Else
|
|
Return EgtTdbRemoveTool_64(sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetFirstTool")>
|
|
Private Function EgtTdbGetFirstTool_32(ByVal nFamily As Integer, ByRef psName As IntPtr, ByRef nType As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetFirstTool")>
|
|
Private Function EgtTdbGetFirstTool_64(ByVal nFamily As Integer, ByRef psName As IntPtr, ByRef nType As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetFirstTool(ByVal nFamily As Integer, ByRef sName As String, ByRef nType As Integer) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtTdbGetFirstTool_32(nFamily, psName, nType)
|
|
Else
|
|
bOk = EgtTdbGetFirstTool_64(nFamily, psName, nType)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetNextTool")>
|
|
Private Function EgtTdbGetNextTool_32(ByVal nFamily As Integer, ByRef psName As IntPtr, ByRef nType As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetNextTool")>
|
|
Private Function EgtTdbGetNextTool_64(ByVal nFamily As Integer, ByRef psName As IntPtr, ByRef nType As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetNextTool(ByVal nFamily As Integer, ByRef sName As String, ByRef nType As Integer) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtTdbGetNextTool_32(nFamily, psName, nType)
|
|
Else
|
|
bOk = EgtTdbGetNextTool_64(nFamily, psName, nType)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrTool")>
|
|
Private Function EgtTdbSetCurrTool_32(ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrTool")>
|
|
Private Function EgtTdbSetCurrTool_64(ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtTdbSetCurrTool(ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSetCurrTool_32(sName)
|
|
Else
|
|
Return EgtTdbSetCurrTool_64(sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSaveCurrTool")>
|
|
Private Function EgtTdbSaveCurrTool_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSaveCurrTool")>
|
|
Private Function EgtTdbSaveCurrTool_64() As Boolean
|
|
End Function
|
|
Public Function EgtTdbSaveCurrTool() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSaveCurrTool_32()
|
|
Else
|
|
Return EgtTdbSaveCurrTool_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbIsCurrToolModified")>
|
|
Private Function EgtTdbIsCurrToolModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbIsCurrToolModified")>
|
|
Private Function EgtTdbIsCurrToolModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtTdbIsCurrToolModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbIsCurrToolModified_32()
|
|
Else
|
|
Return EgtTdbIsCurrToolModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamBool")>
|
|
Private Function EgtTdbSetCurrToolParamBool_32(ByVal nType As Integer, ByVal bVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamBool")>
|
|
Private Function EgtTdbSetCurrToolParamBool_64(ByVal nType As Integer, ByVal bVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtTdbSetCurrToolParam(ByVal nType As Integer, ByVal bVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSetCurrToolParamBool_32(nType, bVal)
|
|
Else
|
|
Return EgtTdbSetCurrToolParamBool_64(nType, bVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamInt")>
|
|
Private Function EgtTdbSetCurrToolParamInt_32(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamInt")>
|
|
Private Function EgtTdbSetCurrToolParamInt_64(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtTdbSetCurrToolParam(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSetCurrToolParamInt_32(nType, nVal)
|
|
Else
|
|
Return EgtTdbSetCurrToolParamInt_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamDouble")>
|
|
Private Function EgtTdbSetCurrToolParamDouble_32(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamDouble")>
|
|
Private Function EgtTdbSetCurrToolParamDouble_64(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtTdbSetCurrToolParam(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSetCurrToolParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtTdbSetCurrToolParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamString")>
|
|
Private Function EgtTdbSetCurrToolParamString_32(ByVal nType As Integer, ByVal sVal As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSetCurrToolParamString")>
|
|
Private Function EgtTdbSetCurrToolParamString_64(ByVal nType As Integer, ByVal sVal As String) As Boolean
|
|
End Function
|
|
Public Function EgtTdbSetCurrToolParam(ByVal nType As Integer, ByVal sVal As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSetCurrToolParamString_32(nType, sVal)
|
|
Else
|
|
Return EgtTdbSetCurrToolParamString_64(nType, sVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamBool")>
|
|
Private Function EgtTdbGetCurrToolParamBool_32(ByVal nType As Integer, ByRef bVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamBool")>
|
|
Private Function EgtTdbGetCurrToolParamBool_64(ByVal nType As Integer, ByRef bVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetCurrToolParam(ByVal nType As Integer, ByRef bVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbGetCurrToolParamBool_32(nType, bVal)
|
|
Else
|
|
Return EgtTdbGetCurrToolParamBool_64(nType, bVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamInt")>
|
|
Private Function EgtTdbGetCurrToolParamInt_32(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamInt")>
|
|
Private Function EgtTdbGetCurrToolParamInt_64(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetCurrToolParam(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbGetCurrToolParamInt_32(nType, nVal)
|
|
Else
|
|
Return EgtTdbGetCurrToolParamInt_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamDouble")>
|
|
Private Function EgtTdbGetCurrToolParamDouble_32(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamDouble")>
|
|
Private Function EgtTdbGetCurrToolParamDouble_64(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetCurrToolParam(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbGetCurrToolParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtTdbGetCurrToolParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamString")>
|
|
Private Function EgtTdbGetCurrToolParamString_32(ByVal nType As Integer, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetCurrToolParamString")>
|
|
Private Function EgtTdbGetCurrToolParamString_64(ByVal nType As Integer, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetCurrToolParam(ByVal nType As Integer, ByRef sVal As String) As Boolean
|
|
Dim psVal As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtTdbGetCurrToolParamString_32(nType, psVal)
|
|
Else
|
|
bOk = EgtTdbGetCurrToolParamString_64(nType, psVal)
|
|
End If
|
|
If bOk Then
|
|
sVal = Marshal.PtrToStringUni(psVal)
|
|
EgtFreeMemory(psVal)
|
|
Else
|
|
sVal = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSave")>
|
|
Private Function EgtTdbSave_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbSave")>
|
|
Private Function EgtTdbSave_64() As Boolean
|
|
End Function
|
|
Public Function EgtTdbSave() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtTdbSave_32()
|
|
Else
|
|
Return EgtTdbSave_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetToolDir")>
|
|
Private Function EgtTdbGetToolDir_32(ByRef psToolDir As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetToolDir")>
|
|
Private Function EgtTdbGetToolDir_64(ByRef psToolDir As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetToolDir(ByRef sToolDir As String) As Boolean
|
|
Dim psToolDir As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtTdbGetToolDir_32(psToolDir)
|
|
Else
|
|
bOk = EgtTdbGetToolDir_64(psToolDir)
|
|
End If
|
|
If bOk Then
|
|
sToolDir = Marshal.PtrToStringUni(psToolDir)
|
|
EgtFreeMemory(psToolDir)
|
|
Else
|
|
sToolDir = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetToolHolderDir")>
|
|
Private Function EgtTdbGetToolHolderDir_32(ByRef psTHolderDir As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtTdbGetToolHolderDir")>
|
|
Private Function EgtTdbGetToolHolderDir_64(ByRef psTHolderDir As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtTdbGetToolHolderDir(ByRef sTHolderDir As String) As Boolean
|
|
Dim psTHolderDir As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtTdbGetToolHolderDir_32(psTHolderDir)
|
|
Else
|
|
bOk = EgtTdbGetToolHolderDir_64(psTHolderDir)
|
|
End If
|
|
If bOk Then
|
|
sTHolderDir = Marshal.PtrToStringUni(psTHolderDir)
|
|
EgtFreeMemory(psTHolderDir)
|
|
Else
|
|
sTHolderDir = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
' Machinings Database
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetMachiningNewName")>
|
|
Private Function EgtMdbGetMachiningNewName_32(ByVal sName As String, ByRef psNewName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetMachiningNewName")>
|
|
Private Function EgtMdbGetMachiningNewName_64(ByVal sName As String, ByRef psNewName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetMachiningNewName(ByRef sName As String) As Boolean
|
|
Dim psNewName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtMdbGetMachiningNewName_32(sName, psNewName)
|
|
Else
|
|
bOk = EgtMdbGetMachiningNewName_64(sName, psNewName)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psNewName)
|
|
EgtFreeMemory(psNewName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbAddMachining")>
|
|
Private Function EgtMdbAddMachining_32(ByVal sName As String, ByVal nType As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbAddMachining")>
|
|
Private Function EgtMdbAddMachining_64(ByVal sName As String, ByVal nType As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtMdbAddMachining(ByVal sName As String, ByVal nType As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbAddMachining_32(sName, nType)
|
|
Else
|
|
Return EgtMdbAddMachining_64(sName, nType)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbCopyMachining")>
|
|
Private Function EgtMdbCopyMachining_32(ByVal sSource As String, ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbCopyMachining")>
|
|
Private Function EgtMdbCopyMachining_64(ByVal sSource As String, ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtMdbCopyMachining(ByVal sSource As String, ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbCopyMachining_32(sSource, sName)
|
|
Else
|
|
Return EgtMdbCopyMachining_64(sSource, sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbRemoveMachining")>
|
|
Private Function EgtMdbRemoveMachining_32(ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbRemoveMachining")>
|
|
Private Function EgtMdbRemoveMachining_64(ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtMdbRemoveMachining(ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbRemoveMachining_32(sName)
|
|
Else
|
|
Return EgtMdbRemoveMachining_64(sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetFirstMachining")>
|
|
Private Function EgtMdbGetFirstMachining_32(ByVal nType As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetFirstMachining")>
|
|
Private Function EgtMdbGetFirstMachining_64(ByVal nType As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetFirstMachining(ByVal nType As Integer, ByRef sName As String) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtMdbGetFirstMachining_32(nType, psName)
|
|
Else
|
|
bOk = EgtMdbGetFirstMachining_64(nType, psName)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetNextMachining")>
|
|
Private Function EgtMdbGetNextMachining_32(ByVal nType As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetNextMachining")>
|
|
Private Function EgtMdbGetNextMachining_64(ByVal nType As Integer, ByRef psName As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetNextMachining(ByVal nType As Integer, ByRef sName As String) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtMdbGetNextMachining_32(nType, psName)
|
|
Else
|
|
bOk = EgtMdbGetNextMachining_64(nType, psName)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachining")>
|
|
Private Function EgtMdbSetCurrMachining_32(ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachining")>
|
|
Private Function EgtMdbSetCurrMachining_64(ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtMdbSetCurrMachining(ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSetCurrMachining_32(sName)
|
|
Else
|
|
Return EgtMdbSetCurrMachining_64(sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSaveCurrMachining")>
|
|
Private Function EgtMdbSaveCurrMachining_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSaveCurrMachining")>
|
|
Private Function EgtMdbSaveCurrMachining_64() As Boolean
|
|
End Function
|
|
Public Function EgtMdbSaveCurrMachining() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSaveCurrMachining_32()
|
|
Else
|
|
Return EgtMdbSaveCurrMachining_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbIsCurrMachiningModified")>
|
|
Private Function EgtMdbIsCurrMachiningModified_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbIsCurrMachiningModified")>
|
|
Private Function EgtMdbIsCurrMachiningModified_64() As Boolean
|
|
End Function
|
|
Public Function EgtMdbIsCurrMachiningModified() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbIsCurrMachiningModified_32()
|
|
Else
|
|
Return EgtMdbIsCurrMachiningModified_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamBool")>
|
|
Private Function EgtMdbSetCurrMachiningParamBool_32(ByVal nType As Integer, ByVal nVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamBool")>
|
|
Private Function EgtMdbSetCurrMachiningParamBool_64(ByVal nType As Integer, ByVal nVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtMdbSetCurrMachiningParam(ByVal nType As Integer, ByVal nVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSetCurrMachiningParamBool_32(nType, nVal)
|
|
Else
|
|
Return EgtMdbSetCurrMachiningParamBool_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamInt")>
|
|
Private Function EgtMdbSetCurrMachiningParamInt_32(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamInt")>
|
|
Private Function EgtMdbSetCurrMachiningParamInt_64(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtMdbSetCurrMachiningParam(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSetCurrMachiningParamInt_32(nType, nVal)
|
|
Else
|
|
Return EgtMdbSetCurrMachiningParamInt_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamDouble")>
|
|
Private Function EgtMdbSetCurrMachiningParamDouble_32(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamDouble")>
|
|
Private Function EgtMdbSetCurrMachiningParamDouble_64(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMdbSetCurrMachiningParam(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSetCurrMachiningParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtMdbSetCurrMachiningParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamString")>
|
|
Private Function EgtMdbSetCurrMachiningParamString_32(ByVal nType As Integer, ByVal sVal As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetCurrMachiningParamString")>
|
|
Private Function EgtMdbSetCurrMachiningParamString_64(ByVal nType As Integer, ByVal sVal As String) As Boolean
|
|
End Function
|
|
Public Function EgtMdbSetCurrMachiningParam(ByVal nType As Integer, ByVal sVal As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSetCurrMachiningParamString_32(nType, sVal)
|
|
Else
|
|
Return EgtMdbSetCurrMachiningParamString_64(nType, sVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamBool")>
|
|
Private Function EgtMdbGetCurrMachiningParamBool_32(ByVal nType As Integer, ByRef bVal As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamBool")>
|
|
Private Function EgtMdbGetCurrMachiningParamBool_64(ByVal nType As Integer, ByRef bVal As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetCurrMachiningParam(ByVal nType As Integer, ByRef bVal As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbGetCurrMachiningParamBool_32(nType, bVal)
|
|
Else
|
|
Return EgtMdbGetCurrMachiningParamBool_64(nType, bVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamInt")>
|
|
Private Function EgtMdbGetCurrMachiningParamInt_32(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamInt")>
|
|
Private Function EgtMdbGetCurrMachiningParamInt_64(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetCurrMachiningParam(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbGetCurrMachiningParamInt_32(nType, nVal)
|
|
Else
|
|
Return EgtMdbGetCurrMachiningParamInt_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamDouble")>
|
|
Private Function EgtMdbGetCurrMachiningParamDouble_32(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamDouble")>
|
|
Private Function EgtMdbGetCurrMachiningParamDouble_64(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetCurrMachiningParam(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbGetCurrMachiningParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtMdbGetCurrMachiningParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamString")>
|
|
Private Function EgtMdbGetCurrMachiningParamString_32(ByVal nType As Integer, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetCurrMachiningParamString")>
|
|
Private Function EgtMdbGetCurrMachiningParamString_64(ByVal nType As Integer, ByRef psVal As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetCurrMachiningParam(ByVal nType As Integer, ByRef sVal As String) As Boolean
|
|
Dim psVal As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtMdbGetCurrMachiningParamString_32(nType, psVal)
|
|
Else
|
|
bOk = EgtMdbGetCurrMachiningParamString_64(nType, psVal)
|
|
End If
|
|
If bOk Then
|
|
sVal = Marshal.PtrToStringUni(psVal)
|
|
EgtFreeMemory(psVal)
|
|
Else
|
|
sVal = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetGeneralParamDouble")>
|
|
Private Function EgtMdbSetGeneralParamDouble_32(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSetGeneralParamDouble")>
|
|
Private Function EgtMdbSetGeneralParamDouble_64(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMdbSetGeneralParam(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSetGeneralParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtMdbSetGeneralParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetGeneralParamDouble")>
|
|
Private Function EgtMdbGetGeneralParamDouble_32(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetGeneralParamDouble")>
|
|
Private Function EgtMdbGetGeneralParamDouble_64(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetGeneralParam(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbGetGeneralParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtMdbGetGeneralParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSave")>
|
|
Private Function EgtMdbSave_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbSave")>
|
|
Private Function EgtMdbSave_64() As Boolean
|
|
End Function
|
|
Public Function EgtMdbSave() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtMdbSave_32()
|
|
Else
|
|
Return EgtMdbSave_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetMachiningDir")>
|
|
Private Function EgtMdbGetMachiningDir_32(ByRef psMachiningDir As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtMdbGetMachiningDir")>
|
|
Private Function EgtMdbGetMachiningDir_64(ByRef psMachiningDir As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtMdbGetMachiningDir(ByRef sMachiningDir As String) As Boolean
|
|
Dim psMachiningDir As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtMdbGetMachiningDir_32(psMachiningDir)
|
|
Else
|
|
bOk = EgtMdbGetMachiningDir_64(psMachiningDir)
|
|
End If
|
|
If bOk Then
|
|
sMachiningDir = Marshal.PtrToStringUni(psMachiningDir)
|
|
EgtFreeMemory(psMachiningDir)
|
|
Else
|
|
sMachiningDir = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
' Operations
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstOperation")>
|
|
Private Function EgtGetFirstOperation_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstOperation")>
|
|
Private Function EgtGetFirstOperation_64() As Integer
|
|
End Function
|
|
Public Function EgtGetFirstOperation() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstOperation_32()
|
|
Else
|
|
Return EgtGetFirstOperation_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextOperation")>
|
|
Private Function EgtGetNextOperation_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextOperation")>
|
|
Private Function EgtGetNextOperation_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetNextOperation(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextOperation_32(nId)
|
|
Else
|
|
Return EgtGetNextOperation_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOperationType")>
|
|
Private Function EgtGetOperationType_32(ByVal nId As Integer) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOperationType")>
|
|
Private Function EgtGetOperationType_64(ByVal nId As Integer) As Integer
|
|
End Function
|
|
Public Function EgtGetOperationType(ByVal nId As Integer) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetOperationType_32(nId)
|
|
Else
|
|
Return EgtGetOperationType_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveOperation")>
|
|
Private Function EgtRemoveOperation_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveOperation")>
|
|
Private Function EgtRemoveOperation_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtRemoveOperation(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveOperation_32(nId)
|
|
Else
|
|
Return EgtRemoveOperation_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveAllOperations")>
|
|
Private Function EgtRemoveAllOperations_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRemoveAllOperations")>
|
|
Private Function EgtRemoveAllOperations_64() As Boolean
|
|
End Function
|
|
Public Function EgtRemoveAllOperations() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRemoveAllOperations_32()
|
|
Else
|
|
Return EgtRemoveAllOperations_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetOperationMode")>
|
|
Private Function EgtSetOperationMode_32(ByVal nId As Integer, ByVal bActive As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetOperationMode")>
|
|
Private Function EgtSetOperationMode_64(ByVal nId As Integer, ByVal bActive As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetOperationMode(ByVal nId As Integer, ByVal bActive As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetOperationMode_32(nId, bActive)
|
|
Else
|
|
Return EgtSetOperationMode_64(nId, bActive)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOperationMode")>
|
|
Private Function EgtGetOperationMode_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOperationMode")>
|
|
Private Function EgtGetOperationMode_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetOperationMode(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetOperationMode_32(nId)
|
|
Else
|
|
Return EgtGetOperationMode_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAllOperationsMode")>
|
|
Private Function EgtSetAllOperationsMode_32(ByVal bActive As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAllOperationsMode")>
|
|
Private Function EgtSetAllOperationsMode_64(ByVal bActive As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetAllOperationsMode(ByVal bActive As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetAllOperationsMode_32(bActive)
|
|
Else
|
|
Return EgtSetAllOperationsMode_64(bActive)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetOperationStatus")>
|
|
Private Function EgtSetOperationStatus_32(ByVal nId As Integer, ByVal bShow As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetOperationStatus")>
|
|
Private Function EgtSetOperationStatus_64(ByVal nId As Integer, ByVal bShow As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetOperationStatus(ByVal nId As Integer, ByVal bShow As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetOperationStatus_32(nId, bShow)
|
|
Else
|
|
Return EgtSetOperationStatus_64(nId, bShow)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOperationStatus")>
|
|
Private Function EgtGetOperationStatus_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOperationStatus")>
|
|
Private Function EgtGetOperationStatus_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetOperationStatus(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetOperationStatus_32(nId)
|
|
Else
|
|
Return EgtGetOperationStatus_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAllOperationsStatus")>
|
|
Private Function EgtSetAllOperationsStatus_32(ByVal bShow As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAllOperationsStatus")>
|
|
Private Function EgtSetAllOperationsStatus_64(ByVal bShow As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetAllOperationsStatus(ByVal bShow As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetAllOperationsStatus_32(bShow)
|
|
Else
|
|
Return EgtSetAllOperationsStatus_64(bShow)
|
|
End If
|
|
End Function
|
|
|
|
' Machinings
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrMachining")>
|
|
Private Function EgtSetCurrMachining_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCurrMachining")>
|
|
Private Function EgtSetCurrMachining_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetCurrMachining(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCurrMachining_32(nId)
|
|
Else
|
|
Return EgtSetCurrMachining_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMachiningParamInt")>
|
|
Private Function EgtSetMachiningParamInt_32(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMachiningParamInt")>
|
|
Private Function EgtSetMachiningParamInt_64(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetMachiningParam(ByVal nType As Integer, ByVal nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetMachiningParamInt_32(nType, nVal)
|
|
Else
|
|
Return EgtSetMachiningParamInt_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMachiningParamDouble")>
|
|
Private Function EgtSetMachiningParamDouble_32(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMachiningParamDouble")>
|
|
Private Function EgtSetMachiningParamDouble_64(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtSetMachiningParam(ByVal nType As Integer, ByVal dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetMachiningParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtSetMachiningParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPreviewMachining")>
|
|
Private Function EgtPreviewMachining_32(ByVal bRecalc As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPreviewMachining")>
|
|
Private Function EgtPreviewMachining_64(ByVal bRecalc As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtPreviewMachining(ByVal bRecalc As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPreviewMachining_32(bRecalc)
|
|
Else
|
|
Return EgtPreviewMachining_64(bRecalc)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMachiningParamInt")>
|
|
Private Function EgtGetMachiningParamInt_32(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMachiningParamInt")>
|
|
Private Function EgtGetMachiningParamInt_64(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetMachiningParam(ByVal nType As Integer, ByRef nVal As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetMachiningParamInt_32(nType, nVal)
|
|
Else
|
|
Return EgtGetMachiningParamInt_64(nType, nVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMachiningParamDouble")>
|
|
Private Function EgtGetMachiningParamDouble_32(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMachiningParamDouble")>
|
|
Private Function EgtGetMachiningParamDouble_64(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtGetMachiningParam(ByVal nType As Integer, ByRef dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetMachiningParamDouble_32(nType, dVal)
|
|
Else
|
|
Return EgtGetMachiningParamDouble_64(nType, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsMachiningEmpty")>
|
|
Private Function EgtIsMachiningEmpty_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtIsMachiningEmpty")>
|
|
Private Function EgtIsMachiningEmpty_64() As Boolean
|
|
End Function
|
|
Public Function EgtIsMachiningEmpty() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtIsMachiningEmpty_32()
|
|
Else
|
|
Return EgtIsMachiningEmpty_64()
|
|
End If
|
|
End Function
|
|
|
|
' Simulation
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimStart")>
|
|
Private Function EgtSimStart_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimStart")>
|
|
Private Function EgtSimStart_64() As Boolean
|
|
End Function
|
|
Public Function EgtSimStart() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSimStart_32()
|
|
Else
|
|
Return EgtSimStart_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimMove")>
|
|
Private Function EgtSimMove_32(ByRef nStatus As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimMove")>
|
|
Private Function EgtSimMove_64(ByRef nStatus As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSimMove(ByRef nStatus As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSimMove_32(nStatus)
|
|
Else
|
|
Return EgtSimMove_64(nStatus)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimHome")>
|
|
Private Function EgtSimHome_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimHome")>
|
|
Private Function EgtSimHome_64() As Boolean
|
|
End Function
|
|
Public Function EgtSimHome() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSimHome_32()
|
|
Else
|
|
Return EgtSimHome_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimGetAxisInfoPos")>
|
|
Private Function EgtSimGetAxisInfoPos_32(ByVal nInd As Integer, ByRef psName As IntPtr, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimGetAxisInfoPos")>
|
|
Private Function EgtSimGetAxisInfoPos_64(ByVal nInd As Integer, ByRef psName As IntPtr, ByRef dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtSimGetAxisInfoPos(ByVal nInd As Integer, ByRef sName As String, ByRef dVal As Double) As Boolean
|
|
Dim psName As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtSimGetAxisInfoPos_32(nInd, psName, dVal)
|
|
Else
|
|
bOk = EgtSimGetAxisInfoPos_64(nInd, psName, dVal)
|
|
End If
|
|
If bOk Then
|
|
sName = Marshal.PtrToStringUni(psName)
|
|
EgtFreeMemory(psName)
|
|
Else
|
|
sName = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimGetToolInfo")>
|
|
Private Function EgtSimGetToolInfo_32(ByRef psTool As IntPtr, ByRef dSpeed As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimGetToolInfo")>
|
|
Private Function EgtSimGetToolInfo_64(ByRef psTool As IntPtr, ByRef dSpeed As Double) As Boolean
|
|
End Function
|
|
Public Function EgtSimGetToolInfo(ByRef sTool As String, ByRef dSpeed As Double) As Boolean
|
|
Dim psTool As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtSimGetToolInfo_32(psTool, dSpeed)
|
|
Else
|
|
bOk = EgtSimGetToolInfo_64(psTool, dSpeed)
|
|
End If
|
|
If bOk Then
|
|
sTool = Marshal.PtrToStringUni(psTool)
|
|
EgtFreeMemory(psTool)
|
|
Else
|
|
sTool = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimGetMoveInfo")>
|
|
Private Function EgtSimGetMoveInfo_32(ByRef nGmove As Integer, ByRef dSpeed As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimGetMoveInfo")>
|
|
Private Function EgtSimGetMoveInfo_64(ByRef nGmove As Integer, ByRef dSpeed As Double) As Boolean
|
|
End Function
|
|
Public Function EgtSimGetMoveInfo(ByRef nGmove As Integer, ByRef dSpeed As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSimGetMoveInfo_32(nGmove, dSpeed)
|
|
Else
|
|
Return EgtSimGetMoveInfo_64(nGmove, dSpeed)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimSetStep")>
|
|
Private Function EgtSimSetStep_32(ByVal dStep As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimSetStep")>
|
|
Private Function EgtSimSetStep_64(ByVal dStep As Double) As Boolean
|
|
End Function
|
|
Public Function EgtSimSetStep(ByVal dStep As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSimSetStep_32(dStep)
|
|
Else
|
|
Return EgtSimSetStep_64(dStep)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimStop")>
|
|
Private Function EgtSimStop_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSimStop")>
|
|
Private Function EgtSimStop_64() As Boolean
|
|
End Function
|
|
Public Function EgtSimStop() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSimStop_32()
|
|
Else
|
|
Return EgtSimStop_64()
|
|
End If
|
|
End Function
|
|
|
|
' Generation
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGenerate")>
|
|
Private Function EgtGenerate_32(ByVal sCncFile As String, ByVal sInfo As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGenerate")>
|
|
Private Function EgtGenerate_64(ByVal sCncFile As String, ByVal sInfo As String) As Boolean
|
|
End Function
|
|
Public Function EgtGenerate(ByVal sCncFile As String, ByVal sInfo As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGenerate_32(sCncFile, sInfo)
|
|
Else
|
|
Return EgtGenerate_64(sCncFile, sInfo)
|
|
End If
|
|
End Function
|
|
|
|
' Machine Calc
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCalcTool")>
|
|
Private Function EgtSetCalcTool_32(ByVal sTool As String, ByVal sHead As String, ByVal nExit As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetCalcTool")>
|
|
Private Function EgtSetCalcTool_64(ByVal sTool As String, ByVal sHead As String, ByVal nExit As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetCalcTool(ByVal sTool As String, ByVal sHead As String, ByVal nExit As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetCalcTool_32(sTool, sHead, nExit)
|
|
Else
|
|
Return EgtSetCalcTool_64(sTool, sHead, nExit)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcTipFromPositions")>
|
|
Private Function EgtGetCalcTipFromPositions_32(dX As Double, dY As Double, dZ As Double, dAngA As Double, dAngB As Double,
|
|
bBottom As Boolean, ByRef ptTip As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcTipFromPositions")>
|
|
Private Function EgtGetCalcTipFromPositions_64(dX As Double, dY As Double, dZ As Double, dAngA As Double, dAngB As Double,
|
|
bBottom As Boolean, ByRef ptTip As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcTipFromPositions(dX As Double, dY As Double, dZ As Double, dAngA As Double, dAngB As Double,
|
|
bBottom As Boolean, ByRef ptTip As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcTipFromPositions_32(dX, dY, dZ, dAngA, dAngB, bBottom, ptTip)
|
|
Else
|
|
Return EgtGetCalcTipFromPositions_64(dX, dY, dZ, dAngA, dAngB, bBottom, ptTip)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcToolDirFromAngles")>
|
|
Private Function EgtGetCalcToolDirFromAngles_32(dAngA As Double, dAngB As Double, ByRef vtDir As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetCalcToolDirFromAngles")>
|
|
Private Function EgtGetCalcToolDirFromAngles_64(dAngA As Double, dAngB As Double, ByRef vtDir As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetCalcToolDirFromAngles(dAngA As Double, dAngB As Double, ByRef vtDir As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetCalcToolDirFromAngles_32(dAngA, dAngB, vtDir)
|
|
Else
|
|
Return EgtGetCalcToolDirFromAngles_64(dAngA, dAngB, vtDir)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyOutstroke")>
|
|
Private Function EgtVerifyOutstroke_32(dX As Double, dY As Double, dZ As Double, dAngA As Double, dAngB As Double, ByRef nStat As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVerifyOutstroke")>
|
|
Private Function EgtVerifyOutstroke_64(dX As Double, dY As Double, dZ As Double, dAngA As Double, dAngB As Double, ByRef nStat As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtVerifyOutstroke(dX As Double, dY As Double, dZ As Double, dAngA As Double, dAngB As Double, ByRef nStat As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVerifyOutstroke_32(dX, dY, dZ, dAngA, dAngB, nStat)
|
|
Else
|
|
Return EgtVerifyOutstroke_64(dX, dY, dZ, dAngA, dAngB, nStat)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOutstrokeInfo")>
|
|
Private Function EgtGetOutstrokeInfo_32(ByRef psInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetOutstrokeInfo")>
|
|
Private Function EgtGetOutstrokeInfo_64(ByRef psInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetOutstrokeInfo(ByRef sInfo As String) As Boolean
|
|
Dim psInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetOutstrokeInfo_32(psInfo)
|
|
Else
|
|
bOk = EgtGetOutstrokeInfo_64(psInfo)
|
|
End If
|
|
If bOk Then
|
|
sInfo = Marshal.PtrToStringUni(psInfo)
|
|
EgtFreeMemory(psInfo)
|
|
Else
|
|
sInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
' Machine Move
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAxisPos")>
|
|
Private Function EgtSetAxisPos_32(ByVal sAxis As String, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetAxisPos")>
|
|
Private Function EgtSetAxisPos_64(ByVal sAxis As String, ByVal dVal As Double) As Boolean
|
|
End Function
|
|
Public Function EgtSetAxisPos(ByVal sAxis As String, ByVal dVal As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetAxisPos_32(sAxis, dVal)
|
|
Else
|
|
Return EgtSetAxisPos_64(sAxis, dVal)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMachineLook")>
|
|
Private Function EgtSetMachineLook_32(nFlag As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMachineLook")>
|
|
Private Function EgtSetMachineLook_64(nFlag As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetMachineLook(nFlag As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetMachineLook_32(nFlag)
|
|
Else
|
|
Return EgtSetMachineLook_64(nFlag)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Scene --------------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitScene")>
|
|
Private Function EgtInitScene_32(ByVal hWnd As IntPtr, ByVal nDriver As Integer,
|
|
ByVal b2Buff As Boolean, ByVal nColorBits As Integer, ByVal nDepthBits As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtInitScene")>
|
|
Private Function EgtInitScene_64(ByVal hWnd As IntPtr, ByVal nDriver As Integer,
|
|
ByVal b2Buff As Boolean, ByVal nColorBits As Integer, ByVal nDepthBits As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtInitScene(ByVal hWnd As IntPtr, ByVal nDriver As Integer,
|
|
ByVal b2Buff As Boolean, ByVal nColorBits As Integer, ByVal nDepthBits As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtInitScene_32(hWnd, nDriver, b2Buff, nColorBits, nDepthBits)
|
|
Else
|
|
Return EgtInitScene_64(hWnd, nDriver, b2Buff, nColorBits, nDepthBits)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetSceneInfo")>
|
|
Private Function EgtGetSceneInfo_32(ByRef psInfo As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetSceneInfo")>
|
|
Private Function EgtGetSceneInfo_64(ByRef psInfo As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetSceneInfo(ByRef sInfo As String) As Boolean
|
|
Dim psInfo As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetSceneInfo_32(psInfo)
|
|
Else
|
|
bOk = EgtGetSceneInfo_64(psInfo)
|
|
End If
|
|
If bOk Then
|
|
sInfo = Marshal.PtrToStringUni(psInfo)
|
|
EgtFreeMemory(psInfo)
|
|
Else
|
|
sInfo = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetBackground")>
|
|
Private Function EgtSetBackground_32(ByRef colTop As Color3d, ByRef colBottom As Color3d, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetBackground")>
|
|
Private Function EgtSetBackground_64(ByRef colTop As Color3d, ByRef colBottom As Color3d, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetBackground(ByRef colTop As Color3d, ByRef colBottom As Color3d, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetBackground_32(colTop, colBottom, bRedraw)
|
|
Else
|
|
Return EgtSetBackground_64(colTop, colBottom, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMarkAttribs")>
|
|
Private Function EgtSetMarkAttribs_32(ByRef colMark As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetMarkAttribs")>
|
|
Private Function EgtSetMarkAttribs_64(ByRef colMark As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetMarkAttribs(ByRef colMark As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetMarkAttribs_32(colMark)
|
|
Else
|
|
Return EgtSetMarkAttribs_64(colMark)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetSelSurfAttribs")>
|
|
Private Function EgtSetSelSurfAttribs_32(ByRef colSelSurf As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetSelSurfAttribs")>
|
|
Private Function EgtSetSelSurfAttribs_64(ByRef colSelSurf As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetSelSurfAttribs(ByRef colSelSurf As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetSelSurfAttribs_32(colSelSurf)
|
|
Else
|
|
Return EgtSetSelSurfAttribs_64(colSelSurf)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoLineAttribs")>
|
|
Private Function EgtSetGeoLineAttribs_32(ByRef colGl As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoLineAttribs")>
|
|
Private Function EgtSetGeoLineAttribs_64(ByRef colGl As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetGeoLineAttribs(ByRef colGl As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGeoLineAttribs_32(colGl)
|
|
Else
|
|
Return EgtSetGeoLineAttribs_64(colGl)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoTriaAttribs")>
|
|
Private Function EgtSetGeoTriaAttribs_32(ByRef colGt As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoTriaAttribs")>
|
|
Private Function EgtSetGeoTriaAttribs_64(ByRef colGt As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetGeoTriaAttribs(ByRef colGt As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGeoTriaAttribs_32(colGt)
|
|
Else
|
|
Return EgtSetGeoTriaAttribs_64(colGt)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetWinRectAttribs")>
|
|
Private Function EgtSetWinRectAttribs_32(ByVal bOutline As Boolean, ByRef colWr As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetWinRectAttribs")>
|
|
Private Function EgtSetWinRectAttribs_64(ByVal bOutline As Boolean, ByRef colWr As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetWinRectAttribs(ByVal bOutline As Boolean, ByRef colWr As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetWinRectAttribs_32(bOutline, colWr)
|
|
Else
|
|
Return EgtSetWinRectAttribs_64(bOutline, colWr)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGlobFrameShow")>
|
|
Private Function EgtSetGlobFrameShow_32(ByVal bShow As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGlobFrameShow")>
|
|
Private Function EgtSetGlobFrameShow_64(ByVal bShow As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetGlobFrameShow(ByVal bShow As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGlobFrameShow_32(bShow)
|
|
Else
|
|
Return EgtSetGlobFrameShow_64(bShow)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridShow")>
|
|
Private Function EgtSetGridShow_32(ByVal bShowGrid As Boolean, ByVal bShowFrame As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridShow")>
|
|
Private Function EgtSetGridShow_64(ByVal bShowGrid As Boolean, ByVal bShowFrame As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetGridShow(ByVal bShowGrid As Boolean, ByVal bShowFrame As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGridShow_32(bShowGrid, bShowFrame)
|
|
Else
|
|
Return EgtSetGridShow_64(bShowGrid, bShowFrame)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridGeo")>
|
|
Private Function EgtSetGridGeo_32(ByVal dSnapStep As Double, ByVal nMinLineSstep As Integer, ByVal nMajLineSstep As Integer, ByVal nExtSstep As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridGeo")>
|
|
Private Function EgtSetGridGeo_64(ByVal dSnapStep As Double, ByVal nMinLineSstep As Integer, ByVal nMajLineSstep As Integer, ByVal nExtSstep As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSetGridGeo(ByVal dSnapStep As Double, ByVal nMinLineSstep As Integer, ByVal nMajLineSstep As Integer, ByVal nExtSstep As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGridGeo_32(dSnapStep, nMinLineSstep, nMajLineSstep, nExtSstep)
|
|
Else
|
|
Return EgtSetGridGeo_64(dSnapStep, nMinLineSstep, nMajLineSstep, nExtSstep)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridColor")>
|
|
Private Function EgtSetGridColor_32(ByRef colMinLine As Color3d, ByRef colMajLine As Color3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGridColor")>
|
|
Private Function EgtSetGridColor_64(ByRef colMinLine As Color3d, ByRef colMajLine As Color3d) As Boolean
|
|
End Function
|
|
Public Function EgtSetGridColor(ByRef colMinLine As Color3d, ByRef colMajLine As Color3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGridColor_32(colMinLine, colMajLine)
|
|
Else
|
|
Return EgtSetGridColor_64(colMinLine, colMajLine)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResize")>
|
|
Private Function EgtResize_32(ByVal nW As Integer, ByVal nH As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResize")>
|
|
Private Function EgtResize_64(ByVal nW As Integer, ByVal nH As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtResize(ByVal nW As Integer, ByVal nH As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResize_32(nW, nH)
|
|
Else
|
|
Return EgtResize_64(nW, nH)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtDraw")>
|
|
Private Function EgtDraw_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtDraw")>
|
|
Private Function EgtDraw_64() As Boolean
|
|
End Function
|
|
Public Function EgtDraw() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtDraw_32()
|
|
Else
|
|
Return EgtDraw_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelect")>
|
|
Private Function EgtSelect_32(ByVal nWinX As Integer, ByVal nWinY As Integer,
|
|
ByVal nSelW As Integer, ByVal nSelH As Integer, ByRef nSel As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSelect")>
|
|
Private Function EgtSelect_64(ByVal nWinX As Integer, ByVal nWinY As Integer,
|
|
ByVal nSelW As Integer, ByVal nSelH As Integer, ByRef nSel As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtSelect(ByVal Curr As Point, ByVal nSelW As Integer, ByVal nSelH As Integer,
|
|
ByRef nSel As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSelect_32(Curr.X, Curr.Y, nSelW, nSelH, nSel)
|
|
Else
|
|
Return EgtSelect_64(Curr.X, Curr.Y, nSelW, nSelH, nSel)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetObjFilterForSelect")>
|
|
Private Function EgtSetObjFilterForSelect_32(ByVal bZeroDim As Boolean, ByVal bCurve As Boolean,
|
|
ByVal bSurf As Boolean, ByVal bVolume As Boolean, ByVal bExtra As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetObjFilterForSelect")>
|
|
Private Function EgtSetObjFilterForSelect_64(ByVal bZeroDim As Boolean, ByVal bCurve As Boolean,
|
|
ByVal bSurf As Boolean, ByVal bVolume As Boolean, ByVal bExtra As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetObjFilterForSelect(ByVal bZeroDim As Boolean, ByVal bCurve As Boolean,
|
|
ByVal bSurf As Boolean, ByVal bVolume As Boolean, ByVal bExtra As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetObjFilterForSelect_32(bZeroDim, bCurve, bSurf, bVolume, bExtra)
|
|
Else
|
|
Return EgtSetObjFilterForSelect_64(bZeroDim, bCurve, bSurf, bVolume, bExtra)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnselectableAdd")>
|
|
Private Function EgtUnselectableAdd_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnselectableAdd")>
|
|
Private Function EgtUnselectableAdd_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtUnselectableAdd(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtUnselectableAdd_32(nId)
|
|
Else
|
|
Return EgtUnselectableAdd_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnselectableRemove")>
|
|
Private Function EgtUnselectableRemove_32(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnselectableRemove")>
|
|
Private Function EgtUnselectableRemove_64(ByVal nId As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtUnselectableRemove(ByVal nId As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtUnselectableRemove_32(nId)
|
|
Else
|
|
Return EgtUnselectableRemove_64(nId)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnselectableClearAll")>
|
|
Private Function EgtUnselectableClearAll_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnselectableClearAll")>
|
|
Private Function EgtUnselectableClearAll_64() As Boolean
|
|
End Function
|
|
Public Function EgtUnselectableClearAll() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtUnselectableClearAll_32()
|
|
Else
|
|
Return EgtUnselectableClearAll_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstObjInSelWin")>
|
|
Private Function EgtGetFirstObjInSelWin_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetFirstObjInSelWin")>
|
|
Private Function EgtGetFirstObjInSelWin_64() As Integer
|
|
End Function
|
|
Public Function EgtGetFirstObjInSelWin() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetFirstObjInSelWin_32()
|
|
Else
|
|
Return EgtGetFirstObjInSelWin_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextObjInSelWin")>
|
|
Private Function EgtGetNextObjInSelWin_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetNextObjInSelWin")>
|
|
Private Function EgtGetNextObjInSelWin_64() As Integer
|
|
End Function
|
|
Public Function EgtGetNextObjInSelWin() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetNextObjInSelWin_32()
|
|
Else
|
|
Return EgtGetNextObjInSelWin_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPointFromSelect")>
|
|
Private Function EgtGetPointFromSelect_32(ByVal nSelId As Integer, ByVal nWinX As Integer, ByVal nWinY As Integer,
|
|
ByRef ptP As Point3d, ByRef nAux As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPointFromSelect")>
|
|
Private Function EgtGetPointFromSelect_64(ByVal nSelId As Integer, ByVal nWinX As Integer, ByVal nWinY As Integer,
|
|
ByRef ptP As Point3d, ByRef nAux As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetPointFromSelect(ByVal nSelId As Integer, ByVal PtWin As Point, ByRef ptP As Point3d, ByRef nAux As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetPointFromSelect_32(nSelId, PtWin.X, PtWin.Y, ptP, nAux)
|
|
Else
|
|
Return EgtGetPointFromSelect_64(nSelId, PtWin.X, PtWin.Y, ptP, nAux)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGraphicSnapPoint")>
|
|
Private Function EgtGetGraphicSnapPoint_32(ByVal nSnap As Integer,
|
|
ByVal nWinX As Integer, ByVal nWinY As Integer, ByVal nSelW As Integer, ByVal nSelH As Integer,
|
|
ByRef ptP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGraphicSnapPoint")>
|
|
Private Function EgtGetGraphicSnapPoint_64(ByVal nSnap As Integer,
|
|
ByVal nWinX As Integer, ByVal nWinY As Integer, ByVal nSelW As Integer, ByVal nSelH As Integer,
|
|
ByRef ptP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetGraphicSnapPoint(ByVal nSnap As Integer,
|
|
ByVal PtWin As Point, ByVal nSelW As Integer, ByVal nSelH As Integer,
|
|
ByRef ptP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetGraphicSnapPoint_32(nSnap, PtWin.X, PtWin.Y, nSelW, nSelH, ptP)
|
|
Else
|
|
Return EgtGetGraphicSnapPoint_64(nSnap, PtWin.X, PtWin.Y, nSelW, nSelH, ptP)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGridSnapPointZ")>
|
|
Private Function EgtGetGridSnapPointZ_32(ByVal bSketch As Boolean,
|
|
ByVal nWinX As Integer, ByVal nWinY As Integer, ByRef ptGrid As Point3d,
|
|
ByRef ptP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGridSnapPointZ")>
|
|
Private Function EgtGetGridSnapPointZ_64(ByVal bSketch As Boolean,
|
|
ByVal nWinX As Integer, ByVal nWinY As Integer, ByRef ptGrid As Point3d,
|
|
ByRef ptP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetGridSnapPointZ(ByVal bSketch As Boolean,
|
|
ByVal PtWin As Point, ByVal ptGrid As Point3d,
|
|
ByRef ptP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetGridSnapPointZ_32(bSketch, PtWin.X, PtWin.Y, ptGrid, ptP)
|
|
Else
|
|
Return EgtGetGridSnapPointZ_64(bSketch, PtWin.X, PtWin.Y, ptGrid, ptP)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastSnapId")>
|
|
Private Function EgtGetLastSnapId_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastSnapId")>
|
|
Private Function EgtGetLastSnapId_64() As Integer
|
|
End Function
|
|
Public Function EgtGetLastSnapId() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastSnapId_32()
|
|
Else
|
|
Return EgtGetLastSnapId_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastSnapDir")>
|
|
Private Function EgtGetLastSnapDir_32(ByRef VtDir As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetLastSnapDir")>
|
|
Private Function EgtGetLastSnapDir_64(ByRef VtDir As Vector3d) As Boolean
|
|
End Function
|
|
Public Function EgtGetLastSnapDir(ByRef VtDir As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetLastSnapDir_32(VtDir)
|
|
Else
|
|
Return EgtGetLastSnapDir_64(VtDir)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetShowMode")>
|
|
Private Function EgtSetShowMode_32(ByVal nShowMode As SM, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetShowMode")>
|
|
Private Function EgtSetShowMode_64(ByVal nShowMode As SM, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetShowMode(ByVal nShowMode As SM, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetShowMode_32(nShowMode, bRedraw)
|
|
Else
|
|
Return EgtSetShowMode_64(nShowMode, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetShowMode")>
|
|
Private Function EgtGetShowMode_32() As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetShowMode")>
|
|
Private Function EgtGetShowMode_64() As Integer
|
|
End Function
|
|
Public Function EgtGetShowMode() As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetShowMode_32()
|
|
Else
|
|
Return EgtGetShowMode_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetShowCurveDirection")>
|
|
Private Function EgtSetShowCurveDirection_32(ByVal bShow As Boolean, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetShowCurveDirection")>
|
|
Private Function EgtSetShowCurveDirection_64(ByVal bShow As Boolean, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetShowCurveDirection(ByVal bShow As Boolean, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetShowCurveDirection_32(bShow, bRedraw)
|
|
Else
|
|
Return EgtSetShowCurveDirection_64(bShow, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetShowCurveDirection")>
|
|
Private Function EgtGetShowCurveDirection_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetShowCurveDirection")>
|
|
Private Function EgtGetShowCurveDirection_64() As Boolean
|
|
End Function
|
|
Public Function EgtGetShowCurveDirection() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetShowCurveDirection_32()
|
|
Else
|
|
Return EgtGetShowCurveDirection_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetShowTriaAdv")>
|
|
Private Function EgtSetShowTriaAdv_32(ByVal bAdvanced As Boolean, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetShowTriaAdv")>
|
|
Private Function EgtSetShowTriaAdv_64(ByVal bAdvanced As Boolean, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetShowTriaAdv(ByVal bAdvanced As Boolean, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetShowTriaAdv_32(bAdvanced, bRedraw)
|
|
Else
|
|
Return EgtSetShowTriaAdv_64(bAdvanced, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetShowTriaAdv")>
|
|
Private Function EgtGetShowTriaAdv_32() As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetShowTriaAdv")>
|
|
Private Function EgtGetShowTriaAdv_64() As Boolean
|
|
End Function
|
|
Public Function EgtGetShowTriaAdv() As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetShowTriaAdv_32()
|
|
Else
|
|
Return EgtGetShowTriaAdv_64()
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtZoom")>
|
|
Private Function EgtZoom_32(ByVal nZoom As ZM, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtZoom")>
|
|
Private Function EgtZoom_64(ByVal nZoom As ZM, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtZoom(ByVal nZoom As ZM, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtZoom_32(nZoom, bRedraw)
|
|
Else
|
|
Return EgtZoom_64(nZoom, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtZoomOnPoint")>
|
|
Private Function EgtZoomOnPoint_32(ByVal nWinX As Integer, ByVal nWinY As Integer, ByVal dCoeff As Double, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtZoomOnPoint")>
|
|
Private Function EgtZoomOnPoint_64(ByVal nWinX As Integer, ByVal nWinY As Integer, ByVal dCoeff As Double, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtZoomOnPoint(ByVal Curr As Point, ByVal dCoeff As Double, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtZoomOnPoint_32(Curr.X, Curr.Y, dCoeff, bRedraw)
|
|
Else
|
|
Return EgtZoomOnPoint_64(Curr.X, Curr.Y, dCoeff, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoLine")>
|
|
Private Function EgtSetGeoLine_32(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoLine")>
|
|
Private Function EgtSetGeoLine_64(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetGeoLine(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGeoLine_32(ptP1, ptP2, bRedraw)
|
|
Else
|
|
Return EgtSetGeoLine_64(ptP1, ptP2, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetGeoLine")>
|
|
Private Function EgtResetGeoLine_32(ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetGeoLine")>
|
|
Private Function EgtResetGeoLine_64(ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtResetGeoLine(Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetGeoLine_32(bRedraw)
|
|
Else
|
|
Return EgtResetGeoLine_64(bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoTria")>
|
|
Private Function EgtSetGeoTria_32(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, ByRef ptP3 As Point3d, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetGeoTria")>
|
|
Private Function EgtSetGeoTria_64(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, ByRef ptP3 As Point3d, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetGeoTria(ByRef ptP1 As Point3d, ByRef ptP2 As Point3d, ByRef ptP3 As Point3d, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetGeoTria_32(ptP1, ptP2, ptP3, bRedraw)
|
|
Else
|
|
Return EgtSetGeoTria_64(ptP1, ptP2, ptP3, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetGeoTria")>
|
|
Private Function EgtResetGeoTria_32(ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetGeoTria")>
|
|
Private Function EgtResetGeoTria_64(ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtResetGeoTria(Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetGeoTria_32(bRedraw)
|
|
Else
|
|
Return EgtResetGeoTria_64(bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetWinRect")>
|
|
Private Function EgtSetWinRect_32(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetWinRect")>
|
|
Private Function EgtSetWinRect_64(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetWinRect(ByVal Prev As Point, ByVal Curr As Point, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetWinRect_32(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
Else
|
|
Return EgtSetWinRect_64(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetWinRect")>
|
|
Private Function EgtResetWinRect_32(ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtResetWinRect")>
|
|
Private Function EgtResetWinRect_64(ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtResetWinRect(Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtResetWinRect_32(bRedraw)
|
|
Else
|
|
Return EgtResetWinRect_64(bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtZoomWin")>
|
|
Private Function EgtZoomWin_32(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtZoomWin")>
|
|
Private Function EgtZoomWin_64(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtZoomWin(ByVal Prev As Point, ByVal Curr As Point, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtZoomWin_32(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
Else
|
|
Return EgtZoomWin_64(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetView")>
|
|
Private Function EgtSetView_32(ByVal nView As VT, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtSetView")>
|
|
Private Function EgtSetView_64(ByVal nView As VT, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtSetView(ByVal nView As VT, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtSetView_32(nView, bRedraw)
|
|
Else
|
|
Return EgtSetView_64(nView, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPanView")>
|
|
Private Function EgtPanView_32(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPanView")>
|
|
Private Function EgtPanView_64(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtPanView(ByVal Prev As Point, ByVal Curr As Point, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPanView_32(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
Else
|
|
Return EgtPanView_64(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotateView")>
|
|
Private Function EgtRotateView_32(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtRotateView")>
|
|
Private Function EgtRotateView_64(ByVal nPrevX As Integer, ByVal nPrevY As Integer, ByVal nCurrX As Integer, ByVal nCurrY As Integer, ByVal bRedraw As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtRotateView(ByVal Prev As Point, ByVal Curr As Point, Optional ByVal bRedraw As Boolean = True) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtRotateView_32(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
Else
|
|
Return EgtRotateView_64(Prev.X, Prev.Y, Curr.X, Curr.Y, bRedraw)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetView")>
|
|
Private Function EgtGetView_32(ByRef nDir As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetView")>
|
|
Private Function EgtGetView_64(ByRef nDir As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetView(ByRef nDir As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetView_32(nDir)
|
|
Else
|
|
Return EgtGetView_64(nDir)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGenericView")>
|
|
Private Function EgtGetGenericView_32(ByRef dAngVertDeg As Double, ByRef dAngHorizDeg As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetGenericView")>
|
|
Private Function EgtGetGenericView_64(ByRef dAngVertDeg As Double, ByRef dAngHorizDeg As Double) As Boolean
|
|
End Function
|
|
Public Function EgtGetGenericView(ByRef dAngVertDeg As Double, ByRef dAngHorizDeg As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetGenericView_32(dAngVertDeg, dAngHorizDeg)
|
|
Else
|
|
Return EgtGetGenericView_64(dAngVertDeg, dAngHorizDeg)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtProjectPoint")>
|
|
Private Function EgtProjectPoint_32(ByRef ptP As Point3d, ByRef ptWin As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtProjectPoint")>
|
|
Private Function EgtProjectPoint_64(ByRef ptP As Point3d, ByRef ptWin As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtProjectPoint(ByRef ptP As Point3d, ByRef ptWin As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtProjectPoint_32(ptP, ptWin)
|
|
Else
|
|
Return EgtProjectPoint_64(ptP, ptWin)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnProjectPoint")>
|
|
Private Function EgtUnProjectPoint_32(ByVal nWinX As Integer, ByVal nWinY As Integer, ByRef ptP As Point3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnProjectPoint")>
|
|
Private Function EgtUnProjectPoint_64(ByVal nWinX As Integer, ByVal nWinY As Integer, ByRef ptP As Point3d) As Boolean
|
|
End Function
|
|
Public Function EgtUnProjectPoint(ByVal Curr As Point, ByRef ptP As Point3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtUnProjectPoint_32(Curr.X, Curr.Y, ptP)
|
|
Else
|
|
Return EgtUnProjectPoint_64(Curr.X, Curr.Y, ptP)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLoadTexture")>
|
|
Private Function EgtLoadTexture_32(ByVal sName As String, ByVal sFile As String,
|
|
ByVal dMMxPix As Double, ByVal dDimX As Double, ByVal dDimY As Double, ByVal nRepeat As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLoadTexture")>
|
|
Private Function EgtLoadTexture_64(ByVal sName As String, ByVal sFile As String,
|
|
ByVal dMMxPix As Double, ByVal dDimX As Double, ByVal dDimY As Double, ByVal nRepeat As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtLoadTexture(ByVal sName As String, ByVal sFile As String,
|
|
ByVal dMMxPix As Double, ByVal dDimX As Double, ByVal dDimY As Double, ByVal nRepeat As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLoadTexture_32(sName, sFile, dMMxPix, dDimX, dDimY, nRepeat)
|
|
Else
|
|
Return EgtLoadTexture_64(sName, sFile, dMMxPix, dDimX, dDimY, nRepeat)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnloadTexture")>
|
|
Private Function EgtUnloadTexture_32(ByVal sName As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtUnloadTexture")>
|
|
Private Function EgtUnloadTexture_64(ByVal sName As String) As Boolean
|
|
End Function
|
|
Public Function EgtUnloadTexture(ByVal sName As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtUnloadTexture_32(sName)
|
|
Else
|
|
Return EgtUnloadTexture_64(sName)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTexturePixels")>
|
|
Private Function EgtGetTexturePixels_32(ByVal sName As String, ByRef nWidth As Integer, ByRef nHeight As Integer) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTexturePixels")>
|
|
Private Function EgtGetTexturePixels_64(ByVal sName As String, ByRef nWidth As Integer, ByRef nHeight As Integer) As Boolean
|
|
End Function
|
|
Public Function EgtGetTexturePixels(ByVal sName As String, ByRef nWidth As Integer, ByRef nHeight As Integer) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetTexturePixels_32(sName, nWidth, nHeight)
|
|
Else
|
|
Return EgtGetTexturePixels_64(sName, nWidth, nHeight)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTextureDimensions")>
|
|
Private Function EgtGetTextureDimensions_32(ByVal sName As String, ByRef dDimX As Double, ByRef dDimY As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetTextureDimensions")>
|
|
Private Function EgtGetTextureDimensions_64(ByVal sName As String, ByRef dDimX As Double, ByRef dDimY As Double) As Boolean
|
|
End Function
|
|
Public Function EgtGetTextureDimensions(ByVal sName As String, ByRef dDimX As Double, ByRef dDimY As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetTextureDimensions_32(sName, dDimX, dDimY)
|
|
Else
|
|
Return EgtGetTextureDimensions_64(sName, dDimX, dDimY)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeTextureDimensions")>
|
|
Private Function EgtChangeTextureDimensions_32(ByVal sName As String, ByVal dDimX As Double, ByVal dDimY As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangeTextureDimensions")>
|
|
Private Function EgtChangeTextureDimensions_64(ByVal sName As String, ByVal dDimX As Double, ByVal dDimY As Double) As Boolean
|
|
End Function
|
|
Public Function EgtChangeTextureDimensions(ByVal sName As String, ByVal dDimX As Double, ByVal dDimY As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtChangeTextureDimensions_32(sName, dDimX, dDimY)
|
|
Else
|
|
Return EgtChangeTextureDimensions_64(sName, dDimX, dDimY)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Photo --------------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddPhoto")>
|
|
Private Function EgtAddPhoto_32(ByVal sName As String, ByVal sFile As String,
|
|
ByRef ptOri As Point3d, ByRef ptCen As Point3d, ByVal dMMxPix As Double,
|
|
ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d) As Integer
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtAddPhoto")>
|
|
Private Function EgtAddPhoto_64(ByVal sName As String, ByVal sFile As String,
|
|
ByRef ptOri As Point3d, ByRef ptCen As Point3d, ByVal dMMxPix As Double,
|
|
ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d) As Integer
|
|
End Function
|
|
Public Function EgtAddPhoto(ByVal sName As String, ByVal sFile As String,
|
|
ByRef ptOri As Point3d, ByRef ptCen As Point3d, ByVal dMMxPix As Double,
|
|
ByVal nParentId As Integer, ByRef ptMin As Point3d, ByRef ptMax As Point3d) As Integer
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtAddPhoto_32(sName, sFile, ptOri, ptCen, dMMxPix, nParentId, ptMin, ptMax)
|
|
Else
|
|
Return EgtAddPhoto_64(sName, sFile, ptOri, ptCen, dMMxPix, nParentId, ptMin, ptMax)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPhotoPath")>
|
|
Private Function EgtGetPhotoPath_32(ByVal nId As Integer, ByRef psFile As IntPtr) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetPhotoPath")>
|
|
Private Function EgtGetPhotoPath_64(ByVal nId As Integer, ByRef psFile As IntPtr) As Boolean
|
|
End Function
|
|
Public Function EgtGetPhotoPath(ByVal nId As Integer, ByRef sFile As String) As Boolean
|
|
Dim psFile As IntPtr
|
|
Dim bOk As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
bOk = EgtGetPhotoPath_32(nId, psFile)
|
|
Else
|
|
bOk = EgtGetPhotoPath_64(nId, psFile)
|
|
End If
|
|
If bOk Then
|
|
sFile = Marshal.PtrToStringUni(psFile)
|
|
EgtFreeMemory(psFile)
|
|
Else
|
|
sFile = String.Empty
|
|
End If
|
|
Return bOk
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangePhotoPath")>
|
|
Private Function EgtChangePhotoPath_32(ByVal nId As Integer, ByVal sFile As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtChangePhotoPath")>
|
|
Private Function EgtChangePhotoPath_64(ByVal nId As Integer, ByVal sFile As String) As Boolean
|
|
End Function
|
|
Public Function EgtChangePhotoPath(ByVal nId As Integer, ByVal sFile As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtChangePhotoPath_32(nId, sFile)
|
|
Else
|
|
Return EgtChangePhotoPath_64(nId, sFile)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Geo Base -----------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorNormalize")>
|
|
Private Function EgtVectorNormalize_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByVal dEps As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorNormalize")>
|
|
Private Function EgtVectorNormalize_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByVal dEps As Double) As Boolean
|
|
End Function
|
|
Private Function EgtVectorNormalize(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
Optional ByVal dEps As Double = EPS_SMALL) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorNormalize_32(X, Y, Z, dEps)
|
|
Else
|
|
Return EgtVectorNormalize_64(X, Y, Z, dEps)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorRotate")>
|
|
Private Function EgtVectorRotate_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorRotate")>
|
|
Private Function EgtVectorRotate_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
Private Function EgtVectorRotate(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorRotate_32(X, Y, Z, VtAx, dAngRotDeg)
|
|
Else
|
|
Return EgtVectorRotate_64(X, Y, Z, VtAx, dAngRotDeg)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorScale")>
|
|
Private Function EgtVectorScale_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorScale")>
|
|
Private Function EgtVectorScale_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
End Function
|
|
Private Function EgtVectorScale(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorScale_32(X, Y, Z, PtOrig, VtX, VtY, VtZ, dCoeffX, dCoeffY, dCoeffZ)
|
|
Else
|
|
Return EgtVectorScale_64(X, Y, Z, PtOrig, VtX, VtY, VtZ, dCoeffX, dCoeffY, dCoeffZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorMirror")>
|
|
Private Function EgtVectorMirror_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorMirror")>
|
|
Private Function EgtVectorMirror_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtVectorMirror(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorMirror_32(X, Y, Z, VtNorm)
|
|
Else
|
|
Return EgtVectorMirror_64(X, Y, Z, VtNorm)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorShear")>
|
|
Private Function EgtVectorShear_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorShear")>
|
|
Private Function EgtVectorShear_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
End Function
|
|
Private Function EgtVectorShear(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorShear_32(X, Y, Z, VtNorm, VtDir, dCoeff)
|
|
Else
|
|
Return EgtVectorShear_64(X, Y, Z, VtNorm, VtDir, dCoeff)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToGlob")>
|
|
Private Function EgtVectorToGlob_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToGlob")>
|
|
Private Function EgtVectorToGlob_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtVectorToGlob(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorToGlob_32(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
Else
|
|
Return EgtVectorToGlob_64(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToLoc")>
|
|
Private Function EgtVectorToLoc_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorToLoc")>
|
|
Private Function EgtVectorToLoc_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtVectorToLoc(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorToLoc_32(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
Else
|
|
Return EgtVectorToLoc_64(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorLocToLoc")>
|
|
Private Function EgtVectorLocToLoc_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtVectorLocToLoc")>
|
|
Private Function EgtVectorLocToLoc_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtVectorLocToLoc(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtVectorLocToLoc_32(X, Y, Z, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
Else
|
|
Return EgtVectorLocToLoc_64(X, Y, Z, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetVectorRotation")>
|
|
Private Function EgtGetVectorRotation_32(ByRef VtS As Vector3d, ByRef VtE As Vector3d, ByRef VtAx As Vector3d,
|
|
ByRef dAngRotDeg As Double, ByRef bDet As Boolean) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetVectorRotation")>
|
|
Private Function EgtGetVectorRotation_64(ByRef VtS As Vector3d, ByRef VtE As Vector3d, ByRef VtAx As Vector3d,
|
|
ByRef dAngRotDeg As Double, ByRef bDet As Boolean) As Boolean
|
|
End Function
|
|
Public Function EgtGetVectorRotation(ByRef VtS As Vector3d, ByRef VtE As Vector3d, ByRef VtAx As Vector3d,
|
|
ByRef dAngRotDeg As Double, ByRef bDet As Boolean) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtGetVectorRotation_32(VtS, VtE, VtAx, dAngRotDeg, bDet)
|
|
Else
|
|
Return EgtGetVectorRotation_64(VtS, VtE, VtAx, dAngRotDeg, bDet)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointTranslate")>
|
|
Private Function EgtPointTranslate_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtMove As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointTranslate")>
|
|
Private Function EgtPointTranslate_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtMove As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtPointTranslate(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef VtMove As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointTranslate_32(X, Y, Z, VtMove)
|
|
Else
|
|
Return EgtPointTranslate_64(X, Y, Z, VtMove)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointRotate")>
|
|
Private Function EgtPointRotate_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointRotate")>
|
|
Private Function EgtPointRotate_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
Private Function EgtPointRotate(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointRotate_32(X, Y, Z, PtAx, VtAx, dAngRotDeg)
|
|
Else
|
|
Return EgtPointRotate_64(X, Y, Z, PtAx, VtAx, dAngRotDeg)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointScale")>
|
|
Private Function EgtPointScale_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointScale")>
|
|
Private Function EgtPointScale_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
End Function
|
|
Private Function EgtPointScale(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByVal dCoeffX As Double, ByVal dCoeffY As Double, ByVal dCoeffZ As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointScale_32(X, Y, Z, PtOrig, VtX, VtY, VtZ, dCoeffX, dCoeffY, dCoeffZ)
|
|
Else
|
|
Return EgtPointScale_64(X, Y, Z, PtOrig, VtX, VtY, VtZ, dCoeffX, dCoeffY, dCoeffZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointMirror")>
|
|
Private Function EgtPointMirror_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointMirror")>
|
|
Private Function EgtPointMirror_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtPointMirror(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOn As Point3d, ByRef VtNorm As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointMirror_32(X, Y, Z, PtOn, VtNorm)
|
|
Else
|
|
Return EgtPointMirror_64(X, Y, Z, PtOn, VtNorm)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointShear")>
|
|
Private Function EgtPointShear_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointShear")>
|
|
Private Function EgtPointShear_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
End Function
|
|
Private Function EgtPointShear(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOn As Point3d, ByRef VtNorm As Vector3d, ByRef VtDir As Vector3d, ByVal dCoeff As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointShear_32(X, Y, Z, PtOn, VtNorm, VtDir, dCoeff)
|
|
Else
|
|
Return EgtPointShear_64(X, Y, Z, PtOn, VtNorm, VtDir, dCoeff)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToGlob")>
|
|
Private Function EgtPointToGlob_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToGlob")>
|
|
Private Function EgtPointToGlob_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtPointToGlob(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointToGlob_32(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
Else
|
|
Return EgtPointToGlob_64(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToLoc")>
|
|
Private Function EgtPointToLoc_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointToLoc")>
|
|
Private Function EgtPointToLoc_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtPointToLoc(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointToLoc_32(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
Else
|
|
Return EgtPointToLoc_64(X, Y, Z, PtOrig, VtX, VtY, VtZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointLocToLoc")>
|
|
Private Function EgtPointLocToLoc_32(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtPointLocToLoc")>
|
|
Private Function EgtPointLocToLoc_64(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtPointLocToLoc(ByRef X As Double, ByRef Y As Double, ByRef Z As Double,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtPointLocToLoc_32(X, Y, Z, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
Else
|
|
Return EgtPointLocToLoc_64(X, Y, Z, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameFrom3Points")>
|
|
Private Function EgtFrameFrom3Points_32(ByRef PtO As Point3d, ByRef PtOnX As Point3d, ByRef PtOnY As Point3d,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameFrom3Points")>
|
|
Private Function EgtFrameFrom3Points_64(ByRef PtO As Point3d, ByRef PtOnX As Point3d, ByRef PtOnY As Point3d,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtFrameFrom3Points(ByRef PtO As Point3d, ByRef PtOnX As Point3d, ByRef PtOnY As Point3d,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameFrom3Points_32(PtO, PtOnX, PtOnY, PtOrig, VtX, VtY, VtZ)
|
|
Else
|
|
Return EgtFrameFrom3Points_64(PtO, PtOnX, PtOnY, PtOrig, VtX, VtY, VtZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameOCS")>
|
|
Private Function EgtFrameOCS_32(ByRef PtO As Point3d, ByRef VtDirZ As Vector3d,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameOCS")>
|
|
Private Function EgtFrameOCS_64(ByRef PtO As Point3d, ByRef VtDirZ As Vector3d,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtFrameOCS(ByRef PtO As Point3d, ByRef VtDirZ As Vector3d,
|
|
ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameOCS_32(PtO, VtDirZ, PtOrig, VtX, VtY, VtZ)
|
|
Else
|
|
Return EgtFrameOCS_64(PtO, VtDirZ, PtOrig, VtX, VtY, VtZ)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameTranslate")>
|
|
Private Function EgtFrameTranslate_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef VtMove As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameTranslate")>
|
|
Private Function EgtFrameTranslate_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef VtMove As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtFrameTranslate(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef VtMove As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameTranslate_32(PtOrig, VtX, VtY, VtZ, VtMove)
|
|
Else
|
|
Return EgtFrameTranslate_64(PtOrig, VtX, VtY, VtZ, VtMove)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameRotate")>
|
|
Private Function EgtFrameRotate_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameRotate")>
|
|
Private Function EgtFrameRotate_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
End Function
|
|
Private Function EgtFrameRotate(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtAx As Point3d, ByRef VtAx As Vector3d, ByVal dAngRotDeg As Double) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameRotate_32(PtOrig, VtX, VtY, VtZ, PtAx, VtAx, dAngRotDeg)
|
|
Else
|
|
Return EgtFrameRotate_64(PtOrig, VtX, VtY, VtZ, PtAx, VtAx, dAngRotDeg)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameToGlob")>
|
|
Private Function EgtFrameToGlob_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameToGlob")>
|
|
Private Function EgtFrameToGlob_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtFrameToGlob(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameToGlob_32(PtOrig, VtX, VtY, VtZ, PtO1, VtX1, VtY1, VtZ1)
|
|
Else
|
|
Return EgtFrameToGlob_64(PtOrig, VtX, VtY, VtZ, PtO1, VtX1, VtY1, VtZ1)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameToLoc")>
|
|
Private Function EgtFrameToLoc_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameToLoc")>
|
|
Private Function EgtFrameToLoc_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtFrameToLoc(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameToLoc_32(PtOrig, VtX, VtY, VtZ, PtO1, VtX1, VtY1, VtZ1)
|
|
Else
|
|
Return EgtFrameToLoc_64(PtOrig, VtX, VtY, VtZ, PtO1, VtX1, VtY1, VtZ1)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameLocToLoc")>
|
|
Private Function EgtFrameLocToLoc_32(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtFrameLocToLoc")>
|
|
Private Function EgtFrameLocToLoc_64(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtFrameLocToLoc(ByRef PtOrig As Point3d, ByRef VtX As Vector3d, ByRef VtY As Vector3d, ByRef VtZ As Vector3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtFrameLocToLoc_32(PtOrig, VtX, VtY, VtZ, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
Else
|
|
Return EgtFrameLocToLoc_64(PtOrig, VtX, VtY, VtZ, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtBBoxToGlob")>
|
|
Private Function EgtBBoxToGlob_32(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtBBoxToGlob")>
|
|
Private Function EgtBBoxToGlob_64(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtBBoxToGlob(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtBBoxToGlob_32(PtMin, PtMax, PtO1, VtX1, VtY1, VtZ1)
|
|
Else
|
|
Return EgtBBoxToGlob_64(PtMin, PtMax, PtO1, VtX1, VtY1, VtZ1)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtBBoxToLoc")>
|
|
Private Function EgtBBoxToLoc_32(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtBBoxToLoc")>
|
|
Private Function EgtBBoxToLoc_64(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtBBoxToLoc(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtBBoxToLoc_32(PtMin, PtMax, PtO1, VtX1, VtY1, VtZ1)
|
|
Else
|
|
Return EgtBBoxToLoc_64(PtMin, PtMax, PtO1, VtX1, VtY1, VtZ1)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtBBoxLocToLoc")>
|
|
Private Function EgtBBoxLocToLoc_32(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtBBoxLocToLoc")>
|
|
Private Function EgtBBoxLocToLoc_64(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
End Function
|
|
Private Function EgtBBoxLocToLoc(ByRef PtMin As Point3d, ByRef PtMax As Point3d,
|
|
ByRef PtO1 As Point3d, ByRef VtX1 As Vector3d, ByRef VtY1 As Vector3d, ByRef VtZ1 As Vector3d,
|
|
ByRef PtO2 As Point3d, ByRef VtX2 As Vector3d, ByRef VtY2 As Vector3d, ByRef VtZ2 As Vector3d) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtBBoxLocToLoc_32(PtMin, PtMax, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
Else
|
|
Return EgtBBoxLocToLoc_64(PtMin, PtMax, PtO1, VtX1, VtY1, VtZ1, PtO2, VtX2, VtY2, VtZ2)
|
|
End If
|
|
End Function
|
|
|
|
|
|
'---------- Messages -----------------------------------------------------------
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtLoadMessages")>
|
|
Private Function EgtLoadMessages_32(ByVal sMsgFilePath As String) As Boolean
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtLoadMessages")>
|
|
Private Function EgtLoadMessages_64(ByVal sMsgFilePath As String) As Boolean
|
|
End Function
|
|
Public Function EgtLoadMessages(ByVal sMsgFilePath As String) As Boolean
|
|
If IntPtr.Size = 4 Then
|
|
Return EgtLoadMessages_32(sMsgFilePath)
|
|
Else
|
|
Return EgtLoadMessages_64(sMsgFilePath)
|
|
End If
|
|
End Function
|
|
|
|
<DllImport(EgtIntDll32, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMsg")>
|
|
Private Function EgtGetMsg_32(ByVal nId As Integer) As IntPtr
|
|
End Function
|
|
<DllImport(EgtIntDll64, CharSet:=CharSet.Unicode, EntryPoint:="EgtGetMsg")>
|
|
Private Function EgtGetMsg_64(ByVal nId As Integer) As IntPtr
|
|
End Function
|
|
Public Function EgtMsg(ByVal nId As Integer) As String
|
|
If IntPtr.Size = 4 Then
|
|
Return Marshal.PtrToStringUni(EgtGetMsg_32(nId))
|
|
Else
|
|
Return Marshal.PtrToStringUni(EgtGetMsg_64(nId))
|
|
End If
|
|
' Non è necessario liberare la memoria nativa perchè usa un buffer statico
|
|
End Function
|
|
|
|
|
|
'---------- Costanti -----------------------------------------------------------
|
|
'Costanti : GEOMETRIA
|
|
Public Const ONEMM As Double = 1.0
|
|
Public Const ONEINCH As Double = 25.4
|
|
Public Const EPS_SMALL As Double = 0.001
|
|
Public Const EPS_ZERO As Double = 0.0000001
|
|
Public Const EPS_ANG_SMALL As Double = 0.001
|
|
Public Const INFINITO As Double = 10000000000.0
|
|
Public Const EPS_STM As Double = 0.05
|
|
Public Const EPS_STM_DRAG As Double = 0.5
|
|
'Costanti : TIPO DI FILE
|
|
Public Enum FT As Integer
|
|
NULL = 0
|
|
NGE = 1
|
|
NFE = 2
|
|
DXF = 11
|
|
STL = 12
|
|
CNC = 13
|
|
CSF = 14
|
|
BTL = 15
|
|
TSC = 101
|
|
LUA = 102
|
|
End Enum
|
|
'Costanti : FORMATO FILE NGE
|
|
Public Enum NGE As Integer
|
|
TEXT = 0
|
|
BIN = 1
|
|
CMPTEXT = 2
|
|
End Enum
|
|
'Costanti : ID GEOMDB
|
|
Public Enum GDB_ID As Integer
|
|
ROOT = 0
|
|
NULL = -1
|
|
SEL = -2
|
|
GRID = -3
|
|
CURRPART = -4
|
|
CURRLAYER = -5
|
|
End Enum
|
|
'Costanti : TIPO OGGETTI
|
|
Public Enum GDB_TY As Integer
|
|
NONE = 0
|
|
GROUP = 2
|
|
GEO_VECTOR = 128
|
|
GEO_POINT = 129
|
|
GEO_FRAME = 130
|
|
CRV_LINE = 256
|
|
CRV_ARC = 257
|
|
CRV_BEZ = 258
|
|
CRV_COMPO = 259
|
|
SRF_MESH = 512
|
|
SRF_FRGN = 513
|
|
VOL_ZMAP = 1024
|
|
EXT_TEXT = 2048
|
|
End Enum
|
|
'Costanti : TIPO RIFERIMENTO DI DATI GEOMETRICI
|
|
Public Enum GDB_RT As Integer
|
|
GLOB = 0
|
|
GRID = -3
|
|
LOC = -6
|
|
End Enum
|
|
'Costanti : POSIZIONE DI COPIA DI UN OGGETTO
|
|
Public Enum GDB_POS As Integer
|
|
FIRST_SON = 0
|
|
LAST_SON = 1
|
|
BEFORE = 2
|
|
AFTER = 3
|
|
End Enum
|
|
'Costanti : LIVELLO DI UN OGGETTO
|
|
Public Enum GDB_LV As Integer
|
|
USER = 1
|
|
SYSTEM = 2
|
|
TEMP = 3
|
|
End Enum
|
|
'Costanti : MODO DI UN OGGETTO
|
|
Public Enum GDB_MD As Integer
|
|
STD = 1
|
|
LOCKED = 2
|
|
HIDDEN = 3
|
|
End Enum
|
|
'Costanti : STATO DI UN OGGETTO
|
|
Public Enum GDB_ST As Integer
|
|
OFF = 0
|
|
ON_ = 1
|
|
SEL = 2
|
|
End Enum
|
|
'Costanti : TIPO VISUALIZZAZIONE
|
|
Public Enum SM As Integer
|
|
WIREFRAME = 0
|
|
HIDDENLINE = 1
|
|
SHADING = 2
|
|
End Enum
|
|
'Costanti : TIPO ZOOM
|
|
Public Enum ZM As Integer
|
|
ALL = 1
|
|
IN_ = 2
|
|
OUT = 3
|
|
End Enum
|
|
'Costanti : TIPO VISTA
|
|
Public Enum VT As Integer
|
|
NONE = 0
|
|
TOP = 1
|
|
FRONT = 2
|
|
RIGHT = 3
|
|
BACK = 4
|
|
LEFT = 5
|
|
BOTTOM = 6
|
|
ISO_SW = 7
|
|
ISO_SE = 8
|
|
ISO_NE = 9
|
|
ISO_NW = 10
|
|
CPLANE = 11
|
|
End Enum
|
|
'Costanti : TIPO SNAP POINT
|
|
Public Enum SP As Integer
|
|
PT_NONE = 0
|
|
PT_SKETCH = 1
|
|
PT_GRID = 2
|
|
PT_END = 3
|
|
PT_MID = 4
|
|
CENTER = 5
|
|
CENTROID = 6
|
|
PT_NEAR = 7
|
|
PT_INTERS = 8
|
|
PT_TANGENT = 9
|
|
PT_PERPENDICULAR = 10
|
|
PT_MINDIST = 11
|
|
End Enum
|
|
'Costanti : TIPO SELECTED POINT
|
|
Public Enum SEP As Integer
|
|
PT_STD = 0
|
|
PT_TG = 1
|
|
PT_PERP = 2
|
|
PT_MINDIST = 3
|
|
End Enum
|
|
'Costanti : ripetizione texture
|
|
Public Enum TXR_REP As Integer
|
|
CLAMP = 0
|
|
REPEAT = 1
|
|
MIRROR = 2
|
|
End Enum
|
|
'Costanti : flag per BBOX
|
|
Public Enum GDB_BB As Integer
|
|
STANDARD = 0
|
|
ONLY_VISIBLE = 1
|
|
EXACT = 2
|
|
IGNORE_TEXT = 4
|
|
IGNORE_DIM = 8
|
|
End Enum
|
|
'Costanti : tipo di offset
|
|
Public Enum OFF_TYPE As Integer
|
|
FILLET = 0
|
|
CHAMFER = 1
|
|
EXTEND = 2
|
|
MEDIA_INTDZ = 4
|
|
FORCE_OPEN = 8
|
|
NO_VERTLINE = 16
|
|
End Enum
|
|
'Costanti : tipo di approssimazione di curva
|
|
Public Enum APP_TYPE As Integer
|
|
LINES = 0
|
|
LEFT_LINES = 1
|
|
RIGHT_LINES = 2
|
|
ARCS = 3
|
|
End Enum
|
|
'Costanti : posizione di inserimento per testi
|
|
Public Enum INS_POS As Integer
|
|
TL = 1
|
|
TC = 2
|
|
TR = 3
|
|
ML = 4
|
|
MC = 5
|
|
MR = 6
|
|
BL = 7
|
|
BC = 8
|
|
BR = 9
|
|
End Enum
|
|
'Costanti : interruzione di riga
|
|
Public Const LINE_BREAK As String = "<br/>"
|
|
'Costanti : tipo creazione pezzo piatto
|
|
Public Enum FPC_TYPE As Integer
|
|
NGE = 0
|
|
REGION = 1
|
|
LAYER = 2
|
|
CLOSEDCURVE = 3
|
|
End Enum
|
|
' Costanti : tipo interferenza lavorazioni piane con pezzi
|
|
Public Enum FMI_TYPE As Integer
|
|
NONE = 0
|
|
LI = 1
|
|
RM = 2
|
|
LO = 4
|
|
End Enum
|
|
'Costanti : posizione di inserimento grezzo su corner
|
|
Public Enum MCH_CR As Integer
|
|
TL = 1
|
|
TR = 2
|
|
BL = 3
|
|
BR = 4
|
|
End Enum
|
|
'Costanti : famiglie di utensili
|
|
Public Enum MCH_TF As Integer
|
|
DRILLBIT = 256
|
|
SAWBLADE = 512
|
|
MILL = 1024
|
|
MORTISE = 2048
|
|
COMPO = 4096
|
|
End Enum
|
|
'Costanti : tipi di utensili
|
|
Public Enum MCH_TY As Integer
|
|
NONE = 0
|
|
DRILL_STD = 256
|
|
DRILL_LONG = 257
|
|
SAW_STD = 512
|
|
SAW_FLAT = 513
|
|
MILL_STD = 1024
|
|
MILL_NOTIP = 1025
|
|
MORTISE_STD = 2048
|
|
COMPO = 4096
|
|
End Enum
|
|
'Costanti : parametri degli utensili
|
|
Public Enum MCH_TP As Integer
|
|
NONE = 0
|
|
CORR = 8192
|
|
EXIT_ = 8193
|
|
TYPE = 8194
|
|
COOLANT = 8195
|
|
CORNRAD = 16384
|
|
DIAM = 16385
|
|
TOTDIAM = 16386
|
|
FEED = 16387
|
|
ENDFEED = 16388
|
|
STARTFEED = 16389
|
|
TIPFEED = 16390
|
|
LEN = 16391
|
|
TOTLEN = 16392
|
|
MAXMAT = 16393
|
|
LONOFFSET = 16394
|
|
RADOFFSET = 16395
|
|
SPEED = 16396
|
|
SIDEANG = 16397
|
|
MAXSPEED = 16398
|
|
THICK = 16399
|
|
MAXABSORPTION = 16400
|
|
MINFEED = 16401
|
|
DRAW = 32768
|
|
HEAD = 32769
|
|
NAME = 32770
|
|
SYSNOTES = 32771
|
|
USERNOTES = 32772
|
|
TCPOS = 32773
|
|
UUID = 32774
|
|
End Enum
|
|
'Costanti : operazioni
|
|
Public Enum MCH_OY As Integer
|
|
NONE = 0
|
|
DISP = 256
|
|
DRILLING = 512
|
|
SAWING = 1024
|
|
MILLING = 2048
|
|
POCKETING = 4096
|
|
MORTISING = 8192
|
|
End Enum
|
|
'Costanti : tipi di lavorazioni (altre operazioni)
|
|
Public Enum MCH_MY As Integer
|
|
NONE = 0
|
|
DRILLING = MCH_OY.DRILLING
|
|
SAWING = MCH_OY.SAWING
|
|
MILLING = MCH_OY.MILLING
|
|
POCKETING = MCH_OY.POCKETING
|
|
MORTISING = MCH_OY.MORTISING
|
|
End Enum
|
|
'Costanti : parametri generali delle lavorazioni
|
|
Public Enum MCH_GP As Integer
|
|
NONE = 0
|
|
SAFEZ = 16384
|
|
EXTRALONCUTREG = 16385
|
|
EXTRARONDRIREG = 16386
|
|
HOLEDIAMTOLER = 16387
|
|
End Enum
|
|
'Costanti : parametri delle lavorazioni
|
|
Public Enum MCH_MP As Integer
|
|
NONE = 0
|
|
INVERT = 4096
|
|
LEAVETAB = 4097
|
|
TYPE = 8192
|
|
WORKSIDE = 8193
|
|
HEADSIDE = 8194
|
|
LEADINTYPE = 8195
|
|
EXTLINKTYPE = 8196
|
|
LEADOUTTYPE = 8197
|
|
CURVEUSE = 8198
|
|
STEPTYPE = 8199
|
|
TOOLSPEED = 16384
|
|
TOOLFEED = 16385
|
|
TOOLSTARTFEED = 16386
|
|
TOOLENDFEED = 16387
|
|
TOOLTIPFEED = 16388
|
|
TOOLOFFSR = 16389
|
|
TOOLOFFSL = 16390
|
|
DEPTH = 16391
|
|
SIDEANGLE = 16392
|
|
APPROX = 16393
|
|
STARTPOS = 16394
|
|
STARTSLOWLEN = 16395
|
|
ENDSLOWLEN = 16396
|
|
THROUADDLEN = 16397
|
|
STEP_ = 16398
|
|
RETURNPOS = 16399
|
|
OVERLAP = 16400
|
|
TABLEN = 16401
|
|
TABDIST = 16402
|
|
TABHEIGHT = 16403
|
|
TABANGLE = 16404
|
|
LITANG = 16405
|
|
LIPERP = 16406
|
|
LIELEV = 16407
|
|
LICOMPLEN = 16408
|
|
LOTANG = 16409
|
|
LOPERP = 16410
|
|
LOELEV = 16411
|
|
LOCOMPLEN = 16412
|
|
STARTADDLEN = 16413
|
|
ENDADDLEN = 16414
|
|
OFFSET = 16415
|
|
STEPEXTARC = 16416
|
|
STEPINTARC = 16417
|
|
NAME = 32768
|
|
TOOL = 32769
|
|
DEPTH_STR = 32770
|
|
TUUID = 32771
|
|
UUID = 32772
|
|
SYSNOTES = 32773
|
|
USERNOTES = 32774
|
|
OVERLAP_STR = 32775
|
|
OFFSET_STR = 32776
|
|
End Enum
|
|
'Costanti : lato di lavoro per il taglio
|
|
Public Enum MCH_SAW_WS As Integer
|
|
CENTER = 0
|
|
LEFT = 1
|
|
RIGHT = 2
|
|
End Enum
|
|
'Costanti : lato di posizionamento della testa per il taglio
|
|
Public Enum MCH_SAW_HS As Integer
|
|
LEFT = 1
|
|
RIGHT = 2
|
|
End Enum
|
|
'Costanti : tipi di attacco per il taglio
|
|
Public Enum MCH_SAW_LI As Integer
|
|
CENT = 0
|
|
STRICT = 1
|
|
OUT = 2
|
|
EXT_CENT = 3
|
|
EXT_OUT = 4
|
|
End Enum
|
|
'Costanti : tipi di link esterni per il taglio
|
|
Public Enum MCH_SAW_EL As Integer
|
|
CENT = 0
|
|
EXT_PREV = 1
|
|
EXT_NEXT = 2
|
|
EXT_BOTH = 3
|
|
End Enum
|
|
'Costanti : tipi di uscite per il taglio
|
|
Public Enum MCH_SAW_LO As Integer
|
|
CENT = 0
|
|
STRICT = 1
|
|
EXT = 2
|
|
End Enum
|
|
'Costanti : stato movimento di simulazione
|
|
Public Enum MCH_SIM As Integer
|
|
OK = 0
|
|
END_STEP = 1
|
|
END_ = 2
|
|
OUTSTROKE = 3
|
|
DIR_ERR = 4
|
|
ERR = 5
|
|
End Enum
|
|
'Costanti : stato visualizzazione macchina
|
|
Public Enum MCH_LOOK As Integer
|
|
TAB = 0
|
|
TAB_TOOL = 1
|
|
TAB_HEAD = 2
|
|
ALL = 3
|
|
End Enum
|
|
|
|
End Module
|