Hallo!

Mit folgendem einfachen Code tauscht mein IOTA-Package den CommentText einer Codezeile ab einer bestimmten Caret-Position bis zum jeweiligen Zeilenende durch einen neuen Text aus:

zusammenfalten · markieren

Delphi-Quellcode:

  TopView := (BorlandIDEServices As IOTAEditorServices).TopView;

  oldCaretX := TopView.Buffer.EditPosition.GetColumn;
  oldCaretY := TopView.Buffer.EditPosition.GetRow;
  TopView.Buffer.EditPosition.Move(spcCaretLine,spcCaretCol);

  J := Length(QuellCodeAnsiStrList.Strings[spcCaretLine-1]) - spcCaretCol +1;
  if J > 0 then TopView.Buffer.EditPosition.Delete(J);
                                                                                
  if length(newCommentString) > 0 then
    TopView.Buffer.EditPosition.InsertText(newCommentString);

  TopView.Buffer.EditPosition.Move(oldCaretY,oldCaretX);

So weit so gut. Nur - wenn ich so einen Vorgang dann aber anschließend per IDE-Undo-Funktion rückgängig mache (per Ctrl-Z-Key oder Mausklick auf die UndoButton), dann wird dieser Undo-Akt eine ziemlich chaotische Sache, welche dann erst oft nach so 10-20 Klicks endet. Zwischendrin springt dann der Caret ganz gerne mal irgendwo in die Gegend, gerne auch mal an den Unit-Anfang insgesamt, um dann nach dem gefühlten "zigten" UndoButton-Klick endlich plötzlich doch wieder an der aufeinmal wiederhergestellten Ausgangszeile aufzutauchen.

Ich habe mir schon überlegt, ob das event. auch was mit meinem IOTA-Code zu tun haben könnte, mittels dem ich diesen Text mit einem anderen austausche. Aber der diesbezügliche IOTA-Code ist eigentlich so einfach, dass der so eine Undo-Irrung kaum verursacht haben könnte.

Gibts event. eine Möglichkeit, diesen Undo-Buffer selbst irgendwie zu manipulieren, bzgl. irgendwelcher Teilarbeiten ein- oder auszuschalten etc..

Bzw. man müsste das Undo so einstellen können, dass er alle ZwischenPositionen des Carets einfach unterdrückt und nur tatsächliche Textänderungen umsetzt. Vllt. noch mit einer einzigen Caret-Positionierung zu diesem TextänderungsOrt davor. Aber das müsste es dann gewesen sein, weil, wie gesagt, alles andere ziemlich schnell in Chaos ausartet.

Thx im Voraus
...

Ein alternatives Vorgehen wäre über CreateReader den Source zu lesen, die Änderungen darin machen und dann mit CreateUndoableWriter wieder zurückschreiben.

Thx, das besagte Chaos ist damit (fast) verschwunden. Gelegentlich allerdings macht der Caret vor der Wiederherstellung des Ausgangsstring immer nochmal einen kleinen einen-UndoKlick-langen Ausflug ans Unit-Ende oder an den Unit-Anfang. Kann man aber zur Not noch mit leben.

BTW:

Bei Methode 1

markieren

Code:

TopView.Buffer.EditPosition.InsertText(replaceCommentString);

hatte ich zwar diese Undo-Probleme, dafür aber kamen zumindest die Umlaute 'ö', 'ü', 'ä' korrekt im Text an.


Bei Methode 2

markieren

Code:

Writer.Insert(PAnsiChar(AnsiString(QuellCodeStrList.Text)));

kann man diesen exakt gleichen „replaceCommentString“-String jetzt gar nicht so ohne weiteres in diese QuellCodeStrList (ist eine StringListe mit dem QuellCode, den ich per IOTAEditReader ausgelesen habe) einbauen, OHNE dass dabei dann aus dessen Umlaute im resultierenden Quelltext kleine Rechtecke o.ä. werden.

Weiß event. noch jemand, in welch speziellem Format dieser „replaceCommentString“-String da zuvor in diese QuellCode-StringListe eingebaut werden muss?

Thx.

Hast du den Kommentar zu IOTAEditWriter gelesen? Da steht

Zitat:

To insert Unicode text using the "Insert" method, the "Text" parameter should be UTF8-encoded.

Thx, muss ich wohl tatsächlich irgendwie überlesen haben

Mit

markieren

Code:

newComment := PWideChar(utf8encode((replaceCommentString)));
...

sind besagte Probleme jetzt aber jedenfalls weg.

So, ich habe meinen Code jetzt nochmal ein bisschen verfeinert. Resultat: Auch diese nachher nochmal kurz erwähnten minimalen Undo-Probs sind verschwunden (wo es vor der Wiederherstellung des AusgangsStrings immer nochmal einen kleinen einen-UndoKlick-langen Caret-Ausflug ans Unit-Ende oder an den Unit-Anfang gab).

Hatte meinen Code ursprünglich von einem anderen Code abgeleitet, der immer den gesamten Quellcode ausgetauscht hatte. Und zwar per StringList, in der ich dann vorher einen bestimmten String speziell zu bearbeiten hatte. Das klappte auch ganz gut, brachte jedoch auch diese besagten kleine Undo-Probs mit sich.

Mein aktueller Code geht jetzt etwas in diese Richtung hier (und dort nach "CreateUndoableWriter" suchen) und tauscht nun auch nur noch mehr den tatsächlich zu ersetzenden Teilstring aus. Effekt: Alle Undo-Probs komplett verschwunden!

zusammenfalten · markieren

Delphi-Quellcode:

procedure TIDENotifier.replaceComment_Execution;
var
  I,BlankGap : integer;
  OTAModuleServices: IOTAModuleServices;
  Module: IOTAModule;
  sourceEditor: IOTASourceEditor;
  writer : IOTAEditWriter;
  CharPos1,CharPos2 : TOTACharPos;
  copyPos1, copyPos2 : longInt;

function unicodeCounts (aCaretPos : integer): integer;
var I : integer;
begin
  result := 0;
  for I := 1 to aCaretPos do
    if QuellCodeAnsiStrList.Strings[last_CharLine-1][I] <> QuellCodeStrList.Strings[last_CharLine-1][I+result] then inc(result);
end;

begin
  // Rückschreiben des geänderten QuellCodes mittels CreateUndoableWriter
  BorlandIDEServices.GetService(IOTAModuleServices, OTAModuleServices);
  Module := OTAModuleServices.CurrentModule;
  for I := 0 to Module.ModuleFileCount - 1 do
    If Module.GetModuleFileEditor(i).QueryInterface(IOTASourceEditor, sourceEditor) = S_OK
    then begin
         Writer := sourceEditor.CreateUndoableWriter;
         try
            if Length(QuellCodeAnsiStrList.Strings[last_CharLine-1])+1 >= last_CharCol // existiert noch eine Blank-Gap zwischen dem Zeilenende und der Position an der der neue Comment einzubauen ist?
            then begin // wenn nein
              BlankGap := 0;
              charPos1.CharIndex := last_CharCol-1 +unicodeCounts(last_CharCol-1); // +unicodeCounts() kann auch weggelassen werden, wenn man sicher ist, dass da keine UnicodeChars drin sind
            end
            else begin // wenn ja (es existiert noch eine Blank-Gap)
              BlankGap := last_CharCol - (Length(QuellCodeAnsiStrList.Strings[last_CharLine-1])+1);
              charPos1.CharIndex := Length(QuellCodeStrList.Strings[last_CharLine-1]) ; // +unicodeCounts() kann auch weggelassen werden, wenn man sicher ist, dass da keine UnicodeChars drin sind
            end;
            charPos1.Line := last_CharLine;
            copyPos1 := sourceEditor.EditViews[0].CharPosToPos(CharPos1);
            Writer.CopyTo(copyPos1);

            charPos2.CharIndex := Length(QuellCodeStrList.Strings[last_CharLine-1]); // bis inklusiv zum Zeilenende
            charPos2.Line := last_CharLine;
            copyPos2 := sourceEditor.EditViews[0].CharPosToPos(CharPos2);
            Writer.DeleteTo(copyPos2);

            Writer.Insert(PAnsiChar(AnsiString( utf8encode((StringOfChar(' ', BlankGap) + replaceCommentString)) )));
         finally
            Writer := nil;
         end;
    end;
end;