Problem mit Variant

[ede57]

habe folgendes problem

Delphi-Quellcode:

// Bohrungs Shape
// Setze Shape
procedure THoleShape.Set_BodyShape(Value:Variant);

Var
  FPosArray  : OleVariant;
  FPosValues : Array[0..2] of Double;
  i          : Integer;
  tta        : tVarType;
  S : string;

begin
   FBodyShape := Value;
// Art der Bohrung
   BohrungsType := FBodyShape.Type;
// Setze Durchmesser
   Diameter := FBodyShape.Diameter.Value;
//Variantes Array erzeugen
   FPosArray := VarArrayOf([FPosValues[ 0],FPosValues[ 1],FPosValues[ 2]]);
   TTA  := vartype(FPosArray[0]); // zeigt 5 an als Double alles OK
   TTA  := vartype(FPosArray[1]);
   TTA  := vartype(FPosArray[2]);
// Abfrage
   FBodyShape.GetOrigin(FPosArray);
// 
   TTA  := vartype(FPosArray[0]); // zeigt 5 an als Double alles OK
   TTA  := vartype(FPosArray[1]);
   TTA  := vartype(FPosArray[2]);
// 
   S := varTypeAsString(FPosArray[0]); // zeigt $00Af an = 175

// Positionen
// sollte 175 - 275 - 0 rauskommen
   FXpos :=  FPosArray[0]; // keine Werte
   FYpos :=  FPosArray[1];
   FZpos :=  0;
end;

die Funktion in der TLB ist folgend

Delphi-Quellcode:

  
  HoleDisp = dispinterface
   ...
   ....
  procedure GetOrigin(ioOrigin: {??PSafeArray}OleVariant); dispid 1611071508;
   ...
   ....

ioOrigion ist als SafeArrayVariant als Double definiert

Es werden nur unsinnige werte oder nur 0 werte zurückgegeben
Vielleicht hat ja jemand eine lösung

[mashutu]

Sorry, aber ich fuerchte Du musst die Frage noch einmal stellen. Und zwar ausfuehrlicher, denn aus Deinem code geht nicht hervor was er machen soll und somit auch nicht, was schief laeuft. Ich gehe trotzdem mal darauf ein:

Delphi-Quellcode:

// Bohrungs Shape
// Setze Shape
procedure THoleShape.Set_BodyShape(Value:Variant);

Var
  FPosArray  : OleVariant;
  FPosValues : Array[0..2] of Double;
  i          : Integer;
  tta        : tVarType;
  S : string;

begin
   FBodyShape := Value;                         // nicht deklariert. Was ist das?
// Art der Bohrung
   BohrungsType := FBodyShape.Type;             // Auch nicht deklariert... und dann eine property namens 'type' Aua!
// Setze Durchmesser
   Diameter := FBodyShape.Diameter.Value;       // -"-

//Variantes Array erzeugen
   FPosArray := VarArrayOf([FPosValues[ 0],FPosValues[ 1],FPosValues[ 2]]);    //Da steht jetzt erst mal Muell drin oder?
   TTA  := vartype(FPosArray[0]); // zeigt 5 an als Double alles OK            //warum sollte es 5 anzeigen?
   TTA  := vartype(FPosArray[1]);                                              //Dann war die erste Zuweisung auf TTA umsonst, wenn Du das hier wieder ueberschreibst
   TTA  := vartype(FPosArray[2]);                                              //-"-
// Abfrage
   FBodyShape.GetOrigin(FPosArray);                                            //Was macht die Anweisung?
// 
   TTA  := vartype(FPosArray[0]); // zeigt 5 an als Double alles OK            //s.o.
   TTA  := vartype(FPosArray[1]);
   TTA  := vartype(FPosArray[2]);
// 
   S := varTypeAsString(FPosArray[0]); // zeigt $00Af an = 175                //hab ich was nicht mitbekommen? wi sollen die 175 herkommen

// Positionen
// sollte 175 - 275 - 0 rauskommen
   FXpos :=  FPosArray[0]; // keine Werte
   FYpos :=  FPosArray[1];
   FZpos :=  0;
end;

die Funktion in der TLB ist folgend

Delphi-Quellcode:

  
  HoleDisp = dispinterface
   ...
   ....
  procedure GetOrigin(ioOrigin: {??PSafeArray}OleVariant); dispid 1611071508;
   ...
   ....

