Linien mit LCL --> der Weg

Mathias · Beitrag von **Mathias** » Di 27. Dez 2022, 08:36

Wie zeichnet die LCL eine Linie, wen man folgendes ein gibt ?

  Canvas.Line(0, 0, 100, 100);

Ich dachte immer, auf der tiefsten Ebene unter Linux müsste man sowas finden.

Code: Alles auswählen

XDrawLine

Ich habe die gesamten Sourcen von Lazarus durchsucht, habe aber keine XDrawLine gefunden, ausser in der xlib.pp.
Gibt es auf der tiefsten Ebene etwas anderes als X11, welches Linie zeichnen kann, ich denke kaum, das dies Pixelweise per Software passiert.
Gibt es da sowas wie OpenGL ?

Was ich mir vorstellen kann, wen man GTK/QT oder was ähnliches verwendet, das die in einer C-Lib steckt.
Aber zumindest für das WidgetSet "customdraw", müsste sowas zu finden sein.

theo · Beitrag von **theo** » Di 27. Dez 2022, 09:16

Das machen die Widetsets.

Die Verbindung die du suchst, findest du am ehesten in den fpGUI Quellen:
https://github.com/graemeg/fpGUI

Dass man für das Zeichnen einer Linie direkt X11 bemühen muss, glaube ich eher nicht.
Eher noch Cairo: https://de.wikipedia.org/wiki/Cairo_(Grafikbibliothek)

P.S. Möchtest du deine Tüftler-Energie nicht lieber auf ein Thema verwenden, wo am Ende vielleicht etwas Brauchbares herauskommt und bei dem alle etwas davon haben?
GTK3 fiele mir da spontan ein.

Mathias · Beitrag von **Mathias** » Di 27. Dez 2022, 13:48

Eher noch Cairo: https://de.wikipedia.org/wiki/Cairo_(Grafikbibliothek)

Ist nicht das was ich gesucht habe, sieht aber recht spannend aus. Lazarus stellt die passenden Units sogar von Hause auf zu Verfügung.
https://www.cairographics.org/tutorial/

P.S. Möchtest du deine Tüftler-Energie nicht lieber auf ein Thema verwenden, wo am Ende vielleicht etwas Brauchbares herauskommt und bei dem alle etwas davon haben?
GTK3 fiele mir da spontan ein.

Mit SDL habe ich mal begonnen, dies wird Gegenwärtig noch verwendet. Ich habe grade gesehen, die sind schon an SDL 3 dran.

theo · Beitrag von **theo** » Di 27. Dez 2022, 15:25

Mathias hat geschrieben: Di 27. Dez 2022, 13:48 Ist nicht das was ich gesucht habe,

Was suchst du eigentlich genau?
Was willst du mit dem ganzen X11 Thema anfangen?
Ich verstehe nicht ganz, wieso du so viel Energie da rein steckst.
Im Grunde ist das für praktische Belange allgemein nicht so interessant.

Winni · Beitrag von **Winni** » Di 27. Dez 2022, 16:28

theo hat geschrieben: Di 27. Dez 2022, 15:25 Ich verstehe nicht ganz, wieso du so viel Energie da rein steckst.
Im Grunde ist das für praktische Belange allgemein nicht so interessant.

Hi!

Genau!

Daür gibt es die Schicht LCL, so dass Du auf jedem OS und auf jedem Widgetset das gleiche Ergebnis erhältst.

Die Macher es LCL haben da viel Zeit und Hirnschlmalz investiert, damit man sich NICHT um die Details kümmern muss. Die ändern sich selbst bei dem gleichen OS und Widgetset alle paar Jahre.

Sei froh, dass Du Dich nicht darum kümmern musst.

Winni

siro · Beitrag von **siro** » Di 27. Dez 2022, 17:20

Es gab mal Zeiten, da habe ich auch EXTREM viel Zeit investiert um eine Line zu zeichnen.
Das Clipping hat mich ne Weile beschäftigt....

Übrigens habe ich später festgestellt, dass der Bresenham Algorithus erstaunlich ähnlich aussieht,
den habe ich aber nicht abgeguckt, sondern tatsächlich selbst was entwickelt, anhand von Zeichnungen diverser Linien auf Karopapier.

Das war noch zu Zeiten der Hercules Grafikkarte

Eigentlich sollte man froh sein, dass man sich darum nicht mehr kümmern muss......

Das sah dann so aus:

Code: Alles auswählen

