Lazarus IDE Tools/ru: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		[[Lazarus Faq/ru\|Lazarus]] IDE - это инструменты библиотеки [[Free Pascal]] для синтаксического анализа и редактирования, называемая "codetools"\[(утилиты кода)\].
2	2
3	3		Эти инструменты предоставляют такие функции для исходников, как "Переход к объявлению", "Завершение кода", "Извлечение", "Перемещение вставки" и "Украшение Паскаля". Эти функции могут сэкономить много времени и пустой работы. Они настраиваются, и каждая функция доступна с помощью ярлыков (см. Editor Options).
4	4
5	5		Поскольку они работают исключительно с исходниками Pascal и понимают коды FPC, [[Delphi]] и [[Kylix]], им не требуются компилированные модули или установленный компилятор Borland/Embarcadero. Код Delphi и FPC можно редактировать одновременно с несколькими версиями Delphi и FPC. Это упрощает перенос кода Delphi в FPC/Lazarus.
6	6
7	7		## Горячие клавиши в IDE
8	8
9	9		\| \| \|
10	10		\|----\|----\|
11	11		\| [[Lazarus IDE Tools\|Переход на объявление]] \| `Ctrl`+ЛКМ или `Alt`+`Up` (Переход на объявление типа или переменной) \|
12	12		\| [[Lazarus IDE Tools/ru\|Переход на метод класса]] \| `Ctrl`+`Shift`+`Up` (Переход туда сюда между объявлением и телом метода) \|
13	13		\| [[Lazarus IDE Tools/ru\|Шаблоны кода]] \| `Ctrl`+`J` \|
14	14		\| [[Lazarus IDE Tools/ru\|Синхронная правка]] \| `Ctrl`+`J` (Пока текст выделен) \|
15	15		\| [[Lazarus IDE Tools/ru\|Завершение кода]] (Завершение класса) \| `Ctrl`+`Shift`+`C` \|
16	16		\| [[Lazarus IDE Tools\|Завершение идентификатора]] \| `Ctrl`+`space` \|
17	17		\| [[Lazarus IDE Tools\|Завершение слова]] \| `Ctrl`+`W` \|
18	18		\| [[Lazarus IDE Tools/ru\|Подсказка для параметров]] \| `Ctrl`+`Shift`+`space` \|
19	19		\| [[Lazarus IDE Tools/ru\|Последовательный поиск]] \| `Ctrl`+`E` \|
20	20
21	21		## Переход между методом и его объявлением
22	22
23	23		Для перехода между телом процедуры (begin..end) и объявлением процедуры (procedure Name;) используйте `Ctrl`+`Shift`+`Up`.
24	24
25	25		Для примера:
26	26
27	27		``` pascal
28	28		interface
29	29
30	30		procedure DoSomething; // Объявление процедуры
31	31
32	32		implementation
33	33
34	34		procedure DoSomething; // Тело процедуры
35	35		begin
36	36		end;
37	37		```
38	38
39	39		Если курсор стоит на теле процедуры и Вы нажмёте `Ctrl`+`Shift`+`Up`, то курсор перескочит на объявление, потом опять `Ctrl`+`Shift`+`Up` и курсор перескочит на тело процедуры, после 'begin'.
40	40
41	41		Это так же работает между методами-процедурами класса.
42	42
43	43		Подсказка: Переход осуществляется на процедуру с таким же именем и списком параметров. Если нет точной такой же процедуры, то переход будет на наиболее подходящего кандидата и позиционирует курсор на первое же различие. (Для дельфийцев: Delphi не может этого сделать). Пример процедуры с различными типами параметров:
44	44
45	45		``` pascal
46	46		interface
47	47
48	48		procedure DoSomething(p: char); // Объявление процедуры
49	49
50	50		implementation
51	51
52	52		procedure DoSomething(p: string); // Тело процедуры
53	53		begin
54	54		end;
55	55		```
56	56
57	57		Переход с определения к телу процедуры будет позиционировать курсор на ключевое слово 'string'. Это можно использовать для переименования методов и / или изменения параметров.
58	58
59	59		Пример:\
60	60		Вы переименовываете 'DoSomething' в 'MakeIt':
61	61
62	62		``` pascal
63	63		interface
64	64
65	65		procedure MakeIt; // Объявление процедуры
66	66
67	67		implementation
68	68
69	69		procedure DoSomething; // Тело процедуры
70	70		begin
71	71		end;
72	72		```
73	73
74	74		Тогда можно перейти от MakeIt к телу. IDE ищет подходящее тело и не находит, а, следовательно, ищет нечто похожее. Так как вы переименовали только одну процедуру есть ровно одно тело без определения (DoSomething) и будет переход к DoSomething, курсор встанет справа от "DoSomething". Тогда вы можете просто переименовать его прямо там. Это работает и для параметров.
75	75
76	76		## Включаемые файлы
77	77
78	78		Включаемые файлы это файлы вставленные в исходный код с помощью директив компилятора
79	79
80	80		``` pascal
81	81		{$I filename}
82	82		```
83	83
84	84		или
85	85
86	86		``` pascal
87	87		{$INCLUDE filename}
88	88		```
89	89
90	90		. Lazarus и FPC используют эти вещи чтобы уменьшить избыточность и избежать нечитаемых {\$IFDEF} конструкций при поддержке различных платформ.
91	91
92	92		В отличие от Delphi, Lazarus IDE полностью поддерживает включаемые файлы. Вы можете для примера перепрыгнуть с метода в .pas файле к телу метода во включаемом файле. Все инструменты для работы с кодом, такие как автозавершение кода, просматривают текст во включаемых файлах на предмет специальных связей.
93	93
94	94		Например: когда автозавершение кода добавляет новое тело метода за другим телом метода, он хранит их обоих в одном файле. Таким образом, вы можете помещать целые реализации классов в файлы include, как, например LCL \[делает\] для почти всех элементов управления.
95	95
96	96		Но \[тут\] есть ловушка для новичков: Если вы впервые откроете файл include и попробуете прыгнуть к методу или найди \[его\] объявление, вы получите сообщение об ошибке. IDE не знает, к какому модулю принадлежит файл include. Сначала вы должны открыть модуль.
97	97
98	98		Как только IDE проанализирует модуль, она \[начнет\] анализировать директивы include, и \[затем\] IDE запоминает эти взаимосвязи. Она сохраняет эту информацию при выходе и при сохранении проекта в ~/.lazarus/includelinks.xml. В следующий раз, когда вы откроете этот include-файл и перейдете \[к объявлению\] или найдете \[его поиском\], IDE будет открывать модуль изнутри \[include-файла\], и переход будет работать. Вы также можете указать подсказку IDE, поставив
99	99
100	100		``` pascal
101	101		{%mainunit yourunit.pas}
102	102		```
103	103
104	104		наверху вашего yourinclude.inc.
105	105
106	106		Конечно, этот механизм имеет ограничения. Некоторые include-файлы включаются дважды или более. Например: lcl/include/winapih.inc.
107	107
108	108		Переходы с объявления процедуры/метода в этом include-файле к \[их\] телу зависят от ваших последних действий. Если вы работаете в lcl/lclintf.pp, среда IDE перейдет в winapi.inc. Если вы работаете в lcl/interfacebase.pp, тогда она перейдет в lcl/include/interfacebase.inc (или в один из других включенных файлов). Если вы работаете над обоими, то вы можете запутаться. ;)
109	109
110	110		## Шаблоны кода
111	111
112	112		Шаблоны кода преобразуют идентификатор в текст, или фрагмент кода.
113	113
114	114		По умолчанию горячие клавиши для шаблонов кода `Ctrl`+`J`. Вы можете ввести идентификатор, нажать `Ctrl`+`J` и идентификатор заменится на текст определенный для этого идентификатора. Шаблоны кода можно задать в Environment -\> Editor Options -\> CodeTools.
115	115
116	116		Пример: Введите идентификатор 'classf', поставьте курсор справа от 'f' и нажмите `Ctrl`+`J`. Идентификатор 'classf' будет заменен на
117	117
118	118		``` pascal
119	119		T = class(T)
120	120		private
121	121
122	122		public
123	123		constructor Create;
124	124		destructor Destroy; override;
125	125		end;
126	126		```
127	127
128	128		и курсор будет находится за 'T'.
129	129
130	130		Вы можете посмотреть список шаблонов установив курсор на пустое место (не на идентификатор) и нажав `Ctrl`+`J`. Список шаблонов кода появится. Используйте стрелки, или введите несколько символов чтобы выбрать нужный шаблон. `Enter` создаст выделенный шаблон, а `Escape` закроет список шаблонов.
131	131
132	132		Больше всего времени экономит шаблон 'b'+`Ctrl`+`J` для begin..end.
133	133
134	134		## Подсказка для параметров
135	135
136	136		Подсказка для параметров позволяет посмотреть список параметров для процедур и функций. Жирным шрифтом выделяется текущий параметр.
137	137
138	138		Например:
139	139
140	140		``` pascal
141	141		Canvas.FillRect();
142	142		```
143	143
144	144		Поместите курсор внутри скобок и нажмите `Ctrl`+`Shift`+`space`. Появится подсказка с параметрами процедуры FillRect.
145	145
146	146		![](/wiki-images/c/c8/Parameterhints1.png)
147	147
148	148		Начиная с версии 0.9.31, справа от каждой декларации имеется кнопка, вставляющая отсутствующие параметры. Это скопирует имена параметров из выбранного объявления в позицию курсора.
149	149
150	150		![](/wiki-images/4/48/Parameterhints2.png)
151	151
152	152		Подсказка: используйте [[Lazarus IDE Tools/ru\|Автозавершение объявления переменной]], чтобы объявить переменные.
153	153
154	154		> Note: Имя ярлычка - "Show code context"\[("Показать контекст кода")\].
155	155
156	156		## Последовательный поиск
157	157
158	158		Последовательный поиск изменяет строку состояния редактора исходного кода. Введите несколько символов, и редактор тут же будет их искать, выделяя все вхождения в тексте. Для вызова поиска, нажмите: `Ctrl`+`e`.
159	159
160	160		- Например, нажмите `e` произведёт поиск и выделение всех букв «е» в коде.
161	161		- Затем, нажав `t` будет произведён поиск и выделение всех вхождений «et» и так далее.
162	162		- Вы можете использовать быстрый переход между найденными позициями в тексте нужной строки. Для быстрого перехода вниз по тексту, используйте `F3` (или `Ctrl`+`e` во время поиска). Для быстрого перехода вверх по тексту, используйте `Shift`+`F3`.
163	163		- `Backspace` удаляет последний символ
164	164		- `Enter` останавливает поиск без добавления новой строки в редакторе.
165	165		- Вы можете возобновить последний поиск, нажав `Ctrl`+`e` во второй раз, сразу же после начала последовательного поиска используя `Ctrl`+`e`. т.е. когда строка поиска пуста.
166	166		- Вставка `Ctrl`+`V` добавит строку из буфера обмена к текущему искомому тексту. (так же как в lazarus 0.9.27 r19824).
167	167
168	168		### Пример использования последовательного поиска для поиска слова
169	169
170	170		- Поместите курсор на нужное слово, не выделяя его
171	171		- Нажмите `Ctrl`+`C`. Редактор исходного кода выделит слово и скопирует его в буфер обмена.
172	172		- Нажмите `Ctrl`+`E` для начала последовательного поиска
173	173		- Нажмите `Ctrl`+`V` для поиска идентификатора (так же, как в 0.9.27)
174	174		- Используйте `F3` и `Shift`+`F3` для быстрого перехода к следующему / предыдущему найденному участку текста.
175	175		- Используйте любую клавишу (например курсор влево или вправо), чтобы закончить поиск
176	176
177	177		## Синхронная правка
178	178
179	179		Синхронная правка позволяет редактировать все места присутствия слова в тексте одновременно (синхронно). Вы просто изменяете, слово в одном месте и все остальные вхождения слова в тексте изменяются автоматически.
180	180
181	181		Синхронная правка влияет на все слова в выделенной области текста. Пример использования:
182	182
183	183		- Выделите блок текста
184	184		- Нажмите `Ctrl`+`J` или воспользуйтесь соответствующим значком. (Это работает только, если есть какие-либо слова, которые встречаются более одного раза в выделенном тексте.)
185	185		- Используйте клавишу `tab` для выделения слова, которое вы хотите изменить. (если было выделено несколько разных слов более одного раза)
186	186		- Измените слово
187	187		- Нажмите `Esc` для окончание работы с синхронной правкой
188	188
189	189		См. анимированный пример [[New IDE features since\|здесь]]
190	190
191	191		> Note: `Ctrl`+`J` также используется для редактирования шаблона. \[Это сочетание клавиш\] переключает свое значение, если вы выберете какой-то текст.
192	192
193	193		## Поиск следующего / предыдущего вхождения слова
194	194
195	195		Обе функции можно найти в контекстном меню редактора исходного кода
196	196
197	197		- Редактор кода / контекстное меню / Найти / Найти следующее вхождение слова
198	198		- Редактор кода / контекстное меню / Найти / Найти предыдущее вхождение слова
199	199
200	200		Вы можете назначить данным пунктам сочетания клавиш в окне настройки редактора исходного кода. Для этого выберите меню "Сервис-\>Параметры" и в левой части появившегося окна выберите "Редактор-\>Комбинации клавиш".
201	201
202	202		## Автозавершение Кода
203	203
204	204		Автозавершение кода можно найти в меню IDE Edit -\> Complete Code, а так же используя сочетания клавиш: `Ctrl`+`Shift`+`C`.
205	205
206	206		Для Делфистов: В Delphi, это называется "автозавершение кода"(code completion) - специальная функция, показывающая список идентификаторов, в текущей позиции исходного кода ((`Ctrl`+`Пробел`). В Lazarus это называется "автозавершение идентификаторов"(Identifier completion).
207	207
208	208		Автозавершение кода сочетает в себе несколько мощных функций, например:
209	209
210	210		- [[Lazarus IDE Tools/ru\|Автозавершение класса]]: завершает объявление свойств, добавляет/обновляет тело метода, добавляет переменные и методы в раздел private класса.
211	211		- [[Lazarus IDE Tools/ru\|Автозавершение предварительно объявленной процедуры]]: добавляет тело процедуры.
212	212		- [[Lazarus IDE Tools/ru\|Автозавершение назначенных процедур обработки событий]]: завершает связи с событием, добавляя определения методов и их тел.
213	213		- [[Lazarus IDE Tools/ru\|Автозавершение объявления переменной]]: добавляет определённые локальные переменные.
214	214		- [[Lazarus IDE Tools/ru\|Автозавершение объявления вызываемой процедуры]]: добавляет новую процедуру.
215	215		- Reversed procedure completion: добавление объявления процедур/функций (Прим.перев. 08:28, 26 October 2018 (CEST): Раздел временно отсутствует)
216	216		- [[Lazarus IDE Tools/ru\|Автозавершение предшествующего объявления класса]]: добавление объявления метода для тела метода внутри класса.
217	217
218	218		Какая из этих функций будет использована, зависит от позиции курсора в редакторе кода.
219	219
220	220		Автозавершение кода можно найти в меню IDE Edit -\> Complete Code, \[а также вызвать\] стандартным сочетанием клавиш `Ctrl`+`Shift`+`C`.
221	221
222	222		### Автозавершение класса
223	223
224	224		Наиболее мощная функция завершения кода является "Автозавершение класса". Вы пишете скелет класса, добавляя в него методы и свойства. Автозавершение кода автоматически завершит их объявления, добавив нужные переменные, тело для реализации метода или свойства, определит способ доступа к ним а так же поля класса.
225	225
226	226		Например: создайте класс (для быстроты можете использовать шаблоны кода):
227	227
228	228		``` pascal
229	229		TExample = class(TObject)
230	230		public
231	231		constructor Create;
232	232		destructor Destroy; override;
233	233		end;
234	234		```
235	235
236	236		Поместите курсор где-то внутри класса и нажмите `Ctrl`+`Shift`+`C`. Это позволит создать скелет для реализации методов и поместит курсор внутри тела метода:
237	237
238	238		``` pascal
239	239		{ TExample }
240	240
241	241		constructor TExample.Create;
242	242		begin
243	243		\|
244	244		end;
245	245
246	246		destructor TExample.Destroy;
247	247		begin
248	248		inherited Destroy;
249	249		end;
250	250		```
251	251
252	252		> Note: символом '\\|' обозначена позиция курсора в коде.
253	253
254	254		Подсказка: Вы можете переключаться между методом и его телом, используя клавиши `Ctrl`+`Shift`+`Up`.
255	255
256	256		Вы можете увидеть, что IDE добавило вызов 'inherited Destroy'. Это происходит, когда в объявлении метода используется ключевое слово 'override'.
257	257
258	258		Теперь добавьте метод DoSomething:
259	259
260	260		``` pascal
261	261		TExample = class(TObject)
262	262		public
263	263		constructor Create;
264	264		procedure DoSomething(i: integer);
265	265		destructor Destroy; override;
266	266		end;
267	267		```
268	268
269	269		Нажмите `Ctrl`+`Shift`+`C` и IDE завершит его, добавив:
270	270
271	271		``` pascal
272	272		procedure TExample.DoSomething(i: integer);
273	273		begin
274	274		\|
275	275		end;
276	276		```
277	277
278	278		Вы можете определить поведение вставки кода в Environment \> Codetools Options -\> Code Creation.
279	279
280	280		Завершение свойств\
281	281		Добавьте свойство AnInteger:
282	282
283	283		``` pascal
284	284		TExample = class(TObject)
285	285		public
286	286		constructor Create;
287	287		procedure DoSomething(i: integer);
288	288		destructor Destroy; override;
289	289		property AnInteger: Integer;
290	290		end;
291	291		```
292	292
293	293		Нажмите Ctrl+Shift+C и вы получите:
294	294
295	295		``` pascal
296	296		procedure TExample.SetAnInteger(const AValue: integer);
297	297		begin
298	298		\|if FAnInteger=AValue then exit;
299	299		FAnInteger:=AValue;
300	300		end;
301	301		```
302	302
303	303		Функция автозавершения кода добавила поля класса и метод, используемые при обращении к свойству. Нажмите `Ctrl`+`Shift`+`Up` для просмотра определения класса:
304	304
305	305		``` pascal
306	306		TExample = class(TObject)
307	307		private
308	308		FAnInteger: integer;
309	309		procedure SetAnInteger(const AValue: integer);
310	310		public
311	311		constructor Create;
312	312		procedure DoSomething(i: integer);
313	313		destructor Destroy; override;
314	314		property AnInteger: integer read FAnInteger write SetAnInteger;
315	315		end;
316	316		```
317	317
318	318		Свойство было изменено. Добавлены ключевые слова Read и Write. Класс получил новый раздел 'private' с полем 'FAnInteger' и методом 'SetAnInteger'. Это общий стиль Delphi, использовать в названиях полей букву 'F' (Field). И в методах на запись слово 'Set'. Данные настройки можно изменить в Environment \> Codetools Options -\> Code Creation.
319	319
320	320		Создание свойства только для чтения:
321	321
322	322		``` pascal
323	323		property PropName: PropType read;
324	324		```
325	325
326	326		Будет расширено до:
327	327
328	328		``` pascal
329	329		property PropName: PropType read FPropName;
330	330		```
331	331
332	332		Создание свойства только для записи:
333	333
334	334		``` pascal
335	335		property PropName: PropType write;
336	336		```
337	337
338	338		Будет расширено до:
339	339
340	340		``` pascal
341	341		property PropName: PropType write SetPropName;
342	342		```
343	343
344	344		Создание свойства только для чтения с указанием метода:
345	345
346	346		``` pascal
347	347		property PropName: PropType read GetPropName;
348	348		```
349	349
350	350		Будет добавлена функция GetPropName:
351	351
352	352		``` pascal
353	353		function GetpropName: PropType;
354	354		```
355	355
356	356		Создание свойства с ключевым словом stored:
357	357
358	358		``` pascal
359	359		property PropName: PropType stored;
360	360		```
361	361
362	362		Будет расширено до:
363	363
364	364		``` pascal
365	365		property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
366	366		```
367	367
368	368		Так как ключевое слово `stored` используется для потокового чтения и записи, нужные поля и процедуры также будут добавлены автоматически.
369	369
370	370		Подсказка: Автозавершение идентификатора также распознает неполные свойства и \[взамен\] предлагает имена по умолчанию. Например:
371	371
372	372		``` pascal
373	373		property PropName: PropType read \|;
374	374		```
375	375
376	376		Поместите курсор сразу за ключевым словом read и нажмите `Ctrl`+`Space` для автозавершения идентификатора. Он предоставит вам переменную FPropName и процедуру SetPropName.
377	377
378	378		### Автозавершение предварительно объявленной процедуры
379	379
380	380		"Автозавершение предварительно объявленной процедуры" является частью автозавершения кода и добавляет отсутствующее тело процедуры. Оно вызывается, когда курсор находится в объявлении заданной процедуры.
381	381
382	382		Например: Добавьте новую процедуру в раздел интерфейса:
383	383
384	384		``` pascal
385	385		procedure DoSomething;
386	386		```
387	387
388	388		Поместите в нее курсор и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Он будет создан в разделе реализации:
389	389
390	390		``` pascal
391	391		procedure DoSomething;
392	392		begin
393	393		\|
394	394		end;
395	395		```
396	396
397	397		Подсказка: вы можете быстро перемещаться между объявлением процедуры и ее телом с помощью `Ctrl`+`Shift`+`Up`.
398	398
399	399		Новое тело процедуры будет добавлено перед методами класса. Если в интерфейсе уже есть некоторые процедуры, IDE попытается сохранить \[их\] порядок. Например:
400	400
401	401		``` pascal
402	402		procedure Proc1;
403	403		procedure Proc2; // новая процедура
404	404		procedure Proc3;
405	405		```
406	406
407	407		Если тела Proc1 и Proc3 уже существуют, то тело Proc2 будет вставлено между телами Proc1 и Proc3. Такое поведение можно настроить в Environment \> Codetools Options -\> Code Creation.
408	408
409	409		Несколько процедур:
410	410
411	411		``` pascal
412	412		procedure Proc1_Old; // тело [процедуры уже] существует
413	413		procedure Proc2_New; // тело [процедуры еще] не существует
414	414		procedure Proc3_New; // "
415	415		procedure Proc4_New; // "
416	416		procedure Proc5_Old; // тело [процедуры уже] существует
417	417		```
418	418
419	419		Автозавершение кода добавит тела всех 3 процедур(Proc2_New, Proc3_New, Proc4_New).
420	420
421	421		Почему это называется "Автозавершение предварительно объявленной процедуры"?
422	422
423	423		Потому что это работает не только для процедур, определенных в интерфейсе, но и для процедур\[, определенных\] с помощью "предварительно объявленного" модификатора. И потому что утилиты кода обрабатывают процедуры в интерфейсе как имеющие неявный "предварительно объявленный" модификатор.
424	424
425	425		### Автозавершение назначенных процедур обработки событий
426	426
427	427		"Автозавершение назначенных процедур обработки событий" является частью автозавершения кода и завершает единственный оператор Event:=\\|. Он вызывается, когда курсор находится за назначенным событием.
428	428
429	429		Например: В методе, скажем, событие FormCreate, добавьте строку 'OnPaint:=':
430	430
431	431		``` pascal
432	432		procedure TForm1.Form1Create(Sender: TObject);
433	433		begin
434	434		OnPaint:=\|
435	435		end;
436	436		```
437	437
438	438		'\\|' - это курсор, и его не следует вводить. Затем нажмите `Ctrl`+`Shift`+`C` для завершения кода. Оператор будет завершен
439	439
440	440		``` pascal
441	441		OnPaint:=@Form1Paint;
442	442		```
443	443
444	444		Новый метод Form1Paint будет добавлен в класс TForm1. Затем запустится автозавершение класса, и вы получите:
445	445
446	446		``` pascal
447	447		procedure TForm1.Form1Paint(Sender: TObject);
448	448		begin
449	449		\|
450	450		end;
451	451		```
452	452
453	453		Это работает так же, как добавление методов в инспекторе объектов.
454	454
455	455		> Note: Вы должны поместить курсор сразу после оператора присваивания ':='. Если вы поместите курсор на идентификатор (например, OnPaint), то автозавершение кода вызовет «Автозавершение локальной переменной», что не удастся, поскольку OnPaint уже определен.
456	456
457	457		Подсказка:\
458	458		*Вы можете выбрать видимость по умолчанию для нового метода в разделе Tools / Options / Codetools / Class Completion / Default (начиная с версии 1.8)
459	459
460	460		- Вы можете определить имя нового метода самостоятельно. Например:
461	461
462	462		``` pascal
463	463		OnPaint:=@ThePaintMethod;
464	464		```
465	465
466	466		Начиная с 0.9.31 Lazarus автозавершает параметры процедуры. Например
467	467
468	468		``` pascal
469	469		procedure TForm1.FormCreate(Sender: TObject);
470	470		var
471	471		List: TList;
472	472		begin
473	473		List:=TList.Create;
474	474		List.Sort(@MySortFunction\|);
475	475		end;
476	476		```
477	477
478	478		Поместите курсор на 'MySortFunction' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите новую процедуру:
479	479
480	480		``` pascal
481	481		function MySortFunction(Item1, Item2: Pointer): Integer;
482	482		begin
483	483		\|
484	484		end;
485	485
486	486		procedure TForm1.FormCreate(Sender: TObject);
487	487		var
488	488		List: TList;
489	489		begin
490	490		List:=TList.Create;
491	491		List.Sort(@MySortFunction);
492	492		end;
493	493		```
494	494
495	495		### Автозавершение объявления переменной
496	496
497	497		"Автозавершение объявления переменной" является частью завершения кода и добавляет определение локальной переменной для \[оператора\] `Identifier:=Term` \[(Идентификатор:=Выражение)\]. Он вызывается, когда курсор находится на идентификаторе присвоения или параметра.
498	498
499	499		Например:
500	500
501	501		``` pascal
502	502		procedure TForm1.Form1Create(Sender: TObject);
503	503		begin
504	504		i:=3;
505	505		end;
506	506		```
507	507
508	508		Поместите курсор на '`i`' или сразу за ним. Затем нажмите `Ctrl`+`Shift`+`C` для автозавершения кода, и вы получите:
509	509
510	510		``` pascal
511	511		procedure TForm1.Form1Create(Sender: TObject);
512	512		var
513	513		i: Integer;
514	514		begin
515	515		i:=3;
516	516		end;
517	517		```
518	518
519	519		Утилиты кода сначала проверяют код \[на наличие объявления\] идентификатора '`i`', и если \[таковой не найден\], то добавляют объявление '`var i: integer;`'. Тип идентификатора угадывается из выражения\[, расположенного\] справа от оператора присвоения '`:=`'. Числа, такие как 3, по умолчанию \[будут иметь тип\] Integer.
520	520
521	521		Другой пример:
522	522
523	523		``` pascal
524	524		type
525	525		TWhere = (Behind, Middle, InFront);
526	526
527	527		procedure TForm1.Form1Create(Sender: TObject);
528	528		var
529	529		a: array[TWhere] of char;
530	530		begin
531	531		for Where:=Low(a) to High(a) do writeln(a[Where]);
532	532		end;
533	533		```
534	534
535	535		Поместите курсор на 'Where' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите:
536	536
537	537		``` pascal
538	538		procedure TForm1.Form1Create(Sender: TObject);
539	539		var
540	540		a: array[TWhere] of char;
541	541		Where: TWhere;
542	542		begin
543	543		for Where:=Low(a) to High(a) do writeln(a[Where]);
544	544		end;
545	545		```
546	546
547	547		Начиная с 0.9.11 Lazarus также автозавершает параметры. Например
548	548
549	549		``` pascal
550	550		procedure TForm1.FormPaint(Sender: TObject);
551	551		begin
552	552		with Canvas do begin
553	553		Line(x1,y1,x2,y2);
554	554		end;
555	555		end;
556	556		```
557	557
558	558		Поместите курсор на 'x1' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите:
559	559
560	560		``` pascal
561	561		procedure TForm1.FormPaint(Sender: TObject);
562	562		var
563	563		x1: integer;
564	564		begin
565	565		with Canvas do begin
566	566		Line(x1,y1,x2,y2);
567	567		end;
568	568		end;
569	569		```
570	570
571	571		Начиная с 0.9.31 Lazarus автозавершает параметры указателя. Например
572	572
573	573		``` pascal
574	574		procedure TForm1.FormCreate(Sender: TObject);
575	575		begin
576	576		CreateIconIndirect(@IconInfo);
577	577		end;
578	578		```
579	579
580	580		Поместите курсор в 'IconInfo' и нажмите `Ctrl`+`Shift`+`C` для автозавершения кода. Вы получите:
581	581
582	582		``` pascal
583	583		procedure TForm1.FormCreate(Sender: TObject);
584	584		var
585	585		IconInfo: TIconInfo;
586	586		begin
587	587		CreateIconIndirect(@IconInfo);
588	588		end;
589	589		```
590	590
591	591		Во всех приведенных выше примерах вы можете использовать `Ctrl`+`Shift`+`X`, чтобы отобразить диалоговое окно создания кода, в котором вы можете установить дополнительные параметры.
592	592
593	593		### Автозавершение объявления вызываемой процедуры
594	594
595	595		\[Механизм\] автозавершение кода может создать \[тело\] новой процедуры из места ее объявления.
596	596
597	597		Допустим, вы просто написали объявление "`DoSomething(Width);`"
598	598
599	599		``` pascal
600	600		procedure SomeProcedure;
601	601		var
602	602		Width: integer;
603	603		begin
604	604		Width:=3;
605	605		DoSomething(Width);
606	606		end;
607	607		```
608	608
609	609		Поместите курсор над идентификатором "DoSomething" и нажмите `Ctrl`+`Shift`+`C`, чтобы получить:
610	610
611	611		``` pascal
612	612		procedure DoSomething(aWidth: LongInt);
613	613		begin
614	614
615	615		end;
616	616
617	617		procedure SomeProcedure;
618	618		var
619	619		Width: integer;
620	620		begin
621	621		Width:=3;
622	622		DoSomething(Width);
623	623		end;
624	624		```
625	625
626	626		Это еще не создает функции или методы.
627	627
628	628		### Автозавершение предшествующего объявления класса
629	629
630	630		"Автозавершение предшествующего объявления класса" является частью Code Completion \[(Автозавершения кода), который\] добавляет объявление для текущего тела метода в private \[разделе интерфейсной части модуля\]. Он вызывается, когда курсор находится в теле метода, еще не определенном в классе. Эта функция доступна с Lazarus 0.9.21.
631	631
632	632		Например:
633	633
634	634		``` pascal
635	635		procedure TForm1.DoSomething(Sender: TObject);
636	636		begin
637	637		end;
638	638		```
639	639
640	640		Метод DoSomething еще не объявлен в TForm1. Нажмите `Ctrl`+`Shift`+`C`, и в IDE будет добавлена "`procedure DoSomething(Sender: TObject);`" в private-разделе TForm1.
641	641
642	642		Для дельфийцев: Автозавершение класса работает в Lazarus всегда одним способом: от класса интерфейсного \[раздела модуля\] к \[разделу\] реализации или наоборот, от класса в \[разделе\] реализации к \[разделу\] интерфейса. Delphi всегда вызывает оба направления. Недостаток способа Delphi заключается в том, что при опечатке легко создать новый метод, не заметив \[этого\].
643	643
644	644		------------------------------------------------------------------------
645	645
646	646		Прим.перев. 09:08, 30 October 2018 (CET): Очевидно имеется ввиду следующее: в Lazarus'е достаточно чуть изменить название метода (справедливо и для параметров) в интерфейсной части модуля и нажать `Ctrl`+`Shift`+`C`, и механизм Code Completion автоматически внесет правки в название уже имеющегося тела метода в разделе implementation. То же справедливо и для случая, когда меняется название метода (справедливо и для параметров) в разделе implementation, а затем вызывается Code Completion - в разделе interface будут внесены соответствующие правки.
647	647
648	648		В Delphi, если тело метода уже существует, то изменение имени метода в разделе interface приведет к созданию тела метода в разделе implementation с измененным именем в дополнению к уже имеющемуся со старым именем. Это, естественно, вызовет ошибку при компиляции проекта.
649	649
650	650		------------------------------------------------------------------------
651	651
652	652		### Комментарии и автозавершение кода
653	653
654	654		Автозавершение кода пытается сохранять комментарии, принадлежащие \[завершаемому коду\]. Например:
655	655
656	656		``` pascal
657	657		FList: TList; // список TComponent
658	658		FInt: integer;
659	659		```
660	660
661	661		При вставке новой переменной между FList и FInd комментарий сохраняется в строке FList. То же самое верно для
662	662
663	663		``` pascal
664	664		FList: TList; { список TComponent
665	665		Это комментарий по нескольким строкам, начиная
666	666		со строки FList, поэтому codetools предполагает, что он принадлежит
667	667		к линии FLIst и не будет [терять с ним]
668	668		связь. Код добавляется за комментарием.}
669	669		FInt: integer;
670	670		```
671	671
672	672		Если комментарий начинается со следующей строки, он будет обрабатываться так, как если бы он принадлежал коду ниже. Например:
673	673
674	674		``` pascal
675	675		FList: TList; // список TComponent
676	676		{ Этот комментарий относится к приведенному ниже операнду.
677	677		Новый код вставлен над этим комментарием и
678	678		позади комментария [для] FList.}
679	679		FInt: integer;
680	680		```
681	681
682	682		### Обновление метода
683	683
684	684		Обычно автозавершение класса добавляет все отсутствующие тела методов. (Начиная с 0.9.27). Но если именно один метод отличается между \[объявлением в\] классе и теле, то тело метода обновляется. Например: у вас есть метод DoSomething.
685	685
686	686		``` pascal
687	687		public
688	688		procedure DoSomething;
689	689		end;
690	690
691	691		procedure TForm.DoSomething;
692	692		begin
693	693		end;
694	694		```
695	695
696	696		Теперь добавляем параметр:
697	697
698	698		``` pascal
699	699		public
700	700		procedure DoSomething(i: integer);
701	701		end;
702	702		```
703	703
704	704		и вызываем автозавершение кода (`Ctrl`+`Shift`+`C`). Тело метода будет обновлено, а новый параметр будет скопирован:
705	705
706	706		``` pascal
707	707		procedure TForm.DoSomething(i: integer);
708	708		begin
709	709		end;
710	710		```
711	711
712	712		## Рефакторинг \[реорганизация кода\]
713	713
714	714		### Инверсия присвоения
715	715
716	716		Аннотация
717	717
718	718		"Invert Assignments" \[("Инверсия присвоения")\] берет некоторые выбранные инструкции pascal и инвертирует все операнды из этого кода. Этот инструмент полезен для преобразования кода "save" в "load" и обратную операцию.
719	719
720	720		Например:\
721	721
722	722		``` pascal
723	723		procedure DoSomething;
724	724		begin
725	725		AValueStudio:= BValueStudio;
726	726		AValueAppartment :=BValueAppartment;
727	727		AValueHouse:=BValueHouse;
728	728		end;
729	729		```
730	730
731	731		Выделите строки с назначением (между началом и концом) и сделайте инвертирование назначений. Все назначения будут инвертированы, а идентификация будет добавлена автоматически. Например:
732	732
733	733		Результат:
734	734
735	735		``` pascal
736	736		procedure DoSomething;
737	737		begin
738	738		BValueStudio := AValueStudio;
739	739		BValueAppartment := AValueAppartment;
740	740		BValueHouse := AValueHouse;
741	741		end;
742	742		```
743	743
744	744		------------------------------------------------------------------------
745	745
746	746		Прим.перев. 14:37, 1 November 2018 (CET): По умолчанию шоткаты для данной операции отсутствуют. Их легко определить самим, вызвав меню Tools --\> Options --\> Editor --\> Key Mappings --\> CodeTools Command --\> Invert Assignment
747	747
748	748		------------------------------------------------------------------------
749	749
750	750		### Заключить выделение \[в какую-либо конструкцию\]
751	751
752	752		Выберите текст и вызовите \[эту команду (ПКМ --\> Enclose Selection) или `Ctrl`+`Shift`+`N`\]. Появится диалоговое окно, в котором вы можете выбрать, следует ли включить выделение в try..finally или многие другие общие блоки.
753	753
754	754		### Переименование идентификатора
755	755
756	756		Поместите курсор на идентификатор и вызовите \[эту команду (ПКМ --\> Rename Identifier) или `F2`\]. Появится диалоговое окно, в котором вы можете настроить область поиска и новое имя.
757	757
758	758		- Это переименует все вхождения и только те, которые фактически используют это объявление. Это означает, что он не переименовывает объявления с тем же именем.
759	759		- И это сначала проверит конфликты имен.
760	760		- Ограничения: Это работает только с исходниками pascal, но не переименовывает файлы, не поддерживает ни файлы lfm/lrs, ни файлы lazdoc.
761	761
762	762		### Поиски ссылок на идентификатор
763	763
764	764		Поместите курсор на идентификатор и вызовите \[эту процедуру (ПКМ --\> Find --\> Find Identifier References) или `Ctrl`+`Shift`+`I`\]. Появится диалоговое окно, в котором вы можете настроить область поиска. Затем IDE будет искать все вхождения и только те, которые фактически используют это объявление. Это означает, что эта \[процедура\] не отображает другие объявления с таким же именем.
765	765
766	766		### Показ абстрактных методов
767	767
768	768		Эта функция перечисляет и автоматически завершает виртуальные, абстрактные методы, которые необходимо реализовать. Поместите курсор на объявление класса и вызовите \[эту функцию (ПКМ --\> Refactoring --\> Abstract Methods)\]. Если отсутствуют абстрактные методы, появится диалоговое окно с их перечислением. Выберите методы для реализации, и среда IDE создаст заглушки метода. Начиная с \[версии\] 1.3 Lazarus также добавляет недостающие методы интерфейса класса.
769	769
770	770		### Извлечение процедуры
771	771
772	772		См. [[IDE Window: Extract Procedure/ru\|Extract Procedure]].
773	773
774	774		## Поиск объявлений
775	775
776	776		Поместите курсор на идентификатор и выполните 'Find Declaration' \[("Найти объявление")\]. Тогда это запустит поиск объявления этого идентификатора, откроет файл и перейдет к нему. Если курсор уже находится в объявлении, он перейдет к предыдущему объявлению с тем же именем. Это позволяет находить переназначения и переопределения.
777	777
778	778		Каждое найденное объявление устанавливает точку перехода. Это означает, что вы прыгнете с найденного объявления \[к следующему найденному\] объявлению и легко вернетесь \[назад\] с помощью Search -\> Jump back.
779	779
780	780		Существуют некоторые отличия от Delphi: утилиты кода работают с исходниками, следующим правилам обычного паскаля, вместо использования выходных \[файлов\] компилятора. Компилятор возвращает конечный тип. Утилиты кода видят исходники и все шаги между ними. Например:
781	781
782	782		Свойство Visible сначала определяется в TControl (controls.pp), затем переопределяется в TCustomForm и, наконец, переопределяется в TForm. Вызов поиска объявления для \[свойства\] Visible сначала приведет вас к Visible в TForm. Затем вы снова можете вызвать Find Declaration \[("Поиск объявления")\], чтобы перейти к \[свойству\] Visible в TCustomForm, и снова, \[чтобы\] перейти к \[свойству\] Visible в TControl.
783	783
784	784		То же самое верно и для таких типов, как TColor. Для компилятора это просто \[тип\] 'longint'. Но в исходниках он определяется как
785	785
786	786		``` pascal
787	787		TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
788	788		TColor = TGraphicsColor;
789	789		```
790	790
791	791		И то же самое \[справедливо\] для forward defined classes \[("предшествующего определения классов")\]: например, в TControl, есть private-переменная
792	792
793	793		``` pascal
794	794		FHostDockSite: TWinControl;
795	795		```
796	796
797	797		Поиск объявления в TWinControl перескочит в предшествующее определение
798	798
799	799		``` pascal
800	800		TWinControl = class;
801	801		```
802	802
803	803		А вызов его снова переведет к реальной реализации
804	804
805	805		``` pascal
806	806		TWinControl = class(TControl)
807	807		```
808	808
809	809		Таким образом вы можете отслеживать каждый идентификатор и находить каждую \[его\] перегрузку.
810	810
811	811		### Подсказки
812	812
813	813		- перейти назад `Ctrl`+`H`.
814	814		- местоположениям через меню: View -\> "jump history"
815	815		- для 5-кнопочной мыши добавьте две дополнительные кнопки для перемещения вперед/назад между посещенными точками
816	816
817	817
818	818		используя [[IDE Window: EditorMouseOptionsAdvanced\|advanced mouse options]], кнопки можно переназначить.
819	819
820	820		## Автозавершение идентификатора
821	821
822	822		"Identifier Completion" \[("автозавершение идентификатора")\] вызывается \[комбинацией клавиш\] `Ctrl`+`space`. Это отображает все идентификаторы в области видимости. Например:
823	823
824	824		``` pascal
825	825		procedure TForm1.FormCreate(Sender: TObject);
826	826		begin
827	827		\|
828	828		end;
829	829		```
830	830
831	831		Поместите курсор между begin и end и нажмите `Ctrl`+`space`. IDE/Утилиты кода теперь будут анализировать весь доступный код и представлять список всех найденных идентификаторов. Утилиты кода кэшируют результаты, поэтому повторное использование этого кода будет намного быстрее.
832	832
833	833		> Note: для Дельфийцев: в Дельфи это называется Автозавершение кода.
834	834
835	835		Некоторые идентификаторы, такие как 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' встроены в компилятор и не определены нигде в исходниках. В автозавершении идентификатора также есть много таких вещей. Если вы обнаружите, что хоть один отсутствует, просто создайте запрос функции в багтрекере.
836	836
837	837		Автозавершение идентификатора не автозавершает все ключевые слова. Поэтому вы не можете использовать его для автозавершения \[ключевого слова\] 'repe' до 'repeat'. Для этого используйте `Ctrl`+`W` [[Lazarus IDE Tools/ru\|Автозавершение слова]] или `Ctrl`+`J` [[Lazarus IDE Tools/ru\|Шаблоны кода]]. Начиная с версии 0.9.27 автозавершение идентификатора автозавершает некоторые ключевые слова.
838	838
839	839		Автозавершение идентификатора показывает даже те идентификаторы, которые несовместимы.
840	840
841	841		### Сопоставление только первой части слова
842	842
843	843		Вы можете вызвать автозавершение идентификатора только по первым нескольким символам в слове. Поместите курсор внутри слова. Для поиска идентификаторов будут использоваться только символы слева от курсора. Например:
844	844
845	845		``` pascal
846	846		procedure TForm1.FormCreate(Sender: TObject);
847	847		begin
848	848		Ca\|ption
849	849		end;
850	850		```
851	851
852	852		Во \[всплывающем\] поле будут показаны только идентификаторы, начинающиеся с 'Ca' (\\| указывает позицию курсора).
853	853
854	854		### Клавиши
855	855
856	856		- Буква или цифра: добавьте символ в редактор исходного кода и текущий префикс. Это обновит список.
857	857		- Backspace: удалит последний символ из исходного редактора и префикса. Обновляет список.
858	858		- Return: заменяет целое слово под курсором на выбранный идентификатор и закрывает всплывающее окно.
859	859		- Shift+Return: как Return, но заменяет только префикс (левая часть) слова под курсором.
860	860		- Up/Down: перемещает выделение
861	861		- Escape: закрывает всплывающее окно без изменений
862	862		- Tab: завершает префикс для следующего выбора. Например: текущий префикс 'But', а завершение идентификатора показывает только 'Button1' и 'Button1Click'. Тогда нажатие Tab завершит префикс 'Button1'.
863	863		- Else: как Return и добавляет символ в редактор исходного кода
864	864
865	865		### Методы
866	866
867	867		Когда курсор находится в определении класса, и ваш идентификатор завершает метод, определенный в классе предков, параметры и ключевое слово переопределения будут добавляться автоматически. Например:
868	868
869	869		``` pascal
870	870		TMainForm = class(TForm)
871	871		protected
872	872		mous\|
873	873		end;
874	874		```
875	875
876	876		Завершение MouseDown дает:
877	877
878	878		``` pascal
879	879		TMainForm = class(TForm)
880	880		protected
881	881		procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
882	882		Y: Integer); override;
883	883		end;
884	884		```
885	885
886	886		### Свойства
887	887
888	888		``` pascal
889	889		property MyInt: integer read \|;
890	890		```
891	891
892	892		Автозавершение идентификатора покажет FMyInt и GetMyInt.
893	893
894	894		``` pascal
895	895		property MyInt: integer write \|;
896	896		```
897	897
898	898		Автозавершение идентификатора покажет FMyInt и SetMyInt.
899	899
900	900		### Секции Uses / Имена модулей
901	901
902	902		В разделах uses автозавершение идентификатора будет отображать имена файлов всех модулей в пути поиска. Они все будут отображаться строчными буквами (например, avl_tree), потому что большинство модулей имеют имена файлов в нижнем регистре. По автозавершении они вставляются в том регистре, \[в каком модуль назван\] (например, AVL_Tree).
903	903
904	904		### Операторы
905	905
906	906		``` pascal
907	907		procedure TMainForm.Button1Click(Sender: TObject);
908	908		begin
909	909		ModalRe\|;
910	910		end;
911	911		```
912	912
913	913		будет выглядеть так:
914	914
915	915		``` pascal
916	916		procedure TMainForm.Button1Click(Sender: TObject);
917	917		begin
918	918		ModalResult:=\|;
919	919		end;
920	920		```
921	921
922	922		### Иконки в окне автозавершения
923	923
924	924		В Lazarus 1.9+ существует опция для отображения значков вместо "типов", для строк в окне автозавершения. На рисунке показаны эти значки:
925	925
926		-	~~<img src="ide_completion_icons.png" title="ide_completion_icons.png" width="250" />~~
	926	+	![](/wiki-images/e/e6/Ide_completion_icons.png)
927	927
928	928		------------------------------------------------------------------------
929	929
930	930		Прим.перев. 21:20, 6 November 2018 (CET): По умолчанию показ иконок отключен. Чтобы включить их, необходимо в меню Tools --\> Options --\> Codetools --\> Identifier Completion (Сервис --\> Параметры --\> Code tools --\> Завершение идентификаторов) в разделе Appearance (Внешний вид) отметить галочкой чекбокс "Icons in code completion box" ("Значки в окне автозавершения кода").
931	931
932		-	~~<img src="icon_in_code_completion.png" title="icon_in_code_completion.png" width="500" />~~
	932	+	![](/wiki-images/e/eb/Icon_in_code_completion.png)
933	933
934	934		------------------------------------------------------------------------
935	935
936	936		## Автозавершение слова
937	937
938	938		Word Completion \[(автозавершение слова)\] вызывается \[сочетанием клавиш\] `Ctrl`+`W`. Оно отображает все слова всех открытых в настоящее время редакторов и поэтому может использоваться в не паскалевских исходниках, в комментариях и ключевых словах.
939	939
940	940		В противном случае это работает так же, как и автозавершение идентификатора.
941	941
942	942		## Словарь Модулей / Идентификатор (Cody)
943	943
944	944		Это диалоговое окно позволяет вам искать идентификаторы в других модулях. Модули не должны использоваться вашим кодом.
945	945
946	946		Эта функция является частью пакета "Cody". Чтобы активировать функцию, установите пакет.
947	947
948	948		## Переход в директиву Include
949	949
950	950		"Goto Include Directive" \[(переход в директиву Include)\] в меню поиска IDE переходит к выражению {\$I filename}, в котором используется текущий файл include.
951	951
952	952		## Публикация проекта
953	953
954	954		Создает копию всего проекта. Если вы хотите отправить кому-то только исходники и параметры компилятора вашего кода, эта функция является вашим другом.
955	955
956	956		Обычный каталог проекта содержит много информации. Большинство из них не нужно публиковать: файл .lpi может содержать информацию о сеансе (например, позицию каретки и закладки закрытых блоков), а каталог проекта содержит много файлов .ppu, .o и исполняемый файл. Чтобы создать файл lpi только с базовой информацией, \[а также создать\] только исходники со всеми подкаталогами, используйте \[опцию\] "Publish Project" \[(опубликовать проект)\].
957	957
958	958		> Note: Начиная с версии 0.9.13, есть новая \[опция в \] Project Option, которая позволяет хранить информацию о сеансе в \[другом\] файле отдельно от обычного файла .lpi. Этот новый файл заканчивается расширением .lps и содержит только информацию о сеансе, что значительно упрощает ваш файл .lpi.
959	959
960	960		В диалоговом окне вы можете настроить фильтр для включения и исключения определенных файлов; с \[возможным выполнением\] команды после того, как вы архивируете выходные файлы.
961	961
962	962		## Советы по комментариям
963	963
964	964		В нескольких местах IDE показывает подсказки для идентификатора. Например, при перемещении мыши по идентификатору в редакторе исходного кода и ожидании нескольких секунд. Когда IDE показывает подсказку для идентификатора, она ищет объявление его и всех его предков, \[а также\] ищет комментарии и файлы fpdoc. Существует много стилей кодирования и много стилей комментариев. Чтобы поддерживать многие общие стили комментариев, среда IDE использует следующий \[механизм\] эвристики:
965	965
966	966		### Комментарии, показанные в подсказке
967	967
968	968		Комментарии перед объявлением без пустой строки и не начинающиеся со знака \<:
969	969
970	970		``` pascal
971	971		var
972	972		{Комментарий}
973	973		Identifier: integer;
974	974		```
975	975
976	976		Комментарии с знаком \< принадлежит к предыдущему идентификатору.
977	977
978	978		Комментарии за идентификатором в одной строке:
979	979
980	980		``` pascal
981	981		var
982	982		identifier, // Комментарий
983	983		other,
984	984		```
985	985
986	986		Комментарии позади определения в той же строке:
987	987
988	988		``` pascal
989	989		var
990	990		identifier:
991	991		char; // Комментарий
992	992		```
993	993
994	994		Пример для знака \<:
995	995
996	996		``` pascal
997	997		const
998	998		a = 1;
999	999		//< комментарий для a
1000	1000		b = 2;
1001	1001		// комментарий для c
1002	1002		c = 3;
1003	1003		```
1004	1004
1005	1005		Поддерживаются все три типа комментариев:
1006	1006
1007	1007		``` pascal
1008	1008		{Комментарий}(Комментарий)//Комментарий
1009	1009		c = 1;
1010	1010		```
1011	1011
1012	1012		### Комментарии, не показываемые в подсказке
1013	1013
1014	1014		Комментарии, начинающиеся с \$ или %, игнорируются. Например, //% Hiddden, //\$ Hidden, (\$ Hidden).
1015	1015
1016	1016		Комментарии спереди, разделенные пустой строкой, рассматриваются как не относящиеся к следующему идентификатору. Например, следующий комментарий заголовка класса не отображается в подсказке:
1017	1017
1018	1018		``` pascal
1019	1019		type
1020	1020		{ TMyClass }
1021	1021
1022	1022		TMyClass = class
1023	1023		```
1024	1024
1025	1025		Комментарии заголовка класса создаются при завершении класса. Вы можете отключить эту \[опцию\] в Options / Codetools / Class completion / Header comment for class (Параметры / Code tools / Завершение классов / Комментарий перед заголовком класса). Если вы хотите показать комментарий заголовка в подсказке, просто удалите пустую строку.
1026	1026
1027	1027		Следующий комментарий будет показан для GL_TRUE, но не для GL_FALSE:
1028	1028
1029	1029		``` pascal
1030	1030		// Boolean
1031	1031		GL_TRUE = 1;
1032	1032		GL_FALSE = 0;
1033	1033		```
1034	1034
1035	1035		## Быстрые исправления
1036	1036
1037	1037		Быстрые исправления - это пункты меню для конкретных сообщений компилятора. Они помогают быстро решить проблему. Выберите сообщение в окне «Сообщения» и щелкните правой кнопкой мыши или щелкните правой кнопкой мыши в редакторе исходного кода на значке слева.
1038	1038
1039	1039		- Unit not found \[модуль не найден\]: удалите из раздела uses
1040	1040		- Unit not found \[модуль не найден\]: найдите модуль в загруженных пакетах и разрешите автоматическое добавление зависимости пакета
1041	1041		- Constructing a class "\$1" with abstract method "\$2" \[Создание класса "\$1" с абстрактным методом "\$2"\]: показ диалогового окна для переопределения всех абстрактных методов
1042	1042		- Local variable "\$1" not used \[Локальная переменная "\$1" не используется\]: удалите определение
1043	1043		- Circular unit reference between \$1 and \$2 \[циркулярная ссылка модуля между \$1 и \$2\]: показывает диалоговое окно зависимостей с полным путем между двумя модулями
1044	1044		- Identifier not found \[Идентификатор не найден\]: поиск через браузер кода
1045	1045		- Identifier not found \[Идентификатор не найден\]: поиск через словарь Cody (нужен пакет [[Cody]])
1046	1046		- Identifier not found \[Идентификатор не найден\]: добавьте локальную переменную
1047	1047		- Recompiling \$1, checksum changed for \$2 \[Перекомпиляция \$1, контрольная сумма изменена для \$2\]: показать диалог с путями поиска и другой информацией
1048	1048		- IDE warning: other sources path of package %s contains directory... \[Предупреждение IDE: другие пути исходников пакета %s содержит каталог ...:\]: откройте пакет
1049	1049		- any hint, note, warning \[любые подсказки, примечания, предупреждения\]: добавьте директиву IDE {%H-}
1050	1050		- any hint, note, warning \[любые подсказки, примечания, предупреждения\]: добавьте директиву компилятора {\$warn id off} (начиная с 1.7)
1051	1051		- any hint, note, warning \[любые подсказки, примечания, предупреждения\]: добавьте опцию компилятора -vm\<messageid\>
1052	1052		- Local variable "i" does not seem to be initialized \[Локальная переменная "i", похоже, не инициализирована\]: вставьте присвоение (начиная с 1.5)
1053	1053		- Inherited method is hidden \[Унаследованный метод скрыт\]: добавьте модификатор override, overload, или reintroduce (начиная с 1.9)
1054	1054
1055	1055		## Контур
1056	1056
1057	1057		Этот параметр находится в диалоговом окне Options --\> Editor --\> Display --\> Markup and Matches --\> Outline (global) \[Параметры --\> Редактор --\> Отображение --\> Подсветка и соответствия --\> Отображать контур блока(глобально)\].
1058	1058
1059	1059		Он выделяет ключевые слова Pascal вместе со своими операторными(begin-end) скобками. Это позволяет видеть вложенность больших блоков.
1060	1060
1061	1061		Например, для такого тела процедуры:
1062	1062
1063	1063		``` pascal
1064	1064		with ADockObject do
1065	1065		begin
1066	1066		if DropAlign = alNone then
1067	1067		begin
1068	1068		if DropOnControl <> nil then
1069	1069		DropAlign := DropOnControl.GetDockEdge(DropOnControl.ScreenToClient(DragPos))
1070	1070		else
1071	1071		DropAlign := Control.GetDockEdge(DragTargetPos);
1072	1072		end;
1073	1073		PositionDockRect(Control, DropOnControl, DropAlign, FDockRect);
1074	1074		end;
1075	1075		```
1076	1076
1077	1077		он подсвечивает:
1078	1078
1079	1079		- внешний with-do-begin-end оранжевым
1080	1080		- следующий if-then-begin-end зеленым
1081	1081		- внутренний if-then-else голубым
1082	1082
1083	1083		![](/wiki-images/3/3c/Ide_outline.png)
1084	1084
1085	1085		---
1086	1086		From the Free Pascal wiki, page "Lazarus IDE Tools/ru", as it stood on 2021-11-19 after a change by AMXS52, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history