syneditactions.pas

SynEditStudio delphi 代码编辑器

{$ELSE}
{$IFDEF SYN_COMPILER_4_UP}
    property DoEndDock: Boolean read FDoEndDock write FDoEndDock;
    property DoStartDock: Boolean read FDoStartDock write FDoStartDock;
{$ENDIF}
{$ENDIF}
    property DoEndDrag: Boolean read FDoEndDrag write FDoEndDrag;
    property DoEnter: Boolean read FDoEnter write FDoEnter;
    property DoExit: Boolean read FDoExit write FDoExit;
    property DoKeyDown: Boolean read FDoKeyDown write FDoKeyDown;
    property DoKeyPress: Boolean read FDoKeyPress write FDoKeyPress;
    property DoKeyUp: Boolean read FDoKeyUp write FDoKeyUp;
    property DoMouseDown: Boolean read FDoMouseDown write FDoMouseDown;
    property DoMouseMove: Boolean read FDoMouseMove write FDoMouseMove;
    property DoMouseUp: Boolean read FDoMouseUp write FDoMouseUp;
    property DoStartDrag: Boolean read FDoStartDrag write FDoStartDrag;
    property DoLoadDocument : Boolean read FDoLoadDocument
      write FDoLoadDocument;
    property DoSaveDocument : Boolean read FDoSaveDocument
      write FDoSaveDocument;
    property DoCloseDocument : Boolean read FDoCloseDocument
      write FDoCloseDocument;
    property DoChange: Boolean read FDoChange write FDoChange;
    property DoClearBookmark: Boolean read FDoClearMark
      write FDoClearMark;
    property DoCommandProcessed: Boolean
      read FDoCommandProcessed write FDoCommandProcessed;
    property DoContextHelp: Boolean
      read FDoContextHelp write FDoContextHelp;
    property DoDropFiles: Boolean read FDoDropFiles write FDoDropFiles;
    property DoGutterClick: Boolean
      read FDoGutterClick write FDoGutterClick;
    property DoGutterGetText: Boolean read FDoGutterGetText
      write FDoGutterGetText;
    property DoGutterPaint: Boolean read FDoGutterPaint
      write FDoGutterPaint;
    property DoMouseCursor: Boolean read FDoMouseCursor
      write FDoMouseCursor;
    property DoPaint: Boolean read FDoPaint write FDoPaint;
    property DoPlaceBookmark: Boolean
      read FDoPlaceMark write FDoPlaceMark;
    property DoProcessCommand: Boolean
      read FDoProcessCommand write FDoProcessCommand;
    property DoProcessUserCommand: Boolean
      read FDoProcessUserCommand write FDoProcessUserCommand;
    property DoReplaceText: Boolean read FDoReplaceText
      write FDoReplaceText;
    property DoScroll: Boolean
      read FDoScroll write FDoScroll;
    property DoSpecialLineColors: Boolean
      read FDoSpecialLineColors write FDoSpecialLineColors;
    property DoStatusChange: Boolean
      read FDoStatusChange write FDoStatusChange;
    property DoPaintTransient: Boolean
      read FDoPaintTransient write FDoPaintTransient;

    property OnClick: TNotifyEvent read FOnClick write FOnClick;
    property OnDblClick: TNotifyEvent read FOnDblClick write FOnDblClick;
    property OnDragDrop: TDragDropEvent read FOnDragDrop write FOnDragDrop;
    property OnDragOver: TDragOverEvent read FOnDragOver write FOnDragOver;
{$IFDEF SYN_CLX}
{$ELSE}
{$IFDEF SYN_COMPILER_4_UP}
    property OnEndDock: TEndDragEvent read FOnEndDock write FOnEndDock;
    property OnStartDock: TStartDockEvent read FOnStartDock write FOnStartDock;
{$ENDIF}
{$ENDIF}
    property OnEndDrag: TEndDragEvent read FOnEndDrag write FOnEndDrag;
    property OnEnter: TNotifyEvent read FOnEnter write FOnEnter;
    property OnExit: TNotifyEvent read FOnExit write FOnExit;
    property OnKeyDown: TKeyEvent read FOnKeyDown write FOnKeyDown;
    property OnKeyPress: TKeyPressEvent read FOnKeyPress write FOnKeyPress;
    property OnKeyUp: TKeyEvent read FOnKeyUp write FOnKeyUp;
    property OnMouseDown: TMouseEvent read FOnMouseDown write FOnMouseDown;
    property OnMouseMove: TMouseMoveEvent read FOnMouseMove write FOnMouseMove;
    property OnMouseUp: TMouseEvent read FOnMouseUp write FOnMouseUp;
    property OnStartDrag: TStartDragEvent read FOnStartDrag write FOnStartDrag;

    property OnLoadDocument : TSynDocumentEvent read FOnLoadDocument
      write FOnLoadDocument;
    property OnSaveDocument : TSynDocumentEvent read FOnSaveDocument
      write FOnSaveDocument;
    property OnCloseDocument : TNotifyEvent read FOnCloseDocument
      write FOnCloseDocument;
    property OnChange: TNotifyEvent read FOnChange write FOnChange;
    property OnClearBookmark: TPlaceMarkEvent read fOnClearMark
      write fOnClearMark;
    property OnCommandProcessed: TProcessCommandEvent
      read fOnCommandProcessed write fOnCommandProcessed;
    property OnContextHelp: TContextHelpEvent
      read fOnContextHelp write fOnContextHelp;
    property OnDropFiles: TDropFilesEvent read fOnDropFiles write fOnDropFiles;
    property OnGutterClick: TGutterClickEvent
      read fOnGutterClick write fOnGutterClick;
    property OnGutterGetText: TGutterGetTextEvent read fOnGutterGetText
      write fOnGutterGetText;
    property OnGutterPaint: TGutterPaintEvent read fOnGutterPaint
      write fOnGutterPaint;
    property OnMouseCursor: TMouseCursorEvent read fOnMouseCursor
      write fOnMouseCursor;
    property OnPaint: TPaintEvent read fOnPaint write fOnPaint;
    property OnPlaceBookmark: TPlaceMarkEvent
      read FOnPlaceMark write FOnPlaceMark;
    property OnProcessCommand: TProcessCommandEvent
      read FOnProcessCommand write FOnProcessCommand;
    property OnProcessUserCommand: TProcessCommandEvent
      read FOnProcessUserCommand write FOnProcessUserCommand;
    property OnReplaceText: TReplaceTextEvent read fOnReplaceText
      write fOnReplaceText;
    property OnScroll: TScrollEvent
      read fOnScroll write fOnScroll;
    property OnSpecialLineColors: TSpecialLineColorsEvent
      read fOnSpecialLineColors write fOnSpecialLineColors;
    property OnStatusChange: TStatusChangeEvent
      read fOnStatusChange write fOnStatusChange;
    property OnPaintTransient: TPaintTransient
      read fOnPaintTransient write fOnPaintTransient;
  end;

  TSynActionsEvent = class(TComponent)
  private
    FOnCloseEditor: TSynCloseEvent;
    FOnCreateEditor: TSynCreateEditorEvent;
    FOnActionsExecute: TSynEditExecuteEvent;
    FOnActionsUpdate: TSynEditUpdateEvent;
  public
    constructor Create(AOwner : TComponent);override;
    destructor destroy;override;
  published
    property OnActionsUpdate : TSynEditUpdateEvent read FOnActionsUpdate
      write FOnActionsUpdate;
    property OnActionsExecute : TSynEditExecuteEvent read FOnActionsExecute
      write FOnActionsExecute;
    property OnCreateEditor : TSynCreateEditorEvent read FOnCreateEditor
      write FOnCreateEditor;
    property OnCloseEditor : TSynCloseEvent read FOnCloseEditor
      write FOnCloseEditor;
  end;

