Liste von vielen unterschiedlichen Grafikobjekten mit unterschiedlichen Properties

[Sir Rufo]

Da du ja die Eigenschaften von mehreren unterschiedliche Objekte zusammenfassen möchtest, brauchst du zunächst etwas, was du vergleichen kannst um gleiche Eigenschaften zusammenzufassen.

Oder anders ausgedrückt, wir benötigen eine Klasse, die eine Eigenschaft darstellen kann (aber nur die Eigenschaft selber, ohne den Wert)

Delphi-Quellcode:

TProperty = class
public
  constructor Create( const PropName : string; PropType : integer );
  function Equals( Obj : TObject ) : Boolean; override;
  function SameValueAs( Other : TProperty ) : Boolean;
published
  property PropName : string read FPropName;
  property PropType : integer read FPropType;
end;

function TProperty.Equals( Obj : TObject ) : Boolean;
begin
  Result := (Self = Obj) or Assigned( Obj ) and ( Self.ClassType = Obj.ClassType ) and SameValueAs( Obj as TProperty );
end;

function TProperty.SameValueAs( Other : Tproperty ) : Boolean;
begin
  Result := (Self = Other) or Assigned( Other ) and SameText( Self.FPropName, Other.FPropName ) and (Self.FPropType = Other.FPropType );
end;

Die nächste Klasse, wäre dann die, wo man auf den Eigenschaftswert zugreifen kann

Delphi-Quellcode:

TPropertyValue = class
public
  constructor Create( Instance : TObject; const PropName : string );
  // True, wenn gleiche Eigenschaft und gleicher Wert
  function Equals( Obj : TObject ) : Boolean; override;
  function SameValueAs( Other : TPropertyValue ) : Boolean;
published
  property Prop : TProperty read FProp;
  property ValueStr : string read GetValueStr write SetValueStr;
end;

Um jetzt ein ganze Instanz zu verwalten benötigen wir eine Klasse, die eine Liste mit den Property-Werten anbietet:

Delphi-Quellcode:

TObjectProperties = class abstract
public
  property Count : Integer read GetCount;
  property PropValue[Index : Integer] : TPropertyValue read GetPropValue;
end;

und diese Klasse benötigen wir für eine Instanz

Delphi-Quellcode:

TSingleObjectProperties = class( TObjectProperties )
public
  constructor Create( Instance : TObject );
end;

und für mehrere

Delphi-Quellcode:

TMultiObjectProperties = class( TObjectProperties )
public
  procedure Add( Object : TSingleObjectProperties );
  procedure Remove( Object : TSingleObjectProperties );
end;

Das ist jetzt alles etwas schematisch, aber das Prinzip sollte jetzt klar geworden sein.

[DeddyH]

Das ist ja ziemlich genau das, was ich gesagt hatte, in Code gegossen. Nur ist sich Bjoerk nicht sicher, ob er später noch versteht, was er da gemacht hat ;)

[Sir Rufo]

Zitat:

Zitat von DeddyH (Beitrag 1266938)

Das ist ja ziemlich genau das, was ich gesagt hatte, in Code gegossen. Nur ist sich Bjoerk nicht sicher, ob er später noch versteht, was er da gemacht hat ;)

Er erweckte in mir den Eindruck deine Worte nicht in Code umsetzen zu können, und mit der Ini-Datei war er auch auf dem völlig falschen Dampfer unterwegs ;)

Sollte nur ein etwas gröberer Stubser werden

[Bjoerk]

Bei einer Holzliste ist das sicherlich kein Problem.. Was machst du wenn das eine Object mit dem andern fast nichts zu tun hat? Den Ansatz von Sir Rufo und DeddyH schaut "ER" sich nachher genauer an, "ER" muß jetzt erst mal was essen..

BTW, jetzt hab ich so, daß ich alles in einem "TMegaShape" drin hab. Wollte aber eigentlich keinen Katastrophencode mehr produzieren..

[Jens01]

Zitat:

Was machst du wenn das eine Object mit dem andern fast nichts zu tun hat?

Vielleicht eine Grundklasse erstellen. Farbe usw könnte man dorthin verfrachten. Wenn die Daten/Properties nichts miteinander zu tun haben, ist fraglich, ob man sie gleich behandeln sollte.
Man könnte mit diesem rtti gleiche Namen heraussuchen, hmm..:gruebel:

Deine Software sieht aber schon ganz gut aus, naja für Betonbauer;)

[stahli]

Zitat:

Zitat von Bjoerk (Beitrag 1266891)

DeddyH, wir hatten schon mal kurz vor ca. einem Jahr darüber im DT gesprochen. Einen OI der alle möglichen Props meiner Objekte anzeigt gibt es schon. Die Frage ist wie krieg ich die aktuellen Werte meiner Liste in die Edits, Comboxen ect. und wie schreib ich die zurück?

Hallo Bjoerk,

