Das sieht mir etwas verunglückt aus. Denn dein Property-Editor ist für die Ausgabe und die Maus-Interaktion zuständig. Das ist schlecht, denn was machst deine Shape-Komponente zur normalen Laufzeit, wenn der Property-Editor gar nicht zur Verfügung steht?
Als erstes: warum ist TMyShape ein TObject und kein TGraphicControl oder TWinControl? Diese können sich selbst zeichnen und kennen die Maus, so dass du diesen Code in die Komponente verlagern kannst. Als Konsequenz kann sich dann TMyShape selbst um die Ausgabe auf seinem/ihrem eigenen Canvas und das Hinzufügen von Punkten kümmern. TMyShape hat wahrscheinlich eine Array-ähnliche Eigenschaft "Points" (oder so ähnlich) für die Polygon-Punkte. Zuständig für den Streaming-Mechanismus neuer Property-Typen ist die Methode DefineProperties, die die Schreib- und Lese-Methoden definiert, wie die Property-Daten in der lfm-Datei geschrieben/gelesen werden. Das Verfahren wird z.B. in dem Example-Projekt "widestringstreaming" durchgespielt, sowie in diversen LCL-Komponenten (TGridColumnTitle in grids). Auch TStrings hat ein DefineProperties. Da es wenig Sinn macht, die Punkt-Koordinaten binär in die lfm-Datei zuschreiben, müssen die von DefineProperties festgelegten Schreib-/Lesemethoden die Koordinaten in Strings umwandeln.
Ohne jetzt viel ausprobiert zu haben, hier die grobe Struktur:
Code: Alles auswählen
type
TMyshapePoints = array of TPoint;
TMyShape = class(TGraphicControl)
private
FPoints: TMyShapePoints;
procedure ReadPoints(Filer: TFiler);
procedure Writepoints(Filer: TFiler);
function GetPoint(AIndex: Integer): TPoint;
procedure Setpoint(AIndex: Integer; AValue: TPoint);
protected
procedure DefineProperties(Filer: TFiler); override;
procedure Paint; override;
procedure MouseDown(...); override;
procedure MouseMove(...); override;
procedure MouseUp(...); override;
...
published
property Points[Index: Integer]: TPoint read GetPoint write Setpoint;
end;
procedure TMyShape.DefineProperties(Filer: TFiler);
begin
inherited DefineProperties(Filer);
Filer.DefineProperty('Points', @ReadPoints, @WritePoints, true);
end;
procedure TMyShape.WritePoints(Writer: TWriter);
var
L: TStrings;
begin
L := TStringList.Create;
try
for i := 0 to High(FPoints) do
L.Add('%d,%d', [FPoints[i].X, FPoints[i].Y]);
L.WriteData(Writer);
finally
L.Free;
end;
end;
procedure TMyshape.ReadPoints(Reader: TReader);
var
L: TStrings;
sa: TStringArray;
begin
L := TStringList.Create;
try
L.ReadData(Reader);
Setlength(FPoints, L.Count);
for i := 0 to L.Count-1 do
begin
sa := L[i].Split(',');
FPoints[i].X := StrToInt(sa[0]);
FPoints[i].Y := StrToInt(sa[1]);
end;
finally
L.Free;
end;
end;
function TMyShape.GetPoint(AIndex: Integer): TPoint;
begin
Result := FPoints[AIndex];
end;
procedure TMyShape.Setpoint(AIndex: Integer; AValue: TPoint);
begin
FPoints[AIndex] := AValue;
end;
Wenn du dann später die Punkte zur Designzeit eingeben willst, brauchst du einen PropertyEditor für TMyshapePoints (ich sehe gerade: möglicherweise muss die Eigenschaft Points als TMyShapePoints deklariert sein...). Ähnlich wie du es schon gemacht hast, erzeugt der ein eigenes Formular, in dem eine Instanz von TMyShape kreiert wird. Mit den Methoden von TMyShape wird diese Instanz gezeichnet, und mit den Mausmethoden werden neue Punkte hinzugefügt usw. Das ganze ist relativ kompliziert und wenig dokumentiert... Am besten du siehst dir die bereits bestehenden PropertyEditoren in der Unit PropEdits an
[EDIT]
Eine andere Variante fällt mir noch ein, nämlich die Punkte nicht in einem dynamischen Array sondern in einer Collection zu speichern. TCollection und Nachfahren sind sowas wie TList oder meinetwegen auch ein Array, aber halt integriert in die IDE. Die einzige Grundbedingung ist, dass die Collection-Items Nachfahren von TCollectionItem sein müssen, das heißt du musst eine Wrapper-Klasse für TPoint schreiben. Aber ansonsten ist alles fertig, auch die Integration in den Objekt-Inspektor. DefineProperties ist nicht mehr nötig.
Code: Alles auswählen
type
TPointCollectionItem = class(TCollectionItem)
private
FPoint: TPoint;
function GetX: Integer;
function GetY: Integer;
procedure SetX(Value: Integer);
procedure SetY(Value: Integer);
public
procedure Assign(ASource: TPersistent); override;
published
property Point: TPoint read FPoint write FPoint;
property X: Integer read GetX write SetX;
property Y: Integer read GetY write SetY;
end;
TPointCollection = class(TCollection)
private
function GetItem(AIndex: Integer): TPointCollectionItem;
procedure SetItem(AIndex: Integer; AValue: TPointCollectionItem);
public
constructor Create;
property Items[AIndex: Integer]: TPointCollectionItem read Getitem write SetItem;
end;
procedure TPointCollectionItem.Assign(ASource: TPersistent);
begin
if ASource is TPointCollectionItem then
begin
FPoint := ASource.Point;
inherited Assign(ASource);
end else
raise Exception.Create('Assign funktioniert nur für TPointCollectionItem');
end;
function TPointCollectionItem.GetX: Integer;
begin
Result := FPoint.X;
end;
procedure TPointCollectionItem.SetX(Value: Integer);
begin
FPoint.X := Value;
end;
constructor TPointCollection.Create;
begin
inherited Create(TPointCollectionItem);
end;
function TPointCollection.GetItem(AIndex: Integer): TPointCollectionItem;
begin
Result := TPointCollectionItem(inherited GetItem(AIndex));
end;
procedure TPointCollection.SetItem(AIndex: Integer; AValue: TPointCollectionItem);
begin
inherited SetItem(AIndex, AValue);
end;
).
Verein
Links
Suche