opensource/HeidiSQL
1
0
Fork 0
mirror of https://github.com/HeidiSQL/HeidiSQL.git synced 2025-08-06 18:24:26 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
HeidiSQL/components/synedit/Source/SynEditOptionsDialog.pas
Ansgar Becker 1e94af8374 Issue #136: update SynEdit sources
2021-03-16 20:12:46 +01:00

1057 lines
34 KiB
ObjectPascal
Raw Permalink Blame History

{-------------------------------------------------------------------------------
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: SynEdit.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: SynEditOptionsDialog.pas,v 1.21.2.5 2005/07/20 13:37:18 maelh Exp $
You may retrieve the latest version of this file at the SynEdit home page,
located at http://SynEdit.SourceForge.net
Known Issues:
-------------------------------------------------------------------------------}
{$IFNDEF QSYNEDITOPTIONSDIALOG}
unit SynEditOptionsDialog;
{$ENDIF}
{$I SynEdit.inc}
interface
uses
{$IFDEF SYN_COMPILER_17_UP}
Types,
{$ENDIF}
Windows,
Messages,
Graphics,
Controls,
Forms,
Dialogs,
StdCtrls,
ComCtrls,
CommCtrl,
Registry,
ExtCtrls,
Buttons,
{$IFDEF SYN_DELPHI_4_UP}
ImgList,
{$ENDIF}
Menus,
SynEdit,
SynEditHighlighter,
SynEditMiscClasses,
SynEditKeyCmds,
Classes,
SysUtils;
type
{$IFNDEF SYN_DELPHI_4_UP}
TLVSelectItemEvent = procedure(Sender: TObject; Item: TListItem;
Selected: Boolean) of object;
{$ENDIF}
TColorPopup = (cpGutter, cpRightEdge);
TSynEditorOptionsUserCommand = procedure(AUserCommand: Integer;
var ADescription: string) of object;
//NOTE: in order for the user commands to be recorded correctly, you must
// put the command itself in the object property.
// you can do this like so:
//
// StringList.AddObject('ecSomeCommand', TObject(ecSomeCommand))
//
// where ecSomeCommand is the command that you want to add
TSynEditorOptionsAllUserCommands = procedure(ACommands: TStrings) of object;
TSynEditorOptionsContainer = class;
TfmEditorOptionsDialog = class(TForm)
btnAddKey: TButton;
btnCancel: TButton;
btnFont: TButton;
btnGutterColor: TPanel;
btnGutterFont: TButton;
btnOk: TButton;
btnRemKey: TButton;
btnRightEdge: TPanel;
btnUpdateKey: TButton;
cbGutterFont: TCheckBox;
cInsertCaret: TComboBox;
ckAltSetsColumnMode: TCheckBox;
ckAutoIndent: TCheckBox;
ckAutoSizeMaxWidth: TCheckBox;
ckBookmarkKeys: TCheckBox;
ckBookmarkVisible: TCheckBox;
ckDisableScrollArrows: TCheckBox;
ckDragAndDropEditing: TCheckBox;
ckEnhanceEndKey: TCheckBox;
ckEnhanceHomeKey: TCheckBox;
cKeyCommand: TComboBox;
ckGroupUndo: TCheckBox;
ckGutterAutosize: TCheckBox;
ckGutterShowLeaderZeros: TCheckBox;
ckGutterShowLineNumbers: TCheckBox;
ckGutterStartAtZero: TCheckBox;
ckGutterVisible: TCheckBox;
ckHalfPageScroll: TCheckBox;
ckHideShowScrollbars: TCheckBox;
ckKeepCaretX: TCheckBox;
ckRightMouseMoves: TCheckBox;
ckScrollByOneLess: TCheckBox;
ckScrollHintFollows: TCheckBox;
ckScrollPastEOF: TCheckBox;
ckScrollPastEOL: TCheckBox;
ckShowScrollHint: TCheckBox;
ckShowSpecialChars: TCheckBox;
ckSmartTabDelete: TCheckBox;
ckSmartTabs: TCheckBox;
ckTabIndent: TCheckBox;
ckTabsToSpaces: TCheckBox;
ckTrimTrailingSpaces: TCheckBox;
ckWantTabs: TCheckBox;
ColorDialog: TColorDialog;
ColorPopup: TPopupMenu;
cOverwriteCaret: TComboBox;
Display: TTabSheet;
eLineSpacing: TEdit;
eRightEdge: TEdit;
eTabWidth: TEdit;
FontDialog: TFontDialog;
gbBookmarks: TGroupBox;
gbCaret: TGroupBox;
gbEditorFont: TGroupBox;
gbGutter: TGroupBox;
gbKeyStrokes: TGroupBox;
gbLineSpacing: TGroupBox;
gbOptions: TGroupBox;
gbRightEdge: TGroupBox;
Image1: TImage;
Image2: TImage;
ImageList: TImageList;
KeyList: TListView;
Keystrokes: TTabSheet;
lblCommand: TLabel;
lblEdgeColor: TLabel;
lblEdgeColumn: TLabel;
lblExtraLines: TLabel;
lblFont: TLabel;
lblGutterColor: TLabel;
lblGutterFont: TLabel;
lblInsertCaret: TLabel;
lblKeystroke: TLabel;
lblKeystroke2: TLabel;
lblOverwriteCaret: TLabel;
lblTabWidth: TLabel;
Menu2: TMenuItem;
mnu3dDarkShadow: TMenuItem;
mnu3DLight: TMenuItem;
mnuActiveBorder: TMenuItem;
mnuActiveCaption: TMenuItem;
mnuApplicationWorkspace: TMenuItem;
mnuBackground: TMenuItem;
mnuButtonFace: TMenuItem;
mnuButtonShadow: TMenuItem;
mnuButtonText: TMenuItem;
mnuCaptionText: TMenuItem;
mnuGrayText: TMenuItem;
mnuHighlight: TMenuItem;
mnuHighlight2: TMenuItem;
mnuHighlightText: TMenuItem;
mnuInactiveBorder: TMenuItem;
mnuInactiveCaption: TMenuItem;
mnuInactiveCaptionText: TMenuItem;
mnuInfoTipBackground: TMenuItem;
mnuInfoTipText: TMenuItem;
mnuMenu: TMenuItem;
mnuNone: TMenuItem;
mnuScrollBar: TMenuItem;
mnuWindow: TMenuItem;
mnuWindowFrame: TMenuItem;
mnuWindowText: TMenuItem;
Options: TTabSheet;
PageControl: TPageControl;
pnlGutterBack: TPanel;
pnlGutterColor: TPanel;
pnlCommands: TPanel;
pnlEditorFont: TPanel;
pnlGutterFontDisplay: TPanel;
pnlRightEdgeBack: TPanel;
pnlRightEdgeColor: TPanel;
procedure PopupMenuClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure pnlGutterColorClick(Sender: TObject);
procedure pnlRightEdgeColorClick(Sender: TObject);
procedure btnFontClick(Sender: TObject);
procedure KeyListSelectItem(Sender: TObject; Item: TListItem;
Selected: Boolean);
procedure btnUpdateKeyClick(Sender: TObject);
procedure btnAddKeyClick(Sender: TObject);
procedure btnRemKeyClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure KeyListEditing(Sender: TObject; Item: TListItem;
var AllowEdit: Boolean);
procedure btnOkClick(Sender: TObject);
procedure btnGutterFontClick(Sender: TObject);
procedure cbGutterFontClick(Sender: TObject);
procedure btnRightEdgeMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure btnGutterColorMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
procedure cKeyCommandExit(Sender: TObject);
procedure cKeyCommandKeyPress(Sender: TObject; var Key: Char);
procedure cKeyCommandKeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure KeyListChanging(Sender: TObject; Item: TListItem;
Change: TItemChange; var AllowChange: Boolean);
private
FSynEdit: TSynEditorOptionsContainer;
FPoppedFrom : TColorPopup;
FUserCommand: TSynEditorOptionsUserCommand;
FAllUserCommands: TSynEditorOptionsAllUserCommands;
FOldSelected: TListItem;
FInChanging: Boolean;
FExtended: Boolean;
{$IFNDEF SYN_COMPILER_4_UP}
FOldWndProc: TWndMethod;
procedure OverridingWndProc(var Message: TMessage);
{$ENDIF}
function GetColor(Item : TMenuItem) : TColor;
procedure GetData;
procedure PutData;
procedure EditStrCallback(const S: string);
procedure FillInKeystrokeInfo(AKey: TSynEditKeystroke; AItem: TListItem);
public
eKeyShort2: TSynHotKey;
eKeyShort1: TSynHotKey;
{$IFNDEF SYN_DELPHI_4_UP}
FOnSelectItem: TLVSelectItemEvent;
{$ENDIF}
function Execute(EditOptions : TSynEditorOptionsContainer) : Boolean;
property GetUserCommandNames: TSynEditorOptionsUserCommand read FUserCommand
write FUserCommand;
property GetAllUserCommands: TSynEditorOptionsAllUserCommands
read FAllUserCommands
write FAllUserCommands;
property UseExtendedStrings: Boolean read FExtended write FExtended;
end;
TSynEditOptionsDialog = class(TComponent)
private
FForm: TfmEditorOptionsDialog;
function GetUserCommandNames: TSynEditorOptionsUserCommand;
procedure SetUserCommandNames(
const Value: TSynEditorOptionsUserCommand);
function GetUserCommands: TSynEditorOptionsAllUserCommands;
procedure SetUserCommands(
const Value: TSynEditorOptionsAllUserCommands);
function GetExtended: Boolean;
procedure SetExtended(const Value: Boolean);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function Execute(EditOptions : TSynEditorOptionsContainer) : Boolean;
property Form: TfmEditorOptionsDialog read FForm;
published
property GetUserCommand: TSynEditorOptionsUserCommand
read GetUserCommandNames
write SetUserCommandNames;
property GetAllUserCommands: TSynEditorOptionsAllUserCommands
read GetUserCommands
write SetUserCommands;
property UseExtendedStrings: Boolean read GetExtended write SetExtended;
end;
//This class is assignable to a SynEdit without modifying key properties that affect function
TSynEditorOptionsContainer = class(TComponent)
private
FHideSelection: Boolean;
FWantTabs: Boolean;
FMaxUndo: Integer;
FExtraLineSpacing: Integer;
FTabWidth: Integer;
FMaxScrollWidth: Integer;
FRightEdge: Integer;
FSelectedColor: TSynSelectedColor;
FRightEdgeColor: TColor;
FFont: TFont;
FBookmarks: TSynBookMarkOpt;
FOverwriteCaret: TSynEditCaretType;
FInsertCaret: TSynEditCaretType;
FKeystrokes: TSynEditKeyStrokes;
FOptions: TSynEditorOptions;
FSynGutter: TSynGutter;
FColor: TColor;
procedure SetBookMarks(const Value: TSynBookMarkOpt);
procedure SetFont(const Value: TFont);
procedure SetKeystrokes(const Value: TSynEditKeyStrokes);
procedure SetOptions(const Value: TSynEditorOptions);
procedure SetSynGutter(const Value: TSynGutter);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure Assign(Source : TPersistent); override;
procedure AssignTo(Dest : TPersistent); override;
published
property Options : TSynEditorOptions read FOptions write SetOptions;
property BookMarkOptions : TSynBookMarkOpt read FBookmarks write SetBookMarks;
property Color : TColor read FColor write FColor;
property Font : TFont read FFont write SetFont;
property ExtraLineSpacing : Integer read FExtraLineSpacing write FExtraLineSpacing;
property Gutter : TSynGutter read FSynGutter write SetSynGutter;
property RightEdge : Integer read FRightEdge write FRightEdge;
property RightEdgeColor : TColor read FRightEdgeColor write FRightEdgeColor;
property WantTabs : Boolean read FWantTabs write FWantTabs;
property InsertCaret : TSynEditCaretType read FInsertCaret write FInsertCaret;
property OverwriteCaret : TSynEditCaretType read FOverwriteCaret write FOverwriteCaret;
property HideSelection : Boolean read FHideSelection write FHideSelection;
property MaxScrollWidth : Integer read FMaxScrollWidth write FMaxScrollWidth;
property MaxUndo : Integer read FMaxUndo write FMaxUndo;
property SelectedColor : TSynSelectedColor read FSelectedColor write FSelectedColor;
property TabWidth : Integer read FTabWidth write FTabWidth;
property Keystrokes : TSynEditKeyStrokes read FKeystrokes write SetKeystrokes;
end;
implementation
{$R *.dfm}
uses
SynEditKeyConst;
{ TSynEditOptionsDialog }
constructor TSynEditOptionsDialog.create(AOwner: TComponent);
begin
inherited;
FForm := TfmEditorOptionsDialog.Create(Self);
end;
destructor TSynEditOptionsDialog.destroy;
begin
FForm.Free;
inherited;
end;
function TSynEditOptionsDialog.Execute(EditOptions : TSynEditorOptionsContainer) : Boolean;
begin
Result := FForm.Execute(EditOptions);
end;
function TSynEditOptionsDialog.GetUserCommands: TSynEditorOptionsAllUserCommands;
begin
Result := FForm.GetAllUserCommands;
end;
function TSynEditOptionsDialog.GetUserCommandNames: TSynEditorOptionsUserCommand;
begin
Result := FForm.GetUserCommandNames
end;
procedure TSynEditOptionsDialog.SetUserCommands(
const Value: TSynEditorOptionsAllUserCommands);
begin
FForm.GetAllUserCommands := Value;
end;
procedure TSynEditOptionsDialog.SetUserCommandNames(
const Value: TSynEditorOptionsUserCommand);
begin
FForm.GetUserCommandNames := Value;
end;
function TSynEditOptionsDialog.GetExtended: Boolean;
begin
Result := FForm.UseExtendedStrings;
end;
procedure TSynEditOptionsDialog.SetExtended(const Value: Boolean);
begin
FForm.UseExtendedStrings := Value;
end;
{ TSynEditorOptionsContainer }
procedure TSynEditorOptionsContainer.Assign(Source: TPersistent);
begin
if Assigned(Source) and (Source is TCustomSynEdit) then
begin
Self.Font.Assign(TCustomSynEdit(Source).Font);
Self.BookmarkOptions.Assign(TCustomSynEdit(Source).BookmarkOptions);
Self.Gutter.Assign(TCustomSynEdit(Source).Gutter);
Self.Keystrokes.Assign(TCustomSynEdit(Source).Keystrokes);
Self.SelectedColor.Assign(TCustomSynEdit(Source).SelectedColor);
Self.Color := TCustomSynEdit(Source).Color;
Self.Options := TCustomSynEdit(Source).Options;
Self.ExtraLineSpacing := TCustomSynEdit(Source).ExtraLineSpacing;
Self.HideSelection := TCustomSynEdit(Source).HideSelection;
Self.InsertCaret := TCustomSynEdit(Source).InsertCaret;
Self.OverwriteCaret := TCustomSynEdit(Source).OverwriteCaret;
Self.MaxScrollWidth := TCustomSynEdit(Source).MaxScrollWidth;
Self.MaxUndo := TCustomSynEdit(Source).MaxUndo;
Self.RightEdge := TCustomSynEdit(Source).RightEdge;
Self.RightEdgeColor := TCustomSynEdit(Source).RightEdgeColor;
Self.TabWidth := TCustomSynEdit(Source).TabWidth;
Self.WantTabs := TCustomSynEdit(Source).WantTabs;
end else
inherited;
end;
procedure TSynEditorOptionsContainer.AssignTo(Dest: TPersistent);
begin
if Assigned(Dest) and (Dest is TCustomSynEdit) then
begin
TCustomSynEdit(Dest).Font.Assign(Self.Font);
TCustomSynEdit(Dest).BookmarkOptions.Assign(Self.BookmarkOptions);
TCustomSynEdit(Dest).Gutter.Assign(Self.Gutter);
TCustomSynEdit(Dest).Keystrokes.Assign(Self.Keystrokes);
TCustomSynEdit(Dest).SelectedColor.Assign(Self.SelectedColor);
TCustomSynEdit(Dest).Color := Self.Color;
TCustomSynEdit(Dest).Options := Self.Options;
TCustomSynEdit(Dest).ExtraLineSpacing := Self.ExtraLineSpacing;
TCustomSynEdit(Dest).HideSelection := Self.HideSelection;
TCustomSynEdit(Dest).InsertCaret := Self.InsertCaret;
TCustomSynEdit(Dest).OverwriteCaret := Self.OverwriteCaret;
TCustomSynEdit(Dest).MaxScrollWidth := Self.MaxScrollWidth;
TCustomSynEdit(Dest).MaxUndo := Self.MaxUndo;
TCustomSynEdit(Dest).RightEdge := Self.RightEdge;
TCustomSynEdit(Dest).RightEdgeColor := Self.RightEdgeColor;
TCustomSynEdit(Dest).TabWidth := Self.TabWidth;
TCustomSynEdit(Dest).WantTabs := Self.WantTabs;
end else
inherited;
end;
constructor TSynEditorOptionsContainer.create(AOwner: TComponent);
begin
inherited;
FBookmarks := TSynBookMarkOpt.Create(Self);
FKeystrokes := TSynEditKeyStrokes.Create(Self);
FSynGutter := TSynGutter.Create;
FSelectedColor := TSynSelectedColor.Create;
FSelectedColor.Foreground := clHighlightText;
FSelectedColor.Background := clHighlight;
FFont := TFont.Create;
FFont.Name := 'Courier New';
FFont.Size := 8;
Color := clWindow;
Keystrokes.ResetDefaults;
Options := [eoAutoIndent,eoDragDropEditing,eoDropFiles,eoScrollPastEol,
eoShowScrollHint,eoSmartTabs,eoAltSetsColumnMode, eoTabsToSpaces,eoTrimTrailingSpaces, eoKeepCaretX];
ExtraLineSpacing := 0;
HideSelection := False;
InsertCaret := ctVerticalLine;
OverwriteCaret := ctBlock;
MaxScrollWidth := 1024;
MaxUndo := 1024;
RightEdge := 80;
RightEdgeColor := clSilver;
TabWidth := 8;
WantTabs := True;
end;
destructor TSynEditorOptionsContainer.destroy;
begin
FBookMarks.Free;
FKeyStrokes.Free;
FSynGutter.Free;
FSelectedColor.Free;
FFont.Free;
inherited;
end;
procedure TSynEditorOptionsContainer.SetBookMarks(
const Value: TSynBookMarkOpt);
begin
FBookmarks.Assign(Value);
end;
procedure TSynEditorOptionsContainer.SetFont(const Value: TFont);
begin
FFont.Assign(Value);
end;
procedure TSynEditorOptionsContainer.SetKeystrokes(
const Value: TSynEditKeyStrokes);
begin
FKeystrokes.Assign(Value);
end;
procedure TSynEditorOptionsContainer.SetOptions(
const Value: TSynEditorOptions);
begin
FOptions := Value;
end;
procedure TSynEditorOptionsContainer.SetSynGutter(const Value: TSynGutter);
begin
FSynGutter.Assign(Value);
end;
{ TfmEditorOptionsDialog }
function TfmEditorOptionsDialog.Execute(EditOptions : TSynEditorOptionsContainer) : Boolean;
begin
if (EditOptions = nil) then
begin
Result := False;
Exit;
end;
//Assign the Containers
FSynEdit := EditOptions;
//Get Data
GetData;
//Show the form
Result := Showmodal = mrOk;
//PutData
if Result then PutData;
end;
procedure TfmEditorOptionsDialog.GetData;
var I : Integer;
Item : TListItem;
begin
//Gutter
ckGutterVisible.Checked := FSynEdit.Gutter.Visible;
ckGutterAutosize.Checked := FSynEdit.Gutter.AutoSize;
ckGutterShowLineNumbers.Checked := FSynEdit.Gutter.ShowLineNumbers;
ckGutterShowLeaderZeros.Checked := FSynEdit.Gutter.LeadingZeros;
ckGutterStartAtZero.Checked := FSynEdit.Gutter.ZeroStart;
cbGutterFont.Checked := FSynEdit.Gutter.UseFontStyle;
pnlGutterColor.Color := FSynEdit.Gutter.Color;
lblGutterFont.Font.Assign(FSynEdit.Gutter.Font);
lblGutterFont.Caption := lblGutterFont.Font.Name + ' ' + IntToStr(lblGutterFont.Font.Size) + 'pt';
//Right Edge
eRightEdge.Text := IntToStr(FSynEdit.RightEdge);
pnlRightEdgeColor.Color := FSynEdit.RightEdgeColor;
//Line Spacing
eLineSpacing.Text := IntToStr(FSynEdit.ExtraLineSpacing);
eTabWidth.Text := IntToStr(FSynEdit.TabWidth);
//Bookmarks
ckBookmarkKeys.Checked := FSynEdit.BookMarkOptions.EnableKeys;
ckBookmarkVisible.Checked := FSynEdit.BookMarkOptions.GlyphsVisible;
//Font
lblFont.Font.Assign(FSynEdit.Font);
lblFont.Caption := lblFont.Font.Name + ' ' + IntToStr(lblFont.Font.Size) + 'pt';
//Options
ckAutoIndent.Checked := eoAutoIndent in FSynEdit.Options;
ckAutoSizeMaxWidth.Checked := eoAutoSizeMaxScrollWidth in FSynEdit.Options;
ckDragAndDropEditing.Checked := eoDragDropEditing in FSynEdit.Options;
ckWantTabs.Checked := FSynEdit.WantTabs;
ckSmartTabs.Checked := eoSmartTabs in FSynEdit.Options;
ckAltSetsColumnMode.Checked := eoAltSetsColumnMode in FSynEdit.Options;
ckHalfPageScroll.Checked := eoHalfPageScroll in FSynEdit.Options;
ckScrollByOneLess.Checked := eoScrollByOneLess in FSynEdit.Options;
ckScrollPastEOF.Checked := eoScrollPastEof in FSynEdit.Options;
ckScrollPastEOL.Checked := eoScrollPastEol in FSynEdit.Options;
ckShowScrollHint.Checked := eoShowScrollHint in FSynEdit.Options;
ckTabsToSpaces.Checked := eoTabsToSpaces in FSynEdit.Options;
ckTrimTrailingSpaces.Checked := eoTrimTrailingSpaces in FSynEdit.Options;
ckKeepCaretX.Checked := eoKeepCaretX in FSynEdit.Options;
ckSmartTabDelete.Checked := eoSmartTabDelete in FSynEdit.Options;
ckRightMouseMoves.Checked := eoRightMouseMovesCursor in FSynEdit.Options;
ckEnhanceHomeKey.Checked := eoEnhanceHomeKey in FSynEdit.Options;
ckEnhanceEndKey.Checked := eoEnhanceEndKey in FSynEdit.Options;
ckGroupUndo.Checked := eoGroupUndo in FSynEdit.Options;
ckTabIndent.Checked := eoTabIndent in FSynEdit.Options;
ckDisableScrollArrows.Checked := eoDisableScrollArrows in FSynEdit.Options;
ckHideShowScrollbars.Checked := eoHideShowScrollbars in FSynEdit.Options;
ckShowSpecialChars.Checked := eoShowSpecialChars in FSynEdit.Options;
//Caret
cInsertCaret.ItemIndex := ord(FSynEdit.InsertCaret);
cOverwriteCaret.ItemIndex := ord(FSynEdit.OverwriteCaret);
KeyList.Items.BeginUpdate;
try
KeyList.Items.Clear;
for I := 0 to FSynEdit.Keystrokes.Count-1 do
begin
Item := KeyList.Items.Add;
FillInKeystrokeInfo(FSynEdit.Keystrokes.Items[I], Item);
Item.Data := FSynEdit.Keystrokes.Items[I];
end;
if (KeyList.Items.Count > 0) then KeyList.Items[0].Selected := True;
finally
KeyList.Items.EndUpdate;
end;
end;
procedure TfmEditorOptionsDialog.PutData;
var
vOptions: TSynEditorOptions;
procedure SetFlag(aOption: TSynEditorOption; aValue: Boolean);
begin
if aValue then
Include(vOptions, aOption)
else
Exclude(vOptions, aOption);
end;
begin
//Gutter
FSynEdit.Gutter.Visible := ckGutterVisible.Checked;
FSynEdit.Gutter.AutoSize := ckGutterAutosize.Checked;
FSynEdit.Gutter.ShowLineNumbers := ckGutterShowLineNumbers.Checked;
FSynEdit.Gutter.LeadingZeros := ckGutterShowLeaderZeros.Checked;
FSynEdit.Gutter.ZeroStart := ckGutterStartAtZero.Checked;
FSynEdit.Gutter.Color := pnlGutterColor.Color;
FSynEdit.Gutter.UseFontStyle := cbGutterFont.Checked;
FSynEdit.Gutter.Font.Assign(lblGutterFont.Font);
//Right Edge
FSynEdit.RightEdge := StrToIntDef(eRightEdge.Text, 80);
FSynEdit.RightEdgeColor := pnlRightEdgeColor.Color;
//Line Spacing
FSynEdit.ExtraLineSpacing := StrToIntDef(eLineSpacing.Text, 0);
FSynEdit.TabWidth := StrToIntDef(eTabWidth.Text, 8);
//Bookmarks
FSynEdit.BookMarkOptions.EnableKeys := ckBookmarkKeys.Checked;
FSynEdit.BookMarkOptions.GlyphsVisible := ckBookmarkVisible.Checked;
//Font
FSynEdit.Font.Assign(lblFont.Font);
//Options
FSynEdit.WantTabs := ckWantTabs.Checked;
vOptions := FSynEdit.Options; //Keep old values for unsupported options
SetFlag(eoAutoIndent, ckAutoIndent.Checked);
SetFlag(eoAutoSizeMaxScrollWidth, ckAutoSizeMaxWidth.Checked);
SetFlag(eoDragDropEditing, ckDragAndDropEditing.Checked);
SetFlag(eoSmartTabs, ckSmartTabs.Checked);
SetFlag(eoAltSetsColumnMode, ckAltSetsColumnMode.Checked);
SetFlag(eoHalfPageScroll, ckHalfPageScroll.Checked);
SetFlag(eoScrollByOneLess, ckScrollByOneLess.Checked);
SetFlag(eoScrollPastEof, ckScrollPastEOF.Checked);
SetFlag(eoScrollPastEol, ckScrollPastEOL.Checked);
SetFlag(eoShowScrollHint, ckShowScrollHint.Checked);
SetFlag(eoTabIndent, ckTabIndent.Checked);
SetFlag(eoTabsToSpaces, ckTabsToSpaces.Checked);
SetFlag(eoTrimTrailingSpaces, ckTrimTrailingSpaces.Checked);
SetFlag(eoKeepCaretX, ckKeepCaretX.Checked);
SetFlag(eoSmartTabDelete, ckSmartTabDelete.Checked);
SetFlag(eoRightMouseMovesCursor, ckRightMouseMoves.Checked);
SetFlag(eoEnhanceHomeKey, ckEnhanceHomeKey.Checked);
SetFlag(eoEnhanceEndKey, ckEnhanceEndKey.Checked);
SetFlag(eoGroupUndo, ckGroupUndo.Checked);
SetFlag(eoDisableScrollArrows, ckDisableScrollArrows.Checked);
SetFlag(eoHideShowScrollbars, ckHideShowScrollbars.Checked);
SetFlag(eoShowSpecialChars, ckShowSpecialChars.Checked);
FSynEdit.Options := vOptions;
//Caret
FSynEdit.InsertCaret := TSynEditCaretType(cInsertCaret.ItemIndex);
FSynEdit.OverwriteCaret := TSynEditCaretType(cOverwriteCaret.ItemIndex);
end;
function TfmEditorOptionsDialog.GetColor(Item: TMenuItem): TColor;
begin
if (Item.Tag = -1) or (Item.Tag > 24) then
Result := clNone
else
Result := TColor(Byte(Item.Tag) or $80000000);
end;
procedure TfmEditorOptionsDialog.PopupMenuClick(Sender: TObject);
var C : TColor;
begin
C := GetColor(TMenuItem(Sender));
//Set the color based on where it was "popped from"
if (FPoppedFrom = cpGutter) then
pnlGutterColor.Color := C
else if (FPoppedFrom = cpRightEdge) then
pnlRightEdgeColor.Color := C;
end;
procedure TfmEditorOptionsDialog.FormCreate(Sender: TObject);
var I : Integer;
C : TColor;
B : TBitmap;
begin
{$IFDEF SYN_COMPILER_4_UP}
KeyList.OnSelectItem := KeyListSelectItem;
{$ELSE}
FOldWndProc := KeyList.WindowProc;
KeyList.WindowProc := OverridingWndProc;
FOnSelectItem := KeyListSelectItem;
{$ENDIF}
FInChanging := False;
B := TBitmap.Create;
try
B.Width := 16;
B.Height := 16;
//Loop through and create colored images
for I := 0 to ColorPopup.Items.Count-1 do
begin
if ColorPopup.Items[I].Tag = -1 then Continue;
C := GetColor(ColorPopup.Items[I]);
B.Canvas.Brush.Color := C;
B.Canvas.Brush.Style := bsSolid;
B.Canvas.Pen.Style := psSolid;
B.Canvas.Pen.Color := clBlack;
B.Canvas.Rectangle(0,0,16,16);
ImageList.Add(B, nil);
{$IFDEF SYN_COMPILER_4_UP}
ColorPopup.Items[I].ImageIndex := ColorPopup.Items[I].Tag;
{$ENDIF}
end;
finally
B.Free;
end;
eKeyShort1 := TSynHotKey.Create(Self);
with eKeyShort1 do
begin
Parent := gbKeystrokes;
Left := 120;
Top := 55;
Width := 185;
Height := 21;
HotKey := 0;
InvalidKeys := [];
Modifiers := [];
TabOrder := 1;
end;
eKeyShort2 := TSynHotKey.Create(Self);
with eKeyShort2 do
begin
Parent := gbKeystrokes;
Left := 120;
Top := 87;
Width := 185;
Height := 21;
HotKey := 0;
InvalidKeys := [];
Modifiers := [];
TabOrder := 2;
end;
end;
procedure TfmEditorOptionsDialog.pnlGutterColorClick(Sender: TObject);
begin
ColorDialog.Color := pnlGutterColor.Color;
if (ColorDialog.Execute) then
pnlGutterColor.Color := ColorDialog.Color;
end;
procedure TfmEditorOptionsDialog.pnlRightEdgeColorClick(Sender: TObject);
begin
ColorDialog.Color := pnlRightEdgeColor.Color;
if (ColorDialog.Execute) then
pnlRightEdgeColor.Color := ColorDialog.Color;
end;
procedure TfmEditorOptionsDialog.btnFontClick(Sender: TObject);
begin
FontDialog.Font.Assign(lblFont.Font);
if FontDialog.Execute then
begin
lblFont.Font.Assign(FontDialog.Font);
lblFont.Caption := lblFont.Font.Name;
lblFont.Caption := lblFont.Font.Name + ' ' + IntToStr(lblFont.Font.Size) + 'pt';
end;
end;
procedure TfmEditorOptionsDialog.KeyListSelectItem(Sender: TObject;
Item: TListItem; Selected: Boolean);
begin
if KeyList.Selected = nil then Exit;
cKeyCommand.Text := KeyList.Selected.Caption;
cKeyCommand.ItemIndex := cKeyCommand.Items.IndexOf(KeyList.Selected.Caption);
eKeyShort1.HotKey := TSynEditKeyStroke(KeyList.Selected.Data).ShortCut;
eKeyShort2.HotKey := TSynEditKeyStroke(KeyList.Selected.Data).ShortCut2;
FOldSelected := Item;
end;
procedure TfmEditorOptionsDialog.btnUpdateKeyClick(Sender: TObject);
var Cmd : Integer;
{ KeyLoc : Integer;
TmpCommand : string;
OldShortcut : TShortcut;
OldShortcut2 : TShortcut;
}
begin
if (KeyList.Selected = nil) and (Sender <> btnAddKey) then
begin
btnAddKey.Click;
Exit;
end;
if KeyList.Selected = nil then Exit;
if cKeyCommand.ItemIndex < 0 then Exit;
Cmd := Integer(cKeyCommand.Items.Objects[cKeyCommand.ItemIndex]);
TSynEditKeyStroke(FOldSelected.Data).Command := Cmd;
if eKeyShort1.HotKey <> 0 then
TSynEditKeyStroke(FOldSelected.Data).ShortCut := eKeyShort1.HotKey;
if eKeyShort2.HotKey <> 0 then
TSynEditKeyStroke(FOldSelected.Data).ShortCut2 := eKeyShort2.HotKey;
FillInKeystrokeInfo(TSynEditKeyStroke(FOldSelected.Data), KeyList.Selected);
end;
procedure TfmEditorOptionsDialog.btnAddKeyClick(Sender: TObject);
var Item : TListItem;
begin
Item := KeyList.Items.Add;
Item.Data := FSynEdit.Keystrokes.Add;
Item.Selected := True;
btnUpdateKeyClick(btnAddKey);
end;
procedure TfmEditorOptionsDialog.btnRemKeyClick(Sender: TObject);
begin
if KeyList.Selected = nil then Exit;
TSynEditKeyStroke(KeyList.Selected.Data).Free;
KeyList.Selected.Delete;
end;
procedure TfmEditorOptionsDialog.EditStrCallback(const S: string);
begin
//Add the Item
if FExtended then
cKeyCommand.Items.AddObject(S, TObject(ConvertExtendedToCommand(S)))
else cKeyCommand.Items.AddObject(S, TObject(ConvertCodeStringToCommand(S)));
end;
procedure TfmEditorOptionsDialog.FormShow(Sender: TObject);
var Commands: TStringList;
i : Integer;
begin
//We need to do this now because it will not have been assigned when
//create occurs
cKeyCommand.Items.Clear;
//Start the callback to add the strings
if FExtended then
GetEditorCommandExtended(EditStrCallback)
else
GetEditorCommandValues(EditStrCallBack);
//Now add in the user defined ones if they have any
if Assigned(FAllUserCommands) then
begin
Commands := TStringList.Create;
try
FAllUserCommands(Commands);
for i := 0 to Commands.Count - 1 do
if Commands.Objects[i] <> nil then
cKeyCommand.Items.AddObject(Commands[i], Commands.Objects[i]);
finally
Commands.Free;
end;
end;
PageControl.ActivePage := PageControl.Pages[0];
end;
procedure TfmEditorOptionsDialog.KeyListEditing(Sender: TObject;
Item: TListItem; var AllowEdit: Boolean);
begin
AllowEdit := False;
end;
procedure TfmEditorOptionsDialog.btnOkClick(Sender: TObject);
begin
btnUpdateKey.Click;
ModalResult := mrOk;
end;
procedure TfmEditorOptionsDialog.btnGutterFontClick(Sender: TObject);
begin
FontDialog.Font.Assign(lblGutterFont.Font);
if FontDialog.Execute then
begin
lblGutterFont.Font.Assign(FontDialog.Font);
lblGutterFont.Caption := lblGutterFont.Font.Name + ' ' + IntToStr(lblGutterFont.Font.Size) + 'pt';
end;
end;
procedure TfmEditorOptionsDialog.cbGutterFontClick(Sender: TObject);
begin
lblGutterFont.Enabled := cbGutterFont.Checked;
btnGutterFont.Enabled := cbGutterFont.Checked;
end;
procedure TfmEditorOptionsDialog.btnRightEdgeMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var P : TPoint;
begin
FPoppedFrom := cpRightEdge;
P := pnlRightEdgeColor.ClientToScreen(Point(-1, pnlRightEdgeColor.Height - 1));
btnRightEdge.BevelOuter := bvLowered;
ColorPopup.Popup(P.X, P.Y);
btnRightEdge.BevelOuter := bvNone;
end;
procedure TfmEditorOptionsDialog.btnGutterColorMouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var P : TPoint;
begin
FPoppedFrom := cpGutter;
P := pnlGutterColor.ClientToScreen(Point(-1, pnlGutterColor.Height - 1));
btnGutterColor.BevelOuter := bvLowered;
ColorPopup.Popup(P.X, P.Y);
btnGutterColor.BevelOuter := bvNone;
end;
procedure TfmEditorOptionsDialog.FillInKeystrokeInfo(
AKey: TSynEditKeystroke; AItem: TListItem);
var TmpString: String;
begin
with AKey do
begin
if Command >= ecUserFirst then
begin
TmpString := 'User Command';
if Assigned(GetUserCommandNames) then
GetUserCommandNames(Command, TmpString);
end else begin
if FExtended then
TmpString := ConvertCodeStringToExtended(EditorCommandToCodeString(Command))
else TmpString := EditorCommandToCodeString(Command);
end;
AItem.Caption := TmpString;
AItem.SubItems.Clear;
TmpString := '';
if Shortcut <> 0 then
TmpString := ShortCutToText(ShortCut);
if (TmpString <> '') and (Shortcut2 <> 0) then
TmpString := TmpString + ' ' + ShortCutToText(ShortCut2);
AItem.SubItems.Add(TmpString);
end;
end;
procedure TfmEditorOptionsDialog.cKeyCommandExit(Sender: TObject);
VAR TmpIndex : Integer;
begin
TmpIndex := cKeyCommand.Items.IndexOf(cKeyCommand.Text);
if TmpIndex = -1 then
begin
if FExtended then
cKeyCommand.ItemIndex := cKeyCommand.Items.IndexOf(ConvertCodeStringToExtended('ecNone'))
else cKeyCommand.ItemIndex := cKeyCommand.Items.IndexOf('ecNone');
end else cKeyCommand.ItemIndex := TmpIndex; //need to force it incase they just typed something in
end;
procedure TfmEditorOptionsDialog.cKeyCommandKeyPress(Sender: TObject;
var Key: Char);
var WorkStr : string;
i : Integer;
begin
//This would be better if componentized, but oh well...
WorkStr := Uppercase(Copy(cKeyCommand.Text, 1, cKeyCommand.SelStart) + Key);
i := 0;
while i < cKeyCommand.Items.Count do
begin
if pos(WorkStr, Uppercase(cKeyCommand.Items[i])) = 1 then
begin
cKeyCommand.Text := cKeyCommand.Items[i];
cKeyCommand.SelStart := length(WorkStr);
cKeyCommand.SelLength := Length(cKeyCommand.Text) - cKeyCommand.SelStart;
Key := #0;
Break;
end
else
Inc(i);
end;
end;
procedure TfmEditorOptionsDialog.cKeyCommandKeyUp(Sender: TObject;
var Key: Word; Shift: TShiftState);
begin
if Key = SYNEDIT_RETURN then btnUpdateKey.Click;
end;
procedure TfmEditorOptionsDialog.KeyListChanging(Sender: TObject;
Item: TListItem; Change: TItemChange; var AllowChange: Boolean);
begin
//make sure that it's saved.
if FInChanging then Exit;
FInChanging := True;
if Visible then
begin
if (Item = FOldSelected) and
((Item.Caption <> cKeyCommand.Text) or
(TSynEditKeystroke(Item.Data).ShortCut <> eKeyShort1.HotKey) or
(TSynEditKeystroke(Item.Data).ShortCut2 <> eKeyShort2.HotKey)) then
begin
btnUpdateKeyClick(btnUpdateKey);
end;
end;
FInChanging := False;
end;
{$IFNDEF SYN_COMPILER_4_UP}
procedure TfmEditorOptionsDialog.OverridingWndProc(var Message: TMessage);
var
Item: TListItem;
begin
FOldWndProc(Message);
if Message.Msg = CN_NOTIFY then
with TWMNotify(Message) do
if NMHdr.code = LVN_ITEMCHANGED then
with PNMListView(NMHdr)^ do
begin
Item := KeyList.Items[iItem];
if Assigned(FOnSelectItem) and (uChanged = LVIF_STATE) then
begin
if (uOldState and LVIS_SELECTED <> 0) and
(uNewState and LVIS_SELECTED = 0) then
FOnSelectItem(Self, Item, False)
else if (uOldState and LVIS_SELECTED = 0) and
(uNewState and LVIS_SELECTED <> 0) then
FOnSelectItem(Self, Item, True);
end;
end;
end;
{$ENDIF}
end.
Reference in New Issue View Git Blame Copy Permalink