pre-Alpha Text Editor Komponente Version: 00.00.00

[theo]

Wie viele Leute wolln denn noch mit sowas anfangen, bin eigentlich ziemlich unglücklich darüber das Theo das unbedingt allein machen will. Seine Komponente ist schon sehr brauchbar (durft vor nem Jahr mal probiern).

Danke für die Blumen!
Das Problem ist halt, dass man bei einer solchen Komponente vom "hundersten ins tausendste" kommt. Bin gerade mit der Druckerei beschäftigt. Das ist wieder ein Kapitel für sich, zumal unter Linux mit PostScript. Im Moment versuche ich, "Hurenkinder und Schusterjungen" wegzukriegen.
http://de.wikipedia.org/wiki/Hurenkind_ ... usterjunge" onclick="window.open(this.href);return false;
Einen kleinen *.odt (OpenOffice) Reader gibt's auch schon, da könnte man aber noch Wochen dran basteln.
Von Tabellen, Positionsrahmen etc pp ganz zu schweigen.

Solange es kein Soruce gibt muss halt jeder seinen eigenen Schreiben. So ist das halt.

Da haste wohl recht....

[Aleks36]

Ich habe in der angefügten Datei einmal diejenigen Teile von meiner Komponente zusammengetragen, die für das Scrollen verantwortlich sind. Wie gesagt habe ich das ganze mit Delphi für Win32 geschrieben und ich weiss grad nicht, was man alles in Lazarus so übernehmen kann...

Ich weiss nicht genau, was Du meinst, dass gescrollt werden soll, wenn sich die Cursor-Postion ändert. Wenn du damit den Caret meinst (den blinkenden Balken im Text), dann würde ich einfach bei jedem Tastendruck UpdateScrollBars aufrufen.

[pluto]

Ja genau den meine ich, aber ich glaube nicht das es aussreicht einfach nur UpdateScrollBars aufzurufen, aber ich werde es ausprobieren.
Danke für deinen Soruce, werde ich mir gleich mal ansehen.

[pluto]

Danke für deinen Sorce Code, ich habe ihn mal übernommen, aber leide sehe ich keine Scrollbalken.
Bei onCreate habe ich FScrollBars:=ssVertical eingebaut, aber das tut sich nix.


und wo setzt du

Code: Alles auswählen

FScrollMaxX: Integer;
FScrollMaxY: Integer; 
 
BufferChangeSize:
FScrollMaxX:=rows.Width;
FScrollMaxY:=rows.Height;

Sobald sich die Größe ändert wird bei mir onBufferChangeSize aufgerufen, und in rows.Width steht dann
die Maxiemal Scroll breite drin.

[Aleks36]

Dass sich nichts tut, wenn Du in OnCreate die Eigenschaft "FScrollBars" setzt liegt daran, dass dann das Fenster schon erzeugt wurde.

Wenn die Edit-Komponente erstellt wird, dann wird die Windows-API-Funktion "CreateWindowEx" mit den nötigen Parametern aufgerufen. Die virtuelle Methode CreateParams einer Komponente dient dazu, die nötigen Parameter zu setzen. Wenn aber das Fenster einmal erstellt ist, wird auch die FScrollBars-Eigenschaft nicht mehr ausgewertet.

Um also die ScrollBars wirklich zu sehen, musst Du nach dem setzen von FScrollBars die Methode RecreateWindow aufrufen (zumindest unter Delphi gibt es diese). Am schönsten ist natürlich, wenn Du eine property ScrollBars definiertst und dazu die Methode

Code: Alles auswählen

procedure TEditor.SetScrollBars(Value: TScrollStyle);
begin
  if (Value <> FScrollBars) then
    begin
      FScrollBars := Value;
      RecreateWindow;
    end;
end;

verwendest. Entsprechend muss es dann in OnCreate "ScrollBars := ssVertical" heissen -- ohne das "F" vorne.

Scrollbars updaten

