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