ioOrigion ist als SafeArrayVariant als Double definiert

Es werden nur unsinnige werte oder nur 0 werte zurückgegeben
Vielleicht hat ja jemand eine lösung[/quote]
Frage: wo werden denn die Deiner Meinung nach unsinnigen Werte zurueckgegeben?
Oder anders herum wo macht welche Funktion etwas, das sinnvolle WErte zurueckgeben koennte?

Ich kapiers einfach nicht.

[ede57]

Also ncoh mal die Frage Stellung :oops:

Probleme mit Korrekten Rückgabe werten eines Varianten Arrays

Delphi-Quellcode:

// Bohrungs Shape
// Setze Shape
procedure THoleShape.Set_BodyShape(Value:Variant);

Var
  FPosArray  : OleVariant;
  FPosValues : Array[0..2] of Double;
  i          : Integer;
  tta        : tVarType;
  S : string;

begin
// Lokale Variant Variable im Object THoleShape
   FBodyShape := Value;
// Art der Bohrung
   BohrungsType := FBodyShape.Type; // Type ist in Interface so definiert
// Setze Durchmesser
   Diameter := FBodyShape.Diameter.Value; // Durchmesser der Bohrung im Unterobejct Diameter ist OK
                                          // wird auch Korrekt ausgelesen
//Variantes Array erzeugen
   FPosArray := VarArrayOf([FPosValues[ 0],FPosValues[ 1],FPosValues[ 2]]);
 // zeigt 5 an als Double alles OK weil Typen vom Array = varDouble - TTA ist nur zum Test
   TTA  := vartype(FPosArray[0]); 
   TTA  := vartype(FPosArray[1]);
   TTA  := vartype(FPosArray[2]);
// Abfrage - übergabe vom Array an 
// procedure GetOrigin(ioOrigin: {??PSafeArray}OleVariant); dispid 1611071508; im Ole Server
// ioOrigion ist laut Hilfe als SafeArrayVariant mit 3 Doublewerten definiert
// Übergabe des Arrays und das Array sollte mit werten gefüllt werden
   FBodyShape.GetOrigin(FPosArray);
// noch mal Array prüfen
   TTA  := vartype(FPosArray[0]); //TTA zeigt 5 an als varDouble alles OK
   TTA  := vartype(FPosArray[1]);
   TTA  := vartype(FPosArray[2]);
// S = Sollte eigentlich Double anzeigen - nur test
   S := varTypeAsString(FPosArray[0]); // zeigt $00Af an = 175

// Die 3 korrekten Bohrungs-Positionen der Bohrung sollten jetzt im Array sein
// sollte 175 - 275 - 0 rauskommen aber alle werte sind 0
   FXpos :=  FPosArray[0]; // keine Werte
   FYpos :=  FPosArray[1];
   FZpos :=  0;
end;

Das problem liegt nur in Rückgabe von den Korrekten werten im Varianten ARRAY
Alle anderen werte können vom Automatisierung-Server (Catia V5) ausgelesen werden

[sirius]

Also, was du übergibst klappt, und was du zrückbekommst klappt nicht?

[ede57]

Ich kann das Array vorher auch mit werten füllen
Nach der Abfrage sind in dem array die gleichen Werte enthalten
Wurden also nicht geändert bz. zurückgegeben.

[sirius]

Wie sieht den die Definiton von GetOrigin aus?

[ede57]

Laut Hilfe so :

Sub GetOrigin( CATSafeArrayVariant ioOrigin)
Returns the origin point which the hole is anchored to.
This point belongs to a tangent plane.
Returns:
oOrigin A Safe Array made up of 3 doubles : X, Y, Z - Hole origin point coordinates
Example:
The following example returns in coordArray the coordinates of hole firstHole:

Call firstHole.GetOrigin coordArray
Set x = coordArray[1]
Set y = coordArray[2]
Set z = coordArray[3]

Ein SafeArray ist so beschrieben:

Defines a CATSafeArrayVariant type to be used by Automation interfaces.
CATSafeArrayVariant are one-dimensional arrays of CATVariants.

[sirius]

Und wenn du dir ein PSafeArray zurückgeben lässt?

[ede57]

Es gibt leider keine Funktion die ein PSafeArray zurückgibt