procedure Line(x1,y1,x2,y2:Integer);
var xdiff,ydiff,direction,nn:Integer;
begin
 xdiff := x2 - x1;
 if xdiff < 0 then begin
   xdiff:=-xdiff;
   nn:=x1; x1:=x2; x2:=nn; { Swap X1 mit x2 }
   nn:=y1; y1:=y2; y2:=nn; { Swap Y1 mit Y2 }
 end;
 direction := +1;
 ydiff     := y2 - y1;
 if ydiff < 0 then begin
   ydiff     := -ydiff;
   direction := -direction     { identical to -1 }
 end;
 if xdiff >= ydiff then begin
   nn := (xdiff+1) DIV 2;
   repeat
{     PutPixel(x1,y1); }
     nn := nn - ydiff;
     if nn < 0 then begin
       nn := nn + xdiff;
       y1 := y1 + direction;
     end;
     x1 := x1 + 1;
   until x1 > x2;

 end else begin
   nn := (ydiff+1) DIV 2;
   repeat
{     PutPixel(x1,y1); }
     nn := nn - xdiff;
     if nn < 0 then begin
       nn := nn + ydiff;
       x1 := x1 + 1;
     end;
     y1 := y1 + direction;
   until y1 > y2;
 end;
end;

{--------------------------------------------------------------------------}
Function ClipLineOnWindow(Var x1,y1,x2,y2:Integer;
                          WinX1,WinY1,WinX2,WinY2:Integer):Boolean;

VAR xdiff,ydiff,n,rest:Word; nn:LongInt;  { muss ein unsigned Longint sein }
    temp:integer;

Begin   { CLIPPING-ROUTINE }
  ClipLineOnWindow:=False;           { Voreinstellung Linie ausserhalb }

  if y1=y2 then Begin                { Sonderfall 1 HORIZONTALE LINIE }
    if y1 < WinY1 then Exit;         { liegt komplett ueber dem Fenster }
    if y1 > WinY2 then Exit;         { liegt komplett unter dem Fenster }
    if x1 > x2 then Begin            { wenn x1 groesser ist als x2 dann }
      temp:=x1; x1:=x2; x2:=temp;    { x1 mit x2 tauschen }
    end;
    if x2 < WinX1 then Exit;         { liegt komplett links vom Fenster }
    if x1 > WinX2 then Exit;         { liegt komplett rechts vom Fenster }
    if x1 < WinX1 then x1:=WinX1;    { Start am linken Fensterrand }
    if x2 > WinX2 then x2:=WinX2;    { Ende  am rechten Fenterrand }
    ClipLineOnWindow:=True;
    Exit;                            { und Ende }
  end;

  if x1=x2 then Begin                { Sonderfall 2 VERTIKALE LINIE }
    if x1 < WinX1 then Exit;         { liegt komplett links vom Fenster }
    if x1 > WinX2 then Exit;         { liegt komplett rechts vom Fenster }
    if y1 > y2 then Begin            { wenn y1 groesser ist als y2 dann }
      temp:=y1; y1:=y2; y2:=temp;    { y1 mit y2 tauschen }
    end;
    if y2 < WinY1 then Exit;         { liegt komplett ueber dem Fenster }
    if y1 > WinY2 then Exit;         { liegt komplett unter dem Fenster }
    if y1 < WinY1 then y1:=WinY1;    { Start am oberen Fensterrand }
    if y2 > WinY2 then y2:=WinY2;    { Ende am unteren Fensterrand }
    ClipLineOnWindow:=True;
    Exit;                     { und Ende }
  end;

  if x1 > x2 then Begin       { wenn xdiff negativ waere Linie nach links }
    temp:=x1; x1:=x2; x2:=temp;     { tausche x1 mit x2 }
    temp:=y1; y1:=y2; y2:=temp;     { tausche y1 mit y2 }
  end;                        { nun laufen alle Linien nach rechts }

  if x1 > WinX2 then Exit;    { Linie liegt komplett rechts }
  if x2 < WinX1 then Exit;    { Linie liegt komplett links  }
{$R-}
  xdiff:=x2;                  { X-Differenz }
  xdiff:=xdiff-x1;
{$R+}
  if y1 > y2 then Begin       { wenn Linie nach oben geht ydiff negativ }
    if y1 < WinY1 then Exit;  { liegt komplett oben }
    if y2 > WinY2 then Exit;  { liegt komplett unten }
    ydiff:=y1;
    ydiff:=ydiff-y2;          { ydiff nun positiv }
                              { Linie nach rechts oben }
    if xdiff >= ydiff then Begin   { wobei xdiff >=ydiff }
      n:=xdiff SHR 1;
      if x1 < WinX1 then Begin                   { clip links }
        nn:=WinX1;
        nn:=nn-x1;
        nn:=nn*ydiff;
        nn:=nn+n;
        n :=nn MOD xdiff;
        nn:=nn DIV xdiff;
        y1:=y1-nn;
        if y1 < WinY1 then Exit;  { liegt oben }
        x1:=WinX1;
      end;
      if x2 > WinX2 then Begin    { clip rechts }
        nn:=WinX2;
        nn:=nn-x1;
        inc(nn);
        nn:=nn*ydiff;
        nn:=nn+n;
        nn:=nn DIV xdiff;
        y2:=y1-nn;
        if y2 > WinY2 then Exit;  { liegt unten }
        x2:=WinX2;
      end;
      if y1 > WinY2 then Begin    { clip unten }
        nn:=y1;
        nn:=nn-WinY2;
        nn:=nn*xdiff;
        nn:=nn-n;
        rest:=nn MOD ydiff;
        nn:=nn DIV ydiff;
        if rest=0 then n:=0;
        if rest > 0 then begin
          inc(nn);
          n:=ydiff-rest;
        end;
        x1:=x1+nn;
        if x1 > WinX2 then Exit;   { liegt rechts }
        y1:=WinY2;
      end;
      if y2 < WinY1 then Begin   { clip oben }
        nn:=y1;
        nn:=nn-WinY1;
        inc(nn);
        nn:=nn*xdiff;
        nn:=nn-n;
        rest:=nn MOD ydiff;
        nn:=nn DIV ydiff;
        if rest=0 then dec(nn);
        x2:=x1+nn;
        if x2 < WinX1 then Exit;   { liegt links }
        y2:=WinY1;
      end;
      ClipLineOnWindow:=True;
      Exit;
    end; { xdiff > ydiff }

                       { Linie nach rechts oben }
    n:=ydiff SHR 1;    { wobei  ydiff > xdiff }
    if y2 < WinY1 then Begin  { clip oben }
      nn:=y1;
      nn:=nn-WinY1;
      inc(nn);
      nn:=nn*xdiff;
      nn:=nn+n;
      nn:=nn DIV ydiff;
      x2:=x1+nn;
      if x2 < WinX1 then Exit; { liegt links }
      y2:=WinY1;
    end;
    if y1 > WinY2 then Begin { clip unten }
      nn:=y1;
      nn:=nn-WinY2;
      nn:=nn*xdiff;
      nn:=nn+n;
      n :=nn MOD ydiff;
      nn:=nn DIV ydiff;
      x1:=x1+nn;
      if x1 > WinX2 then Exit;  { liegt links }
      y1:=WinY2;
    end;
    if x2 > WinX2 then Begin { clip rechts }
      nn:=WinX2;
      nn:=nn-x1;
      inc(nn);
      nn:=nn*ydiff;
      nn:=nn-n;
      rest:=nn MOD xdiff;
      nn:=nn DIV xdiff;
      if rest=0 then dec(nn);
      y2:=y1-nn;
      if y2 > WinY2 then Exit;   { liegt unten }
      x2:=WinX2;
    end;
    if x1 < WinX1 then Begin    { clip links }
      nn:=WinX1;
      nn:=nn-x1;
      nn:=nn*ydiff;
      nn:=nn-n;
      rest:=nn MOD xdiff;
      nn:=nn DIV xdiff;
      if rest=0 then n:=0;
      if rest > 0 then begin
        inc(nn);
        n:=xdiff-rest;
      end;
      y1:=y1-nn;
      if y1 < WinY1 then Exit;  { liegt oben }
      x1:=WinX1;
    end;
    ClipLineOnWindow:=True;
    Exit;                     { und Ende }
  end;

  if y2 < WinY1 then Exit;    { liegt komplett oben }
  if y1 > WinY2 then Exit;    { liegt komplett unten }
{$R-}
  ydiff:=y2;
  ydiff:=ydiff-y1;            { Differenz positiv  }
{$R+}                         { sonst Linie nach rechts unten ydiff positiv }

  if xdiff >= ydiff then Begin
    n:=xdiff SHR 1;

    if x1 < WinX1 then Begin     { CLIP links }
      nn:=WinX1;
      nn:=nn-x1;
      nn:=nn*ydiff;              { ab jetzt long }
      nn:=nn+n;
      n :=nn mod xdiff;    { n ist der Rest der nachfolgenden Division }
      nn:=nn div xdiff;    { hier hinter also MOV n,DX (Rest) }
      y1:=y1+nn;
      if y1 > WinY2 then Exit;   { liegt komplett rechts }
      x1:=WinX1;
    end;
    if x2 > WinX2 then Begin   { CLIP rechts }
      nn:=WinX2;
      nn:=nn-x1;
      inc(nn);
      nn:=nn*ydiff;    { ab jetzt long }
      nn:=nn+n;
      nn:=nn DIV xdiff;
      y2:=nn;
      y2:=y2+y1;
      if y2 < WinY1 then Exit; { liegt oben }
      x2:=WinX2;
    end;
    if y2 > WinY2 then Begin   { CLIP unten }
      nn:=Winy2;
      nn:=nn-y1;
      inc(nn);
      nn:=nn*xdiff;         { ab jetzt long }
      nn:=nn-n;
      rest:=nn mod ydiff;
      nn:=nn div ydiff;
      if rest=0 then dec(nn);
      x2:=nn;
      x2:=x2+x1;
      if x2 < WinX1 then exit;  { liegt links }
      y2:=WinY2;
    end;
    if y1 < WinY1 then Begin   { CLIP oben }
      nn:=WinY1;
      nn:=nn-y1;
      nn:=nn*xdiff;    { ab jetzt long }
      nn:=nn-n;
      rest:=nn MOD ydiff;
      nn:=nn div ydiff;
      if rest = 0 then n:=0;
      if rest > 0 then begin
        inc(nn);
        n:=ydiff-rest;
      end;
      x1:=x1+nn;
      if x1 > WinX2 then Exit; { liegt komplett rechts }
      y1:=WinY1;
    end;
  ClipLineOnWindow:=True;
  Exit; { xdiff >= ydiff }
  end;

  n:=ydiff SHR 1;        { ab hier ydiff > xdiff--------------------- }
  if y1 < WinY1 then Begin    { clip oben }
    nn:=WinY1;
    nn:=nn-y1;
    nn:=nn*xdiff;
    nn:=nn+n;
    n :=nn MOD ydiff;
    nn:=nn DIV ydiff;
    x1:=x1+nn;
    if x1 > WinX2 then exit;   { liegt links }
    y1:=WinY1;
    end;
  if y2 > WinY2 then Begin  { clip unten }
    nn:=Winy2;
    nn:=nn-y1;
    inc(nn);
    nn:=nn*xdiff;         { ab jetzt long }
    nn:=nn+n;
    nn:=nn DIV ydiff;
    x2:=nn;
    x2:=x2+x1;
    if x2< WinX1 then exit;  { liegt links }
    y2:=WinY2;
  end;
  if x2 > WinX2 then Begin  { clip rechts }
    nn:=WinX2;
    nn:=nn-x1;
    inc(nn);
    nn:=nn*ydiff;
    nn:=nn-n;
    rest:=nn mod xdiff;
    nn:=nn DIV xdiff;
    if rest = 0 then dec(nn);
    y2:=nn;
    y2:=y2+y1;
    if y2 < WinY1 then Exit;    { liegt oben }
    x2:=WinX2;
  end;
  if x1 < WinX1 then Begin    { clip links }
    nn:=WinX1;
    nn:=nn-x1;
    nn:=nn*ydiff;
    nn:=nn-n;
    rest:=nn MOD xdiff;
    nn:=nn DIV xdiff;
    if rest=0 then n:=0;
    if rest > 0 then begin
      inc(nn);
      n:=xdiff-rest;
    end;
    y1:=y1+nn;
    if y1>WinY2 then Exit;   { liegt unten }
    x1:=WinX1;
  end;
  ClipLineOnWindow:=True;