var
  Manager : TSynCustomManager = nil;
  ActionsEvent : TSynActionsEvent = nil;
  EditorsEvent : TSynEditorsEvent = nil;

function ActiveSynEditor : TCustomSynEditor;
procedure ExecuteAction(Action : TSynCustomAction;
  SynEditor : TCustomSynEditor = nil);

implementation

uses
  SynPreviewDlg, SynPageSetupDlg, SynFindDlg, SynReplaceDlg, SynJumpDlg,
  SynOptionsDlg, SynToggleHighlighterDlg, SynSpellCheckDlg, SynSpellCheckOpDlg,
  SynHighlighterDlg;

var
  InitialDir : string;
  FilterIndex : Integer;

  aSynClose : TaSynClose;
  aSynNew : TaSynNew;
  aSynOpen: TaSynOpen;

procedure ExecuteAction(Action : TSynCustomAction;
  SynEditor : TCustomSynEditor = nil);
begin
  if SynEditor = nil then
    Action.ExecuteTarget(ActiveSynEditor)
  else
    Action.ExecuteTarget(SynEditor)
end;

function ActiveSynEditor : TCustomSynEditor;
var
  i : integer;
begin
  Result := nil;
  if Manager <> nil then
    for i := 0 to Manager.EditorCount-1 do
    begin
      if ((FocusSynEditor <> nil) and (Manager.Editors[i] = FocusSynEditor)) or
        (Manager.Editors[i].Focused) then
      begin
        result := Manager.Editors[i];
        exit;
      end;
    end;
