Hallo @All (bin neu hier) und hab gleich ne Frage.

Ich schreibe seit geraumer Zeit an ein paar Komponenten rum. Da ich für eine Firma arbeite, die Schwerlasttransporter (genauer gesagt sog. SSC - Ship-Section-Carrier so ab 300t Last aufwärts) herstellt, will ich die Transporter als Delphi-Komponenten schreiben.

Für Interessierte : TITAN-Elevating Transporter

Pi Mal Daumen aufbau der Struktur.....

1.) TArea [Zeichenfläche abgeleitet von TPaintBox32 des Graphics32 Package] u.a. mit PROPERTY TPoleItems (TCollection) hält die u.a. die Komponente TPole (TComponent).

2.) TPole(TComponent) [ist für die Steuerung der einzelnen Achsen eines Transporters / Transporterverbandes zuständig]
und hält u.a. die PROPERTY TTransporterItems (TCollection) welche die einzelnen TTransporter (TComponent) hält...

3.) ..um es kurz zu halten, hat jeder Transporter wieder eine Collection die die einzelen Achsen hält.

Das ganze sieht dann in der IDE so aus (hier nur ein Transporter dargestellt):

http://www.djbommel.de/Pictures/BILD-IDE.jpg

Als fertiges Proggi (hier nur ein Test Projekt - Darstellung Finit [Drehmomente]):

http://www.djbommel.de/Pictures/BILD-RUN.jpg

Nur zum Beispiel der INTERFACE teil der UNIT TTransporters.pas

zusammenfalten · markieren

Delphi-Quellcode:

UNIT TTransporters;

INTERFACE

{$R TTransporters.dcr}
{$REALCOMPATIBILITY ON}

USES
  TMasses,
  TAxles,
  TPoints,
  TAngles,
  TGeometrys,
  TitanConstants,
  Classes,
  Graphics;

TYPE

//----------------------------------------------------------------------------//
// TO KNOW THEM ALL //
//----------------------------------------------------------------------------//

   TTransporterItem = CLASS;
   TTransporterItemClass = CLASS OF TTransporterItem;
   TTransporterItems = CLASS;
   TTransporterItemsPtr = ^TTransporterItems;
   TTransporter = CLASS;

//----------------------------------------------------------------------------//
// TTransporterItem = CLASS(TCollectionItem) //
//----------------------------------------------------------------------------//

  TTransporterItem = CLASS(TCollectionItem)
  PRIVATE
    FItem : TTransporter;
  PROTECTED
    PROCEDURE DoOnChangeInt(Sender:TObject);
  PUBLIC
    CONSTRUCTOR Create(ACollection: TCollection); OVERRIDE;
    DESTRUCTOR Destroy; OVERRIDE;
    PROCEDURE SetItem(Item:TTransporter);
  PUBLISHED
    PROPERTY Index;
    PROPERTY Item:TTransporter READ FItem WRITE SetItem;
  END;

//----------------------------------------------------------------------------//
// TTransporterItems = CLASS(TCollection) //
//----------------------------------------------------------------------------//

  TTransporterItems = CLASS(TCollection)
  PRIVATE
    FOwner : TPersistent;
    FOnChangeInt : TNotifyEvent;
    FUNCTION GetItem(Index:Integer):TTransporterItem;
    PROCEDURE SetItem(Index:Integer;Value:TTransporterItem);
  PROTECTED
    FUNCTION GetOwner: TPersistent;
    PROCEDURE Update(Item: TCollectionItem); OVERRIDE;
    PROCEDURE SubmitChangeInternal(Sender:TObject);
  PUBLIC
    // Whole Class //
    CLASS PROCEDURE SetInternalNotificationOnly(VAR porter:TTransporterItems;Notifi:TNotifyEvent);
    // This Instance //
    CONSTRUCTOR Create(AOwner: TPersistent; ItemClass: TTransporterItemClass);
    DESTRUCTOR Destroy; OVERRIDE;
    FUNCTION Add:TTransporterItem;
    PROCEDURE CreateAddSet(AOwner:TComponent;VAR Porter:TTransporter);
    PROCEDURE UpdateOnBoundsChange;
    PROPERTY Items[Index:Integer]:TTransporterItem READ GetItem WRITE SetItem; //default;
  PUBLISHED
  END;

