Ich erstelle z.Z eine TLine Klasse (Shape).

Dabei habe Ich folgendes Problem: Damit die Line vollständig in das Canvas hineinpasst, muß man beim Zeichnen der Linie Offsets abziehen. Wenn man das aber tut, wird die Linie zwar schön dargestellt (Siehe Paint), aber sie stimmt nicht mehr, weder Start- noch Endpunkt. Man sieht auch, daß der Winkel falsch ist (Siehe Anlage).

Ich müßte die ganze Komponente andersrum aufziehen. Zwei Eckpunkte vorgeben und die Komponentengröße wird dann entsprechend berechnet (statt die Linie einzupassen). Es wäre auch schön, wenn das auch schon zur Designzeit so angezeigt werden könnte.

Da ich von Grafikprogrammierung nur wenig Ahnung habe, wolle ich mal fragen, wie könnte man denn so was machen? TLine ist z.Z. von TGraphicControl abgeleitet?

Edit: Crosspost vergessen

http://forum.delphi-treff.de/showthr...Sets-erstellen

zusammenfalten · markieren

Delphi-Quellcode:

function TLine.OffSet1: integer;
begin
  Result := FPen.Width div 2;
end;

function TLine.OffSet2: integer;
begin
  Result := OffSet1 + FPen.Width mod 2;
end;

procedure TLine.Paint;
var
  X1, Y1, X2, Y2: Integer;
begin
  with Canvas do
  begin
    Pen := FPen;
    X1 := 0;
    Y1 := 0;
    X2 := Width;
    Y2 := Height;
    if X2 < 0 then
    begin
      Dec(X1, OffSet2);
      Inc(X2, OffSet1);
    end
    else
    begin
      Inc(X1, OffSet1);
      Dec(X2, OffSet2);
    end;
    if Y2 < 0 then
    begin
      Dec(Y1, OffSet2);
      Inc(Y2, OffSet1);
    end
    else
    begin
      Inc(Y1, OffSet1);
      Dec(Y2, OffSet2);
    end;
    MoveTo(X1, Y1);
    LineTo(X2, Y2);
  end;
end;

Zum besseren Verständnis hab ich einem Image die korrekte Line mal gezeichnet.

Deine Linien Komponente bräuchte ein Property mit dem angegeben wird wie die Linie im umgebenden "Kasten" ausgerichtet sein soll.

markieren

Delphi-Quellcode:

TLineAlign = (
  laLeft, // links anliegend
  laRight, // rechts anliegend
  laTop, // oben anliegend
  laBottom, // unten anliegen
  laDiagUp, // diagonal "abwärts"
  laDiagDown // diagonal "aufwärts"
  )

Bei laLeft und laRight kann die Linie nur gerade von oben nach unten verlaufen.
Der x-Offset beträgt dann 0.5 * Linienbreite.
Bei laTop und laBottom kann die Linie nur waagerecht verlaufen.
Der y-Offset beträgt dann 0.5 * Linienbreite.
Bei laDiagUp und laDiagDown läuft die Linie von Ecke zu Ecke.
Dein Beispiel wäre laDiagDown weil die Linie von links oben nach rechts unten verläuft.
Bei den diagonalen Linien muss man die Endpunkte der Linie jeweils in x- und y-Richtung
um die halbe Linienbreite verschieben.

Es ist sinnvoll sich diese 6 Fälle grafisch aufzuzeichnen (so wie du das im Anhang schon für einen Fall gemacht hast).

zusammenfalten · markieren

Delphi-Quellcode:

procedure CalcOffsets(la:TLineAlign; Linewidth:integer; var offsetX, offsetY:Integer);
begin
  offsetX = 0;
  offsetY = 0;

  case la of
    laLeft : offsetX := Linewidth div 2;
    laRight: offsetX := -(Linewidth div 2);
    laTop : offsetY := Linewidth div 2;
    laBottom : offsetY := -(Linewidth div 2);
    laDiagUp, laDiagDown :
      begin
        offsetX := Linewidth div 2;
         offsetY := Linewidth div 2;
      end;
  end;
end;

Ja, das ist klar (Siehe OffSet1 und OffSet2). Typen hab ich auch schon (hab ich in der Paint jetzt weggelassen).

zusammenfalten · markieren

Delphi-Quellcode:

  TLineStyle = (lsTop, lsBottom, lsLeft, lsRight,
    lsTopLeft, lsTopRight, lsBottomLeft, lsBottomRight,
    lsTopLeftBottomRight, lsTopRightBottomLeft);

procedure TLine.Paint;
var
  X1, Y1, X2, Y2: Integer;