Wieso glaubst du nicht, dass es genügen wird, UpdateScrollBars aufzurufen? Bei meinem Editor muss ich nach jeder Taste das Caret (den blinkenden Cursor) wieder neu positionieren und das funktioniert bei mir ganz gut. Ich würde die ScrollBars aber auf jeden Fall nur dann neu setzen, wenn sich wirklich etwas geändert hat. API-Funktionen neigen dazu, ziemlich langsam zu sein.

Je nachdem was für einen Textbuffer du verwendest hast du vielleicht sogar eine Art von OnChange Event, dass du für UpdateScrollBars verwenden kannst.

[pluto]

Die Vertikale Leiste wird immer noch nicht angezeigt nur die Horizontale Leiste:

Code: Alles auswählen

constructor TPlutoEditor.Create(TheOwner: TComponent);
begin
  FScrollBars:=ssVertical;
  RecreateWnd(self);
  inherited Create(TheOwner);
 
  FScrollMaxX:=100;
  FScrollMaxY:=0;
 
  FScrollPosX:=0;
  FScrollPosY:=0;
 
  FScrollPagX:=5;
  FScrollPagY:=5;
 
  Rows:=TPlutoEditorRows.Create;
  isCrtl:=False; CurrFile:='';
 
  overwriting:=False; modified:=False; isDebugKeys:=False; Cursor:=crIBeam;
 
  Rows.OutCanvas:=canvas;
  Rows.Buffer.Canvas.Clipping:=True;
  Rows.onBufferChangeSize:=@BufferChangeSize;
  Rows.onChangeScrollPos:=@ChangeScrollPos;
end; // TPlutoEditor.Create

Zum testen mache ich das so. Später ändere ich das noch zu einer Eigenschaft.
Das Seltsame ist wenn ich Horizontal Scrolle kann ich dies nur einmal machen bzw. nur einmal wirkt sich das auf den Inhalt sichtbar aus. Mussi ch andere werte nehmen ?

[Aleks36]

Zuerst einmal irritiert mich, dass es überhaupt funktioniert, wenn du vor dem inherited Create eine Eigenschaft setzst. In der Regel setzt nämlich TObject.Create (das ja letzlich aufgerufen wird) alle Felder auf Null.

Mit den Werten, die du gewählt hast, kann man ja auch nur horizontal (in X-Richtung) scrollen; vertikal liegt der Bereich ja bei 0 bis 0. Das Flag SIF_DISABLENOSCROLL ist eigentlich dafür verantwortlich, die ScrollBar nur dann zur Verfügung zu stellen, wenn auch wirklich gescrollt werden kann.

Schliesslich musst du noch ein UpdateScrollBar aufrufen, um die Informationen, die du in die Felder FScrollMaxX etc. hineingeschrieben hast, an die ScrollBar weiterzuleiten. Die Werte alleine zu verändern hat noch keinen Einfluss auf die ScrollBar.

Versuchs vielleicht mit dem folgenden Code:

Code: Alles auswählen

constructor TPlutoEditor.Create(TheOwner: TComponent);
begin
  inherited Create(TheOwner);
  FScrollBars := ssVertical;
  RecreateWnd(self);
 
  FScrollMaxX := 0;
  FScrollMaxY := 100;
  FScrollPagY := 5;
  UpdateScrollBars;
 
  ...
end;

[pluto]

Nein ! Es geht einfach nicht, ich habe dein Beispiel ausprobiert, aber es wird keine Vertikal Scrolleiste angezeigt.
Kann das sein das ich nirgends den Scroll Bereich setzte ?

Code: Alles auswählen

procedure TPlutoEditor.BufferChangeSize;
begin
//  VertScrollBar.Range:=rows.Height;
//  HorzScrollBar.Range:=rows.Width;
  FScrollMaxX:=rows.Width;
  FScrollMaxY:=rows.Height;
  UpdateScrollBars;
end; // TPlutoEditor.BufferChangeSize