//----------------------------------------------------------------------------//
// TTransporter = CLASS(TComponent) //
//----------------------------------------------------------------------------//

  TTransporter = CLASS(TComponent)
  PRIVATE
    //-- For Handeling The Collection In TPoles ------------------------------//
    FCollection : TCollection;
    FIndex : INTEGER;
    //-- PUBLISHED PROPERTIES
    FAngle : TGlobalAngleClass;
    FAxles : TAxleItems;
    FCenter : TGlobalPointClass;
    FDriveMode : TDriveMode;
    FShow : BOOLEAN;
    FWidth : WORD;
    FLength : WORD;
    FPoleType : TPoleType;
    FRelativMin : TFloat;
    FRelativMax : TFloat;
    FFramePaint : TFramePaint;
    FFinitSize : INTEGER;
    FMasses : TMassItems;
    FSteerAxle : INTEGER;
    // SOME VARS
    FLastSelectedPnt : TNearestPoint;
    FDirVect : TDirectionVect;
    FSelectedAxle : Smallint;
    FShape : TShapeArray;
    FHalf : TGlobalPoint;
    FSelPoint : TShapePoint;
    FSelectedPnt : TShapePoint;
    FHoverPnt : TShapePoint;
    FLastChangedItem : TLastChangeingItem;
    FInternalCall : BOOLEAN;
    FIsMaster : BOOLEAN;
    // FINIT VARS
    FFinitX : INTEGER;
    FFinitY : INTEGER;
    FFinitForces : TFinitArray;
    FFinitForcesCol : TFinitForceColorArray;
    FFinitPoints : TFinitPointsArray;
    FDidFinitPoints : BOOLEAN;
    FDidFinitDist : BOOLEAN;
    FMaxFinitForce : TFloat;
    FMinFinitForce : TFloat;
    FFinitMode : TFinitMode;
    FColorMode : TColorMode;
    // COG VARS (NEEDS FINIT)
    FCOG : TTriplePoint;
    FHeights : THeightsArray;
    // NOTIFICATIONS
    FBeforeChangeInt : TNotifyEvent;
    FBeforeChangeExt : TNotifyEvent;
    FAfterChangeInt : TNotifyEvent;
    FAfterChangeExt : TNotifyEvent;
    FDoNotify : BOOLEAN;
  PROTECTED
    // NOTIFICATIONS
    FUNCTION GetBeforeChange:TNotifyEvent;
    PROCEDURE SetBeforeChange(Proc:TNotifyEvent);
    FUNCTION GetAfterChange:TNotifyEvent;
    PROCEDURE SetAfterChange(Proc:TNotifyEvent);
    PROCEDURE DoBeforeChangeNotifications;
    PROCEDURE DoAfterChangeNotifications;
    // PROPERTIES
    PROCEDURE SetPorterWidth(w:WORD);
    PROCEDURE SetPorterLength(l:WORD);
    PROCEDURE SetDriveMode(mode:TDriveMode);
    PROCEDURE SetSelectedAxle(axno:SMALLINT);
    PROCEDURE SetRelativMin(min:TFloat);
    PROCEDURE SetRelativMax(max:TFloat);
    PROCEDURE SetShow(bool:BOOLEAN);
    PROCEDURE SetFramePaint(FramePaintType:TFramePaint);
    PROCEDURE SetFinitSize(Size:INTEGER);
    PROCEDURE SetColorMode(mode:TColorMode);
    PROCEDURE SetFinitMode(mode:TFinitMode);
    FUNCTION GetHeights(group:TPressureGroup):TFloat;
    PROCEDURE SetHeights(group:TPressureGroup;Value:TFloat);
    PROCEDURE SetHeightA(Value:TFloat);
    PROCEDURE SetHeightB(Value:TFloat);
    PROCEDURE SetHeightC(Value:TFloat);
    PROCEDURE SetHeightD(Value:TFloat);
    // OTHER
    PROCEDURE SetVirginInternal;
    // FINIT CALCULATIONS
    PROCEDURE CalcFinit;
    PROCEDURE CalcAxleLoads;
    PROCEDURE CalcAxleMoments;
    PROCEDURE CalcFinitPointsArray;
    PROCEDURE CalcFinitDistanceArray(VAR AArray:TFinitArray;FromDistance:TGlobalPoint;VAR MaxDistance,SumDistance:EXTENDED);
    PROCEDURE CalcFinitForceArrayAxles;
    PROCEDURE CalcFinitForceArraySurface;
    PROCEDURE CalcFinitForceArrayCOG;
    PROCEDURE SearchMinMaxFinitForce;
    PROCEDURE DoFinitForceColors;
    // COG CALCULATIONS
    PROCEDURE CalcCOG;
    PROCEDURE CalcFrameTilt;
    // NOTIFICATION RECEIVE
    PROCEDURE TransporterRotationBeforeChange(Sender:TObject);
    PROCEDURE TransporterRotationAfterChange(Sender:TObject);
    PROCEDURE TransporterCenterBeforeChange(Sender:TObject);
    PROCEDURE TransporterCenterAfterChange(Sender:TObject);
    PROCEDURE AxleBeforeChange(Sender:TObject);
    PROCEDURE AxleAfterChange(Sender:TObject);
    PROCEDURE ForcePositionBeforeChange(Sender:TObject);
    PROCEDURE ForcePositionAfterChange(Sender:TObject);
    PROCEDURE LoadChanged(Sender:TObject);
  PUBLIC
    // FOR FINT
    FUNCTION IsFinit(val:Integer):BOOLEAN;
    PROCEDURE FindNextFinitSize;
    PROCEDURE FindPreviousFinitSize;
    // Whole Class //
    CLASS PROCEDURE InternalNotificationOnly(bool:BOOLEAN);
    CLASS PROCEDURE EnableInternalNotification;
    CLASS PROCEDURE DisableInternalNotification;
    // This Instance //
    CONSTRUCTOR Create(AOwner:TComponent); OVERRIDE;
    DESTRUCTOR Destroy; OVERRIDE;
    PROCEDURE SetVirgin;
    PROCEDURE Reincarnate;
    PROCEDURE UpdateOnBoundsChange;
    PROCEDURE SetRotation(Degree:TFloat);
    FUNCTION GetAxle(CONST AxleIndex:INTEGER):TAxleItem; OVERLOAD;
    FUNCTION GetAxle(CONST AxleIndex:INTEGER;VAR AAxle:TAxleItem):BOOLEAN; OVERLOAD;
    FUNCTION GetMass(CONST MassIndex:INTEGER):TMassItem; OVERLOAD;
    FUNCTION GetMass(CONST MassIndex:INTEGER; AMass:TMassItem):BOOLEAN; OVERLOAD;
    FUNCTION RunThroughAxles(VAR indexax:INTEGER;VAR AAxle:TAxleItem):BOOLEAN;
    FUNCTION RunThroughMasses(VAR indexm:INTEGER;VAR AMass:TMassItem):BOOLEAN;
    FUNCTION AddAxle(x,y:TFloat):TAxleItem;
    PROCEDURE CloneAxle(x,y:TFloat;CloneAxleNr:INTEGER);
    PROCEDURE CreateAxleGroup(x,y:TFloat;off:TTransOffset);
    PROCEDURE AllAxlesSameDegree(deg:TFloat);
    PROCEDURE GetMinMaxAxlePositions(VAR minx,maxx,miny,maxy:TFloat);
    PROCEDURE SteerToPoint(steer:TGlobalPoint);
    FUNCTION CalcAxleRepalcementPointFromPressuregroup(gr:TPressureGroup):TGlobalPoint;
    PROCEDURE AutoGroupAxles;
    PROCEDURE SetMaster(Sender:TObject;bool:BOOLEAN);
    PROCEDURE SetSteerAxle(AAxle:TAxleItem); OVERLOAD;
    PROCEDURE SetSteerAxle(indexax:INTEGER); OVERLOAD;
    // For The Area //
    PROPERTY LastSelectedPoint:TNearestPoint READ FLastSelectedPnt WRITE FLastSelectedPnt ;
    PROPERTY FinitPoints:TFinitPointsArray READ FFinitPoints;
    PROPERTY FinitForces:TFinitArray READ FFinitForces;
    PROPERTY FinitForcesColors:TFinitForceColorArray READ FFinitForcesCol;
    // For Myself //
    PROPERTY Shape:TShapeArray READ FShape; //WRITE FShape;
    PROPERTY SelectedPoint:TShapePoint READ FSelectedPnt WRITE FSelectedPnt;
    PROPERTY HoveredPoint:TShapePoint READ FHoverPnt WRITE FHoverPnt;
    PROPERTY DirectionVector:TDirectionVect READ FDirVect WRITE FDirVect;
    PROPERTY LastChangedItem:TLastChangeingItem READ FLastChangedItem;
    PROPERTY Heights[group:TPressureGroup]:TFloat READ GetHeights WRITE SetHeights;
    PROPERTY Master:BOOLEAN READ FIsMaster;
    PROPERTY CollectionIndex:INTEGER READ FIndex;
  PUBLISHED
    PROPERTY Angle:TGlobalAngleClass READ FAngle WRITE FAngle;
    PROPERTY Axles:TAxleItems READ FAxles WRITE FAxles;
    PROPERTY TPorterWidth:WORD READ FWidth WRITE SetPorterWidth;
    PROPERTY TPorterLength:WORD READ FLength WRITE SetPorterLength;
    PROPERTY Center:TGlobalPointClass READ FCenter WRITE FCenter;
    PROPERTY PoleType:TPoleType READ FPoleType WRITE FPoleType;
    PROPERTY DriveMode:TDriveMode READ FDriveMode WRITE SetDriveMode;
    PROPERTY SelectedAxle:SMALLINT READ FSelectedAxle WRITE SetSelectedAxle;
    PROPERTY AxleMinDegree:TFloat READ FRelativMin WRITE SetRelativMin;
    PROPERTY AxleMaxDegree:TFloat READ FRelativMax WRITE SetRelativMax;
    PROPERTY Show:BOOLEAN READ FShow WRITE SetShow;
    PROPERTY FramePaint:TFramePaint READ FFramePaint WRITE SetFramePaint;
    PROPERTY FinitSize:INTEGER READ FFinitSize WRITE SetFinitSize;
    PROPERTY Masses:TMassItems READ FMasses WRITE FMasses;
    PROPERTY COG:TTriplePoint READ FCOG WRITE FCOG;
    PROPERTY FinitColorMode:TColorMode READ FColorMode WRITE SetColorMode;
    PROPERTY FinitMode:TFinitMode READ FFinitMode WRITE SetFinitMode;
    PROPERTY HeightA:TFloat READ FHeights[pgA] WRITE SetHeightA;
    PROPERTY HeightB:TFloat READ FHeights[pgB] WRITE SetHeightB;
    PROPERTY HeightC:TFloat READ FHeights[pgC] WRITE SetHeightC;
    PROPERTY HeightD:TFloat READ FHeights[pgD] WRITE SetHeightD;
    // NOTIFICATIONS
    PROPERTY BeforeChange:TNotifyEvent READ GetBeforeChange WRITE SetBeforeChange;
    PROPERTY AfterChange:TNotifyEvent READ GetAfterChange WRITE SetAfterChange;
  END;

