add synmemo.pas syneditplugins.pas synmacrorecorder.pas

git-svn-id: trunk@2282 -

.gitattributes

@@ -46,6 +46,7 @@ components/synedit/synedithighlighter.pp svneol=native#text/pascal
 components/synedit/syneditkeycmds.pp svneol=native#text/pascal
 components/synedit/syneditmiscclasses.pp svneol=native#text/pascal
 components/synedit/syneditmiscprocs.pp svneol=native#text/pascal
+components/synedit/syneditplugins.pas svneol=native#text/pascal
 components/synedit/syneditsearch.pp svneol=native#text/pascal
 components/synedit/syneditstrconst.pp svneol=native#text/pascal
 components/synedit/synedittextbuffer.pp svneol=native#text/pascal
@@ -56,6 +57,8 @@ components/synedit/synhighlighterlfm.pas svneol=native#text/pascal
 components/synedit/synhighlighterpas.pp svneol=native#text/pascal
 components/synedit/synhighlighterperl.pas svneol=native#text/pascal
 components/synedit/synhighlighterxml.pas svneol=native#text/pascal
+components/synedit/synmacrorecorder.pas svneol=native#text/pascal
+components/synedit/synmemo.pas svneol=native#text/pascal
 components/synedit/syntextdrawer.pp svneol=native#text/pascal
 debugger/breakpointsdlg.lrs svneol=native#text/pascal
 debugger/breakpointsdlg.pp svneol=native#text/pascal

components/synedit/synedit.pp

@@ -597,6 +597,7 @@ type
     {$ENDIF}
     function GetWordAtRowCol(XY: TPoint): string;
     procedure GotoBookMark(BookMark: Integer);
+    function IdentChars: TSynIdentChars;
     procedure InvalidateGutter;                                           
     procedure InvalidateLine(Line: integer);
     function IsBookmark(BookMark: integer): boolean;
@@ -5049,6 +5050,14 @@ begin
   end;
 end;
 