Das Event onBufferChangeSize wird beim Zeichnen aufgerufen und bestimmt somit die maximel ScrollHöhe und Scrollbreite. Aber es geht trotzdem nicht.

Code: Alles auswählen

procedure TPlutoEditor.UpdateScrollBars;
var
  S: TScrollInfo;
begin
  if (HandleAllocated) and (FScrollBars in [ssHorizontal, ssBoth]) then
    begin
        S.cbSize := SizeOf(S);
        S.fMask := SIF_POS or SIF_RANGE or SIF_PAGE {or SIF_DISABLENOSCROLL};
        S.nPos := FScrollPosX;
        S.nMin := 0;
        S.nMax := FScrollMaxX;
        if (FScrollPagX > 0) then
          inc(S.nMax, FScrollPagX - 1);
        S.nPage := FScrollPagX;
        SetScrollInfo(Handle, SB_HORZ, S, true);
    end;
 
end;

Kann das da dadran liegen ? Dort wird ja nur Horizontal "behandelt" und nicht Vertikal.

Edit01: Ja daran hat es gelegen:

Code: Alles auswählen

procedure TPlutoEditor.UpdateScrollBars;
var
  S: TScrollInfo;
begin
  if (HandleAllocated) then begin
    if (FScrollBars in [ssHorizontal, ssBoth]) then begin
        S.cbSize := SizeOf(S);
        S.fMask := SIF_POS or SIF_RANGE or SIF_PAGE or SIF_DISABLENOSCROLL;
        S.nPos := FScrollPosX;
        S.nMin := 0;
        S.nMax := FScrollMaxX;
        if (FScrollPagX > 0) then
          inc(S.nMax, FScrollPagX - 1);
        S.nPage := FScrollPagX;
        SetScrollInfo(Handle, SB_HORZ, S, true);
    end;
 
    if (FScrollBars in [ssVertical, ssBoth]) then begin
        S.cbSize := SizeOf(S);
        S.fMask := SIF_POS or SIF_RANGE or SIF_PAGE or SIF_DISABLENOSCROLL;
        S.nPos := FScrollPosY;
        S.nMin := 0;
        S.nMax := FScrollMaxY;
        if (FScrollPagY > 0) then
          inc(S.nMax, FScrollPagY - 1);
        S.nPage := FScrollPagY;
        SetScrollInfo(Handle, SB_Vert, S, true);
    end;
 
  end;
end;

Allerdings kann ich jetzt nur Horizontal Scrollen beim Vertikalen Scrollen Passiert irgendwie nix.

edit02:
endlich, ich musste nur WMVScroll anpassen.
allerdings wird immer noch nicht gescrollt wenn der Cursor am Rand ist.
Bei mir ist der Cursor in zwei Variablen gespeichert:
CursorX und CursorY und beim Setzten der Eigenschaften wird ein Event ausgelöst um dort
UpdateScrollBars aufzurufen.

Edit03: Beim Cursor Setzten muss ich doch nur UpdateScrollBars aufrufen oder nicht ?
Edit04:
also muss ich beim Setzten
FScrollPosX, FScrollPosY anpassen und da nach UpdateScrollBars aufrufen oder wie ?
Wenn ja genau das ist mein Problem. Ich möchte ja die Scroll Position berechnen. beim setzten des Cursors.

[Aleks36]

Tut mir leid, dass ich da etwas verwirrung gestiftet habe. Ich wollte den Quelltext möglichst kurz halten und habe daher die Behandlung der vertikalen ScrollBar ausgelassen...

Mir ist nun noch nicht ganz klar, in wie fern die Cursorposition Auswirkungen auf die ScrollBars haben soll. In der Regel geben die ScrollBars ja die Position der oberen linken Fensterecke innerhalb des Dokumentes wieder. Demnach wäre "FScrollPosY" die erste Zeile, die auf dem Bildschirm sichtbar ist. Wenn ich dich richtig verstehe, dann möchtest du, dass die ScrollBars nicht die Position der linken oberen Fensterecke wiedergeben, sondern die Position des Carets. Dann brauchst du aber natürlich keine eigene Variablen für "FScrollPosX" und "FScrollPosY", sondern kannst einfach die Werte "CursorX" und "CursorY" verwenden.