NACH DER "KURZEN" EINFÜHRUNG NUN ZU MEINEM EIGENTLICHEN PROBLEM.

Ich bekomme es nicht gebacken (und hab auch echt keinem richtigen Plan) wie ich den Property Editor für die CollectionItems
mit einem eigenen ersetze. Jedes (oder fast alle) Tutorial(s) beschreibt(beschreiben) nur die Standard PropertyEditoren (für z.B. TStringProperty, TIntegerProperty, etc..). Doch da ich vermutlich einen PopteryEditor abgeleitet von TClassProperty benötige wollte ich fragen, ob mir da jemand weiterhelfen kann). Hat einer schonmal einen Property bzw. Component Editor für komplexere Componenten geschrieben?
Ich hab echt keinem Plan wie ich aus dem Designtime Package auf die einzelenen Eigenschaften meiner Items zugreifen kann.

Wäre über ne Hilfestellung echt erfreut und schon Danke im voraus.

LoCrux

Hallo LoCrux,

bin vor kurzem über Tutorial Komponentenentwicklung von http://wiki.delphigl.com gestossen. Dabei wird auch von Property Editoren etwas erwähnt.

Vielleicht hilfts.

Im Zweifel die JVCL-Sources durcharbeiten. Im Verzeichnis "design" sind die ganzen Property-Editoren versammelt. Da sollte sich einer finden lassen.
Man kann Property-Editoren auch ersetzen. JvCoreReg.pas zeigt das.

markieren

Delphi-Quellcode:

RegisterPropertyEditor(TypeInfo(string), BaseClass, 'Hint', TJvHintProperty);
RegisterPropertyEditor(TypeInfo(TCaption), BaseClass, '', TJvHintProperty);

Der erste Aufruf ersetzt den Standard-String-Editor fuer alle Properties vom Typ string die "Hint" heissen.
Der zweite Aufruf ersetzt den Standard-Property-Editor fuer alle Properties vom Typ TCaption. Da haben wir einen Property-Editor realisiert der mehrzeilige Texte handhabt. Der Typ TCaption = string existiert nur, um genau solche typspezifischen Property-Editoren zuzulassen. TFileName = string ist auch so ein Typ.
(was BaseClass ist musst du in JvCoreReg.pas nachschlagen)