Wenn ich ein Seblst erzeugtes PSafeArray übergebe
dann kommt die Meldung "TypKonlikt"

Die Funktion meckert ja nicht wenn wenn ein
"Variant array of Variant" (was mit VarArrayOf erzeugt wird)
übergeben wird.

Wenn ich das Array mit werten fülle, sind nach aufruf der Funktion
immer nocht die Selben werte drinne. Es wird vom OleServer nichts eingetragen.

[Uwe Raabe]

Zitat:

Zitat von ede57

Laut Hilfe so :

Sub GetOrigin( CATSafeArrayVariant ioOrigin)
Returns the origin point which the hole is anchored to.
This point belongs to a tangent plane.
Returns:
oOrigin A Safe Array made up of 3 doubles : X, Y, Z - Hole origin point coordinates
Example:
The following example returns in coordArray the coordinates of hole firstHole:

Call firstHole.GetOrigin coordArray
Set x = coordArray[1]
Set y = coordArray[2]
Set z = coordArray[3]

Ein SafeArray ist so beschrieben:

Defines a CATSafeArrayVariant type to be used by Automation interfaces.
CATSafeArrayVariant are one-dimensional arrays of CATVariants.

Ich interpretiere das so, daß ein SafeArray zurückgegeben wird, der Server also selbst für die Initialisierung der OleVariant zuständig ist. Versuch also mal den übergebenen Parameter vor dem Aufruf auf unassigned zu setzen. Vielleicht stört sich Catia ja an dem aktuellen Inhalt. Nach dem Aufruf mal mit VarIsArray prüfen, ob es was gebracht hat.

[ede57]

Also wenn ich ein den Parameter als Unassigned übergebe
sagt Catia falscher variablen Typ

Mit VB funktioniert es so :

Dim P (3) as Variant

dann kann ich mit z.b. Wert = p(3) auf die werte zugreifen
und es funktioniert. Bloß mit Delphi funzt es nicht

[sirius]

Ja, Delphi hat leider eine eigene Implementation über das SafeArray gesetzt (ist jetzt die Frage, ob das SafeArray oder das VarArray eher war). Bisher habe ich dann immer das die WinAPI-Funktionen zum SafeArray genutzt und nicht die VarArray-Sachen von Delphi.

Zitat:

Wenn ich ein Seblst erzeugtes PSafeArray übergebe
dann kommt die Meldung "TypKonlikt"

Das hat noch nichts zu sagen. Manchmal muss man das umgehen.

Kannst du einen Pointer übergeben? (unabhängig davon, ob dann ein sinnvoler Inhalt zurückkommt)

[ede57]

Nein !

Sobald irgendwas anderes übergeben wird kommen Meldungen
wie " TypKonflikt" oder "Arguemnt nicht erlaubt"

bei der Übergabe wird ja sonst nicht gemeckert, bloß es kommen nicht die
werte raus die es sein sollen

In VB funktioniert es ja alles, dann sollte es ja auch
in Delphi Funktionieren. Oder ?? :evil:

[sirius]

Ja, sollte es. Und wird es auch.

Kannst du mal die *_TLB.Pas anhängen?

[ede57]

Im anghang die tlb.pas datei.

Auf alle daten in den Objecten kann man ja zugreifen
bloß nicht auf diese verdammten Arrays
Wenn man ein Array(An einer anderen stelle) und mit werten füllt
werden die werte auch angenommen.

[sirius]

Kannst du anstatt "HoleDisp" auch das Interface "Hole" verwenden. Dort wird ja eindeutig ein PSafeArray übergeben.

Das PSafeArray ist übrigens in deinem VarArray drin gespeichert. Delphi setzt quasi auf das SafeArray seine Struktur nochmal drauf (ähnlich wie beo OleVariant)
Vielleicht versuchst du TVarData(malFPosArray).vArray als Pointer zu übergeben.

[ede57]

Im interface Hole ist eine PsafeArray

Wenn ich eine Variable von Hole erzeuge meckert Delphi rum

E2010: Inkompatible Typen: Hole und Olevariant

in einem Script mit VB funtioniert es ja

DIM FPosValue(3) as Variant
dann die funktion FBodyShape.GetOrigin(FposValue) aufrufen
und alle werte sind eingetragen

[sirius]