Ich hatte bei meinem Editor noch ein Problem, das vielleicht in eine ähnliche Richtung geht: wenn der Benutzer eine lange Zeile schreibt, dann ist der Caret irgendwann rechts ausserhalb des eigentlichen Fensters und der Benutzer sieht nicht mehr, was er schreibt. Dafür habe ich eine eigene Methode "UpdateCaret" geschrieben und Scrolle wenn nötig das Fenster entsprechend:

Code: Alles auswählen

procedure TEditor.UpdateCaret;
var
  X, Y: Integer;
  W: Integer;
begin
  PosToCoord(CursorPos, X, Y);
  W := ClientWidth;
  while (X < 0) do
    begin
      ScrollBy(-W div 2, 0);
      inc(X, W div 2);
    end;
  while (X >= W) do
    begin
      ScrollBy(W div 2, 0);
      dec(X, W div 2);
    end;
  //  Analog für Y...
  SetCaretPos(X, Y);
end;

Dadurch ist der Caret immer im sichtbaren Bereich. Die einzelnen Teile wie PosToCoord und SetCaretPos hängen natürlich dann von deiner Implementation ab.

[pluto]

genau die Idee mit TEditor.UpdateCaret; ist zwar schon nicht schlecht, aber es gibt immer noch ein Problem, was ist wenn vom Cursor z.b. für eine Such Funktion direckt eine Zeile angesprungen wird die nicht im Sichtbereich liegt.

Oder ist genau dafür UpdateCaret da ?
Das ich damit genau den Scroll bereich bestimmen kann.

Also noch mal zu deiner frage:

Mir ist nun noch nicht ganz klar, in wie fern die Cursorposition Auswirkungen auf die ScrollBars haben soll.

Das ist doch ganz klar eigentlich, was ist wenn vom User die Cursorposition direkt gesetzt wird z.b. passiert das bei den Sprungmarken oder beim Suchen, dort werden die Cursorposition direkt gesetzt.

Was ist jetzt wenn die Cursorposition außerhalb des Scrollbereiches liegen ? dann muss dahin Gescrollt werden. Da hilft alles nix. Genau das ist mein Problem zur Zeit. Das ich den Scroll Bereich mit den Cursor Tasten verschieben kann oder mit der Maus(Scrollbalken) habe ich schon ganz gut hinbekommen, aber das alleine bringt mich ja nicht weiter. Leider.

Denn nach dem Scrollen kommt das Suchen dran. und da brauche ich halt diese Funktion.
Und ich bin mir nicht sicher ob es Aussreicht einfach fScrollX auf CaretX zu setzten.
ein versuch ist es zwar wert. Aber naja mal sehen.

Erstmal viele Dank für deine Tipps. ich hoffe dir ist jetzt mein Problem klar was ich meine...

[Aleks36]

Ich möchte im Moment noch nicht meinen ganzen Quelltext veröffentlichen, einfach weil's noch zu stark eine Baustelle ist und ich an allen Ecken und Enden herumbastle. Ich habe dir aber alle Methoden zusammengetragen, die bei mir für den Caret bzw. das Scollen verantwortlich sind.

Was dich vor allem interessieren dürfte ist die Methode DoScrollToCaret:

Code: Alles auswählen

procedure TEditor.DoScrollToCaret;
var
  X, Y: Integer;
begin
  CalcPosToCoord(CaretPos, X, Y);
  if (X <= 0) or (X >= ClientWidth) then
    begin
        dec(X, ClientWidth div 2);
        if (FTextWidth > 0) then X := X div FTextWidth;
    end
  else
      X := 0;
  if (Y <= 0) or (Y > (ClientHeight - FTextHeight)) then
    begin
        if (FTextHeight > 0) then Y := Y div FTextHeight;
        dec(Y, 1);
    end
  else
      Y := 0;
  DoScrollBy(X, Y);
  UpdateCaret;
