1 { /***************************************************************************
2                  codetoolsoptions.pas  -  Lazarus IDE unit
3                  -----------------------------------------
4 
5  ***************************************************************************/
6 
7  ***************************************************************************
8  *                                                                         *
9  *   This source is free software; you can redistribute it and/or modify   *
10  *   it under the terms of the GNU General Public License as published by  *
11  *   the Free Software Foundation; either version 2 of the License, or     *
12  *   (at your option) any later version.                                   *
13  *                                                                         *
14  *   This code is distributed in the hope that it will be useful, but      *
15  *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
17  *   General Public License for more details.                              *
18  *                                                                         *
19  *   A copy of the GNU General Public License is available on the World    *
20  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also      *
21  *   obtain it by writing to the Free Software Foundation,                 *
22  *   Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1335, USA.   *
23  *                                                                         *
24  ***************************************************************************
25 
26   Author: Mattias Gaertner
27 
28   Abstract:
29     - TCodeToolsOptions
30 }
31 unit CodeToolsOptions;
32 
33 {$mode objfpc}{$H+}
34 
35 interface
36 
37 uses
38   Classes, SysUtils,
39   // LazUtils
40   LazFileUtils, Laz2_XMLCfg, LazUTF8, LazFileCache, LazStringUtils,
41   // LCL
42   LCLProc, LCLType,
43   // CodeTools
44   CodeToolManager, DefineTemplates, SourceChanger,
45   // IdeIntf
46   IDEOptionsIntf, IDEOptEditorIntf, MacroIntf,
47   // IDE
48   LazConf, LazarusIDEStrConsts;
49 
50 const
51   DefaultIndentationFilename = 'laz_indentation.pas'; // in directory GetPrimaryConfigPath
52   DefaultCodeCompletionFilename =
53     '$(LazarusDir)'+PathDelim+'components'+PathDelim+'codetools'+PathDelim+'codecompletiontemplates.xml';
54 
55 type
56 
57   TIdentComplIncludeWords = (icwDontInclude, icwIncludeFromCurrentUnit,
58     icwIncludeFromAllUnits);
59 
60   { TCodeToolsOptions }
61 
62   TCodeToolsOptions = class(TAbstractIDEEnvironmentOptions)
63   private
64     FClassHeaderComments: boolean;
65     FClassImplementationComments: boolean;
66     FFilename: string;
67     FIdentComplAddDo: Boolean;
68     FIdentComplAddParameterBrackets: boolean;
69     FIdentComplOnTypeMinLength: Integer;
70     FIdentComplOnTypeOnlyWordEnd: boolean;
71     FIdentComplOnTypeUseTimer: boolean;
72     FIdentComplReplaceIdentifier: boolean;
73     FIdentComplJumpToError: boolean;
74     FIdentComplShowHelp: boolean;
75 
76     // General
77     FAdjustTopLineDueToComment: boolean;
78     FAvoidUnnecessaryJumps: boolean;
79     FIdentComplSortForHistory: boolean;
80     FIdentComplSortForScope: boolean;
81     FJumpSingleLinePos: integer;
82     FJumpCodeBlockPos: integer;
83     FCursorBeyondEOL: boolean;
84     FSkipForwardDeclarations: boolean;
85     FJumpToMethodBody: boolean;
86 
87     // Define Templates
88     FGlobalDefineTemplates: TDefineTemplate;
89     FDefinesEditMainSplitterTop: integer;
90     FDefinesPreviewMainSplitterPos: integer;
91     FDefinesPreviewTemplSplitterPos: integer;
92 
93     // CodeCreation
94     FAddInheritedCodeToOverrideMethod: boolean;
95     FCompleteProperties: boolean;
96     FLineLength: integer;
97     FClassPartInsertPolicy: TClassPartInsertPolicy;
98     FMixMethodsAndProperties: boolean;
99     FForwardProcBodyInsertPolicy: TForwardProcBodyInsertPolicy;
100     FKeepForwardProcOrder: boolean;
101     FMethodInsertPolicy: TMethodInsertPolicy;
102     FMethodDefaultSection: TInsertClassSection;
103     FKeyWordPolicy : TWordPolicy;
104     FIdentifierPolicy: TWordPolicy;
105     FUpdateAllMethodSignatures: boolean;
106     FUpdateMultiProcSignatures: boolean;
107     FUpdateOtherProcSignaturesCase: boolean;
108     FGroupLocalVariables: boolean;
109     FOverrideStringTypesWithFirstParamType: Boolean;
110     FWordPolicyExceptions: TStringList;
111     FDoNotSplitLineInFront: TAtomTypes;
112     FDoNotSplitLineAfter: TAtomTypes;
113     FDoInsertSpaceInFront: TAtomTypes;
114     FDoInsertSpaceAfter: TAtomTypes;
115     FPropertyReadIdentPrefix: string;
116     FPropertyWriteIdentPrefix: string;
117     FPropertyStoredIdentPostfix: string;
118     FPrivateVariablePrefix: string;
119     FSetPropertyVariablename: string;
120     FSetPropertyVariableIsPrefix: Boolean;
121     FSetPropertyVariableUseConst: Boolean;
122     FUsesInsertPolicy: TUsesInsertPolicy;
123 
124     // identifier completion
125     FIdentComplAddSemicolon: Boolean;
126     FIdentComplAddAssignOperator: Boolean;
127     FIdentComplAutoInvokeOnType: boolean;
128     FIdentComplAutoStartAfterPoint: boolean;
129     FIdentComplAutoUseSingleIdent: boolean;
130     FIdentComplUseContainsFilter: Boolean;
131     FIdentComplIncludeCodeTemplates: Boolean;
132     FIdentComplIncludeWords: TIdentComplIncludeWords;
133     FIdentComplShowIcons: Boolean;
134 
135     // auto indentation
136     FIndentOnLineBreak: boolean;
137     FIndentOnPaste: boolean;
138     fIndentationFilename: String;
139     FIndentContextSensitive: boolean;
140 
141     // code completion templates
142     FCodeCompletionTemplateFileName : String;
143 
144     procedure SetCodeCompletionTemplateFileName(aValue: String);
145     procedure SetFilename(const AValue: string);
146     procedure SetSetPropertyVariablename(aValue: string);
147     procedure SetSetPropertyVariableIsPrefix(aValue: Boolean);
148     procedure SetSetPropertyVariableUseConst(aValue: Boolean);
149   public
GetGroupCaptionnull150     class function GetGroupCaption:string; override;
GetInstancenull151     class function GetInstance: TAbstractIDEOptions; override;
152     procedure DoAfterWrite(Restore: boolean); override;
153   public
154     constructor Create;
155     destructor Destroy; override;
156     procedure Clear;
157     procedure ClearGlobalDefineTemplates;
158     procedure Load;
159     procedure Save;
160     procedure AssignGlobalDefineTemplatesToTree(Tree: TDefineTree);
161     property Filename: string read FFilename write SetFilename;
162     procedure SetLazarusDefaultFilename;
163     procedure Assign(Source: TPersistent); override;
164     procedure AssignTo(Dest: TPersistent); override;
IsEqualnull165     function IsEqual(CodeToolsOpts: TCodeToolsOptions): boolean;
CreateCopynull166     function CreateCopy: TCodeToolsOptions;
167     procedure ReadGlobalDefinesTemplatesFromTree(Tree: TDefineTree);
168     procedure CreateDefaultIndentationFile;
169 
170     // General
171     property AdjustTopLineDueToComment: boolean
172       read FAdjustTopLineDueToComment write FAdjustTopLineDueToComment;
173     property AvoidUnnecessaryJumps: boolean read FAvoidUnnecessaryJumps write FAvoidUnnecessaryJumps;
174     property JumpSingleLinePos: integer read FJumpSingleLinePos write FJumpSingleLinePos;
175     property JumpCodeBlockPos: integer read FJumpCodeBlockPos write FJumpCodeBlockPos;
176     property CursorBeyondEOL: boolean
177       read FCursorBeyondEOL write FCursorBeyondEOL;
178     property SkipForwardDeclarations: boolean read FSkipForwardDeclarations write FSkipForwardDeclarations;
179     property JumpToMethodBody: boolean read FJumpToMethodBody write FJumpToMethodBody;
180     // Define Templates
181     property GlobalDefineTemplates: TDefineTemplate read FGlobalDefineTemplates;
182     property DefinesEditMainSplitterTop: integer read FDefinesEditMainSplitterTop
183                                               write FDefinesEditMainSplitterTop;
184     property DefinesPreviewMainSplitterPos: integer
185        read FDefinesPreviewMainSplitterPos write FDefinesPreviewMainSplitterPos;
186     property DefinesPreviewTemplSplitterPos: integer
187        read FDefinesPreviewTemplSplitterPos write FDefinesPreviewTemplSplitterPos;
188 
189     // CodeCreation
190     property CompleteProperties: boolean
191       read FCompleteProperties write FCompleteProperties;
192     property AddInheritedCodeToOverrideMethod: boolean
193       read FAddInheritedCodeToOverrideMethod write FAddInheritedCodeToOverrideMethod;
194     property LineLength: integer read FLineLength write FLineLength;
195     property ClassPartInsertPolicy: TClassPartInsertPolicy
196       read FClassPartInsertPolicy write FClassPartInsertPolicy;
197     property MixMethodsAndProperties: boolean
198       read FMixMethodsAndProperties write FMixMethodsAndProperties;
199     property UpdateAllMethodSignatures: boolean
200       read FUpdateAllMethodSignatures write FUpdateAllMethodSignatures;
201     property ForwardProcBodyInsertPolicy: TForwardProcBodyInsertPolicy
202       read FForwardProcBodyInsertPolicy write FForwardProcBodyInsertPolicy;
203     property KeepForwardProcOrder: boolean
204       read FKeepForwardProcOrder write FKeepForwardProcOrder;
205     property UpdateMultiProcSignatures: boolean
206       read FUpdateMultiProcSignatures write FUpdateMultiProcSignatures;
207     property UpdateOtherProcSignaturesCase: boolean
208       read FUpdateOtherProcSignaturesCase write FUpdateOtherProcSignaturesCase;
209     property GroupLocalVariables: boolean
210       read FGroupLocalVariables write FGroupLocalVariables;
211     property OverrideStringTypesWithFirstParamType: Boolean
212       read FOverrideStringTypesWithFirstParamType write FOverrideStringTypesWithFirstParamType;
213     property ClassHeaderComments: boolean
214       read FClassHeaderComments write FClassHeaderComments;
215     property ClassImplementationComments: boolean
216       read FClassImplementationComments write FClassImplementationComments;
217     property MethodInsertPolicy: TMethodInsertPolicy
218       read FMethodInsertPolicy write FMethodInsertPolicy;
219     property MethodDefaultSection: TInsertClassSection
220       read FMethodDefaultSection write FMethodDefaultSection;
221     property KeyWordPolicy : TWordPolicy
222       read FKeyWordPolicy write FKeyWordPolicy;
223     property IdentifierPolicy: TWordPolicy
224       read FIdentifierPolicy write FIdentifierPolicy;
225     property WordPolicyExceptions: TStringList
226       read FWordPolicyExceptions write FWordPolicyExceptions;
227     property DoNotSplitLineInFront: TAtomTypes
228       read FDoNotSplitLineInFront write FDoNotSplitLineInFront;
229     property DoNotSplitLineAfter: TAtomTypes
230       read FDoNotSplitLineAfter write FDoNotSplitLineAfter;
231     property DoInsertSpaceInFront: TAtomTypes
232       read FDoInsertSpaceInFront write FDoInsertSpaceInFront;
233     property DoInsertSpaceAfter: TAtomTypes
234       read FDoInsertSpaceAfter write FDoInsertSpaceAfter;
235     property PropertyReadIdentPrefix: string
236       read FPropertyReadIdentPrefix write FPropertyReadIdentPrefix;
237     property PropertyWriteIdentPrefix: string
238       read FPropertyWriteIdentPrefix write FPropertyWriteIdentPrefix;
239     property PropertyStoredIdentPostfix: string
240       read FPropertyStoredIdentPostfix write FPropertyStoredIdentPostfix;
241     property PrivateVariablePrefix: string
242       read FPrivateVariablePrefix write FPrivateVariablePrefix;
243     property SetPropertyVariablename: string
244       read FSetPropertyVariablename write SetSetPropertyVariablename;
245     property SetPropertyVariableIsPrefix: Boolean
246       read FSetPropertyVariableIsPrefix write SetSetPropertyVariableIsPrefix;
247     property SetPropertyVariableUseConst: Boolean
248       read FSetPropertyVariableUseConst write SetSetPropertyVariableUseConst;
249     property UsesInsertPolicy: TUsesInsertPolicy
250       read FUsesInsertPolicy write FUsesInsertPolicy;
251 
252     // identifier completion
253     property IdentComplAddSemicolon: Boolean read FIdentComplAddSemicolon
254                                              write FIdentComplAddSemicolon;
255     property IdentComplAddAssignOperator: Boolean read FIdentComplAddAssignOperator
256                                              write FIdentComplAddAssignOperator;
257     property IdentComplAddDo: Boolean read FIdentComplAddDo write FIdentComplAddDo;
258     property IdentComplAutoInvokeOnType: boolean read FIdentComplAutoInvokeOnType
259                                            write FIdentComplAutoInvokeOnType;
260     property IdentComplOnTypeUseTimer: boolean read FIdentComplOnTypeUseTimer
261                                            write FIdentComplOnTypeUseTimer;
262     property IdentComplOnTypeOnlyWordEnd: boolean read FIdentComplOnTypeOnlyWordEnd
263                                            write FIdentComplOnTypeOnlyWordEnd;
264     property IdentComplOnTypeMinLength: Integer read FIdentComplOnTypeMinLength
265                                            write FIdentComplOnTypeMinLength;
266     property IdentComplAutoStartAfterPoint: boolean read FIdentComplAutoStartAfterPoint
267                                            write FIdentComplAutoStartAfterPoint;
268     property IdentComplAutoUseSingleIdent: boolean read FIdentComplAutoUseSingleIdent
269                                            write FIdentComplAutoUseSingleIdent;
270     property IdentComplUseContainsFilter: boolean read FIdentComplUseContainsFilter
271                                            write FIdentComplUseContainsFilter;
272     property IdentComplIncludeCodeTemplates: boolean read FIdentComplIncludeCodeTemplates
273                                            write FIdentComplIncludeCodeTemplates;
274     property IdentComplIncludeWords: TIdentComplIncludeWords read FIdentComplIncludeWords
275                                            write FIdentComplIncludeWords;
276     property IdentComplShowIcons: boolean read FIdentComplShowIcons
277                                            write FIdentComplShowIcons;
278     property IdentComplAddParameterBrackets: boolean
279       read FIdentComplAddParameterBrackets write FIdentComplAddParameterBrackets;
280     property IdentComplReplaceIdentifier: boolean
281       read FIdentComplReplaceIdentifier write FIdentComplReplaceIdentifier;
282     property IdentComplJumpToError: boolean
283       read FIdentComplJumpToError write FIdentComplJumpToError;
284     property IdentComplShowHelp: boolean read FIdentComplShowHelp
285                                          write FIdentComplShowHelp;
286     property IdentComplSortForHistory: boolean read FIdentComplSortForHistory
287                                              write FIdentComplSortForHistory;
288     property IdentComplSortForScope: boolean read FIdentComplSortForScope
289                                              write FIdentComplSortForScope;
290 
291     // indentation
292     property IndentOnLineBreak: boolean read FIndentOnLineBreak
293                                          write FIndentOnLineBreak;
294     property IndentOnPaste: boolean read FIndentOnPaste write FIndentOnPaste;
295     property IndentationFileName: String
296       read fIndentationFileName write fIndentationFileName;
297     property IndentContextSensitive: boolean read FIndentContextSensitive
298       write FIndentContextSensitive;
299 
300     // code completion templates
301     property CodeCompletionTemplateFileName : String read FCodeCompletionTemplateFileName
302                                                      write SetCodeCompletionTemplateFileName;
303   end;
304 
305 var
306   CodeToolsOpts: TCodeToolsOptions = nil;
307 
GetTranslatedAtomTypesnull308 function GetTranslatedAtomTypes(a: TAtomType): string;
TranslatedAtomToTypenull309 function TranslatedAtomToType(const s: string): TAtomType;
ReadIdentifiernull310 function ReadIdentifier(const s, DefaultIdent: string): string;
311 
312 const
313   IdentComplIncludeWordsNames: array[TIdentComplIncludeWords] of shortstring = (
314       'No', 'FromCurrentUnit', 'FromAllUnits'
315     );
IdentComplIncludeWordsNamesToEnumnull316 function IdentComplIncludeWordsNamesToEnum(const s: string): TIdentComplIncludeWords;
317 
318 implementation
319 
320 {$R lazarus_indentation.res}
321 
322 const
323   CodeToolsOptionsVersion = 2;
324   DefaultCodeToolsOptsFile = 'codetoolsoptions.xml';
325 
IdentComplIncludeWordsNamesToEnumnull326 function IdentComplIncludeWordsNamesToEnum(const s: string): TIdentComplIncludeWords;
327 begin
328   for Result:=Low(TIdentComplIncludeWords) to High(TIdentComplIncludeWords) do
329     if SysUtils.CompareText(IdentComplIncludeWordsNames[Result],s)=0 then exit;
330   Result:=icwDontInclude;
331 end;
332 
GetTranslatedAtomTypesnull333 function GetTranslatedAtomTypes(a: TAtomType): string;
334 begin
335   case a of
336   atNone: Result:=lisCodeToolsOptsNone;
337   atKeyword: Result:=lisCodeToolsOptsKeyword;
338   atIdentifier: Result:=lisCodeToolsOptsIdentifier;
339   atColon: Result:=lisCodeToolsOptsColon;
340   atSemicolon: Result:=lisCodeToolsOptsSemicolon;
341   atComma: Result:=lisCodeToolsOptsComma;
342   atPoint: Result:=lisCodeToolsOptsPoint;
343   atAt: Result:=lisCodeToolsOptsAt;
344   atNumber: Result:=lisCodeToolsOptsNumber;
345   atStringConstant: Result:=lisCodeToolsOptsStringConst;
346   atNewLine: Result:=lisCodeToolsOptsNewLine;
347   atSpace: Result:=lisCodeToolsOptsSpace;
348   atSymbol: Result:=lisCodeToolsOptsSymbol;
349   atBracket: Result:=lisCodeToolsOptsBracket;
350   atCaret: Result:=lisCodeToolsOptsCaret;
351   else
352     Result:='???';
353   end;
354 end;
355 
TranslatedAtomToTypenull356 function TranslatedAtomToType(const s: string): TAtomType;
357 begin
358   for Result:=Low(TAtomType) to High(TAtomType) do
359     if s=GetTranslatedAtomTypes(Result) then exit;
360   Result:=atNone;
361 end;
362 
ReadAtomTypesFromXMLnull363 function ReadAtomTypesFromXML(XMLConfig: TXMLConfig; const Path: string;
364   DefaultValues: TAtomTypes): TAtomTypes;
365 var a: TAtomType;
366 begin
367   Result:=[];
368   for a:=Low(TAtomType) to High(TAtomType) do begin
369     if (a<>atNone)
370     and (XMLConfig.GetValue(Path+AtomTypeNames[a]+'/Value',a in DefaultValues))
371     then
372       Include(Result,a);
373   end;
374 end;
375 
376 procedure WriteAtomTypesToXML(XMLConfig: TXMLConfig; const Path: string;
377   NewValues, DefaultValues: TAtomTypes);
378 var a: TAtomType;
379 begin
380   for a:=Low(TAtomType) to High(TAtomType) do begin
381     if (a<>atNone) then
382       XMLConfig.SetDeleteValue(Path+AtomTypeNames[a]+'/Value',
383                                a in NewValues,a in DefaultValues);
384   end;
385 end;
386 
387 
IsIdentifiernull388 function IsIdentifier(const s: string): boolean;
389 var i: integer;
390 begin
391   Result:=false;
392   if (s='') then exit;
393   for i:=1 to length(s) do begin
394     if not (s[i] in ['_','A'..'Z','a'..'z']) then exit;
395   end;
396   Result:=true;
397 end;
398 
ReadIdentifiernull399 function ReadIdentifier(const s, DefaultIdent: string): string;
400 begin
401   if IsIdentifier(s) then
402     Result:=s
403   else
404     Result:=DefaultIdent;
405 end;
406 
407 { TCodeToolsOptions }
408 
409 constructor TCodeToolsOptions.Create;
410 begin
411   inherited Create;
412   FFilename:='';
413   FWordPolicyExceptions := TStringList.Create;
414   Clear;
415 end;
416 
417 destructor TCodeToolsOptions.Destroy;
418 begin
419   ClearGlobalDefineTemplates;
420   FWordPolicyExceptions.Free;
421   inherited Destroy;
422 end;
423 
TCodeToolsOptions.GetGroupCaptionnull424 class function TCodeToolsOptions.GetGroupCaption: string;
425 begin
426   Result := dlgGroupCodetools;
427 end;
428 
TCodeToolsOptions.GetInstancenull429 class function TCodeToolsOptions.GetInstance: TAbstractIDEOptions;
430 begin
431   Result := CodeToolsOpts;
432 end;
433 
434 procedure TCodeToolsOptions.DoAfterWrite(Restore: boolean);
435 begin
436   inherited DoAfterWrite(Restore);
437   if not Restore then
438     Save;
439 end;
440 
441 procedure TCodeToolsOptions.Load;
442 var
443   XMLConfig: TXMLConfig;
444   FileVersion: integer;
445   AJumpCentered: Boolean;
446 
447   procedure LoadGlobalDefineTemplates;
448   begin
449     // delete old one
450     ClearGlobalDefineTemplates;
451     // create empty one
452     FGlobalDefineTemplates:=TDefineTemplate.Create;
453     FGlobalDefineTemplates.Name:='';
454     // load
455     FGlobalDefineTemplates.LoadFromXMLConfig(XMLConfig,'CodeToolsGlobalDefines/',
456       true,true);
457     // delete if still empty
458     if FGlobalDefineTemplates.Name='' then begin
459       ClearGlobalDefineTemplates;
460     end else begin
461       FGlobalDefineTemplates.SetDefineOwner(Self,true);
462     end;
463   end;
464 
465 begin
466   CreateDefaultIndentationFile;
467   try
468     XMLConfig:=TXMLConfig.Create(FFileName);
469     FileVersion:=XMLConfig.GetValue('CodeToolsOptions/Version/Value',0);
470     if (FileVersion<>0) and (FileVersion<CodeToolsOptionsVersion) then
471       debugln(lisCompilerNOTELoadingOldCodetoolsOptionsFile, FFileName);
472 
473     // General
474     FAdjustTopLineDueToComment:=XMLConfig.GetValue(
475       'CodeToolsOptions/AdjustTopLineDueToComment/Value',true);
476     if FileVersion<2 then
477     begin
478       AJumpCentered:=XMLConfig.GetValue('CodeToolsOptions/JumpCentered/Value',
479         true);
480       if AJumpCentered then
481         FJumpSingleLinePos := 50
482       else
483         FJumpSingleLinePos := 0;
484       FJumpCodeBlockPos := 0;
485     end else
486     begin
487       FJumpSingleLinePos:=XMLConfig.GetValue('CodeToolsOptions/JumpSingleLinePos/Value', 50);
488       FJumpCodeBlockPos:=XMLConfig.GetValue('CodeToolsOptions/JumpCodeBlockPos/Value', 0);
489     end;
490     FAvoidUnnecessaryJumps:=XMLConfig.GetValue('CodeToolsOptions/AvoidUnnecessaryJumps/Value', True);
491     FCursorBeyondEOL:=XMLConfig.GetValue(
492       'CodeToolsOptions/CursorBeyondEOL/Value',true);
493     FSkipForwardDeclarations:=XMLConfig.GetValue(
494       'CodeToolsOptions/SkipForwardDeclarations/Value',false);
495     FJumpToMethodBody:=XMLConfig.GetValue(
496       'CodeToolsOptions/JumpToMethodBody/Value',false);
497 
498     // Define templates
499     LoadGlobalDefineTemplates;
500     FDefinesEditMainSplitterTop:=XMLConfig.GetValue(
501       'CodeToolsOptions/DefinesEditMainSplitter/Top',100);
502     FDefinesPreviewMainSplitterPos:=XMLConfig.GetValue(
503       'CodeToolsOptions/DefinesPreviewMainSplitter/Position',280);
504     FDefinesPreviewTemplSplitterPos:=XMLConfig.GetValue(
505       'CodeToolsOptions/DefinesPreviewTemplSplitter/Position',100);
506 
507     // CodeCreation
508     FAddInheritedCodeToOverrideMethod:=XMLConfig.GetValue(
509       'CodeToolsOptions/AddInheritedCodeToOverrideMethod/Value',true);
510     FCompleteProperties:=XMLConfig.GetValue(
511       'CodeToolsOptions/CompleteProperties/Value',true);
512     FLineLength:=XMLConfig.GetValue(
513       'CodeToolsOptions/LineLengthXMLConfig/Value',80);
514     FClassPartInsertPolicy:=ClassPartPolicyNameToPolicy(XMLConfig.GetValue(
515       'CodeToolsOptions/ClassPartInsertPolicy/Value',
516       ClassPartInsertPolicyNames[cpipAlphabetically]));
517     FMixMethodsAndProperties:=XMLConfig.GetValue(
518       'CodeToolsOptions/MixMethodsAndProperties/Value',false);
519     FUpdateAllMethodSignatures:=XMLConfig.GetValue(
520       'CodeToolsOptions/UpdateAllMethodSignatures/Value',true);
521     FForwardProcBodyInsertPolicy:=ForwardProcBodyInsertPolicyNameToPolicy(
522       XMLConfig.GetValue('CodeToolsOptions/ForwardProcBodyInsertPolicy/Value',
523         ForwardProcBodyInsertPolicyNames[fpipInFrontOfMethods]));
524     FKeepForwardProcOrder:=XMLConfig.GetValue(
525       'CodeToolsOptions/KeepForwardProcOrder/Value',true);
526     FUpdateMultiProcSignatures:=XMLConfig.GetValue(
527       'CodeToolsOptions/UpdateMultiProcSignatures/Value',true);
528     FUpdateOtherProcSignaturesCase:=XMLConfig.GetValue(
529       'CodeToolsOptions/UpdateOtherProcSignaturesCase/Value',true);
530     FGroupLocalVariables:=XMLConfig.GetValue(
531       'CodeToolsOptions/GroupLocalVariables/Value',true);
532     FOverrideStringTypesWithFirstParamType:=XMLConfig.GetValue(
533       'CodeToolsOptions/OverrideStringTypesWithFirstParamType/Value',true);
534     FClassHeaderComments:=XMLConfig.GetValue(
535       'CodeToolsOptions/ClassHeaderComments/Value',true);
536     FClassImplementationComments:=XMLConfig.GetValue(
537       'CodeToolsOptions/ClassImplementationComments/Value',true);
538 
539     FMethodInsertPolicy:=MethodInsertPolicyNameToPolicy(XMLConfig.GetValue(
540       'CodeToolsOptions/MethodInsertPolicy/Value',
541       MethodInsertPolicyNames[mipClassOrder]));
542     FMethodDefaultSection:=InsertClassSectionNameToSection(XMLConfig.GetValue(
543       'CodeToolsOptions/MethodDefaultSection/Value',
544       InsertClassSectionNames[DefaultMethodDefaultSection]));
545     FKeyWordPolicy:=WordPolicyNameToPolicy(XMLConfig.GetValue(
546       'CodeToolsOptions/KeyWordPolicy/Value',
547       WordPolicyNames[wpLowerCase]));
548     FIdentifierPolicy:=WordPolicyNameToPolicy(XMLConfig.GetValue(
549       'CodeToolsOptions/IdentifierPolicy/Value',
550       WordPolicyNames[wpNone]));
551     WordPolicyExceptions.Text:=LineBreaksToSystemLineBreaks(XMLConfig.GetValue(
552       'CodeToolsOptions/WordPolicyExceptions/Value', ''));
553     FDoNotSplitLineInFront:=ReadAtomTypesFromXML(XMLConfig,
554       'CodeToolsOptions/DoNotSplitLineInFront/',DefaultDoNotSplitLineInFront);
555     FDoNotSplitLineAfter:=ReadAtomTypesFromXML(XMLConfig,
556       'CodeToolsOptions/DoNotSplitLineAfter/',DefaultDoNotSplitLineAfter);
557     FDoInsertSpaceInFront:=ReadAtomTypesFromXML(XMLConfig,
558       'CodeToolsOptions/DoInsertSpaceInFront/',DefaultDoInsertSpaceInFront);
559     FDoInsertSpaceAfter:=ReadAtomTypesFromXML(XMLConfig,
560       'CodeToolsOptions/DoInsertSpaceAfter/',DefaultDoInsertSpaceAfter);
561     FPropertyReadIdentPrefix:=ReadIdentifier(XMLConfig.GetValue(
562       'CodeToolsOptions/PropertyReadIdentPrefix/Value',''),'Get');
563     FPropertyWriteIdentPrefix:=ReadIdentifier(XMLConfig.GetValue(
564       'CodeToolsOptions/PropertyWriteIdentPrefix/Value',''),'Set');
565     FPropertyStoredIdentPostfix:=ReadIdentifier(XMLConfig.GetValue(
566       'CodeToolsOptions/PropertyStoredIdentPostfix/Value',''),'IsStored');
567     FPrivateVariablePrefix:=ReadIdentifier(XMLConfig.GetValue(
568       'CodeToolsOptions/PrivateVariablePrefix/Value',''),'F');
569     FSetPropertyVariablename:=ReadIdentifier(XMLConfig.GetValue(
570       'CodeToolsOptions/SetPropertyVariablename/Value',''),'AValue');
571     FSetPropertyVariableIsPrefix:=XMLConfig.GetValue(
572       'CodeToolsOptions/SetPropertyVariableIsPrefix/Value',false);
573     FSetPropertyVariableUseConst:=XMLConfig.GetValue(
574       'CodeToolsOptions/SetPropertyVariableUseConst/Value',false);
575     FUsesInsertPolicy:=UsesInsertPolicyNameToPolicy(XMLConfig.GetValue(
576       'CodeToolsOptions/UsesInsertPolicy/Value',
577       UsesInsertPolicyNames[DefaultUsesInsertPolicy]));
578 
579     // identifier completion
580     FIdentComplAddSemicolon:=XMLConfig.GetValue(
581       'CodeToolsOptions/IdentifierCompletion/AddSemicolon',true);
582     FIdentComplAddAssignOperator:=XMLConfig.GetValue(
583       'CodeToolsOptions/IdentifierCompletion/AddAssignOperator',true);
584     FIdentComplAddDo:=XMLConfig.GetValue(
585       'CodeToolsOptions/IdentifierCompletion/AddDo',true);
586     FIdentComplAutoInvokeOnType:=XMLConfig.GetValue(
587       'CodeToolsOptions/IdentifierCompletion/AutoInvokeOnType',False);
588     FIdentComplOnTypeUseTimer:=XMLConfig.GetValue(
589       'CodeToolsOptions/IdentifierCompletion/OnTypeUseTimer',true);
590     FIdentComplOnTypeOnlyWordEnd:=XMLConfig.GetValue(
591       'CodeToolsOptions/IdentifierCompletion/OnTypeOnlyWordEnd',true);
592     FIdentComplOnTypeMinLength:=XMLConfig.GetValue(
593       'CodeToolsOptions/IdentifierCompletion/OnTypeMinLength',2);
594     FIdentComplAutoStartAfterPoint:=XMLConfig.GetValue(
595       'CodeToolsOptions/IdentifierCompletion/AutoStartAfterPoint',true);
596     FIdentComplAutoUseSingleIdent:=XMLConfig.GetValue(
597       'CodeToolsOptions/IdentifierCompletion/AutoUseSingleIdent',true);
598     FIdentComplUseContainsFilter:=XMLConfig.GetValue(
599       'CodeToolsOptions/IdentifierCompletion/UseContainsFilter',true);
600     FIdentComplIncludeCodeTemplates:=XMLConfig.GetValue(
601       'CodeToolsOptions/IdentifierCompletion/IncludeCodeTemplates',true);
602     FIdentComplIncludeWords:=IdentComplIncludeWordsNamesToEnum(XMLConfig.GetValue(
603       'CodeToolsOptions/IdentifierCompletion/IncludeWords',
604       IdentComplIncludeWordsNames[icwIncludeFromAllUnits]));
605     FIdentComplShowIcons:=XMLConfig.GetValue(
606       'CodeToolsOptions/IdentifierCompletion/ShowIcons',false);
607     FIdentComplAddParameterBrackets:=XMLConfig.GetValue(
608       'CodeToolsOptions/IdentifierCompletion/AutoAddParameterBrackets',true);
609     FIdentComplReplaceIdentifier:=XMLConfig.GetValue(
610       'CodeToolsOptions/IdentifierCompletion/ReplaceIdentifier',true);
611     FIdentComplJumpToError:=XMLConfig.GetValue(
612       'CodeToolsOptions/IdentifierCompletion/JumpToError',true);
613     FIdentComplShowHelp:=XMLConfig.GetValue(
614       'CodeToolsOptions/IdentifierCompletion/ShowHelp',false);
615     FIdentComplSortForHistory:=XMLConfig.GetValue(
616       'CodeToolsOptions/IdentifierCompletion/SortForHistory',true);
617     FIdentComplSortForScope:=XMLConfig.GetValue(
618       'CodeToolsOptions/IdentifierCompletion/SortForScope',true);
619 
620     // indentation
621     FIndentOnLineBreak :=
622       XMLConfig.GetValue('CodeToolsOptions/Indentation/OnLineBreak/Enabled',true);
623     FIndentOnPaste :=
624       XMLConfig.GetValue('CodeToolsOptions/Indentation/OnPaste/Enabled',true);
625     fIndentationFilename :=
626       XMLConfig.GetValue('CodeToolsOptions/Indentation/FileName'
627       , TrimFilename(AppendPathDelim(GetPrimaryConfigPath)+DefaultIndentationFilename));
628     FIndentContextSensitive :=
629       XMLConfig.GetValue('CodeToolsOptions/Indentation/ContextSensitive',true);
630 
631     // code completion templates
632     FCodeCompletionTemplateFileName :=
633       XMLConfig.GetValue('CodeToolsOptions/CodeCompletionTemplate/FileName'
634       , DefaultCodeCompletionFilename);
635 
636     XMLConfig.Free;
637   except
638     on E: Exception do begin
639       DebugLn('[TCodeToolsOptions.Load]  error reading "',FFilename,'": ',E.Message);
640     end;
641   end;
642 end;
643 
644 procedure TCodeToolsOptions.Save;
645 var
646   XMLConfig: TXMLConfig;
647 
648   procedure SaveGlobalDefineTemplates;
649   begin
650     if FGlobalDefineTemplates<>nil then
651       FGlobalDefineTemplates.SaveToXMLConfig(XMLConfig,
652         'CodeToolsGlobalDefines/',true,false,true,false);
653   end;
654 
655 begin
656   try
657     InvalidateFileStateCache;
658     XMLConfig:=TXMLConfig.CreateClean(FFileName);
659     XMLConfig.SetValue('CodeToolsOptions/Version/Value',CodeToolsOptionsVersion);
660 
661     // General
662     XMLConfig.SetDeleteValue('CodeToolsOptions/AdjustTopLineDueToComment/Value',
663                              FAdjustTopLineDueToComment,true);
664     XMLConfig.SetDeleteValue('CodeToolsOptions/JumpSingleLinePos/Value',
665                              FJumpSingleLinePos,50);
666     XMLConfig.SetDeleteValue('CodeToolsOptions/JumpCodeBlockPos/Value',
667                              FJumpCodeBlockPos,0);
668     XMLConfig.SetDeleteValue('CodeToolsOptions/AvoidUnnecessaryJumps/Value',
669                              FAvoidUnnecessaryJumps,True);
670     XMLConfig.SetDeleteValue('CodeToolsOptions/CursorBeyondEOL/Value',
671                              FCursorBeyondEOL,true);
672     XMLConfig.SetDeleteValue('CodeToolsOptions/SkipForwardDeclarations/Value',
673                              FSkipForwardDeclarations,false);
674     XMLConfig.SetDeleteValue('CodeToolsOptions/JumpToMethodBody/Value',
675                              FJumpToMethodBody,false);
676     // Define templates
677     SaveGlobalDefineTemplates;
678     XMLConfig.SetDeleteValue('CodeToolsOptions/DefinesEditMainSplitter/Top',
679                              FDefinesEditMainSplitterTop,100);
680     XMLConfig.SetDeleteValue('CodeToolsOptions/DefinesPreviewMainSplitter/Position',
681                              FDefinesPreviewMainSplitterPos,280);
682     XMLConfig.SetDeleteValue('CodeToolsOptions/DefinesPreviewTemplSplitter/Position',
683                              FDefinesPreviewTemplSplitterPos,100);
684 
685     // CodeCreation
686     XMLConfig.SetDeleteValue(
687       'CodeToolsOptions/AddInheritedCodeToOverrideMethod/Value',
688       AddInheritedCodeToOverrideMethod,true);
689     XMLConfig.SetDeleteValue(
690       'CodeToolsOptions/CompleteProperties/Value',CompleteProperties,true);
691     XMLConfig.SetDeleteValue(
692       'CodeToolsOptions/LineLengthXMLConfig/Value',FLineLength,80);
693     XMLConfig.SetDeleteValue('CodeToolsOptions/ClassPartInsertPolicy/Value',
694       ClassPartInsertPolicyNames[FClassPartInsertPolicy],
695       ClassPartInsertPolicyNames[cpipAlphabetically]);
696     XMLConfig.SetDeleteValue(
697       'CodeToolsOptions/MixMethodsAndProperties/Value',FMixMethodsAndProperties,
698       false);
699     XMLConfig.SetDeleteValue(
700       'CodeToolsOptions/UpdateAllMethodSignatures/Value',FUpdateAllMethodSignatures,
701       true);
702     XMLConfig.SetDeleteValue('CodeToolsOptions/ForwardProcBodyInsertPolicy/Value',
703       ForwardProcBodyInsertPolicyNames[FForwardProcBodyInsertPolicy],
704       ForwardProcBodyInsertPolicyNames[fpipInFrontOfMethods]);
705     XMLConfig.SetDeleteValue(
706       'CodeToolsOptions/KeepForwardProcOrder/Value',FKeepForwardProcOrder,true);
707     XMLConfig.SetDeleteValue(
708       'CodeToolsOptions/ClassHeaderComments/Value',FClassHeaderComments,true);
709     XMLConfig.SetDeleteValue(
710       'CodeToolsOptions/UpdateMultiProcSignatures/Value',FUpdateMultiProcSignatures,
711       true);
712     XMLConfig.SetDeleteValue(
713       'CodeToolsOptions/UpdateOtherProcSignaturesCase/Value',FUpdateOtherProcSignaturesCase,
714       true);
715     XMLConfig.SetDeleteValue(
716       'CodeToolsOptions/GroupLocalVariables/Value',FGroupLocalVariables,
717       true);
718     XMLConfig.SetDeleteValue(
719       'CodeToolsOptions/OverrideStringTypesWithFirstParamType/Value',FOverrideStringTypesWithFirstParamType,
720       true);
721     XMLConfig.SetDeleteValue(
722       'CodeToolsOptions/ClassImplementationComments/Value',
723       FClassImplementationComments,true);
724     XMLConfig.SetDeleteValue('CodeToolsOptions/MethodInsertPolicy/Value',
725       MethodInsertPolicyNames[FMethodInsertPolicy],
726       MethodInsertPolicyNames[mipClassOrder]);
727     XMLConfig.SetDeleteValue('CodeToolsOptions/MethodDefaultSection/Value',
728       InsertClassSectionNames[FMethodDefaultSection],
729       InsertClassSectionNames[DefaultMethodDefaultSection]);
730     XMLConfig.SetDeleteValue('CodeToolsOptions/KeyWordPolicy/Value',
731       WordPolicyNames[FKeyWordPolicy],
732       WordPolicyNames[wpLowerCase]);
733     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierPolicy/Value',
734       WordPolicyNames[FIdentifierPolicy],
735       WordPolicyNames[wpNone]);
736     XMLConfig.SetDeleteValue('CodeToolsOptions/WordPolicyExceptions/Value',
737       Trim(LineBreaksToSystemLineBreaks(WordPolicyExceptions.Text)),'');
738     WriteAtomTypesToXML(XMLConfig,'CodeToolsOptions/DoNotSplitLineInFront/',
739       FDoNotSplitLineInFront,DefaultDoNotSplitLineInFront);
740     WriteAtomTypesToXML(XMLConfig,'CodeToolsOptions/DoNotSplitLineAfter/',
741       FDoNotSplitLineAfter,DefaultDoNotSplitLineAfter);
742     WriteAtomTypesToXML(XMLConfig,'CodeToolsOptions/DoInsertSpaceInFront/',
743       FDoInsertSpaceInFront,DefaultDoInsertSpaceInFront);
744     WriteAtomTypesToXML(XMLConfig,'CodeToolsOptions/DoInsertSpaceAfter/',
745       FDoInsertSpaceAfter,DefaultDoInsertSpaceAfter);
746     XMLConfig.SetDeleteValue('CodeToolsOptions/PropertyReadIdentPrefix/Value',
747       FPropertyReadIdentPrefix,'Get');
748     XMLConfig.SetDeleteValue('CodeToolsOptions/PropertyWriteIdentPrefix/Value',
749       FPropertyWriteIdentPrefix,'Set');
750     XMLConfig.SetDeleteValue('CodeToolsOptions/PropertyStoredIdentPostfix/Value',
751       FPropertyStoredIdentPostfix,'IsStored');
752     XMLConfig.SetDeleteValue('CodeToolsOptions/PrivateVariablePrefix/Value',
753       FPrivateVariablePrefix,'F');
754     XMLConfig.SetDeleteValue('CodeToolsOptions/SetPropertyVariablename/Value',
755       FSetPropertyVariablename,'AValue');
756     XMLConfig.SetDeleteValue('CodeToolsOptions/SetPropertyVariableIsPrefix/Value',
757       FSetPropertyVariableIsPrefix,false);
758     XMLConfig.SetDeleteValue('CodeToolsOptions/SetPropertyVariableUseConst/Value',
759       FSetPropertyVariableUseConst,false);
760     XMLConfig.SetDeleteValue('CodeToolsOptions/UsesInsertPolicy/Value',
761       UsesInsertPolicyNames[FUsesInsertPolicy],
762       UsesInsertPolicyNames[DefaultUsesInsertPolicy]);
763 
764     // identifier completion
765     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AddSemicolon',
766       FIdentComplAddSemicolon,true);
767     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AddAssignOperator',
768       FIdentComplAddAssignOperator,true);
769     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AddDo',
770       FIdentComplAddDo,true);
771     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AutoInvokeOnType',
772       FIdentComplAutoInvokeOnType,False);
773     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/OnTypeUseTimer',
774       FIdentComplOnTypeUseTimer,true);
775     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/OnTypeOnlyWordEnd',
776       FIdentComplOnTypeOnlyWordEnd,true);
777     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/OnTypeMinLength',
778       FIdentComplOnTypeMinLength,2);
779     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AutoStartAfterPoint',
780       FIdentComplAutoStartAfterPoint,true);
781     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AutoUseSingleIdent',
782       FIdentComplAutoUseSingleIdent,true);
783     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/UseContainsFilter',
784       FIdentComplUseContainsFilter,true);
785     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/IncludeCodeTemplates',
786       FIdentComplIncludeCodeTemplates,true);
787     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/IncludeWords',
788       IdentComplIncludeWordsNames[FIdentComplIncludeWords],
789       IdentComplIncludeWordsNames[icwIncludeFromAllUnits]);
790     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/ShowIcons',
791       FIdentComplShowIcons,false);
792     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/AutoAddParameterBrackets',
793       FIdentComplAddParameterBrackets,true);
794     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/ReplaceIdentifier',
795       FIdentComplReplaceIdentifier,true);
796     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/JumpToError',
797       FIdentComplJumpToError,true);
798     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/ShowHelp',
799       FIdentComplShowHelp,false);
800     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/SortForHistory',
801       FIdentComplSortForHistory,true);
802     XMLConfig.SetDeleteValue('CodeToolsOptions/IdentifierCompletion/SortForScope',
803       FIdentComplSortForScope,true);
804 
805     // indentation
806     XMLConfig.SetDeleteValue('CodeToolsOptions/Indentation/OnLineBreak/Enabled'
807       , FIndentOnLineBreak, true);
808     XMLConfig.SetDeleteValue('CodeToolsOptions/Indentation/OnPaste/Enabled'
809       , FIndentOnPaste, true);
810     XMLConfig.SetDeleteValue('CodeToolsOptions/Indentation/FileName'
811       , fIndentationFilename, '');
812     XMLConfig.SetDeleteValue('CodeToolsOptions/Indentation/ContextSensitive'
813       , FIndentContextSensitive, true);
814 
815     // code completion templates
816     XMLConfig.SetDeleteValue('CodeToolsOptions/CodeCompletionTemplate/FileName'
817       , FCodeCompletionTemplateFileName, DefaultCodeCompletionFilename);
818 
819     XMLConfig.Flush;
820     XMLConfig.Free;
821   except
822     on E: Exception do begin
823       DebugLn('[TCodeToolsOptions.Save]  error writing "',FFilename,'": ',E.Message);
824     end;
825   end;
826 end;
827 
828 procedure TCodeToolsOptions.SetCodeCompletionTemplateFileName(aValue: String);
829 begin
830   aValue:=TrimFilename(aValue);
831   if FCodeCompletionTemplateFileName=aValue then Exit;
832   FCodeCompletionTemplateFileName:=aValue;
833 end;
834 
835 procedure TCodeToolsOptions.SetFilename(const AValue: string);
836 begin
837   FFilename:=AValue;
838 end;
839 
840 procedure TCodeToolsOptions.SetLazarusDefaultFilename;
841 var
842   ConfFileName: string;
843 begin
844   ConfFileName:=AppendPathDelim(GetPrimaryConfigPath)+DefaultCodeToolsOptsFile;
845   CopySecondaryConfigFile(DefaultCodeToolsOptsFile);
846   if (not FileExistsCached(ConfFileName)) then begin
847     debugln('Looking for code tools config file:  "' + ConfFileName + '"');
848     debugln(lisCompilerNOTECodetoolsConfigFileNotFoundUsingDefaults);
849   end;
850   FFilename:=ConfFilename;
851 end;
852 
853 procedure TCodeToolsOptions.SetSetPropertyVariableIsPrefix(aValue: Boolean);
854 begin
855   if FSetPropertyVariableIsPrefix=aValue then Exit;
856   FSetPropertyVariableIsPrefix:=aValue;
857 end;
858 
859 procedure TCodeToolsOptions.SetSetPropertyVariablename(aValue: string);
860 begin
861   if FSetPropertyVariablename=aValue then Exit;
862   FSetPropertyVariablename:=aValue;
863 end;
864 
865 procedure TCodeToolsOptions.SetSetPropertyVariableUseConst(aValue: Boolean);
866 begin
867   if FSetPropertyVariableUseConst=aValue then Exit;
868   FSetPropertyVariableUseConst:=aValue;
869 end;
870 
871 procedure TCodeToolsOptions.Assign(Source: TPersistent);
872 var
873   CodeToolsOpts: TCodeToolsOptions absolute Source;
874 begin
875   if not ((Source = nil) or (Source is TCodeToolsOptions)) then
876   begin
877     inherited Assign(Source);
878     Exit;
879   end;
880 
881   if CodeToolsOpts <> nil then
882   begin
883     // General
884     FAdjustTopLineDueToComment:=CodeToolsOpts.FAdjustTopLineDueToComment;
885     FJumpSingleLinePos:=CodeToolsOpts.FJumpSingleLinePos;
886     FJumpCodeBlockPos:=CodeToolsOpts.FJumpCodeBlockPos;
887     FAvoidUnnecessaryJumps:=CodeToolsOpts.FAvoidUnnecessaryJumps;
888     FCursorBeyondEOL:=CodeToolsOpts.FCursorBeyondEOL;
889     FAddInheritedCodeToOverrideMethod:=CodeToolsOpts.AddInheritedCodeToOverrideMethod;
890     FCompleteProperties:=CodeToolsOpts.CompleteProperties;
891     FSkipForwardDeclarations:=CodeToolsOpts.FSkipForwardDeclarations;
892     FJumpToMethodBody:=CodeToolsOpts.FJumpToMethodBody;
893 
894     // define templates
895     ClearGlobalDefineTemplates;
896     FGlobalDefineTemplates:=
897       CodeToolsOpts.FGlobalDefineTemplates.CreateCopy(false,true,true);
898     if FGlobalDefineTemplates<>nil then
899       FGlobalDefineTemplates.SetDefineOwner(Self,true);
900     FDefinesEditMainSplitterTop:=CodeToolsOpts.DefinesEditMainSplitterTop;
901     FDefinesPreviewMainSplitterPos:=CodeToolsOpts.DefinesPreviewMainSplitterPos;
902     FDefinesPreviewTemplSplitterPos:=CodeToolsOpts.DefinesPreviewTemplSplitterPos;
903 
904     // CodeCreation
905     FLineLength:=CodeToolsOpts.FLineLength;
906     FClassPartInsertPolicy:=CodeToolsOpts.FClassPartInsertPolicy;
907     FMixMethodsAndProperties:=CodeToolsOpts.MixMethodsAndProperties;
908     FUpdateAllMethodSignatures:=CodeToolsOpts.UpdateAllMethodSignatures;
909     FForwardProcBodyInsertPolicy:=CodeToolsOpts.ForwardProcBodyInsertPolicy;
910     FKeepForwardProcOrder:=CodeToolsOpts.KeepForwardProcOrder;
911     FUpdateMultiProcSignatures:=CodeToolsOpts.UpdateMultiProcSignatures;
912     FUpdateOtherProcSignaturesCase:=CodeToolsOpts.UpdateOtherProcSignaturesCase;
913     FGroupLocalVariables:=CodeToolsOpts.GroupLocalVariables;
914     FOverrideStringTypesWithFirstParamType:=CodeToolsOpts.OverrideStringTypesWithFirstParamType;
915     FClassHeaderComments:=CodeToolsOpts.ClassHeaderComments;
916     FClassImplementationComments:=CodeToolsOpts.ClassImplementationComments;
917     FMethodInsertPolicy:=CodeToolsOpts.FMethodInsertPolicy;
918     FMethodDefaultSection:=CodeToolsOpts.FMethodDefaultSection;
919     FKeyWordPolicy:=CodeToolsOpts.FKeyWordPolicy;
920     FIdentifierPolicy:=CodeToolsOpts.FIdentifierPolicy;
921     FDoNotSplitLineInFront:=CodeToolsOpts.FDoNotSplitLineInFront;
922     FDoNotSplitLineAfter:=CodeToolsOpts.FDoNotSplitLineAfter;
923     FDoInsertSpaceInFront:=CodeToolsOpts.FDoInsertSpaceInFront;
924     FDoInsertSpaceAfter:=CodeToolsOpts.FDoInsertSpaceAfter;
925     FPropertyReadIdentPrefix:=CodeToolsOpts.FPropertyReadIdentPrefix;
926     FPropertyWriteIdentPrefix:=CodeToolsOpts.FPropertyWriteIdentPrefix;
927     FPropertyStoredIdentPostfix:=CodeToolsOpts.FPropertyStoredIdentPostfix;
928     FPrivateVariablePrefix:=CodeToolsOpts.FPrivateVariablePrefix;
929     FSetPropertyVariablename:=CodeToolsOpts.FSetPropertyVariablename;
930     FSetPropertyVariableIsPrefix:=CodeToolsOpts.FSetPropertyVariableIsPrefix;
931     FSetPropertyVariableUseConst:=CodeToolsOpts.FSetPropertyVariableUseConst;
932     FUsesInsertPolicy:=CodeToolsOpts.FUsesInsertPolicy;
933 
934     // identifier completion
935     FIdentComplAddSemicolon:=CodeToolsOpts.FIdentComplAddSemicolon;
936     FIdentComplAddAssignOperator:=CodeToolsOpts.FIdentComplAddAssignOperator;
937     FIdentComplAddDo:=CodeToolsOpts.FIdentComplAddDo;
938     FIdentComplAutoInvokeOnType:=CodeToolsOpts.FIdentComplAutoInvokeOnType;
939     FIdentComplOnTypeUseTimer:=CodeToolsOpts.FIdentComplOnTypeUseTimer;
940     FIdentComplOnTypeOnlyWordEnd:=CodeToolsOpts.FIdentComplOnTypeOnlyWordEnd;
941     FIdentComplOnTypeMinLength:=CodeToolsOpts.FIdentComplOnTypeMinLength;
942     FIdentComplAutoStartAfterPoint:=CodeToolsOpts.FIdentComplAutoStartAfterPoint;
943     FIdentComplAutoUseSingleIdent:=CodeToolsOpts.FIdentComplAutoUseSingleIdent;
944     FIdentComplUseContainsFilter:=CodeToolsOpts.FIdentComplUseContainsFilter;
945     FIdentComplIncludeCodeTemplates:=CodeToolsOpts.FIdentComplIncludeCodeTemplates;
946     FIdentComplShowIcons:=CodeToolsOpts.FIdentComplShowIcons;
947     FIdentComplAddParameterBrackets:=CodeToolsOpts.FIdentComplAddParameterBrackets;
948     FIdentComplReplaceIdentifier:=CodeToolsOpts.FIdentComplReplaceIdentifier;
949     FIdentComplJumpToError:=CodeToolsOpts.FIdentComplJumpToError;
950     FIdentComplShowHelp:=CodeToolsOpts.FIdentComplShowHelp;
951     FIdentComplSortForHistory:=CodeToolsOpts.FIdentComplSortForHistory;
952     FIdentComplSortForScope:=CodeToolsOpts.FIdentComplSortForScope;
953   end
954   else
955     Clear;
956 end;
957 
958 procedure TCodeToolsOptions.Clear;
959 // !!! Does not reset Filename !!!
960 begin
961   // General
962   FAdjustTopLineDueToComment:=true;
963   FJumpSingleLinePos:=50;
964   FJumpCodeBlockPos:=0;
965   FAvoidUnnecessaryJumps:=true;
966   FCursorBeyondEOL:=true;
967 
968   // define templates
969   ClearGlobalDefineTemplates;
970   FDefinesEditMainSplitterTop:=100;
971   FDefinesPreviewMainSplitterPos:=280;
972   FDefinesPreviewTemplSplitterPos:=100;
973 
974   // CodeCreation
975   FAddInheritedCodeToOverrideMethod:=true;
976   FCompleteProperties:=true;
977   FLineLength:=80;
978   FClassPartInsertPolicy:=cpipLast;
979   FMixMethodsAndProperties:=false;
980   FUpdateAllMethodSignatures:=true;
981   FForwardProcBodyInsertPolicy:=fpipInFrontOfMethods;
982   FKeepForwardProcOrder:=true;
983   FUpdateMultiProcSignatures:=true;
984   FUpdateOtherProcSignaturesCase:=true;
985   FGroupLocalVariables:=true;
986   FOverrideStringTypesWithFirstParamType:=true;
987   FClassHeaderComments:=true;
988   FClassImplementationComments:=true;
989   FMethodInsertPolicy:=mipClassOrder;
990   FMethodDefaultSection:=DefaultMethodDefaultSection;
991   FKeyWordPolicy:=wpLowerCase;
992   FIdentifierPolicy:=wpNone;
993   FDoNotSplitLineInFront:=DefaultDoNotSplitLineInFront;
994   FDoNotSplitLineAfter:=DefaultDoNotSplitLineAfter;
995   FDoInsertSpaceInFront:=DefaultDoInsertSpaceInFront;
996   FDoInsertSpaceAfter:=DefaultDoInsertSpaceAfter;
997   FPropertyReadIdentPrefix:='Get';
998   FPropertyWriteIdentPrefix:='Set';
999   FPropertyStoredIdentPostfix:='IsStored';
1000   FPrivateVariablePrefix:='f';
1001   FSetPropertyVariablename:='AValue';
1002   FSetPropertyVariableIsPrefix:=false;
1003   FSetPropertyVariableUseConst:=false;
1004   FUsesInsertPolicy:=DefaultUsesInsertPolicy;
1005 
1006   // identifier completion
1007   FIdentComplAddSemicolon:=true;
1008   FIdentComplAddAssignOperator:=true;
1009   FIdentComplAddDo:=true;
1010   FIdentComplAutoInvokeOnType:=False;
1011   FIdentComplOnTypeUseTimer:=true;
1012   FIdentComplOnTypeOnlyWordEnd:=true;
1013   FIdentComplOnTypeMinLength:=2;
1014   FIdentComplAutoStartAfterPoint:=true;
1015   FIdentComplAutoUseSingleIdent:=true;
1016   FIdentComplUseContainsFilter:=true;
1017   FIdentComplIncludeCodeTemplates:=true;
1018   FIdentComplShowIcons:=false;
1019   FIdentComplAddParameterBrackets:=true;
1020   FIdentComplReplaceIdentifier:=true;
1021   FIdentComplJumpToError:=true;
1022   FIdentComplShowHelp:=false;
1023   FIdentComplSortForHistory:=true;
1024   FIdentComplSortForScope:=true;
1025 
1026   // indentation
1027   FIndentOnLineBreak:=true;
1028   FIndentOnPaste:=true;
1029   fIndentationFilename:=
1030     TrimFilename(AppendPathDelim(GetPrimaryConfigPath)+DefaultIndentationFilename);
1031   FIndentContextSensitive:=true;
1032 
1033   // code completion templates
1034   fCodeCompletionTemplateFileName := DefaultCodeCompletionFilename;
1035 end;
1036 
1037 procedure TCodeToolsOptions.ClearGlobalDefineTemplates;
1038 begin
1039   if FGlobalDefineTemplates<>nil then begin
1040     FGlobalDefineTemplates.Clear(true);
1041     FGlobalDefineTemplates.Free;
1042     FGlobalDefineTemplates:=nil;
1043   end;
1044 end;
1045 
TCodeToolsOptions.IsEqualnull1046 function TCodeToolsOptions.IsEqual(CodeToolsOpts: TCodeToolsOptions): boolean;
1047 begin
1048   Result:=
1049     // General
1050         (FAdjustTopLineDueToComment=CodeToolsOpts.FAdjustTopLineDueToComment)
1051     and (FJumpSingleLinePos=CodeToolsOpts.FJumpSingleLinePos)
1052     and (FJumpCodeBlockPos=CodeToolsOpts.FJumpCodeBlockPos)
1053     and (FAvoidUnnecessaryJumps=CodeToolsOpts.FAvoidUnnecessaryJumps)
1054     and (FCursorBeyondEOL=CodeToolsOpts.FCursorBeyondEOL)
1055     and (AddInheritedCodeToOverrideMethod=CodeToolsOpts.AddInheritedCodeToOverrideMethod)
1056     and (CompleteProperties=CodeToolsOpts.CompleteProperties)
1057     and (FSkipForwardDeclarations=CodeToolsOpts.FSkipForwardDeclarations)
1058     and (FJumpToMethodBody=CodeToolsOpts.FJumpToMethodBody)
1059 
1060     // define templates
1061     and (FGlobalDefineTemplates.IsEqual(
1062                                 CodeToolsOpts.FGlobalDefineTemplates,true,true))
1063     and (FDefinesEditMainSplitterTop=CodeToolsOpts.fDefinesEditMainSplitterTop)
1064     and (FDefinesPreviewMainSplitterPos=CodeToolsOpts.FDefinesPreviewMainSplitterPos)
1065     and (FDefinesPreviewTemplSplitterPos=CodeToolsOpts.FDefinesPreviewTemplSplitterPos)
1066 
1067     // CodeCreation
1068     and (FLineLength=CodeToolsOpts.FLineLength)
1069     and (FClassPartInsertPolicy=CodeToolsOpts.FClassPartInsertPolicy)
1070     and (FMixMethodsAndProperties=CodeToolsOpts.MixMethodsAndProperties)
1071     and (FUpdateAllMethodSignatures=CodeToolsOpts.UpdateAllMethodSignatures)
1072     and (FForwardProcBodyInsertPolicy=CodeToolsOpts.ForwardProcBodyInsertPolicy)
1073     and (FKeepForwardProcOrder=CodeToolsOpts.KeepForwardProcOrder)
1074     and (FUpdateMultiProcSignatures=CodeToolsOpts.UpdateMultiProcSignatures)
1075     and (FUpdateOtherProcSignaturesCase=CodeToolsOpts.UpdateOtherProcSignaturesCase)
1076     and (FGroupLocalVariables=CodeToolsOpts.GroupLocalVariables)
1077     and (FOverrideStringTypesWithFirstParamType=CodeToolsOpts.OverrideStringTypesWithFirstParamType)
1078     and (FClassHeaderComments=CodeToolsOpts.ClassHeaderComments)
1079     and (FClassImplementationComments=CodeToolsOpts.ClassImplementationComments)
1080     and (FMethodInsertPolicy=CodeToolsOpts.FMethodInsertPolicy)
1081     and (FMethodDefaultSection=CodeToolsOpts.FMethodDefaultSection)
1082     and (FKeyWordPolicy=CodeToolsOpts.FKeyWordPolicy)
1083     and (FIdentifierPolicy=CodeToolsOpts.FIdentifierPolicy)
1084     and (FDoNotSplitLineInFront=CodeToolsOpts.FDoNotSplitLineInFront)
1085     and (FDoNotSplitLineAfter=CodeToolsOpts.FDoNotSplitLineAfter)
1086     and (FDoInsertSpaceInFront=CodeToolsOpts.FDoInsertSpaceInFront)
1087     and (FDoInsertSpaceAfter=CodeToolsOpts.FDoInsertSpaceAfter)
1088     and (FPropertyReadIdentPrefix=CodeToolsOpts.FPropertyReadIdentPrefix)
1089     and (FPropertyWriteIdentPrefix=CodeToolsOpts.FPropertyWriteIdentPrefix)
1090     and (FPropertyStoredIdentPostfix=CodeToolsOpts.FPropertyStoredIdentPostfix)
1091     and (FPrivateVariablePrefix=CodeToolsOpts.FPrivateVariablePrefix)
1092     and (FSetPropertyVariablename=CodeToolsOpts.FSetPropertyVariablename)
1093     and (FSetPropertyVariableIsPrefix=CodeToolsOpts.FSetPropertyVariableIsPrefix)
1094     and (FSetPropertyVariableUseConst=CodeToolsOpts.FSetPropertyVariableUseConst)
1095     and (FUsesInsertPolicy=CodeToolsOpts.FUsesInsertPolicy)
1096 
1097     // identifier completion
1098     and (FIdentComplAddSemicolon=CodeToolsOpts.FIdentComplAddSemicolon)
1099     and (FIdentComplAddAssignOperator=CodeToolsOpts.FIdentComplAddAssignOperator)
1100     and (FIdentComplAddDo=CodeToolsOpts.FIdentComplAddDo)
1101     and (FIdentComplAutoInvokeOnType=CodeToolsOpts.FIdentComplAutoInvokeOnType)
1102     and (FIdentComplOnTypeUseTimer=CodeToolsOpts.FIdentComplOnTypeUseTimer)
1103     and (FIdentComplOnTypeOnlyWordEnd=CodeToolsOpts.FIdentComplOnTypeOnlyWordEnd)
1104     and (FIdentComplOnTypeMinLength=CodeToolsOpts.FIdentComplOnTypeMinLength)
1105     and (FIdentComplAutoStartAfterPoint=CodeToolsOpts.FIdentComplAutoStartAfterPoint)
1106     and (FIdentComplAutoUseSingleIdent=CodeToolsOpts.FIdentComplAutoUseSingleIdent)
1107     and (FIdentComplUseContainsFilter=CodeToolsOpts.FIdentComplUseContainsFilter)
1108     and (FIdentComplIncludeCodeTemplates=CodeToolsOpts.FIdentComplIncludeCodeTemplates)
1109     and (FIdentComplShowIcons=CodeToolsOpts.FIdentComplShowIcons)
1110     and (FIdentComplAddParameterBrackets=CodeToolsOpts.FIdentComplAddParameterBrackets)
1111     and (FIdentComplReplaceIdentifier=CodeToolsOpts.FIdentComplReplaceIdentifier)
1112     and (FIdentComplJumpToError=CodeToolsOpts.FIdentComplJumpToError)
1113     and (FIdentComplShowHelp=CodeToolsOpts.FIdentComplShowHelp)
1114     and (FIdentComplSortForHistory=CodeToolsOpts.FIdentComplSortForHistory)
1115     and (FIdentComplSortForScope=CodeToolsOpts.FIdentComplSortForScope)
1116    ;
1117 end;
1118 
TCodeToolsOptions.CreateCopynull1119 function TCodeToolsOptions.CreateCopy: TCodeToolsOptions;
1120 begin
1121   Result:=TCodeToolsOptions.Create;
1122   Result.Assign(Self);
1123   Result.Filename:=Filename;
1124 end;
1125 
1126 procedure TCodeToolsOptions.ReadGlobalDefinesTemplatesFromTree(Tree: TDefineTree);
1127 begin
1128   ClearGlobalDefineTemplates;
1129   FGlobalDefineTemplates:=
1130     Tree.ExtractTemplatesOwnedBy(Self,[],[dtfAutoGenerated]);
1131   if FGlobalDefineTemplates<>nil then begin
1132     FGlobalDefineTemplates.SetDefineOwner(Self,true);
1133   end;
1134 end;
1135 
1136 procedure TCodeToolsOptions.CreateDefaultIndentationFile;
1137 var
1138   res: TResourceStream;
1139   fs: TFileStream;
1140 begin
1141   // indentations (laz_indentation.pas)
1142   CopySecondaryConfigFile(DefaultIndentationFilename);
1143   if not FileExistsUTF8(IndentationFilename) then
1144   begin
1145     res := TResourceStream.Create(HInstance, PChar('indentation'), PChar(RT_RCDATA));
1146     try
1147       InvalidateFileStateCache;
1148       fs := TFileStream.Create(IndentationFilename, fmCreate);
1149       try
1150         fs.CopyFrom(res, res.Size);
1151       finally
1152         fs.Free;
1153       end;
1154     except
1155       DebugLn('WARNING: unable to write indentation file "',
1156         IndentationFilename, '"');
1157     end;
1158     res.Free;
1159   end;
1160 end;
1161 
1162 procedure TCodeToolsOptions.AssignTo(Dest: TPersistent);
1163 var
1164   Boss: TCodeToolManager absolute Dest;
1165   Beauty: TBeautifyCodeOptions absolute Dest;
1166   aFilename: String;
1167 begin
1168   if Dest is TCodeToolManager then
1169   begin
1170     // General - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1171     Boss.AdjustTopLineDueToComment:=AdjustTopLineDueToComment;
1172     Boss.JumpSingleLinePos:=JumpSingleLinePos;
1173     Boss.JumpCodeBlockPos:=JumpCodeBlockPos;
1174     Boss.CursorBeyondEOL:=CursorBeyondEOL;
1175     Boss.AddInheritedCodeToOverrideMethod:=AddInheritedCodeToOverrideMethod;
1176     Boss.CompleteProperties:=CompleteProperties;
1177 
1178     // CreateCode - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1179     AssignTo(Boss.SourceChangeCache.BeautifyCodeOptions);
1180     Boss.SetPropertyVariablename:=SetPropertyVariablename;
1181     Boss.SetPropertyVariableIsPrefix:=SetPropertyVariableIsPrefix;
1182     Boss.SetPropertyVariableUseConst:=SetPropertyVariableUseConst;
1183 
1184     // Identifier Completion - - - - - - - - - - - - - - - - - - - - - - - - - -
1185     Boss.IdentifierList.SortForHistory:=IdentComplSortForHistory;
1186     Boss.IdentifierList.SortForScope:=IdentComplSortForScope;
1187 
1188     // Code Templates- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1189     aFilename:=CodeCompletionTemplateFileName;
1190     IDEMacros.SubstituteMacros(aFilename);
1191     aFilename:=TrimFilename(aFilename);
1192     if (aFilename<>'') and not FilenameIsAbsolute(aFilename) then
1193       aFilename:=TrimFilename(AppendPathDelim(GetPrimaryConfigPath)+aFilename);
1194     Boss.CodeCompletionTemplateFileName:=aFilename;
1195   end
1196   else
1197   if Dest is TBeautifyCodeOptions then
1198   begin
1199     Beauty.LineLength:=LineLength;
1200     Beauty.ClassPartInsertPolicy:=ClassPartInsertPolicy;
1201     Beauty.MixMethodsAndProperties:=MixMethodsAndProperties;
1202     Beauty.UpdateAllMethodSignatures:=UpdateAllMethodSignatures;
1203     Beauty.ForwardProcBodyInsertPolicy:=ForwardProcBodyInsertPolicy;
1204     Beauty.KeepForwardProcOrder:=KeepForwardProcOrder;
1205     Beauty.UpdateMultiProcSignatures:=UpdateMultiProcSignatures;
1206     Beauty.UpdateOtherProcSignaturesCase:=UpdateOtherProcSignaturesCase;
1207     Beauty.GroupLocalVariables:=GroupLocalVariables;
1208     Beauty.OverrideStringTypesWithFirstParamType:=OverrideStringTypesWithFirstParamType;
1209     Beauty.ClassHeaderComments:=ClassHeaderComments;
1210     Beauty.ClassImplementationComments:=ClassImplementationComments;
1211     Beauty.MethodInsertPolicy:=MethodInsertPolicy;
1212     Beauty.MethodDefaultSection:=MethodDefaultSection;
1213     Beauty.KeyWordPolicy:=KeyWordPolicy;
1214     Beauty.IdentifierPolicy:=IdentifierPolicy;
1215     Beauty.SetupWordPolicyExceptions(WordPolicyExceptions);
1216     Beauty.DoNotSplitLineInFront:=DoNotSplitLineInFront;
1217     Beauty.DoNotSplitLineAfter:=DoNotSplitLineAfter;
1218     Beauty.DoInsertSpaceInFront:=DoInsertSpaceInFront;
1219     Beauty.DoInsertSpaceAfter:=DoInsertSpaceAfter;
1220     Beauty.PropertyReadIdentPrefix:=PropertyReadIdentPrefix;
1221     Beauty.PropertyWriteIdentPrefix:=PropertyWriteIdentPrefix;
1222     Beauty.PropertyStoredIdentPostfix:=PropertyStoredIdentPostfix;
1223     Beauty.PrivateVariablePrefix:=PrivateVariablePrefix;
1224     Beauty.UsesInsertPolicy:=UsesInsertPolicy;
1225   end
1226   else
1227     inherited AssignTo(Dest);
1228 end;
1229 
1230 procedure TCodeToolsOptions.AssignGlobalDefineTemplatesToTree(Tree: TDefineTree);
1231 begin
1232   // Define templates - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1233   // remove old custom define templates
1234   Tree.RemoveTemplatesOwnedBy(Self,[],[dtfAutoGenerated]);
1235   // merge current custom define templates
1236   if FGlobalDefineTemplates<>nil then
1237     Tree.MergeDefineTemplates(FGlobalDefineTemplates,'');
1238 end;
1239 
1240 initialization
1241   RegisterIDEOptionsGroup(GroupCodetools, TCodeToolsOptions);
1242 end.
1243 
1244