Dein Screenshot hat mich animiert, den Thread nochmal genauer anzuschauen...
Respekt für das erreichte. Sieht richtig cool und aufgeräumt aus.

Wenn ich Dich richtig verstehe suchst Du nach "Databinding" (wobei Dein Screenshot suggeriert, dass das schon gelöst ist).
Oder ist Dein Problem nur, wie Du mit unterschiedlichen Werten mehrerer markierter Objekte umgehen sollst?

[Bjoerk]

Thanx. Das Ganze ist auch (fast) schon fertig, aber m.E. ziemlich unprofessionell gelöst? Es gibt ein zweidimensionales Array[Aufzahlungstyp über alle ShapeTypen, AufzählungsTyp über alle PropertiyTypen] of boolean.

Zum Beispiel hat das Objekt Line die Properties X1, Y1, X2, Y2.Diese Klasse setzt nun im Constructor

Delphi-Quellcode:

  Prop[gtLine, X1Prop] := true;
  Prop[gtLine, X2Prop] := true;
  Prop[gtLine, Y1Prop] := true;
  Prop[gtLine, Y2Prop] := true;

Der OI bekommt eine aktuelle Liste und geht a) die ganze Liste von hinten bis vorne durch b) über alle Typen und c) über alle Props. Wenn ein Object der Liste markiert ist und es ein X1Prop hat dann erzeugt der OI (einmal) ein TEdit, setzt einen TabIndex und gibt dem Edit als Tag TProp(X1Prop) mit. Der Oi setzt auch zweites Edit und schreibt "das ist die X1 Koordinate in Metern".

Und Schließlich speichert den Wert der Property in TEdit.Text.

Delphi-Quellcode:

 if CurrentItem.Prop[X1Prop] then EditX1.Text := FloatToStr(Item.X1);

Dann legt der OI eine Kopie aller Edit.Texts and an und überprüft bei jedem TEdit.OnExit ob sich ein Wert geändert hat.
Falls ja speichert den Wert zurück und zeichnet die Grafik neu.

Delphi-Quellcode:

 if CurrentItem[X1Prop] and (Edit.Tag = TProp(X1Prop)) then Item.X1 := StrToFloat(EditX1.Text);

Hinzu kommt daß es nur Object gibt daß Instanzen aller Klassentypen hat. *gmpf*

[stahli]

Wenn Du magst, dann schau mal nach DSharp oder ssFramework. Beide realisieren ein Databinding.
Am ssFramework arbeite ich aber nicht mehr weiter.
(Embarcadero unterstützt ja inzwischen auch LiveBindings, aber da will ich mal nicht weiter drauf eingehen.)

Grundsätzlich kann man die Eigenschaften der Objekte direkt untersuchen und diese nach Namen ermitteln. Vor D2010 gab es dafür IsPublishedProp.
Damit kann man ermitteln, ob ein Objekt die veröffentlichte Eigenschaft XYZ besitzt und dessen Wert verarbeiten.

Ab D2010 gibt es mit der neuen RTTI dafür noch deutlich mehr Möglichkeiten.

Wenn Deine Lösung so funktioniert würde ich es dabei belassen. Ein komplettes Databindingframework aufzubauen wird sich für ein (fast fertiges Projekt) nicht lohnen.
Wenn man aber von vorn herein eine solche Lösung verfügbar hat, dann kann man sich viel Arbeit sparen. Deshalb will ich ohne Databinding auch möglichst nicht mehr arbeiten.

Im Grunde kannst Du dann mit normalen Controls wie mit DBControls arbeiten und die an die Datenschicht binden. Die Datenschicht ist dann nur keine Datenbank sondern ein Manager, der das benötigte Objekt ermittelt und den Wert dessen benötigter Eigenschaft zurück gibt.

[Sir Rufo]

@stahli

Niemand sucht in diesem Thread nach DataBinding

Hier wird nach einer Möglichkeit gesucht, von einer Gruppe von Instanzen, die als gemeinsamen Vorfahren TObject haben, die Eigenschaften herauszufinden, die in diesen Instanzen vorkommen (das nennt sich Schnittmenge).

Wie diese Eigenschaften dann angezeigt und bearbeitet werden hat er gelöst (siehe Screenshot), wenn er diese denn nur hätte. Das DataBinding kann ihm da genauso helfen, wie das Bemalen der Blätter der Bäume an der Allee von der Straße wo man auch schon mal hergefahren ist, wenn man kein Benzin im Tank hat. Sieht lustig aus, ist nicht langweilig, aber hilft beim aktuellen Problem nicht weiter.

[Bjoerk]

Stahli, auch selbst wenn ich das Beispiel von Sir Rufo / DeddyH verstehen würde dann wärs vermutlich ein neues Programm? Dein ssFramework kenn ich vom Namen her hab es aber noch nie verwendet. Ist bestimmt sehr gut.

Ich lass es jetzt erst mal so. Sooo schlimm isses eigentlich nicht (wenn man so viel wie möglich wegkapselt). Mit meinem Codegenerator geht’s eigentlich ganz gut.

Delphi-Quellcode:

procedure TGraphicShape.DoSomething;
begin
  if Util_LineWerkzeug(FTyp) then
    case FTyp of
      gtLine:
        FLine.DoSomething;
      gtCircleLine:
        FCircleLine.DoSomething;
      gtHelpLine:
        FHelpLine.DoSomething;
      gtArrow:
        FArrow.DoSomething;
      gtPos:
        FPos.DoSomething;
      gtPosition:
        FPosition.DoSomething;
      gtDimension:
        FDimension.DoSomething;
      gtGerade:
        FGerade.DoSomething;
      gtSchnitt:
        FSchnitt.DoSomething;
      gtAchse:
        FAchse.DoSomething;
      gtHint:
        FHint.DoSomething;
      gtPosHint:
        FPosHint.DoSomething;
      gtDoubleLine:
        FDoubleLine.DoSomething;
    end
  else
    if Util_PolygonWerkzeug(FTyp) then
      case FTyp of
        gtPolyLine:
          FPolyLine.DoSomething;
        gtPolygon:
          FPolygon.DoSomething;
        gtRubber:
          FRubber.DoSomething;
        gtNEck:
          FNEck.DoSomething;
        gtHelpPolygon:
          FHelpPolygon.DoSomething;
        gtHelpNEck:
          FHelpNEck.DoSomething;
      end
    else
      if Util_RectWerkzeug(FTyp) then
      begin
        case FTyp of
          gtRect:
            FRect.DoSomething;
          gtCircle:
            FCircle.DoSomething;
          gtTriangle:
            FTriangle.DoSomething;
          gtAngleDimension:
            FAngleDimension.DoSomething;
        end
      end
      else
        if Util_ProfilWerkzeug(FTyp) then
          case FTyp of
            gtI:
              FI.DoSomething;
            gtHalfI:
              FHalfI.DoSomething;
            gtU:
              FU.DoSomething;
            gtL:
              FL.DoSomething;
            gtZ:
              FZ.DoSomething;
            gtT:
              FT.DoSomething;
            gtPipe:
              FPipe.DoSomething;
            gtFrame:
              FFrame.DoSomething;
            gtEllipsePipe:
              FEllipsePipe.DoSomething;
          end
        else
          if Util_TextWerkzeug(FTyp) then
            case FTyp of
              gtText:
                FText.DoSomething;
              gtKote:
                FKote.DoSomething;
            end
          else
            if Util_GraphicWerkzeug(FTyp) then
              case FTyp of
                gtGraphic:
                  FGraphic.DoSomething;
              end
            else
              if Util_ReinforcementWerkzeug(FTyp) or Util_ReinforcementPolygonWerkzeug(FTyp) then
                case FTyp of
                  gtGeschlossenerBuegel:
                    FGeschlossenerBuegel.DoSomething;
                  gtOffenerBuegel:
                    FOffenerBuegel.DoSomething;
                  gtRandbuegel:
                    FRandbuegel.DoSomething;
                  gtOffenerBuegelExInnen:
                    FOffenerBuegelExInnen.DoSomething;
                  gtOffenerBuegelExAussen:
                    FOffenerBuegelExAussen.DoSomething;
                  gtKoecherbuegel:
                    FKoecherbuegel.DoSomething;
                  gtSteckbuegel:
                    FSteckbuegel.DoSomething;
                  gtStab:
                    FStab.DoSomething;
                  gtCircleStab:
                    FCircleStab.DoSomething;
                  gtWinkel:
                    FWinkel.DoSomething;
                  gtAufbiegung:
                    FAufbiegung.DoSomething;
                  gtStabPunkt:
                    FStabPunkt.DoSomething;
                  gtSchlaufe:
                    FSchlaufe.DoSomething;
                  gtSHaken:
                    FSHaken.DoSomething;
                  gtMatteVertikal:
                    FMatteVertikal.DoSomething;
                  gtMatteHorizontal:
                    FMatteHorizontal.DoSomething;
                  gtMatte:
                    FMatte.DoSomething;
                  gtApsta:
                    FApsta.DoSomething;
                  gtPolygonStab:
                    FPolygonStab.DoSomething;
                end;
end;

Wenigstens "etwas" RTTI kann ich nutzen. :)

Delphi-Quellcode:

function Util_TGraphicObjectTypToStr(const Value: TGraphicObjectTyp): string;
begin
  Result := GetEnumName(TypeInfo(TGraphicObjectTyp), Ord(Value));
end;

function Util_TPropToStr(const Value: TProp): string;
begin
  Result := GetEnumName(TypeInfo(TProp), Ord(Value));
end;

function Util_TActionToStr(const Value: TAction): string;
begin
  Result := GetEnumName(TypeInfo(TAction), Ord(Value));
end;

LG
Thomas