end;

Zuerst wird bestimmt, wo der Caret wäre. Wenn ich einfach direkt DoScrollBy mit den Caret-Koordinaten aufrufen würde, dann wäre der Caret danach genau in der linken oberen Ecke des Fensters. Mit den Zeilen 9 und 17 stelle ich aber sicher, dass der Caret horizontal etwa in der Mitte des Fensters und vertikal in der zweiten Zeile steht.

Der Caret ist ja nicht in jedem Fall im Fenster sichtbar. Manchmal scrollt man auch mit der Maus in einen anderen Bereich des Textes, um etwas nachzuschauen und lässt dabei den Caret dort wo er ist. Sobald aber eine Taste gedrückt wird, rufe ich DoScrollToCaret auf, um den Caret wieder in das Blickfeld zu holen. Wenn er schon sichtbar ist, dann passiert natürlich nichts, weil nur gescrollt wird, wenn der Caret ausserhalb des sichtbaren Bereichs liegt.

Das Suchen habe ich ganz analog gelöst: ich durchsuche einfach den Text und wenn ich den Begriff gefunden habe, selektiere ich die Fundstelle und rufe wieder DoScrollToCaret auf.

---

Ich habe eben schon zwei verschiedene Möglichkeiten gesehen, wie man die Scrollbalken einsetzen kann. In der Regel geben die Scrollbalken ja die Position der linken oberen Fensterecke an. Aber es gibt auch Programme, wo die Scrollbalken die aktuelle Cursorposition angeben. Ich war mir nicht sicher, welche der beiden Varianten du umsetzen möchtest.

[pluto]

Erstmal Danke für deine Antwort !
Also ist bei dir DoScrollToCaret dafür Verantwortlich das der Cursor im Sichtbaren bereich.

Ich habe das eigentlich bei mir so gelöst: Beim Zeichen werden alle Zeichen ausgefiltern die nicht in das Aktuelle Rect(ScrollR) Pasen.

Beim Scrollen wird dieses Rect entsprechend angepasst.

edit: Leider fehlt mir die Procedure/Funktion: CalcPosToCoord
ich habe jetzt DoScrollToCaret angepasst. Aber leider geht das noch nicht.
Was ist bei der FTextWidth und FTextHeight ?
Wird dort gespeichert wie groß der Scroll bereich ist ?

Nochmals vielen Dank für deine Sorcen. und ich wollte eigentlich das übliche Scrollverhalten hinbekommen. z.b. das von SynEdit oder Gedit(Linux).

edit2: Ich kann jetzt zwar nach Recht Scrollen, aber nicht nach links.

Code: Alles auswählen

procedure TPlutoEditor.DoScrollToCaret;
var
  X, Y,w,xi: Integer;
begin
//  CalcPosToCoord(CaretPos, X, Y);
  x:=Rows.CursorPT.X; y:=Rows.CursorPT2.Y;