end;

{ TSynCustomAction }

function TSynCustomAction.HandlesTarget(Target: TObject): Boolean;
begin
  result := SynEditAllocated(Target);
end;

procedure TSynCustomAction.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited;
  if (AComponent = FSynEdit) and (Operation = opremove) then
    FSynEdit := nil;
end;

procedure TSynCustomAction.SetSynEdit(const Value: TCustomSynEditor);
begin
  if FSynEdit <> nil then
    FSynEdit.RemoveFreeNotification(self);
  FSynEdit := Value;
  if FSynEdit <> nil then
    FSynEdit.FreeNotification(self);
end;

function TSynCustomAction.SynEditAllocated(Target: TObject) : Boolean;
begin
  FActiveSynEdit := nil;
  if (FSynEdit <> nil) then
    FActiveSynEdit := FSynEdit
  else if (Manager <> nil) and (Manager.FSynEditor <> nil) then
    FActiveSynEdit := Manager.FSynEditor
  else if (Target <> nil) and (Target is TCustomSynEditor) then
    FActiveSynEdit := TCustomSynEditor(Target);
  Result := FActiveSynEdit <> nil;
end;

{ TSynEditUndo }

procedure TaSynUndo.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.Undo;
end;

function TaSynUndo.HandlesTarget(Target: TObject): Boolean;
begin
  result := SynEditAllocated(Target) and FActiveSynEdit.CanUndo;
end;

{ TSynEditRedo }

procedure TaSynRedo.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.Redo;
end;

function TaSynRedo.HandlesTarget(Target: TObject): Boolean;
begin
  result := SynEditAllocated(Target) and FActiveSynEdit.CanRedo;
end;

{ TSynEditCut }

procedure TaSynCut.ExecuteTarget(Target: TObject);
begin
  IF SynEditAllocated(Target) then
    FActiveSynEdit.CutToClipboard;
end;

{ TSynEditCopy }

procedure TaSynCopy.ExecuteTarget(Target: TObject);
begin
  If SynEditAllocated(Target) then
    FActiveSynEdit.CopyToClipboard;
end;

function TaSynCopy.HandlesTarget(Target: TObject): Boolean;
begin
  result := SynEditAllocated(Target) and FActiveSynEdit.SelAvail;
end;

{ TSynEditPaste }

procedure TaSynPaste.ExecuteTarget(Target: TObject);
begin
  If SynEditAllocated(Target) then
    FActiveSynEdit.PasteFromClipboard;
end;

function TaSynPaste.HandlesTarget(Target: TObject): Boolean;
begin
  result := SynEditAllocated(Target) and FActiveSynEdit.CanPaste;
end;

{ TSynEditAction }

procedure TSynEditAction.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(FOnExecute) then
    FOnExecute(Self, FActiveSynEdit)
  else if SynEditAllocated(Target) and (ActionsEvent <> nil) and
    Assigned(ActionsEvent.OnActionsExecute) then
    ActionsEvent.OnActionsExecute(Self, FActiveSynEdit)
end;

function TSynEditAction.HandlesTarget(Target: TObject): Boolean;
begin
  result := SynEditAllocated(Target);
  if SynEditAllocated(Target) and Assigned(FOnUpdate) then
    Result := FOnUpdate(Self, FActiveSynEdit)
  else if SynEditAllocated(Target) and (ActionsEvent <> nil) and
    Assigned(ActionsEvent.OnActionsUpdate) then
    Result := ActionsEvent.OnActionsUpdate(Self, FActiveSynEdit)
end;

{ TSynEditUpperCase }

procedure TaSynUpperCase.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.ExecuteCommand(ecAutoUpperCase, #0, nil);
end;

{ TSynChangeAction }

function TSynChangeAction.HandlesTarget(Target: TObject): Boolean;
begin
  Result := SynEditAllocated(Target) and not FActiveSynEdit.ReadOnly;
end;

{ TSynEditLowerCase }

procedure TaSynLowerCase.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.ExecuteCommand(ecAutoLowerCase, #0, nil);
end;

{ TSynEditToggleCase }

procedure TaSynToggleCase.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.ExecuteCommand(ecAutoToggleCase, #0, nil);
end;

{ TSynEditTitleCase }

procedure TaSynTitleCase.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.ExecuteCommand(ecAutoTitleCase, #0, nil);
end;

{ TSynEditFind }

procedure TaSynFind.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(FindDialogClass) then
    Searcher.Find(FActiveSynEdit);
end;

{ TSynEditFindNext }

procedure TaSynFindNext.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(FindDialogClass) then
    Searcher.FindNext(FActiveSynEdit);
end;

{ TSynEditFindLast }

procedure TaSynFindLast.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(FindDialogClass) then
    Searcher.FindLast(FActiveSynEdit);
end;

{ TSynEditFindNextWord }

procedure TaSynFindNextWord.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(FindDialogClass) then
    Searcher.FindNextForWord(FActiveSynEdit);
end;

{ TSynEditFindLastWord }

procedure TaSynFindLastWord.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(FindDialogClass) then
    Searcher.FindLastForWord(FActiveSynEdit);
end;

{ TSynEditReplace }

procedure TaSynReplace.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(ReplaceDialogClass) then
    Searcher.Replace(FActiveSynEdit);
end;

{ TSynEditReplaceNext }

procedure TaSynReplaceNext.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(ReplaceDialogClass) then
    Searcher.ReplaceNext(FActiveSynEdit);
end;

{ TSynEditReplaceLast }

procedure TaSynReplaceLast.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) and Assigned(ReplaceDialogClass) then
    Searcher.ReplaceLast(FActiveSynEdit);
end;

{ TSynEditGotoBookmark }

procedure TaSynGotoBookmark.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.GotoBookMark(fBookmark);
end;

{ TSynEditSetBookmark }

procedure TaSynSetBookmark.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    FActiveSynEdit.ExecuteCommand(ecSetMarker0 + fBookmark, #0, nil);
end;

{ TSynEditClearBookmark }

procedure TaSynClearBookmark.ExecuteTarget(Target: TObject);
begin
  if SynEditAllocated(Target) then
    if fBookmark >= 0 then
      FActiveSynEdit.ClearBookMark(fBookmark)
    else
      FActiveSynEdit.ExecuteCommand(ecClearMarkers, #0, nil);
end;

{ TSynEditIndent }

procedure TaSynBlockIndent.ExecuteTarget(Target: TObject);