VB und SafeArray sind ja beide Microsoft-Erfindungen. Die funktionieren natürlich problemlos miteinander. Ist genauso, als würdest du eine DLL mit einem Delphi-typischen String anbieten. Damit hätten auch alle anderen Programmiersprachen Probleme (deswegen macht man sowas ja auch nicht).

In Delphi ist ein VarArray ein wenig anders als ein reines SafeArray. Du musst eben einfach nur wissen, welchen Teil die jetzt genau wollen (oleVariant sagt ja leider nichts aus).

Zitat:

E2010: Inkompatible Typen: Hole und Olevariant

???
Ich meine -> FBodyShape als Hole

[ede57]

Es ist egal was ich mache es gibt immer die meldung
" Typkonflikt " oder
"Inkompatible typen"

An einer anderen Stelle im Programm übergeb ich auch ein Array der gleichen
Art mit werten. Die werte kommen alle Korrekt rüber.
Wenn ich die Werte auf null setze und dann wieder auslese
bleiben die Werte null.

Delphi-Quellcode:

 
 Move = interface(AnyObject)
    ['{8DB9CA92-9403-11D1-A5E2-00A0C95AF74C}']
    function Get_MovableObject: Move; safecall;
    procedure Apply([u]iTransformationArray: PSafeArray[/u]); safecall;
    property MovableObject: Move read Get_MovableObject;
  end;

Irgendwie scheint die Funktion im Interface nicht Korrekt zu sein
Leider kann ich kein C++ womit ich es auch ausprobieren könnte.

[ede57]

Habe alles gegeben
Habe ein Testproject mit C++ Builder 2007 erstellt
----- C++ Code

Variant CatApp;
Variant CatDocList;
Variant CatDoc;
Variant CatDocPart;
Variant CatDocBodies;
Variant CatBodiesBody;
Variant CatBodieShapes;
Variant CatShape;
Variant ShapePoints;
double points[3];
int bounds[2] = {0,2};
unsigned short vx;
String name;
//---------------------------------------------------------
CatApp = GetActiveOleObject("Catia.Application");
CatDocList = CatApp.OlePropertyGet("Documents");
CatDoc = CatDocList.OleFunction("Item",1);
CatDocPart = CatDoc.OlePropertyGet("Part");
CatDocBodies = CatDocPart.OlePropertyGet("Bodies");
CatBodiesBody = CatDocBodies.OleFunction("Item",1);
CatBodieShapes = CatBodiesBody.OlePropertyGet("Shapes");
CatShape = CatBodieShapes.OleFunction("Item",3);
name = CatShape.OlePropertyGet("Name");
Memo1->Lines->Add(name); // its OK
ShapePoints = VarArrayCreate(bounds,1,varVariant);
// SafeArrayRedim(*ShapePoints.VArray,AB);
vx == TVarData(ShapePoints).VType; // its 0x200C
CatShape.OleFunction("getOrigin",ShapePoints);
vx == TVarData(ShapePoints).VType; // its 0x200C
points[0] = ShapePoints.GetElement(0);
Memo1->Lines->Add(FloatToStr(points[0])); // its 0 not 185
----------------------------

Keinen Erfolg :pale:

Dann habe ich jetzt das testproject mal mit Visaul Basic 2008 erstellt
----------VB Code
Private Testprocedure
Dim CatApp As Object
Dim catDocs As Object
Dim CatDoc As Object
Dim CatPart As Object
Dim CatBodies As Object
Dim CatBody As Object
Dim CatbodyShapes As Object
Dim CatShape As Object
Dim name As String
Dim BPoints(3) As Object
;-----------------------------------------
CatApp = CreateObject("Catia.Application")
catDocs = CatApp.Documents
CatDoc = catDocs.Item(1)
CatPart = CatDoc.Part
CatBodies = CatPart.Bodies
CatBody = CatBodies.Item(1)
CatbodyShapes = CatBody.Shapes
CatShape = CatbodyShapes.Item(3)
name = CatShape.name
ListBox1.Items.Add(name)
CatShape.GetOrigin(BPoints)
ListBox1.Items.Add(FormatNumber(BPoints(0)))
ListBox1.Items.Add(FormatNumber(BPoints(1)))
ListBox1.Items.Add(FormatNumber(BPoints(2)))
End Sub
----------VB Code
Kann alle Werte Ohne Probleme auslesen :-D
Warum nicht mit Delphi 2007 oder C++ Builder 2007 :gruebel: