Liste von vielen unterschiedlichen Grafikobjekten mit unterschiedlichen Properties

[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.
 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.

 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

[Bjoerk]

Jens, deine Idee Werkzeuge zu gruppieren werd' ich umsetzen. Thanx! Damit kann der case Kram weggekapselt werden.

Bei meinem OI ist es übrigens so daß nicht nur die Schnittmenge angezeigt wird sondern alle Eigenschaften, sofern sie denn vorhanden sind. Zur Unterscheidung für den User werden die InfoEdits dieser Eigenschaften dann mit Font.Color rot statt blau angezeigt.

[Sir Rufo]

Wenn ich mir das recht überlege, dann ist mein Ansatz zwar umsetzbar, allerdings mit einem sehr, sehr hohem Aufwand. Du müsstest jede Eigenschaft dahingehend untersuchen, ob diese wirklich jetzt vom Namen und Typ exakt übereinstimmt.

Der OI von Delphi geht hierbei ja die Vererbungsliste der Klassen durch, bis er die größte gemeinsame Basis-Klasse gefunden hat und zeigt die Eigenschaften dieser Basis-Klasse an. Das ist sehr simpel zu realisieren.

Schwierig wird es, wenn unterschiedliche Objekte mit gleichem Eigenschaftsnamen und gleichem Typ aber etwas Anderes bedeuten (etwas konstruiert, aber denkbar). Unübersichtlich wird es, wenn bei den Objekten Eigenschaften mit gleichem Namen und unterschiedlichen Typen vorkommen und diese nun in der Liste präsentiert werden. Dann spielt es keine Rolle mehr, ob die nun farblich markiert sind oder nicht, der Anwender wird verwirrt, wenn dort Eigenschaften mit gleichem Namen auftauchen, weil dann der Bezug fehlt.

Du kannst auch eine Mega-Basis-Klasse erstellen mit allen Eigenschaften, die bei allen Objekten vorkommen, diese allerdings protected . Wird diese Eigenschaft in einer Klasse dann benötigt, dann einfach als published deklarieren.

Delphi-Quellcode:

TCustomFoo = class
private
  FValue1 : Integer;
  FValue2 : string;
  procedure SetValue1( const Value : Integer );
  procedure SetValue2( const Value : string );
protected
  procedure SomeValueChanged; virtual;
  property Value1 : Integer read FValue1 write SetValue1;
  property Value2 : string read FValue2 write SetValue2;
end;

procedure TCustomFoo.SetValue1( const Value : Integer );
begin
  if FValue1 <> Value then
  begin
    FValue1 := Value;
    SomeValueChanged;
  end;
end;

procedure TCustomFoo.SetValue2( const Value : string );
begin
  if FValue2 <> Value then
  begin
    FValue2 := Value;
    SomeValueChanged;
  end;
end;

procedure TCustomFoo.SomeValueChanged;
begin
end;

TFoo = class( TCustomFoo )
protected
  procedure SomeValueChanged; override;
published
  property Value1;
end;

procedure TFoo.SomeValueChanged;
begin
  inherited;
  // Neuzeichnen ... oder was auch immer auslösen
end;

TBar = class( TFoo )
protected
  procedure SomeValueChanged; override;
published
  property Value2;
end;

procedure TBar.SomeValueChanged;
begin
  inherited;
  // Neuzeichnen ... oder was auch immer auslösen
end;

Neue Eigenschaften werden dann in der Basis-Klasse eingeführt und in der abgeleiteten Klasse auf published gesetzt. Das funktioniert dann ohne die anderen Klassen zu stören und man hat garantiert keine Überschneidungen bei den Eigenschaftsnamen.

[Bjoerk]

Hab nur ein Klasse? Ein Bezug fehlt da nicht? Das Ding ist ja schließlich markiert und hat diese Eigenschaft? Aber ich kann's als Option anbieten. Ist ja mit meinem Hiftsarray no problem nur die Gemeinsamen anzuzeigen.

Delphi-Quellcode:

    N := PropertySelectedCount;
    if N > 1 then
      for I := Low(TProp) to High(TProp) do
        if Properties.Count[I] < N then
          Properties.Prop[I] := false;

Danke für den Hinweis!

[Bjoerk]

Ah. Jetzt. Ja. Kaum vergeht ein Jahr schon ist mir das jetzt auch klar.

Gruß an DeddyH. Eben bei einem Ereignis hab ich‘s gemerkt. Es können in der Tat nur Eigenschaften und Methoden dargestellt werden die alle markierten Elemente teilen. Also nix mit rot und blau..

Und auch nochmal Danke an Sir Rufo Sir, ohne dich hätts vermutlich noch n Jahr gedauert...