//  writeln('Test1:',x,'\',Rows.ScrollR.Right);
  if Rows.CursorX <=Rows.CurrLine.Count-1 then
    xi:=Rows.CursorX
  else
    xi:=Rows.CurrLine.Count-1;
 
  w:=Rows.ScrollR.Right-30-Rows.CurrLine.Items[xi].Pos1.Right;
  if (X <= 5) or (X >=w ) then begin
    if x >= w then dec(X, w);
 
    if (Rows.CursorPT.x <= 5) then begin
      writeln('X:',Rows.CursorPT2.x,'\',w);
 
      X := Rows.CursorPT.x div w;
    end;
  end
  else
      X := 0;
 
  if (Y <= 0) or (Y > (Rows.ScrollR.Bottom-Rows.Height)) then
    begin
        if (Rows.Height > 0) then Y := Y div Rows.Height;
        dec(Y, 1);
    end
  else
      Y := 0;
 
  //writeln('Test1:',x,'\',y);
  DoScrollBy(X, Y);
//  UpdateCaret;
end;

So sieht mein Code dazu jetzt aus.
Ich weiß auch nicht genau was bei dir FTextWidth ClientWidth bedeutet.
Meine Spalten fangen nicht bei 0 an sondern bei 5.

[Aleks36]

CalcPosToCoord
In der normalen TMemo-Komponente von Delphi wird die Position des Carets als Integer-Offset innerhalb des Textes angegeben. Dieser Offset muss je nach Bedarf in Bildschirm-Koordinaten umgerechnet werden. Genau dazu ist CalcPosToCoord da. Wenn du bereits die Caret_Position als TPoint mit X- und Y-Wert speicherst, dann wird diese Funktion natürlich mehr oder weniger überflüssig.

FTextHeight, FTextWidth
Bei mir wird nicht Pixelweise gescrollt, sondern Zeichenweise. Die Position des Caret muss aber für Windows in Pixeln angegeben werden. Daher brauche ich diese beiden Werte zum Umrechnen:
Pixel_X = Char_X * FTextWidth.

Wenn die Schrift eine feste Zeichenbreite hat (z.B. "Courier"), dann lassen sich diese Werte direkt bestimmen. Da ich aber auch Schriften mit variabler Zeichenbreite (z.B. "Arial") zulasse, schätze ich den Wert von "FTextWidth" z.B. durch FTextWidth = FTextHeight div 2. FTextHeight lässt sich immer exakt bestimmen -- das ist auch im Source drin.

Und hier kommt auch CalcPosToCoord noch einmal ins Spiel. Diese Funktion rechnet die internen Koordinaten (in Zeichen) in Bildschirm-Pixel-Koordinaten um. Das sieht in etwa so aus:

Code: Alles auswählen

procedure CalcPosToCoord(Pos: Integer; out X, Y: Integer);
begin
  // Pos in Zeile Y und Spalte X umrechnen
  X := (X - FScrollPosX) * FTextWidth;
  Y := (Y - FScrollPosY) * FTextHeight;
end;

Der erste Schritt hängt leider davon ab, wie du den Text intern verwaltest. Ich verwende dazu im Moment eine TStringList.

P.S. Alles gern geschehen. Ich habe das alles schliesslich auch nicht selber erfunden, sondern vieles aus verschiedenen Quellen zusammengetragen :).

[pluto]

Ich habe meinen vorletzen Beitrag noch mal bearbeitet, weil ich deine Antwort noch nicht gesehen hab. Also so wie ich deine Antwort verstehe müsste ich bereist die Pixel Angaben für mein Cursor schon speichern in Rows.CursortPT
wobei in Rows.CursorX z.b.die Spalte drin steht. Aber ich werde es Trozdem damit nochmal versuchen.

edit: Also beim besten willen, ich bekomme das einfach nicht hin. Ich glaube mir bleibt nix übrig als selbst mal in den Sorucen vom Memo rein. Bei SynEdit habe ich schon rein geschaut, aber auch nicht alles verstanden. Aber ich glaube die machen das auch so wie du es gemacht hast.

[Aleks36]

Leider bringen die Sourcen von TMemo nicht allzu viel. Im wesentlichen leitet TMemo die Aufgaben nur an Windows weiter und so sieht man nichts, wie es wirklich implementiert ist :-(.

Ich glaube, wir sprechen teilweise aneinander vorbei. Deshalb habe ich nochmals versucht, in Worten und mit einem Bild zusammenzufassen, wie die ganze Geschichte bei mir funktioniert, damit der Caret auch wirklich auf dem Bildschirm ist. Ich habe bei dieser Gelegenheit auch gleich einige Bezeichner sinnvoller gewählt - etwa CharWidth anstatt TextWidth.