begin
  with Canvas do
  begin
    Pen := FPen;
    X1 := 0;
    Y1 := 0;
    X2 := Width;
    Y2 := Height;
    if X2 < 0 then
    begin
      Dec(X1, OffSet2);
      Inc(X2, OffSet1);
    end
    else
    begin
      Inc(X1, OffSet1);
      Dec(X2, OffSet2);
    end;
    if Y2 < 0 then
    begin
      Dec(Y1, OffSet2);
      Inc(Y2, OffSet1);
    end
    else
    begin
      Inc(Y1, OffSet1);
      Dec(Y2, OffSet2);
    end;
    case FStyle of
      lsTop, lsLeft, lsTopRight, lsBottomLeft, lsTopLeftBottomRight:
        MoveTo(X1, Y1);
      lsRight, lsTopLeft, lsBottomRight, lsTopRightBottomLeft:
        MoveTo(X2, Y1);
      lsBottom:
        MoveTo(X1, Y2);
    end;
    case FStyle of
      lsTopLeft:
        LineTo(X1, Y1);
      lsTopRight:
        LineTo(X2, Y1);
      lsBottomLeft:
        LineTo(X1, Y2);
      lsBottomRight:
        LineTo(X2, Y2);
    end;
    case FStyle of
      lsTop:
        LineTo(X2, Y1);
      lsLeft, lsTopLeft, lsBottomRight, lsTopRightBottomLeft:
        LineTo(X1, Y2);
      lsBottom, lsRight, lsTopRight, lsBottomLeft, lsTopLeftBottomRight:
        LineTo(X2, Y2);
    end;
  end;
end;

Das Problem ist aber ein anderes. Ich mu0 hier genau zeichen. Ich will ja eine Line von z.B. P1 nach P2 haben und nicht von P1 + Offset nach P2 - Offset?

Vielleicht nochmal zur Erläuterung. Man gibt die roten Koordinaten (Siehe 2. Anlage) vor und die Komponente wird dann so dargestellt (möglichst schon zur Designzeit auf der Form, Offset nach außen, also so wie MoveTo/LineTo das eigentlich machen würde). Das krieg ich aber nicht hin?

Zitat von Bjoerk:

Das Problem ist aber ein anderes. Ich mu0 hier genau zeichen. Ich will ja eine Line von z.B. P1 nach P2 haben und nicht von P1 + Offset nach P2 - Offset?

Wenn die Linien dicker werden, dann geht das aber nicht so einfach.
Das Rechteck, dass von der Komponente mit Top, Left, Height und Width aufgespannt wird, darf auf keinen Fall überschritten werden. (das blaue Rechteck)
Die beiden Endpunkte einer Linie spannen ebenfalls ein Rechteck auf. (das rote Rechteck)
Dieses Rechteck muss bei diagonalen Linien jeweils um die halbe Linienbreite kleiner sein als das umgebende Rechteck der Komponente.
Du könntest der Komponente eine Methode spendieren, die das Rechteck der Komponente entsprechend vergrössert:

markieren

Delphi-Quellcode:

procedure TLine.InflateBoundingRect;
var
  lw2 : integer;
begin
   lw2 := LineWidth div 2;

   // TODO: Fallunterscheidung bzgl. TLineAline bzw.TLineStyle
   SetBounds(Left-lw2, Top-lw2, Width+lw2, Height+lw2);
end;

Zitat:

Wenn die Linien dicker werden, dann geht das aber nicht so einfach.

Genau!!

Zitat:

Du könntest der Komponente eine Methode spendieren, die das Rechteck der Komponente entsprechend vergrössert:

Also, wenns so einfach geht wäre natürlich super. Probier ich sofort aus. Thanx! Hoffe Paint spielt dann nicht verrückt...

Nee, das geht nicht. Wo sollte ich das auch hinschreiben? In Paint geht ja nicht. Da würde ja bei jedem Paint With und Height der Komponente vergrößert. Width und Height sind ja die von TGraphicControl geerbten. Deshalb meinte ich, man sollte die Komponente vielleicht von was ganz anderem ableiten, nur von welcher? wobei ich die Mauseereignisse schon bräuchte..

Was mir gestern abend noch eingefallen ist, was ich brauch' nennt man wohl Autosize.

Deshalb schau ich mir gerade die TCustomLabel an, weil die auch von TGraphicControl ebgeleitet ist und ein Autosize hat (die Komponentenhöhe wird da ja auch anhand der Fontgröße gesetzt, falls Autosize true ist).

In diesem Zusammenhang ist bei mir folgende Frage aufgetaucht:

markieren

Delphi-Quellcode:

  TCustomLabel = class(TGraphicControl)
    ..
  public
    ..
    property Caption;
    property Canvas;
  end;

Die beiden Properties. Diese Syntax ist mir nicht bekannt.
Wieso weiß denn Delphi, von welchem Typ die sind?

Die Property ist in TControl als protected implementiert und wird in TCustomLabel sichtbar gesetzt (public)

TCustomLabel/TGraphicControl/TControl

Ok. Thanx.

Die Methode Loaded war mir auch nicht bekannt. Es geht so, wie sx2008 vorgeschlagen hat. Hab aber nicht gewußt, daß das nach Loaded rein muß. Was aber immer noch nicht geht, daß es zur Designzeit angezeigt wird.

markieren

Delphi-Quellcode:

procedure TLine.Loaded;
begin
  inherited Loaded;
  AdjustBounds;
end;