end;{LINE}


{============================================================================}
{ liefert TRUE wenn sich Px und Py auf der uebergebenen Linie befindet }
Function PointInLine(Px,Py,Lx1,Ly1,Lx2,Ly2:Integer):Boolean;
Begin
  PointInLine:=ClipLineOnWindow(Lx1,Ly1,Lx2,Ly2,Px,Py,Px,Py);
end;
{============================================================================}

Mathias · Beitrag von **Mathias** » Di 27. Dez 2022, 17:45

Was suchst du eigentlich genau?
Was willst du mit dem ganzen X11 Thema anfangen?

Ich wollte einfach in die tiefste Ebene runter sehen, wie die ganze Linux-GUI aufgebaut ist.
Aber leider sieht es nach einem bodenlosen Fass aus.
Egal, was für einen Weg, man wählt, es endet fast immer in einer C-Lib.
So wie es aussieht, verschwindet sogar "customdraw" in einer C-Lib. ansonsten würde man in den Lazarus/FPC-Sourcen ein XDrawLine finden.

theo · Beitrag von **theo** » Di 27. Dez 2022, 17:52

Mein Tipp: Vergiss es!
Es bringt dir und der Welt nichts, wenn du dich damit beschäftigst. (CH: "Für d' Füchs").
Wenn du eine Herausforderung suchst, dann verbessere etwas am GTK3 Interface.
Cairo und Pango kommen da auch vor.
Man wird es dir danken!