+function TCustomSynEdit.IdentChars: TSynIdentChars;
+begin
+  if Highlighter <> nil then
+    Result := Highlighter.IdentChars
+  else
+    Result := [#33..#255];
+end;
+
 procedure TCustomSynEdit.SetBookMark(BookMark: Integer; X: Integer; Y: Integer);
 var
   i: Integer;
@@ -6186,33 +6195,30 @@ function TCustomSynEdit.NextWordPos: TPoint;
 var
   CX, CY, LineLen: integer;
   Line: string;
-  IdentChars, WhiteChars: TSynIdentChars;
+  CurIdentChars, WhiteChars: TSynIdentChars;
 begin
   CX := CaretX;
   CY := CaretY;
   // valid line?
   if (CY >= 1) and (CY <= Lines.Count) then begin
     Line := Lines[CY - 1];
-    if Assigned(Highlighter) then
-      IdentChars := Highlighter.IdentChars
-    else
-      IdentChars := [#33..#255];
-    WhiteChars := [#1..#255] - IdentChars;
+    CurIdentChars:=IdentChars;
+    WhiteChars := [#1..#255] - CurIdentChars;
     LineLen := Length(Line);
     if CX >= LineLen then begin
       // find first IdentChar in the next line
       if CY < Lines.Count then begin
         Line := Lines[CY];
         Inc(CY);
-        CX := Max(1, StrScanForCharInSet(Line, 1, IdentChars));
+        CX := Max(1, StrScanForCharInSet(Line, 1, CurIdentChars));
       end;
     end else begin
       // find first "whitespace" if next char is an IdentChar
-      if Line[CX] in IdentChars then
+      if Line[CX] in CurIdentChars then
         CX := StrScanForCharInSet(Line, CX, WhiteChars);
       // if "whitespace" found find the first IdentChar behind
       if CX > 0 then
-        CX := StrScanForCharInSet(Line, CX, IdentChars);
+        CX := StrScanForCharInSet(Line, CX, CurIdentChars);
       // if one of those failed just position at the end of the line
       if CX = 0 then
         CX := LineLen + 1;
@@ -6225,7 +6231,7 @@ function TCustomSynEdit.PrevWordPos: TPoint;
 var
   CX, CY: integer;
   Line: string;
-  IdentChars, WhiteChars: TSynIdentChars;
+  CurIdentChars, WhiteChars: TSynIdentChars;
 begin
   CX := CaretX;
   CY := CaretY;
@@ -6233,11 +6239,8 @@ begin
   if (CY >= 1) and (CY <= Lines.Count) then begin
     Line := Lines[CY - 1];
     CX := Min(CX, Length(Line) + 1);
-    if Assigned(Highlighter) then
-      IdentChars := Highlighter.IdentChars
-    else
-      IdentChars := [#33..#255];
-    WhiteChars := [#1..#255] - IdentChars;
+    CurIdentChars:=IdentChars;
+    WhiteChars := [#1..#255] - CurIdentChars;
     if CX <= 1 then begin
       // find last IdentChar in the previous line
       if CY > 1 then begin
@@ -6248,7 +6251,7 @@ begin
     end else begin
       // if previous char is a "whitespace" search for the last IdentChar
       if Line[CX - 1] in WhiteChars then
-        CX := StrRScanForCharInSet(Line, CX - 1, IdentChars);
+        CX := StrRScanForCharInSet(Line, CX - 1, CurIdentChars);
       if CX > 0 then
         // search for the first IdentChar of this "word"
         CX := StrRScanForCharInSet(Line, CX - 1, WhiteChars) + 1

components/synedit/syneditkeycmds.pp

@@ -179,8 +179,21 @@ const
   ecTab             = 612;  // Tab key
   ecShiftTab        = 613;  // Shift+Tab key
 
+  ecUpperCase       = 620; // apply to the current or previous word
+  ecLowerCase       = 621;
+  ecToggleCase      = 622;
+  ecTitleCase       = 623;
+  ecUpperCaseBlock  = 625; // apply to current selection, or current char if no selection
+  ecLowerCaseBlock  = 626;
+  ecToggleCaseBlock = 627;
+
+  ecString          = 630;  //Insert a whole string
+
   ecAutoCompletion  = 650;
 
+  ecGotFocus        = 700;
+  ecLostFocus       = 701;
+
   ecUserFirst       = 1001; // Start of user-defined commands
 
 type

components/synedit/syneditplugins.pas

@@ -0,0 +1,572 @@
+{-------------------------------------------------------------------------------
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS" basis,
+WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+the specific language governing rights and limitations under the License.
+
+The Original Code is: SynEditPlugins.pas, released 2001-10-17.
+
+Author of this file is Flávio Etrusco.
+Portions created by Flávio Etrusco are Copyright 2001 Flávio Etrusco.
+All Rights Reserved.
+
+Contributors to the SynEdit project are listed in the Contributors.txt file.
+
+Alternatively, the contents of this file may be used under the terms of the
+GNU General Public License Version 2 or later (the "GPL"), in which case
+the provisions of the GPL are applicable instead of those above.
+If you wish to allow use of your version of this file only under the terms
+of the GPL and not to allow others to use your version of this file
+under the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the GPL.
+If you do not delete the provisions above, a recipient may use your version
+of this file under either the MPL or the GPL.
+
+$Id$
+
+You may retrieve the latest version of this file at the SynEdit home page,
+located at http://SynEdit.SourceForge.net
+
+Known Issues:
+-------------------------------------------------------------------------------}
+
+unit SynEditPlugins;
+
+{$I synedit.inc}
+
+interface
+
+uses
+  Classes,
+{$IFDEF SYN_CLX}
+  Qt,
+  Types,
+  QMenus,
+{$ELSE}
+  {$IFDEF SYN_LAZARUS}
+  LCLLinux,
+  {$ELSE}
+  Windows,
+  {$ENDIF}
+  Menus,
+{$ENDIF}
+  SynEdit,
+  SynEditKeyCmds;
+
+type
+  TAbstractSynPlugin = class(TComponent)
+  private
+    procedure SetEditor(const Value: TCustomSynEdit);
+    function GetEditors(aIndex: integer): TCustomSynEdit;
+    function GetEditor: TCustomSynEdit;
+    function GetEditorCount: integer;
+  protected
+    fEditors: TList;
+    procedure Notification(aComponent: TComponent;
+      aOperation: TOperation); override;
+    procedure DoAddEditor(aEditor: TCustomSynEdit); virtual;
+    procedure DoRemoveEditor(aEditor: TCustomSynEdit); virtual;
+    function AddEditor(aEditor: TCustomSynEdit): integer;
+    function RemoveEditor(aEditor: TCustomSynEdit): integer;
+  public
+    destructor Destroy; override;
+    property Editors[aIndex: integer]: TCustomSynEdit read GetEditors;
+    property EditorCount: integer read GetEditorCount;
+  published
+    property Editor: TCustomSynEdit read GetEditor write SetEditor;
+  end;
+
+  TAbstractSynHookerPlugin = class(TAbstractSynPlugin)
+  protected
+    procedure HookEditor(aEditor: TCustomSynEdit; aCommandID: TSynEditorCommand;
+      aOldShortCut, aNewShortCut: TShortCut);
+    procedure UnHookEditor(aEditor: TCustomSynEdit;
+      aCommandID: TSynEditorCommand; aShortCut: TShortCut);
+    procedure OnCommand(Sender: TObject; AfterProcessing: boolean;
+      var Handled: boolean; var Command: TSynEditorCommand; var aChar: char;
+      Data: pointer; HandlerData: pointer); virtual; abstract;
+  end;
+
+  TPluginState = (psNone, psExecuting, psAccepting, psCancelling);
+
+  TAbstractSynSingleHookPlugin = class(TAbstractSynHookerPlugin)
+  private
+    fCommandID: TSynEditorCommand;
+    function IsShortCutStored: Boolean;
+    procedure SetShortCut(const Value: TShortCut);
+  protected
+    fState: TPluginState;
+    fCurrentEditor: TCustomSynEdit;
+    fShortCut: TShortCut;
+    class function DefaultShortCut: TShortCut; virtual;
+    procedure DoAddEditor(aEditor: TCustomSynEdit); override;
+    procedure DoRemoveEditor(aEditor: TCustomSynEdit); override;
+    {}
+    procedure DoExecute; virtual; abstract;
+    procedure DoAccept; virtual; abstract;
+    procedure DoCancel; virtual; abstract;
+  public
+    constructor Create(aOwner: TComponent); override;
+    destructor Destroy; override;
+    property CommandID: TSynEditorCommand read fCommandID;
+    {}
+    property CurrentEditor: TCustomSynEdit read fCurrentEditor;
+    function Executing: boolean;
+    procedure Execute(aEditor: TCustomSynEdit);
+    procedure Accept;
+    procedure Cancel;
+  published
+    property ShortCut: TShortCut read fShortCut write SetShortCut
+      stored IsShortCutStored;
+  end;
+
+  { use TAbstractSynCompletion for non-visual completion }
+
+  TAbstractSynCompletion = class(TAbstractSynSingleHookPlugin)
+  protected
+    fCurrentString: String;
+  protected
+    procedure SetCurrentString(const Value: String); virtual;
+    procedure OnCommand(Sender: TObject; AfterProcessing: boolean;
+      var Handled: boolean; var Command: TSynEditorCommand; var aChar: char;
+      Data: pointer; HandlerData: pointer); override;
+    procedure DoExecute; override;
+    procedure DoAccept; override;
+    procedure DoCancel; override;
+    function GetCurrentEditorString: String; virtual;
+  public
+    procedure AddEditor(aEditor: TCustomSynEdit);
+    property CurrentString: String read fCurrentString write SetCurrentString;
+  end;
+
+function NewPluginCommand: TSynEditorCommand;
+procedure ReleasePluginCommand(aCmd: TSynEditorCommand);
+
+implementation
+
+uses
+  SynEditTypes,
+  SysUtils,
+{$IFDEF SYN_CLX}
+  QForms,
+{$ELSE}
+  Forms,
+{$ENDIF}
+  SynEditStrConst,
+  SynEditMiscProcs;
+
+const
+  ecPluginBase = 64000;
+
+var
+  gCurrentCommand: integer;
+
+function NewPluginCommand: TSynEditorCommand;
+begin
+  Result := gCurrentCommand;
+  Inc( gCurrentCommand );
+end;
+
+procedure ReleasePluginCommand(aCmd: TSynEditorCommand);
+begin
+  if aCmd = Pred( gCurrentCommand ) then
+    gCurrentCommand := aCmd;
+end;
+
+{ TAbstractSynPlugin }
+
+function TAbstractSynPlugin.AddEditor(aEditor: TCustomSynEdit): integer;
+begin
+  if fEditors = nil then
+  begin
+    fEditors := TList.Create;
+  end
+  else
+    if fEditors.IndexOf( aEditor ) >= 0 then
+    begin
+      Result := -1;
+      Exit;
+    end;
+  aEditor.FreeNotification( Self );
+  Result := fEditors.Add( aEditor );
+  DoAddEditor( aEditor );
+end;
+
+destructor TAbstractSynPlugin.Destroy;
+begin
+  { RemoveEditor will free fEditors when it reaches count = 0}
+  while Assigned( fEditors ) do
+    RemoveEditor( Editors[0] );
+  inherited;
+end;
+
+procedure TAbstractSynPlugin.Notification(aComponent: TComponent;
+  aOperation: TOperation);
+begin
+  inherited;
+  if aOperation = opRemove then
+  begin
+    if (aComponent = Editor) or (aComponent is TCustomSynEdit) then
+      RemoveEditor( TCustomSynEdit(aComponent) );
+  end;
+end;
+
+procedure TAbstractSynPlugin.DoAddEditor(aEditor: TCustomSynEdit);
+begin
+
+end;
+
+procedure TAbstractSynPlugin.DoRemoveEditor(aEditor: TCustomSynEdit);
+begin
+
+end;
+
+function TAbstractSynPlugin.RemoveEditor(aEditor: TCustomSynEdit): integer;
+begin
+  if fEditors = nil then
+  begin
+    Result := -1;
+    Exit;
+  end;
+  Result := fEditors.Remove( aEditor );
+  //aEditor.RemoveFreeNotification( Self );
+  if fEditors.Count = 0 then
+  begin
+    fEditors.Free;
+    fEditors := nil;
+  end;
+  if Result >= 0 then
+    DoRemoveEditor( aEditor );
+end;
+
+procedure TAbstractSynPlugin.SetEditor(const Value: TCustomSynEdit);
+var
+  iEditor: TCustomSynEdit;
+begin
+  iEditor := Editor;
+  if iEditor <> Value then
+  try
+    if (iEditor <> nil) and (fEditors.Count = 1) then
+      RemoveEditor( iEditor );
+    if Value <> nil then
+      AddEditor( Value );
+  except
+    if [csDesigning] * ComponentState = [csDesigning] then
+      Application.HandleException(Self)
+    else
+      raise;
+  end;
+end;
+
+function TAbstractSynPlugin.GetEditors(aIndex: integer): TCustomSynEdit;
+begin
+  Result := TCustomSynEdit(fEditors[aIndex]);
+end;
+
+function TAbstractSynPlugin.GetEditor: TCustomSynEdit;
+begin
+  if fEditors <> nil then
+    Result := TCustomSynEdit(fEditors[0])
+  else
+    Result := nil;
+end;
+
+function TAbstractSynPlugin.GetEditorCount: integer;
+begin
+  if fEditors <> nil then
+    Result := fEditors.Count
+  else
+    Result := 0;
+end;
+
+{ TAbstractSynHookerPlugin }
+
+procedure TAbstractSynHookerPlugin.HookEditor(aEditor: TCustomSynEdit;
+  aCommandID: TSynEditorCommand; aOldShortCut, aNewShortCut: TShortCut);
+var
+  iIndex: integer;
+  iKeystroke: TSynEditKeyStroke;
+begin
+  Assert( aNewShortCut <> 0 );
+  { shortcurts aren't created while in design-time }
+  if [csDesigning] * ComponentState = [csDesigning] then
+  begin
+    if TSynEdit(aEditor).Keystrokes.FindShortcut( aNewShortCut ) >= 0 then
+      raise ESynKeyError.Create(SYNS_EDuplicateShortCut)
+    else
+      Exit;
+  end;
+  { tries to update old Keystroke }
+  if aOldShortCut <> 0 then
+  begin
+    iIndex := TSynEdit(aEditor).Keystrokes.FindShortcut( aOldShortCut );
+    if (iIndex >= 0) then
+    begin
+      iKeystroke := TSynEdit(aEditor).Keystrokes[iIndex];
+      if iKeystroke.Command = aCommandID then
+      begin
+        iKeystroke.ShortCut := aNewShortCut;
+        Exit;
+      end;
+    end;
+  end;
+  { new Keystroke }
+  iKeystroke := TSynEdit(aEditor).Keystrokes.Add;
+  try
+    iKeystroke.ShortCut := aNewShortCut;
+  except
+    iKeystroke.Free;
+    raise;
+  end;
+  iKeystroke.Command := aCommandID;
+  aEditor.RegisterCommandHandler( {$IFDEF FPC}@{$ENDIF}OnCommand, Self );
+end;
+
+procedure TAbstractSynHookerPlugin.UnHookEditor(aEditor: TCustomSynEdit;
+  aCommandID: TSynEditorCommand; aShortCut: TShortCut);
+var
+  iIndex: integer;
+begin
+  aEditor.UnregisterCommandHandler( {$IFDEF FPC}@{$ENDIF}OnCommand );
+  iIndex := TSynEdit(aEditor).Keystrokes.FindShortcut( aShortCut );
+  if (iIndex >= 0) and
+    (TSynEdit(aEditor).Keystrokes[iIndex].Command = aCommandID) then
+    TSynEdit(aEditor).Keystrokes[iIndex].Free;
+end;
+
+{ TAbstractSynHookerPlugin }
+
+procedure TAbstractSynSingleHookPlugin.Accept;
+begin
+  fState := psAccepting;
+  try
+    DoAccept;
+  finally
+    fCurrentEditor := nil;
+    fState := psNone;
+  end;
+end;
+
+procedure TAbstractSynSingleHookPlugin.Cancel;
+begin
+  fState := psCancelling;
+  try
+    DoCancel;
+  finally
+    fCurrentEditor := nil;
+    fState := psNone;
+  end;
+end;
+
+constructor TAbstractSynSingleHookPlugin.Create(aOwner: TComponent);
+begin
+  inherited;
+  fCommandID := NewPluginCommand;
+  fShortCut := DefaultShortCut;
+end;
+
+class function TAbstractSynSingleHookPlugin.DefaultShortCut: TShortCut;
+begin
+  Result := 0;
+end;
+
+destructor TAbstractSynSingleHookPlugin.Destroy;
+begin
+  if Executing then
+    Cancel;
+  ReleasePluginCommand( CommandID );
+  inherited;
+end;
+
+procedure TAbstractSynSingleHookPlugin.DoAddEditor(
+  aEditor: TCustomSynEdit);
+begin
+  if ShortCut <> 0 then
+    HookEditor( aEditor, CommandID, 0, ShortCut );
+end;
+
+procedure TAbstractSynSingleHookPlugin.Execute(aEditor: TCustomSynEdit);
+begin
+  if Executing then
+    Cancel;
+  Assert( fCurrentEditor = nil );
+  fCurrentEditor := aEditor;
+  Assert( fState = psNone );
+  fState := psExecuting;
+  try
+    DoExecute;
+  except
+    Cancel;
+    raise;
+  end;
+end;
+
+function TAbstractSynSingleHookPlugin.Executing: boolean;
+begin
+  Result := fState = psExecuting;
+end;
+
+function TAbstractSynSingleHookPlugin.IsShortCutStored: Boolean;
+begin
+  Result := fShortCut <> DefaultShortCut;
+end;
+
+procedure TAbstractSynSingleHookPlugin.DoRemoveEditor(aEditor: TCustomSynEdit);
+begin
+  if ShortCut <> 0 then
+    UnHookEditor( aEditor, CommandID, ShortCut );
+  if Executing and (CurrentEditor = aEditor) then
+    Cancel;
+end;
+
+procedure TAbstractSynSingleHookPlugin.SetShortCut(const Value: TShortCut);
+var
+  cEditor: integer;
+begin
+  if fShortCut <> Value then
+  begin
+    if Assigned(fEditors) then
+      if Value <> 0 then
+      begin
+        for cEditor := 0 to fEditors.Count -1 do
+          HookEditor( Editors[cEditor], CommandID, fShortCut, Value );
+      end
+      else
+      begin
+        for cEditor := 0 to fEditors.Count -1 do
+          UnHookEditor( Editors[cEditor], CommandID, fShortCut );
+      end;
+    fShortCut := Value;
+  end;
+end;
+
+{ TAbstractSynCompletion }
+
+function TAbstractSynCompletion.GetCurrentEditorString: String;
+var
+  iString: String;
+  cCol: integer;
+  iIdentChars: TSynIdentChars;
+begin
+  iString := CurrentEditor.LineText;
+  if (CurrentEditor.CaretX > 1) and
+    (CurrentEditor.CaretX -1 <= Length(iString)) then
+  begin
+    iIdentChars := CurrentEditor.IdentChars;
+    for cCol := CurrentEditor.CaretX -1 downto 1 do
+      if not (iString[cCol] in iIdentChars) then
+        break;
+    Result := Copy( iString, cCol +1, CurrentEditor.CaretX - cCol -1);
+  end;
+end;
+
+procedure TAbstractSynCompletion.DoAccept;
+begin
+  fCurrentString := '';
+end;
+
+procedure TAbstractSynCompletion.DoCancel;
+begin
+  fCurrentString := '';
+end;
+
+procedure TAbstractSynCompletion.DoExecute;
+begin
+  CurrentString := GetCurrentEditorString;
+end;
+
+procedure TAbstractSynCompletion.OnCommand(Sender: TObject;
+  AfterProcessing: boolean; var Handled: boolean;
+  var Command: TSynEditorCommand; var aChar: char; Data,
+  HandlerData: pointer);
+var
+  iString: String;
+begin
+  if not Executing then
+  begin
+    if (Command = CommandID) then
+    begin
+      Execute( Sender as TCustomSynEdit );
+      Handled := True;
+    end;
+  end
+  else { Executing }
+    if Sender = CurrentEditor then
+    begin
+      if not AfterProcessing then
+      begin
+          case Command of
+            ecChar:
+              if aChar = #27 then
+              begin
+                Cancel;
+                Handled := True;
+              end
+              else
+              begin
+                if not(aChar in CurrentEditor.IdentChars) then
+                  Accept;
+                {don't handle the char}
+              end;
+            ecLineBreak:
+            begin
+              Accept;
+              Handled := True;
+            end;
+            ecLeft, ecSelLeft:
+              if CurrentString = '' then
+                Handled := True;
+            ecDeleteLastChar:
+              if CurrentString = '' then
+                Handled := True;
+            ecTab:
+              Accept;
+            ecDeleteChar,
+            ecRight, ecSelRight,
+            ecLostFocus, ecGotFocus:
+              ; {processed on AfterProcessing}
+            else
+              Cancel;
+          end;
+      end
+      else { AfterProcessing }
+        case Command of
+          ecLostFocus, ecGotFocus,
+          ecDeleteChar:
+            ;
+          ecDeleteLastChar,
+          ecLeft, ecSelLeft,
+          ecChar:
+            CurrentString := GetCurrentEditorString;
+          ecRight, ecSelRight: begin
+            iString := GetCurrentEditorString;
+            if iString = '' then
+              Cancel
+            else
+              CurrentString := iString;
+          end;
+          else
+            if CurrentString <> GetCurrentEditorString then
+              Cancel;
+        end;
+    end; {endif Sender = CurrentEditor}
+end;
+
+procedure TAbstractSynCompletion.SetCurrentString(const Value: String);
+begin
+  fCurrentString := Value;
+end;
+
+procedure TAbstractSynCompletion.AddEditor(aEditor: TCustomSynEdit);
+begin
+  inherited AddEditor(aEditor);
+end;
+
+initialization
+  gCurrentCommand := ecPluginBase;
+
+end.

components/synedit/synmemo.pas

@@ -0,0 +1,218 @@
+{-------------------------------------------------------------------------------
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS" basis,
+WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+the specific language governing rights and limitations under the License.
+
+The Original Code is: SynMemo.pas, released 2000-04-07.
+The Original Code is based on mwCustomEdit.pas by Martin Waldenburg, part of
+the mwEdit component suite.
+Portions created by Martin Waldenburg are Copyright (C) 1998 Martin Waldenburg.
+All Rights Reserved.
+
+Contributors to the SynEdit and mwEdit projects are listed in the
+Contributors.txt file.
+
+Alternatively, the contents of this file may be used under the terms of the
+GNU General Public License Version 2 or later (the "GPL"), in which case
+the provisions of the GPL are applicable instead of those above.
+If you wish to allow use of your version of this file only under the terms
+of the GPL and not to allow others to use your version of this file
+under the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the GPL.
+If you do not delete the provisions above, a recipient may use your version
+of this file under either the MPL or the GPL.
+
+$Id$
+
+You may retrieve the latest version of this file at the SynEdit home page,
+located at http://SynEdit.SourceForge.net
+
+Known Issues:
+  - a handler for the different EM_XXX messages has to be implemented to make
+    this more compatible with TMemo
+-------------------------------------------------------------------------------}
+
+unit SynMemo;
+
+{$I synedit.inc}
+
+interface
+
+uses
+  Classes,
+{$IFDEF SYN_CLX}
+  Qt,
+  Types,
+{$ELSE}
+  {$IFDEF SYN_LAZARUS}
+  LCLLinux,
+  {$ELSE}
+  Windows,
+  {$ENDIF}
+{$ENDIF}
+  SynEdit;
+
+//SelStart and SelEnd are now in TCustomSynEdit                                 //DDH Addition
+
+type
+  TCustomSynMemo = class(TCustomSynEdit)
+  public
+    function CharIndexToRowCol(Index: integer): TPoint;                         //as 2000-11-09
+    function RowColToCharIndex(RowCol: TPoint): integer;                        //as 2000-11-09
+  end;
+
+  TSynMemo = class(TCustomSynMemo)
+{begin}                                                                         //mh 2000-09-23
+  public
+    // TCustomSynMemo properties
+{end}                                                                           //mh 2000-09-23
+  published
+    // inherited properties
+(*    property Align;
+{$IFDEF SYN_COMPILER_4_UP}
+    property Anchors;
+    property Constraints;
+{$ENDIF}
+    property Color;
+  {$IFNDEF SYN_CLX}
+    property Ctl3D;
+  {$ENDIF}
+    property Enabled;
+    property Font;
+    property Height;
+    property Name;
+    property ParentColor;
+  {$IFNDEF SYN_CLX}
+    property ParentCtl3D;
+  {$ENDIF}
+    property ParentFont;
+    property ParentShowHint;
+    property PopupMenu;
+    property ShowHint;
+    property TabOrder;
+    property TabStop default True;
+    property Tag;
+    property Visible;
+    property Width;
+    // inherited events
+    property OnClick;
+    property OnDblClick;
+    property OnDragDrop;
+    property OnDragOver;
+{$IFDEF SYN_COMPILER_4_UP}
+{$IFNDEF SYN_CLX}
+{$IFNDEF SYN_LAZARUS}
+    property OnEndDock;
+{$ENDIF}
+{$ENDIF}
+{$ENDIF}
+    property OnEndDrag;
+    property OnEnter;
+    property OnExit;
+    property OnKeyDown;
+    property OnKeyPress;
+    property OnKeyUp;
+    property OnMouseDown;
+    property OnMouseMove;
+    property OnMouseUp;
+{$IFDEF SYN_COMPILER_4_UP}
+{$IFNDEF SYN_CLX}
+{$IFNDEF SYN_LAZARUS}
+    property OnStartDock;
+{$ENDIF}
+{$ENDIF}
+{$ENDIF}
+    property OnStartDrag;
+    // TCustomSynEdit properties
+    property BookMarkOptions;
+    property BorderStyle;
+    property ExtraLineSpacing;
+    property Gutter;
+    property HideSelection;
+    property Highlighter;
+    property InsertCaret;
+    property InsertMode;
+    property Keystrokes;
+    property Lines;
+    property MaxLeftChar;
+    property MaxUndo;
+    property Options;
+    property OverwriteCaret;
+    property ReadOnly;
+    property RightEdge;
+    property RightEdgeColor;
+    {$IFNDEF SYN_LAZARUS}
+    property SearchEngine;
+    {$ENDIF}
+    property ScrollBars;
+    property SelectedColor;
+    property SelectionMode;
+    property TabWidth;
+    property WantTabs;
+    // TCustomSynEdit events
+    property OnChange;
+    property OnClearBookmark;                                                   // djlp 2000-08-29
+    property OnCommandProcessed;
+    property OnDropFiles;
+    property OnGutterClick;
+    {$IFNDEF SYN_LAZARUS}
+    property OnGutterGetText;
+    property OnGutterPaint;
+    {$ENDIF}
+    property OnPaint;
+    property OnPlaceBookmark;
+    property OnProcessCommand;
+    property OnProcessUserCommand;
+    property OnReplaceText;
+    property OnSpecialLineColors;
+    property OnStatusChange;
+    {$IFNDEF SYN_LAZARUS}
+    property OnPaintTransient;
+    {$ENDIF} *)
+  end;
+
+implementation
+
+uses
+  SynEditStrConst, SynEditMiscProcs;
+
+{ TCustomSynMemo }
+
+function TCustomSynMemo.CharIndexToRowCol(Index: integer): TPoint;
+var
+  x, y, Chars: integer;
+begin
+  x := 0;
+  y := 0;
+  Chars := 0;
+  while y < Lines.Count do begin
+    x := Length(Lines[y]);
+    if Chars + x + 2 > Index then begin
+      x := Index - Chars;
+      break;
+    end;
+    Inc(Chars, x + 2);
+    x := 0;
+    Inc(y);
+  end;
+  Result := Point(x + 1, y + 1);
+end;
+
+function TCustomSynMemo.RowColToCharIndex(RowCol: TPoint): integer;
+var
+  i: integer;
+begin
+  Result := 0;
+  RowCol.y := Min(Lines.Count, RowCol.y) - 1;
+  for i := 0 to RowCol.y - 1 do
+    Result := Result + Length(Lines[i]) + 2;
+  Result := Result + RowCol.x;
+end;
+
+end.
+