Mathias · Beitrag von **Mathias** » Di 27. Dez 2022, 18:16

Man wird es dir danken!

So wie bei meiner AVR-IDE Erweiterung. Die nützt sicher vielen, wen sie mit Ebedded-System anfangen.
Aber erstmal beschäftige ich mich mal mit SDL. Das scheint auch spannend zu sein.

Pango ? Da muss ich zuerst schauen, was das genau ist.

theo · Beitrag von **theo** » Di 27. Dez 2022, 18:20

Mathias hat geschrieben: Di 27. Dez 2022, 18:16 Pango ? Da muss ich zuerst schauen, was das genau ist.

https://de.wikipedia.org/wiki/Pango

Mathias · Beitrag von **Mathias** » Mi 28. Dez 2022, 09:09

So wie es aussieht, passen Pango und Cairo zusammmen: https://docs.gtk.org/PangoCairo/pango_cairo.html

theo · Beitrag von **theo** » Mi 28. Dez 2022, 09:36

Ja klar, es gibt auch "lazpangocairo1.pas" in "lazarus/lcl/interfaces/gtk3/gtk3bindings/"

PascalDragon · Beitrag von **PascalDragon** » Mi 28. Dez 2022, 14:48

Mathias hat geschrieben: Di 27. Dez 2022, 08:36 Wie zeichnet die LCL eine Linie, wen man folgendes ein gibt ?
Code: Alles auswählen
  Canvas.Line(0, 0, 100, 100);
Ich dachte immer, auf der tiefsten Ebene unter Linux müsste man sowas finden.
Code: Alles auswählen
XDrawLine
Ich habe die gesamten Sourcen von Lazarus durchsucht, habe aber keine XDrawLine gefunden, ausser in der xlib.pp.
Gibt es auf der tiefsten Ebene etwas anderes als X11, welches Linie zeichnen kann, ich denke kaum, das dies Pixelweise per Software passiert.
Gibt es da sowas wie OpenGL ?

Was ich mir vorstellen kann, wen man GTK/QT oder was ähnliches verwendet, das die in einer C-Lib steckt.
Aber zumindest für das WidgetSet "customdraw", müsste sowas zu finden sein.

Mit Ausnahme des CustomDrawn X11 WidgetSet interagiert die LCL nicht direkt mit X11, sondern das ist Sache des WidgetSet (was es erlaubt, dass das Qt WidgetSet zum Beispiel auch unter Windows oder macOS nutzbar ist, wo es standardmäßig kein X11 gibt).

Und das Grundkonzept des CustomDrawn WidgetSet ist, dass in einen Puffer gezeichnet wird und dieser dann vom darunterliegenden WidgetSet (WinAPI, Cocoa, Android, X11) als ein Stück gezeichnet wird, statt die primitiven (*) Zeichenfunktionen des WidgetSet zu nutzen (der gleiche Ansatz wird übrigens auch von Qt genutzt, du wirst dort also ebenfalls kein XDrawLine finden).

(*) Das „primitiv” soll jetzt nicht heißen, dass die schlecht sind, sondern dass das eben die low level Zeichenfunktionen sind, auf denen alles andere aufbaut; das Zeichnen eines Puffers zählt auch als eine solche primitive Operation.

Mathias · Beitrag von **Mathias** » Mi 28. Dez 2022, 18:17

@PascalDragon
Jetzt verstehe ich es hoffentlich.
Das kann man so vorstellen, man zeichnet alles in eine Bitmap und am Schluss wird nur noch die Bitmap an X11 übergeben ?
Dies würde Sinn machen, da X11 zB. kein Pen und Brush oder auch Antialiasing kennt.

PascalDragon · Beitrag von **PascalDragon** » Do 29. Dez 2022, 15:49

Mathias hat geschrieben: Mi 28. Dez 2022, 18:17 Das kann man so vorstellen, man zeichnet alles in eine Bitmap und am Schluss wird nur noch die Bitmap an X11 übergeben ?

Korrekt.

Deutsches Lazarusforum

Linien mit LCL --> der Weg

Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg

Re: Linien mit LCL --> der Weg