<?xml version="1.0" ?>
<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.5-Based Variant V1.1//EN"
"dtd/kdedbx45.dtd" [
  <!ENTITY kdevelop "<application
>KDevelop</application
>">
  <!ENTITY % addindex "IGNORE">
  <!ENTITY % Russian "INCLUDE">
]>
<book id="kdevelop" lang="&language;">
<bookinfo>
<title
>Руководство пользователя &kdevelop;</title>
<authorgroup>
<author>
<personname
><firstname
>Эта документация создана на основе страницы <ulink url=" https://userbase.kde.org/KDevelop4/Manual"
>KDevelop4/Manual</ulink
> сайта пользовательской базы знаний KDE.</firstname
> <surname
></surname
> </personname>
    </author>
<othercredit role="translator"
><firstname
>Олеся</firstname
><surname
>Герасименко</surname
><affiliation
><address
><email
>translation-team@basealt.ru</email
></address
></affiliation
><contrib
>Перевод на русский язык</contrib
></othercredit
> 
    </authorgroup>
<legalnotice
>&FDLNotice;</legalnotice>
<date
>19 августа 2012 г.</date>
    <releaseinfo
>&kdevelop; 4.4 (&kde; 4.9)</releaseinfo>
<abstract>
<para
>&kdevelop; — интегрированная среда разработки, предназначенная для выполнения различных задач программирования.</para>
    </abstract>
  <keywordset>
    <keyword
>KDE</keyword>
    <keyword
>KDevelop</keyword>
    <keyword
>IDE</keyword>
    <keyword
>разработка</keyword>
    <keyword
>программирование</keyword>
  </keywordset>
</bookinfo>
<!--userbase <timestamp
>2012-08-19T12:36:08Z</timestamp
>-->

<!--userbase-content-->
<chapter id="what-is-kdevelop"
><title
>Что такое &kdevelop;?</title>
<para
><ulink url="https://www.kdevelop.org/"
>&kdevelop;</ulink
> — современная интегрированная среда разработки (integrated development environment, IDE) для C++ (и других языков программирования), одно из многих <ulink url="https://kde.org/applications/"
>приложений KDE</ulink
>. Она работает в &Linux; (даже если используется другое окружение рабочего стола, например, GNOME), но доступна и для большинства других вариантов &UNIX;, а также для Windows.</para>
<para
>&kdevelop; предоставляет все возможности современных интегрированных сред разработки. Для работы с большими проектами и приложениями наиболее важным является то, что &kdevelop; <emphasis
>понимает C++</emphasis
>: программа анализирует всю базу кода и запоминает, элементом каких классов является каждая из функций, где заданы переменные и каковы их типы, а также многие другие параметры кода. Например, допустим, что в одном из заголовочных файлов проекта объявлен класс</para>
<para
><programlisting
>class Car {
  // ...
  public:
    std::string get_color () const;
};
</programlisting>
</para>
<para
>и дальше в программе есть код</para>
<para
><programlisting
>Car my_ride;
// ...какие-то действия с этой переменной...
std::string color = my_ride.ge
</programlisting>
</para>
<para
>так как программа помнит о том, что <varname
>my_ride</varname
> в последней строке представляет собой переменную типа <varname
>Car</varname
>, она предложит дополнить <varname
>ge</varname
> как <varname
>get_color()</varname
>, так как эта функция является единственной функцией класса <varname
>Car</varname
>, название которой так начинается. Продолжать набирать текст не нужно — достаточно просто нажать клавишу «Ввод» для получения целого слова; это экономит время, позволяет избегать опечаток и не держать в голове точные названия сотен или тысяч функций и классов, из которых складываются большие проекты.</para>
<para
>В качестве второго примера рассмотрим такой код:</para>
<para
><programlisting
>double foo ()
{
  double var = my_func();
 return var * var;
}
double bar ()
{
  double var = my_func();
  return var * var * var;
}
</programlisting
></para>
<para
>Если навести указатель мыши на переменную <varname
>var</varname
> в функции <varname
>bar</varname
>, будут показаны все случаи использования этой переменной. При щелчке по ней будут показаны только случаи её использования в функции <varname
>bar</varname
>, так как &kdevelop; понимает, что переменная <varname
>var</varname
> в функции <varname
>foo</varname
> — это совсем другая переменная. Аналогичным образом, щелчок по имени переменной правой кнопкой мыши позволяет переименовать её; это действие затронет только переменную в функции <varname
>bar</varname
>, но не переменную с тем же именем в функции <varname
>foo</varname
>.</para>
<para
>Возможности &kdevelop; не ограничиваются редактированием кода. Программа позволяет выделять исходный ход разными цветами и настраивать расстановку отступов, содержит интегрированный интерфейс к отладчику GNU <application
>gdb</application
>, показывает справку при наведении указателя мыши на функцию, поддерживает работу с различными средами сборки и компиляторами (например, с проектами на основе <guilabel
>make</guilabel
> и <guilabel
>cmake</guilabel
>), а также предоставляет многие другие возможности, о которых рассказывается в этом руководстве.</para>
</chapter>
<chapter id="sessions-and-projects--the-basics-of-kdevelop"
><title
>Сеансы и проекты: основы &kdevelop;</title>
<para
>В этом разделе разбирается терминология и система структурирования работы, используемые в программе &kdevelop;. В частности, вводятся такие понятия, как <emphasis
>сеансы</emphasis
> и <emphasis
>проекты</emphasis
>, а также рассказывается о настройке проектов, над которыми планируется работать в &kdevelop;.</para>
<sect1 id="terminology"
><title
>Терминология</title>
<para
>В &kdevelop; предусмотрены <emphasis
>сеансы</emphasis
> и <emphasis
>проекты</emphasis
>. Сеанс содержит все проекты, которые как-либо связаны между собой. В приведённых далее примерах можно представить себя разработчиком как библиотеки, так и использующего её приложения. В роли библиотеки выступают библиотеки KDE, а в роли приложения — &kdevelop;. Другой пример: представьте себя разработчиком ядра &Linux;, который также работает и над драйвером устройства для &Linux;, который ещё не был добавлен в дерево ядра.</para>
<para
>Если взять последний пример, то в &kdevelop; был бы сеанс с двумя проектами: ядром &Linux; и драйвером устройства. С этими проектами лучше работать в рамках одного сеанса (а не создавать два сеанса с одним проектом в каждом), потому что будет полезно видеть в &kdevelop; функции ядра и структуры данных при написании исходного кода для драйвера — например, чтобы имена функций и переменных ядра автоматически разворачивались или чтобы видеть справку по функциям ядра при работе над драйвером устройства.</para>
<para
>Теперь представьте, что также ведёте разработку KDE. В этом случае потребовался бы второй сеанс, содержащий KDE в качестве проекта. В принципе, можно использовать для всего этого один сеанс, но в этом нет особого смысла: при работе над KDE не нужен доступ к функциям ядра или драйвера устройства, а при работе над ядром &Linux; не требуется автоматическое разворачивание имён классов KDE. Кроме того, сборка библиотек KDE не связана с пересборкой ядра &Linux; (с другой стороны, при сборке драйвера устройства было бы неплохо пересобрать и ядро &Linux;, если некоторые заголовочные файлы ядра изменились).</para>
<para
>Кроме того, сеансы полезны, когда ведётся работа как над текущей разрабатываемой версией проекта, так и над его ветвью: в этом случае &kdevelop; не должна путать классы, относящиеся к основному проекту и к его ветви, поэтому потребуются два сеанса, с одинаковым набором проектов, но разными каталогами сохранения (в соответствии с разными ветками разработки).</para>
</sect1>
<sect1 id="setting-up-a-session-and-importing-an-existing-project"
><title
>Настройка сеанса и импорт существующего проекта</title>
<para
>Продолжим рассматривать пример с работой над ядром &Linux; и драйвером устройства — чтобы реализовать этот пример в своей системе, потребуется заменить названия библиотек и проектов. Чтобы создать новый сеанс, содержащие эти два проекта, воспользуйтесь пунктом меню <menuchoice
><guimenu
>Сеанс</guimenu
><guimenuitem
>Начать новый сеанс</guimenuitem
></menuchoice
> (или, если &kdevelop; запускается впервые, просто воспользуйтесь создаваемым по умолчанию пустым сеансом).</para>
<para
>Дальше требуется добавить в этот сеанс проекты, которые уже где-то существуют (о создании проектов с нуля рассказывается в другом разделе этого руководства). Фактически, это можно сделать двумя способами (в зависимости от того, находится ли уже проект на жёстком диске или же должен быть загружен с сервера).</para>
<sect2 id="option-1--importing-a-project-from-a-version-control-system-server"
><title
>Способ 1: импорт проекта с сервера системы управления версиями</title>
<para
>Сначала предположим, что проект, который требуется настроить (ядро &Linux;), находится в какой-либо системе управления версиями на сервере, но копия репозитория ещё не была загружена на локальный жёсткий диск. В этом случае следует перейти в меню <guilabel
>Проект</guilabel
> для создания проекта ядра &Linux; в рамках текущего сеанса и затем выполнить следующие действия:</para>
<itemizedlist>
<listitem
><para
>Выберите пункт меню <menuchoice
><guimenu
>Проект</guimenu
><guimenuitem
>Получить проект</guimenuitem
></menuchoice
> для импорта проекта </para
></listitem>
<listitem
><para
>После этого будут доступны несколько способов создания нового проекта в текущем сеансе (в зависимости от того, откуда должны быть взяты файлы исходного кода): можно либо указать программе &kdevelop; на существующий каталог (смотрите «Способ 2» ниже), либо запросить у программы &kdevelop; получение исходного кода из репозитория. </para
></listitem>
<listitem
><para
>Если копия кода ещё не получена из хранилища системы управления версиями: <itemizedlist>
<listitem
><para
>В диалоговом окне (под надписью <guilabel
>Выбор источника</guilabel
>) выберите подходящий вариант: <guilabel
>Из файловой системы</guilabel
>, <guilabel
>Subversion</guilabel
>, <guilabel
>Git</guilabel
>, <guilabel
>GitHub</guilabel
> или <guilabel
>KDE</guilabel
> </para
></listitem>
<listitem
><para
>Укажите рабочий каталог как место назначения для файлов исходного кода </para
></listitem>
<listitem
><para
>Укажите URL-адрес репозитория, откуда могут быть получены файлы исходного кода </para
></listitem>
<listitem
><para
>Нажмите кнопку <guilabel
>Получить</guilabel
>. Процесс получения может занять много времени (это зависит от скорости соединения и размера проекта). К сожалению, в &kdevelop; 4.2.x панель хода выполнения неинформативна, но ход выполнения можно отслеживать, периодически проверяя вывод командной строки по команде <screen
>du -sk <replaceable
>/путь/к/проекту/&kdevelop;</replaceable
></screen
> для оценки объёма уже загруженных данных. </para
></listitem>
</itemizedlist>
</para
></listitem>
</itemizedlist
><para
><note
><para
>Разработчикам известно о проблеме с панелью хода выполнения: <ulink url="https://bugs.kde.org/show_bug.cgi?id=256832"
>&kdevelop;, ошибка 256832</ulink
>.</para
></note
></para>
<para
><note
><para
>Также появляется сообщение об ошибке <emphasis
>You need to specify a valid location for the project</emphasis
> («Необходимо указать корректное расположение проекта»). На него можно не обращать внимания.</para
></note
></para>
<itemizedlist>
<listitem
><para
>Программа предлагает выбрать файл проекта &kdevelop; в этом каталоге. Так как такого файла, скорее всего, ещё нет, просто нажмите кнопку <guilabel
>Далее</guilabel
> </para
></listitem>
<listitem
><para
>Снова нажмите кнопку <guilabel
>Далее</guilabel
> </para
></listitem>
<listitem
><para
>Затем программа &kdevelop; предложит выбрать диспетчер проектов. Если в проекте используются стандартные файлы make &UNIX;, выберите нетиповой диспетчер проектов makefile </para
></listitem>
<listitem
><para
>После этого программа &kdevelop; приступит к синтаксическому анализу всего проекта. Этот процесс займёт довольно много времени, так как требуется проверить все файлы, проиндексировать классы и так далее. В нижней части главного окна есть панель хода выполнения, отображающая длительность процесса. (Если у процессора несколько ядер, можно ускорить обработку: выберите пункт меню <menuchoice
><guimenu
>Настройка</guimenu
><guimenuitem
>Настроить &kdevelop;…</guimenuitem
></menuchoice
>, затем выберите в списке, расположенном в левой части окна, раздел <guilabel
>Фоновый анализ кода</guilabel
> и увеличьте количество потоков для выполнения синтаксического анализа в фоновом режиме.) </para
></listitem>
</itemizedlist>
</sect2>
<sect2 id="option-2--importing-a-project-that-is-already-on-your-hard-drive"
><title
>Способ 2: импорт проекта, который уже находится на жёстком диске</title>
<para
>Либо, если проект, с которым планируется работать, уже находится на жёстком диске (например, был загружен как архив с FTP-сервера, был получен из системы управления версиями или был создан на этом компьютере и существует <emphasis
>только</emphasis
> на жёстком диске), выберите пункт меню <menuchoice
><guimenu
>Проект</guimenu
><guimenuitem
>Открыть/импортировать проект...</guimenuitem
></menuchoice
> и в диалоговом окне укажите каталог, в котором расположен проект.</para>
</sect2>
</sect1>
<sect1 id="setting-up-an-application-as-a-second-project"
><title
>Настройка приложения в качестве второго проекта</title>
<para
>Следующий шаг — настроить другие проекты в том же сеансе. В примере выше в качестве второго проекта нужно добавить драйвер устройства; это можно сделать, выполнив точно такие же действия.</para>
<para
>Если приложений или библиотек несколько, просто повторяйте эти действия для их добавления в сеанс.</para>
</sect1>
<sect1 id="creating-projects-from-scratch"
><title
>Создание проектов с нуля</title>
<para
>Конечно, может понадобиться создать проект с нуля. Это можно сделать с помощью пункта меню <menuchoice
><guimenu
>Проект</guimenu
><guimenuitem
>Создать из шаблона…</guimenuitem
></menuchoice
>; будет предложено выбрать шаблон. С &kdevelop; поставляются несколько шаблонов проектов, но можно получить и другие, установив программу <application
>KAppTemplate</application
>. Выберите в диалоговом окне тип проекта и язык программирования, укажите название и расположение проекта, а затем нажмите кнопку <guilabel
>Далее</guilabel
>. </para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-project-dialog.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
  </mediaobject>
</screenshot>
</para>
<para
>На второй странице диалога можно настроить систему управления версиями. Выберите систему, которую следует использовать, и, если требуется, укажите для неё параметры настройки. Если систему управления версиями не следует использовать или планируется настроить её вручную позднее, выберите вариант <guilabel
>Нет</guilabel
>. После окончания настройки нажмите кнопку <guilabel
>Готово</guilabel
>. </para>
<para
>Проект был создан, теперь можно попробовать собрать или установить его. Некоторые шаблоны содержат комментарии внутри кода или даже отдельный файл README — рекомендуется сначала ознакомиться с ними. После этого можно приступить к работе над проектом, добавляя нужные возможности. </para>
</sect1>
</chapter>
<chapter id="working-with-source-code"
><title
>Работа с исходным кодом</title>
<para
>При разработке большая часть времени (не считая отладку) уходит на изучение и написание исходного кода. Для этих задач в &kdevelop; предусмотрено множество способ анализа исходного кода и оптимизации его написания. Как более подробно рассказывается в последующих разделах, &kdevelop; — не просто редактор исходного кода; скорее, это система управления исходным кодом, которая может предоставлять различные данные, полученные на основе анализа общей совокупности всего кода в сеансе работы.</para>
<sect1 id="tools-and-views"
><title
>Инструменты и представления</title>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-7.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Для работы над проектами в &kdevelop; предусмотрены <emphasis
>инструменты</emphasis
>. Инструмент позволяет использовать определённое представление исходного кода или выполнить над ним какое-либо действие. Инструментам соответствуют кнопки по периметру окна (с вертикальным текстом вдоль левой и правой границ и горизонтальным текстом вдоль нижней границы). При нажатии такой кнопки внутри главного окна откроется дочернее окно — <emphasis
>представление</emphasis
>; если снова нажать кнопку, это дочернее окно исчезнет.</para>
<para
>Чтобы убрать дочернее окно, также можно нажать кнопку <guilabel
>x</guilabel
>, расположенную в его правом верхнем углу</para>
<!--FIXME How to add a tool-->
<para
>На изображении выше показан определённый набор инструментов, расположенных по левому и правому краям окна; инструмент <guilabel
>Классы</guilabel
> открыт с левой стороны, инструмент <guilabel
>Фрагменты</guilabel
> — с правой, а в середине находится редактор файлов исходного кода. На практике, скорее всего, большую часть времени будет открыт редактор и, возможно, инструмент <guilabel
>Классы</guilabel
> или <guilabel
>Навигация по коду</guilabel
> слева. Панели других инструментов, как правило, открываются на время использования и затем закрываются, чтобы оставить больше места для редактора.</para>
<para
>При первом запуске &kdevelop; уже будет доступна кнопка инструмента <guilabel
>Проекты</guilabel
>. Нажмите её: откроется дочернее окно, в нижней части которого показаны добавленные в сеанс проекты, а в верхней — представление каталогов проектов в файловой системе.</para>
<para
>В &kdevelop; есть много других инструментов. Не все из них изначально представлены кнопками по периметру. Чтобы добавить соответствующие кнопки, выберите пункт меню <menuchoice
><guimenu
>Окно</guimenu
><guimenuitem
>Добавить панель…</guimenuitem
></menuchoice
>. Скорее всего, будут полезны следующие инструменты:</para>
<itemizedlist>
<listitem
><para
><guilabel
>Классы</guilabel
>: полный перечень всех классов, определённых в одном из проектов или в сеансе, со всеми входящими в них функциями и переменными. Если щёлкнуть по любому члену класса, появится окно редактора исходного кода с местом объявления соответствующего элемента. </para
></listitem>
<listitem
><para
><guilabel
>Документы</guilabel
>: список последних использовавшихся файлов, по типу (например, файлы исходного кода, файлы исправлений, текстовые документы). </para
></listitem>
<listitem
><para
><guilabel
>Навигация по коду</guilabel
>: отображает информацию, которая определяется положением курсора в файле. Например, когда курсор находится на строке <varname
>#include</varname
>, будет показана информация о включаемом файле (например, данные об объявленных в нём классах); когда курсор находится на пустой строке в файле, будут показаны классы и функции, объявленные и определённые в текущем файле (все в виде ссылок: по щелчку будет выполняться переход к тому месту, где фактически находится соответствующее объявление или определение); когда курсор находится на определении функции, будет показано место объявления, и предоставлен список мест, в которых используется эта функция. </para
></listitem>
<listitem
><para
><guilabel
>Файловая система</guilabel
>: позволяет просматривать файловую систему в виде дерева. </para
></listitem>
<listitem
><para
><guilabel
>Документация</guilabel
>: позволяет выполнять поиск данных на man-страницах и в других справочных документах. </para
></listitem>
<listitem
><para
><guilabel
>Фрагменты</guilabel
>: избавляет от необходимости каждый раз набирать заново последовательности текста, которые используются снова и снова. Например, в проекте, снимок которого представлен выше, часто требуется набирать код </para
></listitem>
</itemizedlist>
<para
><programlisting
>for (typename Triangulation&lt; dim&gt;::active_cell_iterator cell
      = triangulation.begin_active();
   cell != triangulation.end();
   ++cell)</programlisting
>Выражение довольно неуклюжее, но используется почти без изменений каждый раз, когда нужен цикл, — отличный кандидат на включение в список фрагментов.</para>
<itemizedlist>
<listitem
><para
><guilabel
>Konsole</guilabel
>: открывает внутри главного окна &kdevelop; окно командной строки, что позволяет при необходимости вводить команды (например, чтобы выполнить <varname
>./configure</varname
>). </para
></listitem>
</itemizedlist>
<para
>Полный перечень инструментов и представлений доступен <ulink url="https://userbase.kde.org/Special:myLanguage/KDevelop4/Manual/Tool list"
>здесь</ulink
>.</para>
<para
>Для многих программистов наиболее ценно экранное пространство по вертикали. Поэтому панели можно разместить по левому и правому краям окна: чтобы переместить панель, щёлкните по её заголовку правой кнопкой мыши и выберите новое положение.</para>
</sect1>
<sect1 id="exploring-source-code"
><title
>Изучение исходного кода</title>
<sect2 id="local-information"
><title
>Локальная информация</title>
<para
>&kdevelop; <emphasis
>понимает</emphasis
> исходный код и, следовательно, может предоставлять информацию о переменных или функциях в программе. Например, на следующем снимке показана работа с фрагментом кода, когда указатель мыши наведён на переменную <varname
>cell</varname
> в строке 1316 (если используется только клавиатура, то же самое можно сделать, некоторое время удерживая нажатой клавишу &Alt;):</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-13.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>&kdevelop; показывает подсказку с типом переменной (здесь: <varname
>DoFHandler&lt;dim&gt;active_cell_iterator</varname
>), местом объявления этой переменной (<emphasis
>контейнер</emphasis
>, которым в этом случае является окружающая функция <varname
>get_maximal_velocity</varname
>, так как это локальная переменная), её сущностью (это переменная, а не функция, класс или пространство имён) и строкой её объявления (в строке 1314, всего на несколько строк выше в коде).</para>
<para
>В текущем контексте с элементом, на который наведён указатель мыши, не связана никакая документация. Если в рассматриваемом примере навести указатель мыши на элемент <varname
>get_this_mpi_process</varname
> в строке 1318, результат будет таким:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-14.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Здесь &kdevelop; показывает объявление из постороннего файла (<filename
>utilities.h</filename
>, который является частью совсем другого проекта того же сеанса) вместе с комментарием в формате Doxygen, сопровождающим это объявление.</para>
<para
>Динамичность делает эти подсказки ещё полезнее: можно щёлкнуть по контейнеру для получения информации о контексте, в котором объявлена переменная (например, о пространстве имён <varname
>System</varname
>, в частности, месте его объявления, определении, использовании и документации), а также щёлкать по синим ссылкам для перемещения курсора на место объявления элемента (например, в <varname
>utilities.h</varname
>, строка 289) или получить список мест, где этот элемент используется в рамках текущего файла или всех проектов текущего сеанса. Последний вариант пригодится, когда нужно узнать, например, как определённая функция используется в объёмном коде.</para>
<note
><para
>Всплывающая подсказка со временем исчезает: чтобы открыть её снова, придётся опять удерживать нажатой клавишу &Alt; или наводить указатель мыши на фрагменты кода. Если данные должны отображаться постоянно, откройте панель инструмента <guilabel
>Навигация по коду</guilabel
>. В рассматриваемом примере курсор находится на той же функции, о которой говорилось ранее, а на панели инструмента слева показаны те же сведения, что и в ранее вызванной всплывающей подсказке:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-15.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>При перемещении курсора вправо на панели слева появится другая информация. Более того, если нажать расположенную сверху справа кнопку <guilabel
>Зафиксировать текущее представление</guilabel
>, эта информация будет зафиксирована — она перестанет зависеть от перемещения курсора.</para
></note>
<para
><note
><para
>Такая контекстная информация доступна не только в редакторе исходного кода, но и во многих других местах &kdevelop;. Например, при удержании клавиши &Alt; нажатой в списке автоматического дополнения (например, при быстром открытии) также появится контекстная информация о текущем элементе.</para
></note
></para>
</sect2>
<sect2 id="file-scope-information"
><title
>Информация о файле</title>
<para
>Следующий уровень — получить информацию обо всём файле исходного кода, над которым ведётся работа. Для этого поместите курсор в область текущего файла и посмотрите на данные, которые появятся на панели <guilabel
>Навигация по коду</guilabel
>:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-16.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Тут программа показывает список пространств имён, классов и функций, объявленных или определённых в текущем файле, позволяя получить общее представление о его назначении и перейти непосредственно к любому из этих объявлений или определений без затрат времени на прокрутку файла или поиск конкретного фрагмента.</para>
<para
><note
><para
>Информация об области файла полностью совпадает с информацией, представляемой в режиме навигации по коду <quote
>Структура</quote
>, описание которого приводится далее; разница заключается в том, что в режиме структуры эта информация содержится во временной всплывающей подсказке.</para
></note
></para>
</sect2>
<sect2 id="project-and-session-scope-information"
><title
>Информация о проекте и сеансе</title>
<para
>Получить информацию обо всём проекте (фактически, обо всех проектах в сеансе) можно разными способами. Такая информация обычно предоставляется с помощью различных инструментов. Например, на панели инструмента <guilabel
>Классы</guilabel
> показана древовидная структура всех классов и окружающих пространств имён для всех проектов сеанса, а также входящие в эти классы функции и переменные:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-17.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Опять же, с помощью наведения указателя мыши на запись в списке можно получить информацию об элементе, месте его объявления и определения, а также случаях его использования. Двойной щелчок по записи в этом иерархическом списке позволяет открыть окно редактора с местом, где объявлен или определён этот элемент.</para>
<para
>Глобальную информацию можно рассмотреть и под другим углом. Например, инструмент <guilabel
>Документы</guilabel
> позволяет увидеть, какие файлы или иные документы составляют проект:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-18.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
</sect2>
<sect2 id="rainbow-color-highlighting-explained"
><title
>Пояснение о выделении разными цветами</title
> 
<para
>В <application
>KDevelop</application
> для выделения объектов в коде используется целая палитра цветов. Если знать, чему соответствуют разные цвета, можно быстро получить много информации вообще без чтения кода — исключительно на основе цвета. Правила выделения цветом таковы: </para>
<itemizedlist>
<listitem
><para
>Объекты типов Class / Struct, Enum (значения и тип), (глобальные) функции и участники классов выделяются разными цветами (классы — зелёным, перечисления — тёмно-красным, участники — тёмно-жёлтым или фиолетовым, (глобальные) функции — всегда фиолетовым).</para
></listitem>
<listitem
><para
>Все глобальные переменные выделяются тёмно-зелёным.</para
></listitem>
<listitem
><para
>Идентификаторы, представляющие собой определения других типов, выделяются сине-зелёным цветом.</para
></listitem>
<listitem
><para
>Все объявления и определения объектов выделяются полужирным.</para
></listitem>
<listitem
><para
>Если доступ к участнику класса осуществляется из контекста его определения (базового или производного класса), он выделяется жёлтым цветом, а в ином случае — фиолетовым.</para
></listitem>
<listitem
><para
>Если участник класса является закрытым или защищённым, для его выделения используется более тёмный цвет.</para
></listitem>
<listitem
><para
>Для переменных, локальных по отношению к области тела функции, цвета выбираются на основе хэша идентификатора. Это касается и параметров функции. Идентификатор всегда будет иметь один и тот же цвет внутри своей области (но тот же самый идентификатор получит другой цвет, если представляет другой объект; например, если он был переопределён в более вложенной области), и обычно одно и то же имя идентификатора будет выделяться одним и тем же цветом в разных областях. Следовательно, если имеется несколько функций, принимающих параметры с одинаковыми именами, все аргументы будут выделены одним и тем же цветом. Использование таких цветов можно отключить независимо от глобального выделения цветом с помощью диалога настройки.</para
></listitem>
<listitem
><para
>Идентификаторы, для которых &kdevelop; не удалось найти соответствующие объявления, выделяются белым цветом. Иногда причиной может быть отсутствие инструкций <varname
>#include</varname
>.</para
></listitem>
<listitem
><para
>Помимо такого выделения цветом, применяются обычные правила подсветки синтаксических конструкций, заданные в &kate;. При возникновении конфликтов приоритет всегда получают правила подсветки &kdevelop;.</para
></listitem>
</itemizedlist>
</sect2>
</sect1>
<sect1 id="navigating-in-source-code"
><title
>Перемещение между фрагментами кода</title>
<para
>В предыдущем разделе рассказывалось об изучении исходного кода, то есть получении информации об элементах, файлах и проектах. Следующий шаг — перемещение по базе кода. Это возможно делать на разных уровнях: локально, внутри файла и внутри проекта.</para>
<para
><note
><para
>Многие из способов перемещения по коду доступны в меню <guilabel
>Навигация</guilabel
> главного окна &kdevelop;.</para
></note
></para>
<sect2 id="local-navigation"
><title
>Локальное перемещение</title>
<para
>Возможности &kdevelop; гораздо шире, чем у простого редактора, но программа <emphasis
>также</emphasis
> является редактором исходного кода. Конечно, можно перемещать курсор в тексте с помощью клавиш со стрелками. Также можно использовать клавиши <keycap
>PageUp</keycap
> и <keycap
>PageDown</keycap
>, как и все остальные команды, которые применяются в обычном текстовом редакторе.</para>
</sect2>
<sect2 id="file-scope-navigation-and-outline-mode"
><title
>Перемещение по области файла и режим структуры</title>
<para
>В &kdevelop; предусмотрено много способов перемещения по исходному коду на уровне области файла. Например:</para>
<itemizedlist>
<listitem
><para
><guilabel
>Структура</guilabel
>: получить структуру текущего файла можно как минимум тремя разными способами: <itemizedlist>
<listitem
><para
>Щёлкните по текстовому полю <guilabel
>Структура</guilabel
> в правой верней части части главного окна или нажмите комбинацию клавиш <keycombo
>&Alt;&Ctrl;<keycap
>N</keycap
></keycombo
> для вызова раскрывающегося меню со списком всех объявлений функций и классов: <screenshot
> <screeninfo
></screeninfo
> <mediaobject
> <imageobject
> <imagedata fileref="kdevelop-19.png" format="PNG"/> </imageobject
> <textobject
> <phrase
></phrase
> </textobject
> <caption
> <para
></para
> </caption
> </mediaobject
> </screenshot
> Затем можно просто выбрать нужный пункт для перехода к нему или (если таких пунктов много) начать набирать текст, который может быть частью названия нужного пункта; по мере набора список будет сокращаться (несовпадающие названия отсеиваются), и будет проще выбрать нужный пункт среди оставшихся. </para
></listitem>
<listitem
><para
>Поместите курсор в область файла (то есть вне объявлений или определений функций или классов), когда открыта панель <guilabel
>Навигация по коду</guilabel
>: <screenshot
> <screeninfo
></screeninfo
> <mediaobject
> <imageobject
> <imagedata fileref="kdevelop-16.png" format="PNG"/> </imageobject
> <textobject
> <phrase
></phrase
> </textobject
> <caption
> <para
></para
> </caption
> </mediaobject
> </screenshot
> Это также позволит получить структуру текущего файла и выбрать место для перехода. </para
></listitem>
<listitem
><para
>Наведите указатель мыши на вкладку одного из открытых файлов. При этом также будет показана структура соответствующего файла. </para
></listitem>
</itemizedlist>
</para
></listitem>
<listitem
><para
>Файлы исходного кода организованы в виде списка объявлений или определений функций. При нажатии комбинаций клавиш <keycombo
>&Alt;&Ctrl;<keycap
>PgUp</keycap
></keycombo
> и <keycombo
>&Alt;&Ctrl;<keycap
>PgDown</keycap
></keycombo
> выполняется переход, соответственно, к предыдущему или следующему определению функции в этом файле. </para
></listitem>
</itemizedlist>
</sect2>
<sect2 id="project-and-session-scope-navigation--semantic-navigation"
><title
>Перемещение по области проекта и сеанса: семантическое перемещение</title>
<para
>Как упоминалось ранее, &kdevelop; обычно работает не с отдельными файлами исходного кода, а с проектами в целом (точнее, со всеми проектами, которые являются частью текущего сеанса). Соответственно, программа предоставляет много способов перемещения в пределах целых проектов. Некоторые из них являются производными от тех возможностей, о которых уже рассказывалось в разделе <link linkend="exploring-source-code"
>Изучение исходного кода</link
>, в то время как другие абсолютно не похожи на них. Объединяет эти возможности перемещения тот факт, что они основаны на <emphasis
>понимании семантики</emphasis
> кода, то есть для работы с ними требуется проводить анализ целых проектов и связывание данных. В следующем списке приводятся некоторые способы перемещения по исходному коду, который может храниться в очень большом количестве отдельных файлов:</para>
<itemizedlist>
<listitem
><para
>Как говорилось в разделе <link linkend="exploring-source-code"
>Изучение исходного кода</link
>,  подсказку со сведениями об отдельном пространстве имён, классе, функции или переменной можно вызвать путём наведения указателя мыши на соответствующий элемент или нажатия и удерживания клавиши &Alt;. Пример: <screenshot
> <screeninfo
></screeninfo
> <mediaobject
> <imageobject
> <imagedata fileref="kdevelop-14.png" format="PNG"/> </imageobject
> <textobject
> <phrase
></phrase
> </textobject
> </mediaobject
> </screenshot
> Если щёлкнуть по ссылке на объявление элемента или развернуть список случаев использования, будет можно перейти к соответствующими местам в коде. Аналогичный результат можно получить с помощью инструмента <guilabel
>Навигация по коду</guilabel
>, описание которого также приводилось ранее. </para
></listitem>
<listitem
><para
>Чтобы быстро переходить к объявлению элемента, не щёлкая по ссылкам во всплывающей подсказке, можно временно включить <guilabel
>Режим навигации по коду</guilabel
>: нажмите и удерживайте клавишу &Alt; или &Ctrl;. В этом режиме для перехода к объявлению элемента достаточно щёлкнуть по этому элементу прямо в редакторе. </para
></listitem>
<listitem
><para
><guilabel
>Быстрый переход</guilabel
>: различные способы <emphasis
>быстрого перехода</emphasis
>, предусмотренные в &kdevelop;, позволяют переходить к другим файлам или расположениям. Доступны четыре варианта: <itemizedlist>
<listitem
><para
><guilabel
>Быстрый переход к классам</guilabel
> (пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Быстрый переход к классам</guimenuitem
></menuchoice
> или комбинация клавиш <keycombo
>&Alt;&Ctrl;<keycap
>C</keycap
></keycombo
>): позволяет получить список всех классов в этом сеансе. Начните набирать имя (или часть имени) класса, чтобы в списке остались только соответствующие введённому тексту пункты. Когда список станет достаточно коротким, выберите элемент с помощью клавиш со стрелками «вверх» и «вниз», и программа &kdevelop; откроет то место в коде, где объявлен этот класс. </para
></listitem>
<listitem
><para
><guilabel
>Быстрый переход к функциям</guilabel
> (пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Быстрый переход к функциям</guimenuitem
></menuchoice
> или комбинация клавиш <keycombo
>&Alt;&Ctrl;<keycap
>M</keycap
></keycombo
>): позволяет получить список всех функций(-членов), являющихся частью проектов в текущем сеансе. Выбор из списка осуществляется приведённым ранее способом. Обратите внимание, что в списке могут встречаться как объявления, так и определения функций. </para
></listitem>
<listitem
><para
><guilabel
>Быстрый переход к файлам</guilabel
> (пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Быстрый переход к файлам</guimenuitem
></menuchoice
> или комбинация клавиш <keycombo
>&Alt;&Ctrl;<keycap
>O</keycap
></keycombo
>): позволяет получить список всех файлов, которые являются частью проектов в текущем сеансе. Выбор из списка осуществляется приведённым ранее способом. </para
></listitem>
<listitem
><para
><guilabel
>Универсальный быстрый переход</guilabel
> (пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Быстрый переход</guimenuitem
></menuchoice
> или комбинация клавиш <keycombo
>&Alt;&Ctrl;<keycap
>Q</keycap
></keycombo
>): универсальный вариант на тот случай, когда не удаётся вспомнить комбинации клавиш для выполнения перечисленных ранее специализированных команд. Позволяет получить объединённый список всех файлов, функций, классов и других элементов, в котором можно выбрать нужный пункт. </para
></listitem>
</itemizedlist>
</para
></listitem>
<listitem
><para
><guilabel
>Перейти к объявлению/определению</guilabel
>: при реализации функции(-члена) часто бывает нужно вернуться к месту объявления функции (например, для обеспечения соответствия списка аргументов функции в декларации и в определении или для обновления документации). Чтобы это сделать, наведите указатель мыши на имя функции и выберите пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Перейти к объявлению</guimenuitem
></menuchoice
> (или нажмите комбинацию клавиш <keycombo
>&Ctrl;<keycap
>.</keycap
></keycombo
>). Вернуться обратно можно несколькими способами: <itemizedlist>
<listitem
><para
>Выберите пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Перейти к определению</guimenuitem
></menuchoice
> (или нажмите комбинацию клавиш <keycombo
>&Ctrl;<keycap
>,</keycap
></keycombo
>). </para
></listitem>
<listitem
><para
>Выберите пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Предыдущий контекст</guimenuitem
></menuchoice
> (или нажмите комбинацию клавиш <keycombo
><keycap
>Meta</keycap
><keycap
>стрелка «влево»</keycap
></keycombo
>), как описано далее. </para
></listitem>
</itemizedlist>
</para
></listitem>
</itemizedlist
><para
><note
><para
>Переход к объявлению элемента не ограничивается реализуемыми функциями. Он выполняется также и при наведении указателя мыши на переменную (локальную, глобальную или переменную-член). Аналогичным образом, можно навести указатель мыши на имя класса (например, в объявлении переменной функции) и перейти к его объявлению.</para
></note
></para>
<itemizedlist>
<listitem
><para
><guilabel
>Переключение между объявлением и определением</guilabel
>: в рассматриваемом выше примере для перехода к объявлению текущей функций необходимо сначала навести указатель мыши на имя функции. Чтобы исключить этот шаг, можно выбрать пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Перейти к объявлению/определению</guimenuitem
></menuchoice
> (или нажать комбинацию клавиш <keycombo
>&Shift;&Ctrl;<keycap
>C</keycap
></keycombo
>) для перехода к объявлению функции, внутри которой сейчас находится курсор. При повторном выборе этого пункта меня выполняется возврат к месту определения функции. </para
></listitem>
<listitem
><para
><guilabel
>Предыдущее или следующее обращение</guilabel
>: поместите курсор на имя локальной переменной и выберите пункт меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Следующее обращение</guimenuitem
></menuchoice
> (или нажмите комбинацию клавиш <keycombo
><keycap
>Meta</keycap
>&Shift;<keycap
>стрелка «вправо»</keycap
></keycombo
>) для перехода к месту следующего обращения к этой переменной в коде. (Обратите внимание, что программа не просто выполняет поиск следующего вхождения имени переменной, но и учитывает, что переменные с тем же именем, но в других областях, представляют собой другие переменные.) То же самое относится и к обращениям к функциям. При выборе пункта меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Предыдущее обращение</guimenuitem
></menuchoice
> (или нажатии комбинации клавиш <keycombo
><keycap
>Meta</keycap
>&Shift;<keycap
>стрелка «влево»</keycap
></keycombo
>) выполняется переход к предыдущему обращению к элементу. </para
></listitem>
</itemizedlist>
<para
><note
><para
>Для просмотра списка всех случаев использования имени, циклический переход по которому осуществляется с помощью этих команд, поместите курсор на это имя, а затем откройте панель <guilabel
>Навигация по коду</guilabel
> или нажмите и удерживайте клавишу &Alt;. Более подробные сведения об этом приёме содержатся в разделе <link linkend="file-scope-information"
>Изучение исходного кода</link
>.</para
></note
></para>
<itemizedlist>
<listitem
><para
><guilabel
>Список контекстов</guilabel
>: в веб-браузерах предусмотрена возможность перемещения вперёд и назад по списку недавно посещённых веб-страниц. В &kdevelop; есть похожая возможность, только вместо веб-страниц используются <emphasis
>контексты</emphasis
>. Контекст — это текущее расположение курсора. Он меняется, когда для перемещения из этого расположения используется что-либо, кроме команд курсора (например, щелчок по месту, указанному в подсказке, на панели <guilabel
>Навигация по коду</guilabel
>, выбор одного из пунктов меню <guilabel
>Навигация</guilabel
> или использование любой другой команды перехода. С помощью пунктов меню <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Предыдущий контекст</guimenuitem
></menuchoice
> (<keycombo
><keycap
>Meta</keycap
><keycap
>стрелка «влево»</keycap
></keycombo
>) и <menuchoice
><guimenu
>Навигация</guimenu
><guimenuitem
>Следующий контекст</guimenuitem
></menuchoice
> (<keycombo
><keycap
>Meta</keycap
><keycap
>стрелка «вправо»</keycap
></keycombo
>) можно перемещаться по списку посещённых контекстов так же, как это делается в браузере при использовании кнопок <guilabel
>назад</guilabel
> и <guilabel
>вперёд</guilabel
> для перехода к предыдущей или следующей посещённой веб-странице. </para
></listitem>
<listitem
><para
>Наконец, доступны инструменты, которые позволяют переходить к другим местам в базе кода. Например, с помощью инструмента <guilabel
>Классы</guilabel
> можно получить список всех пространств имён и классов во всех проектах текущего сеанса. Пункты этого списка можно разворачивать для просмотра функций и переменных, входящих в эти классы: <screenshot
> <screeninfo
></screeninfo
> <mediaobject
> <imageobject
> <imagedata fileref="kdevelop-17.png" format="PNG"/> </imageobject
> <textobject
> <phrase
></phrase
> </textobject
> <caption
> <para
></para
> </caption
> </mediaobject
> </screenshot
> При двойном щелчке по элементу (или использовании соответствующего пункта контекстного меню, которое доступно по щелчку правой кнопкой мыши) выполняется переход к объявлению этого элемента. Другие инструменты предоставляют схожие возможности; например, инструмент <guilabel
>Проекты</guilabel
> позволяет получить список файлов, которые являются частью сеанса: <screenshot
> <screeninfo
></screeninfo
> <mediaobject
> <imageobject
> <imagedata fileref="kdevelop-13.png" format="PNG"/> </imageobject
> <textobject
> <phrase
></phrase
> </textobject
> <caption
> <para
></para
> </caption
> </mediaobject
> </screenshot
> Открытие файла, опять-таки, выполняется по двойному щелчку. </para
></listitem>
</itemizedlist>
</sect2>
</sect1>
<sect1 id="writing-source-code"
><title
>Написание исходного кода</title>
<para
>Так как &kdevelop; понимает исходный код проектов, программа может помочь при написании нового кода. Далее приводится обзор некоторых таких возможностей.</para>
<sect2 id="auto-completion"
><title
>Автодополнение</title>
<para
>Возможно, автодополнение — это самая полезная возможность при написании нового кода. Рассмотрим, например, такой фрагмент кода:</para>
<para
><programlisting
>class Car {
  // ...
  public:
    std::string get_color () const;
};
void foo()
{
  Car my_ride;
  // ...какие-то действия с этой переменной...
  std::string color = my_ride.ge
</programlisting
></para>
<para
>Так как программа помнит о том, что <varname
>my_ride</varname
> в последней строке представляет собой переменную типа <varname
>Car</varname
>, она автоматически предложит дополнить имя функции-члена <varname
>ge</varname
> как <varname
>get_color()</varname
>. Фактически, требуется только продолжать набирать текст, пока не останется только одно совпадение, а затем нажать клавишу «Ввод»:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-42.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Обратите внимание, что можно щёлкнуть по подсказке, чтобы увидеть больше сведений о функции, а не только тип данных, которые она возвращает, и то, является ли она открытой:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-43.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Автодополнение позволяет сэкономить много времени на наборе текста, когда в проекте используются длинные имена переменных и функций; более того, оно предотвращает опечатки (и возникающие в этой связи ошибки компиляции) и помогает вспоминать точные имена функций. Например, если имена всех функций получения начинаются с <varname
>get_</varname
>, то возможность автодополнения представит список вариантов имён этих функций только после ввода первых четырёх символов. Скорее всего, при просмотре этого списка получится вспомнить нужное имя. Обратите внимание, что автодополнение будет работать даже в том случае, если класс <varname
>Car</varname
> и переменная <varname
>my_ride</varname
> объявлены не в том файле, в котором в данный момент выполняется написание кода. &kdevelop; просто должно быть известно, что эти классы и переменные связаны, то есть файлы, в которых установлены эти связи, должны быть частью проекта, над которым сейчас ведётся работа.</para>
<para
><note
><para
>Программе &kdevelop; не всегда удаётся определить, когда пользователю требуется дополнение кода. Если всплывающая подсказка с вариантами автодополнения не появилась автоматически, воспользуйтесь комбинацией клавиш <keycombo
>&Ctrl;<keycap
>Пробел</keycap
></keycombo
> для открытия списка вариантов вручную. В целом, для того, чтобы возможность автодополнения работала, &kdevelop; необходимо выполнять синтаксический анализ файлов исходного кода. После запуска &kdevelop; выполняет такую обработку всех файлов, которые являются частью проектов текущего сеанса, в фоновом режиме, а также при приостановке набора текста пользователем (длительность паузы можно настроить).</para
></note
></para>
<para
><note
><para
>&kdevelop; выполняет обработку только тех файлов, которые являются файлами исходного кода (определяется типом MIME файла). Этот тип задаётся при первом сохранении файла; следовательно, если создать новый файл и начать писать в нём код, обработка этого файла для использования данных в целях автодополнения не будет выполнена. Чтобы она выполнялась, необходимо сохранить файл.</para
></note
></para>
<para
><note
><para
>Как было сказано ранее, чтобы автодополнение работало, &kdevelop; необходимо искать объявления в заголовочных файлах. Программа выполняет поиск по ряду стандартных путей. Если заголовочный файл не удастся найти автоматически, соответствующий пункт в списке будет подчёркнут красной линией. Следует щёлкнуть по этому пункту правой кнопкой мыши и явным образом сообщить &kdevelop;, где следует искать файл и данные, которые в нём хранятся.</para
></note
></para>
<para
><note
><para
>О настройке автодополнения рассказывается в <link linkend="customizing-code-auto-completion"
>этом разделе данного руководства</link
>.</para
></note
></para>
</sect2>
<sect2 id="adding-new-classes-and-implementing-member-functions"
><title
>Добавление новых классов и реализация функций-членов</title>
<para
>В &kdevelop; предусмотрена вспомогательная программа для добавления новых классов. Описание этой процедуры приводится в разделе <link linkend="creating-a-new-class"
>Создание нового класса</link
>. Простой класс C++ можно создать, выбрав соответствующий шаблон в категории <filename
>Класс</filename
>. Во вспомогательной программе доступны несколько типовых функций-членов, например пустой конструктор, конструктор копирования и деструктор. </para>
<para
>После завершения работы вспомогательной программы файлы будут созданы и открыты в редакторе. В заголовочном файле уже есть защита от повторного включения, а новый класс содержит все выбранные функции-члены. Следующие два шага — задокументировать класс и его функции-члены и реализовать их. Средства документирования классов и функций рассматриваются далее. Чтобы реализовать уже добавленные специальные функции, просто перейдите на вкладку <guilabel
>bus.cpp</guilabel
>, которая уже содержит каркас функций:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-30.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Чтобы добавить новые функции-члены, вернитесь на вкладку <guilabel
>bus.h</guilabel
> и добавьте имя функции. Например, добавим это:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-31.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Обратите внимание, что реализация уже началась. Однако согласно многим стилям программирования функция должна быть реализована не в заголовочном файле, а в соответствующем файле .cpp. Чтобы сделать это, разместите курсор на имени функции и выберите пункт меню <menuchoice
><guimenu
>Код</guimenu
><guimenuitem
>Переместить в код</guimenuitem
></menuchoice
> или воспользуйтесь комбинацией клавиш <keycombo
>&Ctrl;&Alt;<keycap
>S</keycap
></keycombo
>. Код, расположенный в фигурных скобках, будет удалён из заголовочного файла (он будет заменён на точку с запятой, так как необходимо завершить объявление функции) и перемещён в файл исходного кода:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-32.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Ввод кода начат. Переменная <varname
>students</varname
> должна, вероятно, быть переменной-членом класса <varname
>Bus</varname
>, но она ещё не добавлена в этот класс. &kdevelop; подчёркивает эту переменную, чтобы указать на то, что среде ещё ничего не известно о ней. Эту проблему просто решить; при щелчке по имени переменной появится следующая подсказка:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-33.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>(Тот же результат можно получить с помощью пункта контекстного меню <guilabel
>Решить: Объявить как</guilabel
>.) Давайте выберем <quote
>3 - private unsigned int</quote
> (с помощью мыши или комбинации клавиш <keycombo
>&Alt;<keycap
>3</keycap
></keycombo
>) и посмотрим, что будет добавлено в заголовочный файл:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-34.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Следует учитывать, что &kdevelop; извлекает тип переменной, которая будет объявлена, из выражения, используемого для её инициализации. Например, если бы добавление было записано следующим неоднозначным образом, программа бы предложила объявить переменную как тип <varname
>double</varname
>:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-35.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>И последнее: при использовании пункта меню <menuchoice
><guimenu
>Код</guimenu
><guimenuitem
>Переместить в код</guimenuitem
></menuchoice
> новая функция-член не всегда появляется там, где это нужно. Например, её может потребоваться отметить маркером <varname
>inline</varname
> и поместить в конце заголовочного файла. В таком случае напишите объявление и начните писать объявление этой функции так:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-36.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>&kdevelop; автоматически предлагает все возможные варианты дополнения. При выборе одной из двух записей <varname
>add_students</varname
> получится следующий код, в котором уже будет полностью заполнен список аргументов:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-37.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
><note
><para
>В рассматриваемом примере принятие одного из вариантов, предлагаемых средством автоматического дополнения, позволяет получить корректную подпись, но, к сожалению, удаляет уже записанный маркер <varname
>inline</varname
>. Об этой ошибке уже известно разработчикам: <ulink url="https://bugs.kde.org/show_bug.cgi?id=274245"
>&kdevelop;, ошибка 274245</ulink
>.</para
></note
></para>
</sect2>
<sect2 id="documenting-declarations"
><title
>Документирование объявлений</title>
<para
>Хороший код хорошо документируется как на уровне реализации алгоритмов в функциях, так и на уровне интерфейса — то есть необходимо документировать классы, функции (в том числе функции-члены и глобальные функции) и переменные, чтобы были понятны их назначение, возможные значения аргументов, пред- и постусловия и так далее. В плане документирования интерфейса стандартом де-факто стала программа <ulink url="http://www.doxygen.org"
>doxygen</ulink
>; она позволяет форматировать комментарии, которые затем можно извлечь и представить на поддерживающих поиск веб-страницах.</para>
<para
>В &kdevelop; предусмотрена поддержка комментариев в этом формате. Возможно создать структуру из комментариев, документирующих класс или функцию-член. Например, допустим, что уже был написан такой код:</para>
<para
><programlisting
>class Car {
  public:
    std::string get_color () const;
};
</programlisting>
</para>
<para
>Теперь нужно добавить документацию как для класса, так и для функции-члена. Чтобы это сделать, переместите курсор на первую строку и выберите пункт меню <menuchoice
><guimenu
>Код</guimenu
><guimenuitem
>Документировать объявление</guimenuitem
></menuchoice
> или воспользуйтесь комбинацией клавиш <keycombo
>&Alt;&Shift;<keycap
>D</keycap
></keycombo
>. &kdevelop; сделает следующее:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-23.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Курсор уже находится в серой области для ввода краткого описания (после ключевого слова Doxygen <varname
>@brief</varname
>) этого класса. Затем к этому комментарию можно продолжить добавлять документацию с более подробным обзором назначения класса:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-24.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Пока редактирование выполняется в тексте комментария, он выделяется зелёным цветом (выделение цветом исчезает, когда курсор перемещается за пределы комментария). По достижении конца строки нажмите клавишу «Ввод», и программа &kdevelop; автоматически добавит новую строку, которая начинается со звёздочки, и поместит в неё курсор с отступом в один символ.</para>
<para
>Теперь задокументируем функцию-член. Снова поместите курсор на строке объявления и выберите пункт меню <menuchoice
><guimenu
>Код</guimenu
><guimenuitem
>Документировать объявление</guimenuitem
></menuchoice
> или воспользуйтесь комбинацией клавиш <keycombo
>&Alt;&Shift;<keycap
>D</keycap
></keycombo
>:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-25.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Программа &kdevelop; снова автоматически создаст каркас комментария, содержащий документацию по самой функции, а также тип данных, которые она возвращает. В данном случае имя функции понятно само по себе, но зачастую смысл аргументов функции не так очевиден и требует отдельного документирования. Например, рассмотрим немного более интересную функцию и комментарий, который автоматически создаёт &kdevelop;:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-26.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>В этом примере в предложенном комментарии уже содержатся все поля Doxygen для отдельных параметров.</para>
</sect2>
<sect2 id="renaming-variables-functions-and-classes"
><title
>Переименование переменных, функций и классов</title>
<para
>Иногда требуется переименовать функцию, класс или переменную. Например, имеется следующий код:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-38.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Затем становится понятно, что имя <varname
>remove_students</varname
> не очень удачное и лучше было бы его заменить, скажем, на <varname
>throw_out_students</varname
>. Можно воспользоваться возможностью поиска и замены, но возникают две проблемы:</para>
<itemizedlist>
<listitem
><para
>Функция может использоваться в нескольких файлах. </para
></listitem>
<listitem
><para
>Нужно переименовать только эту функцию, а не те функции, которые имеют такое же имя, но объявлены в других классах или пространствах имён.  </para
></listitem>
</itemizedlist>
<para
>Обе эти проблемы можно решить, если переместить курсор на одно из вхождений имени функции и выбрать пункт меню <menuchoice
><guimenu
>Код</guimenu
><guimenuitem
>Переименовать объявление</guimenuitem
></menuchoice
> (или щелкнуть по имени правой кнопкой мыши и выбрать в контекстном меню пункт <guilabel
>Переименовать Bus::remove_students</guilabel
>).</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-39.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
</sect2>
<sect2 id="code-snippets"
><title
>Фрагменты кода</title>
<para
>Во многих проектах есть фрагменты, которые часто используются в исходном коде. Например: цикл для всех инструкций (при написании компилятора), проверка корректности введённых пользователем данных и открытие окна с сообщением об ошибке в случае их некорректности (при написании интерфейса пользователя); в проекте автора этих строк это был бы код наподобие</para>
<para
><programlisting
>for (typename Triangulation::active_cell_iterator
       cell = triangulation.begin_active();
     cell != triangulation.end(); ++cell)
  ... какие-то действия с ячейкой ...
</programlisting>
</para>
<para
>Чтобы не набирать подобный текст снова и снова (и не допускать сопутствующие опечатки), можно воспользоваться инструментом <guilabel
>Фрагменты</guilabel
> &kdevelop;. Откройте панель этого инструмента (обратитесь к разделу <link linkend="tools-and-views"
>Инструменты и представления</link
>, если соответствующей кнопки ещё нет по периметру окна). Затем нажмите кнопку <quote
>Создать комплект</quote
> — она позволяет создать именованный набор фрагментов исходного кода определённого вида (например, набор фрагментов кода C++) — и создайте пустой комплект. После этого нажмите кнопку <inlinemediaobject
> <imageobject
> <imagedata fileref="Icon-list-add.png" format="PNG"/> </imageobject
> </inlinemediaobject
> для добавления фрагмента. Появится такое диалоговое окно:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-40.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
><note
><para
>Имя фрагмента не может содержать пробелы или другие специальные символы, потому что оно должно выглядеть как имя обычной функции или переменной (причины раскрываются в следующем абзаце).</para
></note
></para>
<para
>Чтобы использовать определённый таким образом фрагмент, при редактировании кода можно просто ввести имя фрагмента так же, как имя любой другой функции или переменной. Это имя будет доступным для автодополнения, поэтому для фрагмента можно спокойно использовать длинное подробное имя (как в примере выше). При принятии варианта дополнения (для этого достаточно нажать клавишу «Ввод») уже введённая часть названия фрагмента будет заменена его полным названием и снабжена надлежащим отступом:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-41.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Обратите внимание, что для работы этой возможности не требуется открывать или делать видимой панель <guilabel
>Фрагменты</guilabel
>: она нужна только для определения новых фрагментов. Ещё один (но менее удобный) способ развернуть фрагмент — просто щёлкнуть по нему на соответствующей панели.</para>
<para
><note
><para
>Фрагменты предоставляют и многие другие возможности. Полное описание этих возможностей доступно в <ulink url="https://userbase.kde.org/Special:myLanguage/KDevelop4/Manual/Tool_list/Snippets"
>подробной документации по инструменту «Фрагменты»</ulink
>.</para
></note
></para>
</sect2>
</sect1>
<sect1 id="modes-and-working-sets"
><title
>Режимы и рабочие наборы</title>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop4_noworkingset.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Посмотрите на правый верхний угол главного окна &kdevelop;: как показано на изображении, в &kdevelop; предусмотрены три <guilabel
>режима</guilabel
>: <guilabel
>Код</guilabel
> (об этом режиме рассказывается в текущей главе о работе с исходным кодом), <guilabel
>Отладка</guilabel
> (смотрите раздел <link linkend="debugging-programs-in-kdevelop"
>Отладка программ</link
>) и <guilabel
>Рецензирование</guilabel
> (смотрите раздел <link linkend="working-with-version-control-systems"
>Работа с системами управления версиями</link
>).</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop4_sessionsprojectsworkingsets.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Для каждого режима предусмотрен собственный набор инструментов, кнопки которых расположены по периметру окна, а также собственный <emphasis
>рабочий набор</emphasis
> из открытых в текущий момент файлов и документов. Более того, каждый такой рабочий набор связан с текущим сеансом (пример такой взаимосвязи показан выше). Обратите внимание, что файлы в рабочем наборе относятся к одному и тому же сеансу, но могут быть из разных входящих в этот сеанс проектов.</para>
<para
>При первом запуске &kdevelop; рабочий набор пуст — открытых файлов нет. Но по мере открытия файлов для редактирования (или отладки, рецензирования в других режимах) он будет расти. Тот факт, что набор не пуст, обозначается значком на вкладке (как на изображении ниже). При закрытии &kdevelop; рабочий набор сохраняется, а при последующем запуске программы — восстанавливается, что позволяет продолжить работу с тем же набором открытых файлов.</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-10.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Если навести указатель мыши на значок рабочего набора, появится всплывающая подсказка с перечнем файлов, которые сейчас открыты в этом рабочем наборе (в примере: файлы <varname
>step-32.cc</varname
> и <varname
>step-1.cc</varname
>). Нажатие кнопки с красным знаком «минус» приводит к закрытию вкладки с соответствующим файлом. Нажатие кнопки с соответствующим названием позволяет <guilabel
>закрыть</guilabel
> сразу весь рабочий набор (то есть закрыть все открытые в текущий момент файлы); в этом случае файлы сохраняются перед закрытием, а затем открывается новый, ещё пустой набор. Пример:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-11.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Обратите внимание на два значка слева от трёх вкладок режимов (сердечко и символ слева от него). Каждый из них представляет сохранённый рабочий набор (в дополнение к текущему открытому рабочему набору). Если навести указатель мыши на символ сердца, будет показано примерно следующее:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-12.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>На изображении показан соответствующий рабочий набор, содержащий два файла и названия соответствующих проектов: <varname
>Makefile</varname
> и <varname
>changes.h</varname
>. При нажатии кнопки <guilabel
>Загрузить</guilabel
> текущий рабочий набор будет сохранён и закрыт (в рассматриваемом примере он состоит из файлов <varname
>tria.h</varname
> и <varname
>tria.cc</varname
>), а вместо него будет открыт выбранный рабочий набор. Также можно удалить рабочий набор без возможности восстановления (он будет удалён из списка сохранённых рабочих наборов).</para>
</sect1>
<sect1 id="some-useful-keyboard-shortcuts"
><title
>Некоторые полезные комбинации клавиш</title>
<para
>Редактор &kdevelop; поддерживает стандартные комбинации клавиш для всех обычных действий редактирования. Кроме того, поддерживаются и другие комбинации клавиш, связанные с рядом более сложных действий по редактированию исходного кода. Следующие комбинации клавиш часто оказываются особенно полезными:</para>
<para>
<informaltable>
  <tgroup cols="2">
    <colspec colname="c1"/>
    <colspec colname="c2"/>
  <thead>
  <row>
    <entry namest="c1" nameend="c2"
>Переход по коду</entry>
  </row>
  </thead>
  <tbody>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>O</keycap
></keycombo
></entry>
    <entry
>Быстрый переход к файлу: введите часть имени файла и выберите нужный файл в каталогах проектов текущего сеанса; этот файл будет открыт</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>C</keycap
></keycombo
></entry>
    <entry
>Быстрый переход к классу: введите часть имени класса и выберите нужный класс среди совпадающих имён; курсор перейдёт к объявлению класса</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>M</keycap
></keycombo
></entry>
    <entry
>Быстрый переход к функции: введите часть имени функции(-члена) и выберите нужную функцию среди совпадающих имён (обратите внимание, что в списке будут показаны как объявления, так и определения); курсор перейдёт к выбранному пункту</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>Q</keycap
></keycombo
></entry>
    <entry
>Универсальный быстрый переход: введите любой текст (имя файла, имя класса, имя функции) и получите список всех совпадений</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>N</keycap
></keycombo
></entry>
    <entry
>Структура: получить список всех действий, которые выполняются в файле (например, объявлений классов и определений функций)</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>,</keycap
></keycombo
></entry>
    <entry
>Перейти к определению функции, если курсор в данный момент находится в месте объявления функции</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>.</keycap
></keycombo
></entry>
    <entry
>Перейти к объявлению функции или переменной, если курсор в данный момент находится в месте определения функции</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>PageDown</keycap
></keycombo
></entry>
    <entry
>Перейти к следующей функции</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>PageUp</keycap
></keycombo
></entry>
    <entry
>Перейти к предыдущей функции</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>G</keycap
></keycombo
></entry>
    <entry
>Перейти к строке</entry>
  </row>
  </tbody>
  </tgroup>
</informaltable>
</para>
<para>
<informaltable>
  <tgroup cols="2">
    <colspec colname="c1"/>
    <colspec colname="c2"/>
  <thead>
  <row>
    <entry namest="c1" nameend="c2"
>Поиск и замена</entry>
  </row>
  </thead>
  <tbody>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>F</keycap
></keycombo
></entry>
    <entry
>Найти</entry>
  </row>
  <row>
    <entry
><keycap
>F3</keycap
></entry>
    <entry
>Найти далее</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>R</keycap
></keycombo
></entry>
    <entry
>Заменить</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Alt;<keycap
>F</keycap
></keycombo
></entry>
    <entry
>Поиск и замена в нескольких файлах</entry>
  </row>
  </tbody>
  </tgroup>
</informaltable>
</para>
<para>
<informaltable>
  <tgroup cols="2">
    <colspec colname="c1"/>
    <colspec colname="c2"/>
  <thead>
  <row>
    <entry namest="c1" nameend="c2"
>Прочее</entry>
  </row>
  </thead>
  <tbody>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>_</keycap
></keycombo
></entry>
    <entry
>Свернуть один уровень: скрыть этот блок (например, если требуется изучить общую картину внутри функции)</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>+</keycap
></keycombo
></entry>
    <entry
>Развернуть один уровень: отменить свёртывание</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>D</keycap
></keycombo
></entry>
    <entry
>Раскомментировать выбранный текст или текущую строку</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;&Shift;<keycap
>D</keycap
></keycombo
></entry>
    <entry
>Закомментировать выбранный текст или текущую строку</entry>
  </row>
  <row>
    <entry
><keycombo
>&Alt;&Shift;<keycap
>D</keycap
></keycombo
></entry>
    <entry
>Задокументировать текущую функцию. Если курсор находится на объявлении функции или класса, то при нажатии этой комбинации клавиш будет создан комментарий в формате Doxygen, уже содержащий перечень всех параметров, возвращаемых значений и так далее.</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>T</keycap
></keycombo
></entry>
    <entry
>Поменять местами текущий и предыдущий символы</entry>
  </row>
  <row>
    <entry
><keycombo
>&Ctrl;<keycap
>K</keycap
></keycombo
></entry>
    <entry
>Удалить текущую строку (примечание: это действие не совпадает по результату сдействием «удалить отсюда до конца строки» в emacs)</entry>
  </row>
  </tbody>
  </tgroup>
</informaltable>
</para>
</sect1>
</chapter>
<chapter id="code-generation-with-templates"
><title
>Генерация кода с помощью шаблонов</title>
<para
>В &kdevelop; для генерации файлов исходного файла используются шаблоны. Кроме того, с их помощью можно избежать повторного написания часто используемых частей кода. </para>
<sect1 id="creating-a-new-class"
><title
>Создание нового класса</title>
<para
>Создавать код по шаблону чаще всего требуется, вероятно, при написании нового класса. Чтобы создать новый класс в уже созданном проекте, щёлкните правой кнопкой мыши по папке проекта и выберите в контекстном меню пункт <guilabel
>Создать из шаблона…</guilabel
>. То же диалоговое окно можно открыть с помощью пункта меню <menuchoice
><guimenu
>Файл</guimenu
><guimenuitem
>Создать из шаблона…</guimenuitem
></menuchoice
>, но у использования папки проекта есть преимущество — будет установлен базовый URL-адрес для выходных файлов. В представлении выбора категории выберите <filename
>Класс</filename
>, а в двух других представлениях — нужные язык программирования и шаблон. После выбора шаблона класса следует указать другие характеристики нового класса. </para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-template-selection.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
  </mediaobject>
</screenshot>
</para>
<para
>Сначала необходимо указать идентификатор нового класса. Это может быть как просто имя (например, <varname
>Bus</varname
>), так и полный идентификатор с пространствами имён (например, <varname
>Transportation::Bus</varname
>). В последнем случае &kdevelop; выполнит синтаксический анализ идентификатора и корректно отделит пространства имён от самого имени. На той же самой странице можно добавить базовые классы для нового класса. Как можно было заметить, в некоторых шаблонах уже сделан выбор базового класса; этот класс можно удалить и/или добавить другие. Здесь необходимо указать полную инструкцию наследования. Она зависит от языка: <varname
>public QObject</varname
> для C++, <varname
>extends SomeClass</varname
> для PHP или просто имя класса для Python. </para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-template-inheritance.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
  </mediaobject>
</screenshot>
</para>
<para
>На следующей странице будет можно выбрать виртуальные методы из всех унаследованных классов, а также стандартные конструкторы, деструкторы и операторы. Установка флажка рядом с подписью метода позволяет реализовать этот метод в новом классе. </para>
<para
>При нажатии кнопки <guilabel
>Далее</guilabel
> появляется страница, на которой можно добавить в класс методы. В зависимости от того, какой шаблон выбран, методы могут быть реализованы в новом классе как переменные-члены или быть созданы свойствами с функциями установки и получения значений. В языках программирования, где необходимо объявлять типы переменных (например, в C++), потребуется указать как тип, так и имя члена, например: <varname
>int number</varname
> или <varname
>QString name</varname
>. В других языках можно не указывать тип, но рекомендуется всё равно сделать это (возможно, такое указание будет полезно для дальнейшей работы с шаблоном). </para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-template-members.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
  </mediaobject>
</screenshot>
</para>
<para
>На следующих страницах можно выбрать условия лицензирования для нового класса, задать нестандартные параметры, необходимые для работы выбранного шаблона, и настроить расположения выходных данных для всех создаваемых файлов. Нажатие кнопки <guilabel
>Готово</guilabel
> приводит к завершению работы вспомогательной программы и созданию нового класса. Созданные файлы будут открыты в редакторе, что позволит сразу же приступить к добавлению кода. </para>
<para
>После создания нового класса C++ появится возможность добавить его к цели проекта. Выберите цель на странице диалога или закройте её и добавьте файлы к цели вручную. </para>
<para
>Если выбрать шаблон <filename
>Qt Object</filename
>, отметить некоторые из стандартных методов и добавить две переменные-члена, вывод будет выглядеть так, как показано на следующем изображении. </para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-template-result.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
  </mediaobject>
</screenshot>
</para>
<para
>Как можно видеть, данные-элементы преобразованы в свойства Qt с функциями доступа и макросами Q_PROPERTY. Аргументы для функций присваивания даже передаются константными ссылками (когда это возможно). Кроме того, объявлен закрытый класс и создан закрытый указатель с Q_DECLARE_PRIVATE. Всё это выполнено шаблоном; если выбрать на первом этапе другой шаблон, результат может быть совсем другим. </para>
</sect1>
<sect1 id="creating-a-new-unit-test"
><title
>Создание нового модульного теста</title>
<para
>Хотя на большинстве платформ тестирования каждый тест должен быть отдельным классом, в &kdevelop; предусмотрен способ упростить создание модульных тестов. Чтобы создать новый тест, щёлкните по папке проекта правой кнопкой мыши и выберите в контекстном меню пункт <guilabel
>Создать из шаблона...</guilabel
>. На странице выбора шаблона укажите <filename
>Тест</filename
> в качестве категории, а затем выберите нужные язык программирования и шаблон и нажмите кнопку <guilabel
>Далее</guilabel
>. </para>
<para
>Будет предложено указать имя теста и список тестовых случаев. Тестовые случаи указываются по именам. На некоторых платформах тестирования (например, PyUnit and PHPUnit) имена тестовых случаев должны начинаться со специального префикса. В &kdevelop; добавление этого префикса выполняется шаблоном, поэтому его не нужно указывать при перечислении имён. Нажмите кнопку <guilabel
>Далее</guilabel
> и укажите условия лицензирования и выходные расположения для создаваемых файлов. После этого тест будет создан. </para>
<para
>Созданные таким образом модульные тесты не будут автоматически добавлены к какой-либо цели. Если используется CTest или какая-либо другая платформа тестирования, обязательно добавьте новые файлы к цели. </para>
</sect1>
<sect1 id="other-files"
><title
>Другие файлы</title>
<para
>Несмотря на то, что при создании кода на основе шаблонов больше внимания уделяется созданию классов и модульных тестов, такую методику можно применять для создания файлов кода любого типа. Например, можно воспользоваться шаблоном для создания модуля поиска CMake или файла .desktop. Для этого просто выберите пункт <guilabel
>Создать из шаблона…</guilabel
>, а затем укажите нужные категорию и шаблон. Если шаблон не относится к категориям <filename
>Класс</filename
> или <filename
>Тест</filename
>, будет возможно выбрать только условия лицензирования, значения дополнительных параметров шаблона и расположения выходных файлов. Как и в случае классов и тестов, после завершения работы вспомогательной программы соответствующие файлы будут созданы и открыты в редакторе. </para>
</sect1>
<sect1 id="managing-templates"
><title
>Управление шаблонами</title>
<para
>С помощью вспомогательной программы (<menuchoice
><guimenu
>Файл</guimenu
><guimenuitem
>Создать из шаблона</guimenuitem
></menuchoice
>) также можно загрузить дополнительные шаблоны файлов: нажмите кнопку <guilabel
>Получить другие шаблоны…</guilabel
>. Появится окно получения новых данных, с помощью которого можно установить дополнительные шаблоны, а также обновить или удалить их. Также имеется модуль настройки шаблонов (<menuchoice
><guimenu
>Настройка</guimenu
><guisubmenu
>Настроить &kdevelop;…</guisubmenu
><guimenuitem
>Шаблоны</guimenuitem
></menuchoice
>). С помощью этого модуля можно управлять как шаблонами файлов (их описание приводится выше), так и шаблонами проектов (используются для создания новых проектов). </para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-template-manager.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
  </mediaobject>
</screenshot>
</para>
<para
>Конечно же, если ни один из доступных шаблонов не подходит для проекта, можно создать свой собственный. Проще всего сделать это путём копирования и изменения существующего шаблона, опираясь на краткое <ulink url="https://techbase.kde.org/Development/Tutorials/KDevelop/Creating_a_class_template"
>практическое руководство</ulink
> и более подробный <ulink url="https://techbase.kde.org/Projects/KDevelop4/File_template_specification"
>документ с техническими условиями</ulink
>. Чтобы скопировать установленный шаблон, откройте диспетчер шаблонов (<menuchoice
><guimenu
>Настройка</guimenu
><guisubmenu
>Настроить KDevelop...</guisubmenu
><guimenuitem
>Шаблоны</guimenuitem
></menuchoice
>), выберите нужный шаблон и нажмите кнопку <guilabel
>Скопировать шаблон</guilabel
>. Выберите папку для сохранения содержимого шаблона и нажмите кнопку <guilabel
>OK</guilabel
>. Затем можно отредактировать шаблон, открыв его файлы в этой папке и изменив их. После завершения редактирования можно импортировать новый шаблон в &kdevelop;: откройте диспетчер шаблонов, перейдите на соответствующую вкладку (либо <guilabel
>Шаблоны проектов</guilabel
>, либо <guilabel
>Шаблоны файлов</guilabel
>) и нажмите кнопку <guilabel
>Загрузить шаблон из файла</guilabel
>. Откройте файл описания шаблона, то есть файл с суффиксом <varname
>.kdevtemplate</varname
> или <varname
>.desktop</varname
>. &kdevelop; сожмёт файлы в архив шаблона и выполнит его импорт. </para>
<para
><note
><para
>Когда копируется существующий шаблон, необходимо переименовать копию перед импортом. Если этого не сделать, старый шаблон будет перезаписан или в списке окажутся два шаблона с одинаковыми именами. Чтобы переименовать шаблон, переименуйте файл описания так, чтобы его имя было уникальным (но при этом сохраните суффикс), и измените запись <filename
>Name</filename
> в файле описания. </para
></note>
</para>
<para
>Если требуется создать шаблон с нуля, можно начать с образца шаблона класса C++: <link linkend="creating-projects-from-scratch"
>создайте новый проект</link
> и выберите проект <filename
>Шаблон класса C++</filename
> в категории <filename
>KDevelop</filename
>. </para>
</sect1>
</chapter>
<chapter id="building-compiling-projects-with-custom-makefiles"
><title
>Сборка (компиляция) проектов с нестандартными Makefile</title>
<para
>Во многих проектах описание способа сборки файлов кода (и определения тех файлов, которые следует повторно собрать после внесения изменений в код) выполняется с помощью файлов Makefile, обработку которых осуществляет программа <guilabel
>make</guilabel
> (см., например, <ulink url ="https://www.gnu.org/software/make/"
>GNU make</ulink
>). В простых проектах несложно создать такой файл самостоятельно. В больших проектах создание таких файлов часто выполняется с помощью инструментов <guilabel
>GNU autotools</guilabel
> (autoconf, autoheader, automake). В этом разделе предполагается, что файл Makefile проекта уже создан и просто нужно указать &kdevelop;, каким образом следует взаимодействовать с этим файлом.</para>
<para
><note
><para
>На момент написания этого раздела руководства &kdevelop; 4.x не поддерживает работу с инструментами <guilabel
>GNU autotools</guilabel
>. Если они используются в проекте, потребуется запустить <varname
>./configure</varname
> или подобный сценарий вручную из командной строки. Если следует сделать это внутри &kdevelop;, откройте панель <guilabel
>Konsole</guilabel
> (при необходимости добавив её по периметру главного окна:  <menuchoice
><guimenu
>Окно</guimenu
><guimenuitem
>Добавить панель…</guimenuitem
></menuchoice
>) и в появившемся командном окне укажите команду <varname
>./configure</varname
>.</para
></note
></para>
<para
>Сначала необходимо указать &kdevelop; на цели сборки в файлах Makefile. Это можно сделать двумя способами: выбрать отдельные цели Makefile или выбрать набор целей, которые требуется собирать часто. Для применения обоих способов следует открыть панель <guilabel
>Проекты</guilabel
> (нажмите кнопку <guilabel
>Проекты</guilabel
>; если такой кнопки ещё нет по периметру окна, добавьте её согласно приведённым выше инструкциям). Панель <guilabel
>Проекты</guilabel
> состоит из двух частей. В верхней части (<guilabel
>Проекты</guilabel
>) приводится список всех проектов, пункты каталогов можно разворачивать. В нижней части (<guilabel
>Последовательность сборки</guilabel
>) находятся те проекты, которые будут собраны при выборе пункта меню <menuchoice
><guimenu
>Проект</guimenu
><guimenuitem
>Собрать выделенное</guimenuitem
></menuchoice
> или нажатии клавиши <keycap
>F8</keycap
>; эта часть будет более подробно рассмотрена далее.</para>
<sect1 id="building-individual-makefile-targets"
><title
>Сборка отдельных целей Makefile</title>
<para
>В верхней части панели проекта разверните список для одного из проектов (например, того, для которого следует выполнить сборку одной из целей Makefile). В списке будут видны значки каталогов этого проекта, файлов в каталоге верхнего уровня этого проекта, а также целей Makefile, которые удалось определить &kdevelop;. На изображении эти категории показаны справа. Обратите внимание, что &kdevelop; в некоторой мере <emphasis
>понимает</emphasis
> синтаксис Makefile и, следовательно, может предлагать заданные в этом файле Makefile цели (такое понимание имеет свои границы: не будут показаны сборные или неявные цели).</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-1a.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Чтобы собрать какую-либо из целей в списке, щёлкните по ней правой кнопкой мыши и выберите в контекстном меню пункт <guilabel
>Собрать</guilabel
>. Выполнение этих действий, например, для цели <quote
>clean</quote
> приведёт к выполнению команды <quote
>make clean</quote
>. Сообщения о выполнении действий будут показаны в дочернем окне <guilabel
>Сборка</guilabel
>. (Это окно соответствует инструменту <guilabel
>Собрать</guilabel
>, поэтому его можно закрыть и затем снова открыть с помощью кнопки <guilabel
>Собрать</guilabel
> на панели инструментов главного окна. Оно показано в нижней правой части изображения.)</para>
</sect1>
<sect1 id="selecting-a-collection-of-makefile-targets-for-repeated-building"
><title
>Выбор набора целей Makefile для регулярной сборки</title>
<para
>Щёлкать правой кнопкой мыши по отдельным целям Makefile быстро становится утомительным. Намного проще было бы создать для одного или нескольких проектов отдельные цели, которые постоянно собираются в ходе разработки. Для этого в среде реализована «сборка обозначенных целей»: это набор целей Makefile, которые собираются одна за другой при нажатии кнопки <guilabel
>Собрать выделенное</guilabel
> в расположенном в верхней части окна ряду кнопок, выборе пункта меню <menuchoice
><guimenu
>Проект</guimenu
><guimenuitem
>Собрать выделенное</guimenuitem
></menuchoice
> или использовании функциональной клавиши <keycap
>F8</keycap
>.</para>
<para
>Список выбранных целей Makefile отображается в нижней части панели <guilabel
>Проекты</guilabel
>.</para>
<para
>По умолчанию выбираются все проекты, но это поведение можно изменить. Например, если в списке проектов их три (базовая библиотека L и два приложения, A и B), но в данное время ведётся работа только над проектом A, то можно удалить проект B из списка: выделите соответствующий пункт списка и нажмите кнопку <inlinemediaobject
> <imageobject
> <imagedata fileref="Icon-list-remove.png" format="PNG"/> </imageobject
> </inlinemediaobject
>. Скорее всего, будет нужно, чтобы библиотека L собиралась перед проектом A. Изменить порядок пунктов списка можно с помощью кнопок, расположенных справа от списка. Также можно добавить в список определённую цель Makefile, щёлкнув по ней правой кнопкой мыши и выбрав в контекстном меню пункт <guilabel
>Добавить в комплект сборки</guilabel
> (или просто выделив её и нажав кнопку <inlinemediaobject
> <imageobject
> <imagedata fileref="Icon-list-add.png" format="PNG"/> </imageobject
> </inlinemediaobject
>, расположенную прямо над списком выбранных целей).</para>
<para
>&kdevelop; позволяет указать, что следует делать при сборке выделенных целей. Выберите пункт меню <menuchoice
><guimenu
>Проект</guimenu
><guimenuitem
>Настроить проект...</guimenuitem
></menuchoice
>. Появившееся диалоговое окно позволяет, например, выбрать количество заданий, которые <quote
>make</quote
> может выполнять одновременно (если у процессора компьютера, например, 8 ядер, то в соответствующем поле уместно будет указать значение «8»). В диалоговом окне <guilabel
>Цель сборки по умолчанию</guilabel
> — это цель Makefile, используемая для <emphasis
>всех</emphasis
> целей в наборе.</para>
</sect1>
<sect1 id="what-to-do-with-error-messages"
><title
>Работа с сообщениями об ошибках</title>
<para
>Если во время компиляции будет обнаружена ошибка, просто щёлкните по строке с ошибкой. Курсор будет переведен в строку (и, если указано, позицию в строке), где была обнаружена ошибка. В зависимости от типа ошибки &kdevelop; может также предложить несколько вариантов действий для её исправления (например, если была обнаружена неизвестная переменная, будет предложено объявить её).</para>
</sect1>
</chapter>
<chapter id="running-programs-in-kdevelop"
><title
>Запуск программ в &kdevelop;</title>
<para
>После сборки программу потребуется запустить. Чтобы сделать это, необходимо настроить <emphasis
>конфигурации запуска</emphasis
> для проектов. <emphasis
>Конфигурация запуска</emphasis
> состоит из имени исполняемого файла, набора параметров командной строки и среды выполнения (например, <quote
>запустить эту программу в командной оболочке</quote
> или <quote
>запустить эту программу в отладчике</quote
>).</para>
<sect1 id="setting-up-launches-in-kdevelop"
><title
>Настройка конфигураций запуска в &kdevelop;</title>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-2.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Чтобы выполнить такую настройку, выберите пункт меню <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Настроить конфигурации запуска…</guimenuitem
></menuchoice
>, выберите тот проект, для которого следует добавить конфигурацию запуска, и нажмите кнопку <inlinemediaobject
> <imageobject
> <imagedata fileref="Icon-list-add.png" format="PNG"/> </imageobject
> </inlinemediaobject
>. Затем укажите имя исполняемого файла и путь к каталогу, из которого следует запустить программу. Если запуск исполняемого файла зависит от результатов сборки этого файла и/или других библиотек, можно добавить их в список, расположенный в нижней части окна: выберите в раскрывающемся меню пункт <guilabel
>Собрать</guilabel
>, нажмите кнопку <inlinemediaobject
> <imageobject
> <imagedata fileref="Icon-folder.png" format="PNG"/> </imageobject
> </inlinemediaobject
>, расположенную справа от поля для ввода текста, и выберите цель сборки. В примере выше выбрана цель <guilabel
>все</guilabel
> из проекта <replaceable
>1.deal.II</replaceable
> и <replaceable
>step-32</replaceable
> из проекта <replaceable
>1.step-32</replaceable
>, чтобы обеспечить сборку базовой библиотеки и программы на её основе перед фактическим выполнением программы. В этом разделе настройки также можно настроить запуск отладки: щёлкните по значку <guilabel
>Отладка</guilabel
> и укажите исполняемый файл программы отладки; если это системный отладчик по умолчанию (например, <application
>gdb</application
> в &Linux;), этот шаг не нужен.</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-3.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Теперь можно попробовать запустить программу: выберите в главном меню &kdevelop; пункт <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Выполнить запуск</guimenuitem
></menuchoice
> (или воспользуйтесь комбинацией клавиш <keycombo
>&Shift;<keycap
>F9</keycap
></keycombo
>), и программа будет запущена в отдельном дочернем окне &kdevelop;. На приведённом выше изображении показан результат: новое дочернее окно инструмента <guilabel
>Выполнение</guilabel
>, в нижней части которого отображается вывод запущенной программы (в рассматриваемом примере — программы <replaceable
>step-32</replaceable
>).</para>
<para
><note
><para
>Если настроено несколько конфигураций запуска, с помощью пункта меню <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Текущая конфигурация запуска</guimenuitem
></menuchoice
> можно выбрать ту, которая будет выполняться при использовании комбинации клавиш <keycombo
>&Shift;<keycap
>F9</keycap
></keycombo
>. Существует неочевидный способ изменить название конфигурации: в диалоговом окне, которое появляется при выборе пункта меню <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Текущая конфигурация запуска</guimenuitem
></menuchoice
>, нужно сделать двойной щелчок по названию конфигурации в расположенном слева иерархическом списке. После этого название можно будет изменить.</para
></note
></para>
</sect1>
<sect1 id="some-useful-keyboard-shortcuts0"
><title
>Некоторые полезные комбинации клавиш</title>
<para>
<informaltable>
  <tgroup cols="2">
    <colspec colname="c1"/>
    <colspec colname="c2"/>
  <thead>
  <row>
    <entry namest="c1" nameend="c2"
>Запуск программы</entry>
  </row>
  </thead>
  <tbody>
  <row>
    <entry
><keycap
>F8</keycap
></entry>
    <entry
>Собрать (вызвать make)</entry>
  </row>
  <row>
    <entry
><keycombo
>&Shift;<keycap
>F9</keycap
></keycombo
></entry>
    <entry
>Запустить</entry>
  </row>
  <row>
    <entry
><keycombo
>&Alt;<keycap
>F9</keycap
></keycombo
></entry>
    <entry
>Запустить программу в отладчике. Перед таким запуском следует установить точки останова (достаточно щёлкнуть правой кнопкой мыши по соответствующей строке кода и выбрать нужный пункт контекстного меню).</entry>
  </row>
  </tbody>
  </tgroup>
</informaltable>
</para>
</sect1>
</chapter>
<chapter id="debugging-programs-in-kdevelop"
><title
>Отладка программ в &kdevelop;</title>
<sect1 id="running-a-program-in-the-debugger"
><title
>Запуск программы в отладчике</title>
<para
>После настройки запуска программы (смотрите раздел <link linkend="running-programs-in-kdevelop"
>Запуск программ</link
>) также можно запустить её в отладчике: выберите пункт меню <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Начать отладку</guimenuitem
></menuchoice
> или воспользуйтесь комбинацией клавиш <keycombo
>&Alt;<keycap
>F9</keycap
></keycombo
>. Результат будет аналогичен запуску <application
>gdb</application
> с указанием исполняемого файла, заданного в конфигурации запуска, и последующей команды <varname
>Run</varname
>. Это означает, что если программа где-либо вызовет <varname
>abort()</varname
> (например, в случае сбоя проверочного утверждения) или если произойдёт ошибка сегментации, то отладчик остановится. С другой стороны, если программа отработает до конца (как правильно, так и неправильно), то сам отладчик не остановится, пока программа не завершит работу. В таком случае потребуется до запуска отладки установить точки останова на всех строках кода, где должен останавливаться отладчик. Чтобы это сделать, установите курсор на такую строку и выберите пункт меню <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Поставить или убрать точку останова</guimenuitem
></menuchoice
> или щёлкните по строке правой кнопкой мыши и выберите в контекстном меню пункт <guilabel
>Поставить или убрать точку останова</guilabel
>.</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-4.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Запуск программы в отладчике переведёт &kdevelop; в другой режим: все кнопки инструментов, расположенные по периметру главного окна, будут заменены на кнопки отладки, а не редактирования. Понять, в каком режиме ведётся работа, можно по верхней правой части окна: там расположены вкладки <guilabel
>Рецензирование</guilabel
>, <guilabel
>Отладка</guilabel
> и <guilabel
>Код</guilabel
>. С помощью щелчков по этим вкладкам выполняется переключение между тремя режимами; для каждого режима предусмотрен свой набор панелей (их перечень настраивается так же, как настраивались инструменты режима <guilabel
>Код</guilabel
> в разделе <link linkend="tools-and-views"
>Инструменты и представления</link
>).</para>
<para
>Когда отладчик остановится (в точке останова или точке, где вызывается <varname
>abort()</varname
>), будет можно ознакомиться с различными сведениями об отлаживаемой программе. Например, на изображении выше в нижней части окна открыта панель <guilabel
>Стек</guilabel
> (приблизительный эквивалент команд <quote
>backtrace</quote
> и <quote
>info threads</quote
> <application
>gdb</application
>), на которой слева показаны различные потоки, которые в настоящее время запущены в программе (в примере их всего 8), а справа — как выполнение дошло до текущей точки остановки (в примере: <varname
>main()</varname
> вызвала <varname
>run()</varname
>; список был бы длиннее, если бы остановка произошла в функции, вызванной самой <varname
>run()</varname
>). Слева показаны локальные переменные, в том числе текущий объект (объект, на который указывает переменная <varname
>this</varname
>).</para>
<para
>После остановки доступны несколько вариантов действий: можно выполнить текущую строку (<keycap
>F10</keycap
>, команда <quote
>next</quote
> <application
>gdb</application
>), перейти в функции (<keycap
>F11</keycap
>, команда <quote
>step</quote
> <application
>gdb</application
>) или выполнить инструкции до конца функции (<keycap
>F12</keycap
>, команда <quote
>finish</quote
> <application
>gdb</application
>). На каждом из этапов выполнения &kdevelop; обновляет значения показанных слева переменных. Также можно навести указатель мыши на элемент в коде (например, на переменную); &kdevelop; отобразит текущее значение и предложит остановить выполнение программы при следующем изменении значения этой переменной. Если пользователь умеет работать с <application
>gdb</application
>, также можно нажать кнопку инструмента <guilabel
>GDB</guilabel
>, расположенную в нижней части окна, и ввести нужные команды <application
>gdb</application
>, например, чтобы изменить значение переменной (в текущей версии среды не предусмотрено другого способа сделать это).</para>
</sect1>
<sect1 id="attaching-the-debugger-to-a-running-process"
><title
>Подключение отладчика к выполняющемуся процессу</title>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-9.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Иногда требуется выполнить отладку уже запущенной программы. Одним из таких случаев является отладка параллельно запущенных с помощью <ulink url="https://computing.llnl.gov/tutorials/mpi/"
>MPI</ulink
> программ или отладка длительно выполняемого фонового процесса. Выполнить такую отладку можно с помощью пункта меню<menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Подключиться к процессу</guimenuitem
></menuchoice
>; будет открыто окно, похожее на приведённое выше. Потребуется выбрать приложение, которое соответствует текущему открытому проекту в &kdevelop;. В рассматриваемом случае такой программой будет step-32.</para>
<para
>Список программ часто оказывается очень длинным. Работу с ним можно упростить с помощью раскрывающегося меню в верхней правой части окна. Значение по умолчанию — <guilabel
>Пользовательские процессы</guilabel
>, то есть все программы, запущенные всеми пользователями, которые сейчас работают в системе (если используется личный настольный компьютер или ноутбук, скорее всего, пользователь будет только один, не считая пользователя root и различные учётные записи служб); но в список не входят процессы, запущенные пользователем root. Список можно ограничить, выбрав вариант <guilabel
>Ваши процессы</guilabel
> (в этом случае из списка будут удалены все программы, запущенные другими пользователями). Или ещё лучше: выберите вариант <guilabel
>Только программы</guilabel
> для удаления из списка многочисленных процессов, формально выполняемых от имени пользователя, но не запущенных пользователем собственноручно (например, диспетчер окон, фоновые задачи и так далее), для которых вряд ли требуется отладка.</para>
<para
>Подключение к выбранному процессу переводит &kdevelop; в режим отладки; будут открыты все обычные панели отладчика, а программа остановится на строке, которая выполнялась в момент подключения. После этого можно указать точки останова, точки просмотра или другие необходимые параметры и продолжить выполнение программы с помощью пункта меню <menuchoice
><guimenu
>Выполнение</guimenu
><guimenuitem
>Продолжить</guimenuitem
></menuchoice
>.</para>
</sect1>
<sect1 id="some-useful-keyboard-shortcuts1"
><title
>Некоторые полезные комбинации клавиш</title>
<para>
<informaltable>
  <tgroup cols="2">
    <colspec colname="c1"/>
    <colspec colname="c2"/>
  <thead>
  <row>
    <entry namest="c1" nameend="c2"
>Отладка</entry>
  </row>
  </thead>
  <tbody>
  <row>
    <entry
><keycap
>F10</keycap
></entry>
    <entry
>Шаг с обходом (<quote
>next</quote
> в gdb)</entry>
  </row>
  <row>
    <entry
><keycap
>F11</keycap
></entry>
    <entry
>Шаг с заходом (<quote
>step</quote
> в gdb)</entry>
  </row>
  <row>
    <entry
><keycap
>F12</keycap
></entry>
    <entry
>Шаг с выходом (<quote
>finish</quote
> в gdb)</entry>
  </row>
  </tbody>
  </tgroup>
</informaltable>
</para>
</sect1>
</chapter>
<chapter id="working-with-version-control-systems"
><title
>Работа с системами управления версиями</title>
<para
>При работе над крупными проектами для кода обычно используется система управления версиями (например, <ulink url="https://subversion.apache.org/"
>subversion</ulink
> или <ulink url="https://git-scm.com/"
>git</ulink
>). Дальнейшее описание основывается на <guilabel
>subversion</guilabel
>, но оно справедливо и для <guilabel
>git</guilabel
> или любой другой поддерживаемой системы управления версиями.</para>
<para
>Во-первых, если каталог, в котором расположен проект, находится под управлением такой системы, программа &kdevelop; автоматически определит это. Другими словами: при настройке проекта не требуется указывать &kdevelop;, что необходимо получить код из репозитория; достаточно указать программе тот каталог, в котором хранится ранее полученная копия кода. Если такой каталог имеется, откройте панель <guilabel
>Проекты</guilabel
>:</para>
<itemizedlist>
<listitem
><para
>Если данные в каталоге устарели, их можно обновить из репозитория: щёлкните по названию проекта правой кнопкой мыши, перейдите в меню <guilabel
>Subversion</guilabel
> и выберите пункт <guilabel
>Обновить</guilabel
>. Все относящиеся к этому проекту файлы будут обновлены. </para
></listitem>
<listitem
><para
>Если при обновлении нужно ограничиться отдельными подкаталогами или файлами, разверните дерево проекта до нужного уровня и щёлкните по подкаталогу или файлу правой кнопкой мыши, а затем повторите приведённые выше действия. </para
></listitem>
</itemizedlist>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-8.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<itemizedlist>
<listitem
><para
>Если в один или несколько файлов были внесены изменения, разверните дерево проекта до каталога с этими файлами и щёлкните по нему правой кнопкой мыши. В появившемся контекстном меню будет доступен пункт <guilabel
>Subversion</guilabel
>, который содержит различные варианты действий. Выберите среди них <guilabel
>Сравнить с base</guilabel
> для просмотра различий между изменённой версией файла и той его версией, которая ранее была получена из репозитория (версия <quote
>base</quote
>). В результате будут показаны различия (<quote
>diff</quote
>) для всех файлов в этом каталоге. </para
></listitem>
<listitem
><para
>Если был изменён только один файл, для него также можно вызвать меню <guilabel
>Subversion</guilabel
>: просто щёлкните правой кнопкой мыши по соответствующему файлу в представлении проекта. Ещё проще: щёлкните правой кнопкой мыши в представлении <guilabel
>Редактор</guilabel
>, где открыт этот файл. </para
></listitem>
<listitem
><para
>Если требуется отправить в репозиторий один или несколько изменённых файлов, щёлкните правой кнопкой мыши по отдельному файлу, по подкаталогу или по всему проекту и выберите в контекстном меню пункт <menuchoice
><guimenu
>Subversion</guimenu
><guimenuitem
>Зафиксировать</guimenuitem
></menuchoice
>. После выбора этого пункта среда будет переведена в режим <guilabel
>Рецензирование</guilabel
>, третий режим, пункт которого находится рядом с пунктами режимов <guilabel
>Код</guilabel
> и <guilabel
>Отладка</guilabel
> в правом верхнем углу главного окна &kdevelop;. На изображении справа показано окно в этом режиме. В режиме<guilabel
>Рецензирование</guilabel
> в верхней части окна показаны различия в файлах всего подкаталога или проекта, все изменённые файлы с различиями обозначаются цветом (см. различные вкладки в этой части окна). По умолчанию все изменённые файлы будут добавлены в набор изменений, который будет передан в репозиторий, но можно отменить выбор некоторых файлов, если внесённые в них изменения не относятся к тем изменениям, которые следует отправить. В рассматриваемом примере не будут отправлены <varname
>step-32.cc</varname
> и <varname
>step-32.prm</varname
>; поскольку изменения в этих файлах не связаны с другими изменениями в проекте, в этот раз они не будут отправлены в хранилище (их можно будет отправить позже отдельной фиксацией). После просмотра изменений можно ввести сообщение фиксации в поле ввода текста и нажать кнопку <guilabel
>Фиксировать</guilabel
>, расположенную справа, чтобы отправить изменения в репозиторий. </para
></listitem>
<listitem
><para
>Как и в случае просмотра различий, если нужно отправить один файл, можно просто щёлкнуть правой кнопкой мыши в представлении редактора и выбрать в контекстном меню пункт <menuchoice
><guimenu
>Subversion</guimenu
><guimenuitem
>Зафиксировать</guimenuitem
></menuchoice
>. </para
></listitem>
</itemizedlist>
</chapter>
<chapter id="customizing-kdevelop"
><title
>Настройка &kdevelop;</title>
<para
>Иногда требуется изменить стандартный внешний вид или поведение &kdevelop; (например, если пользователь привык к другим комбинациям клавиш или если для проекта требуется другой стиль расстановки отступов в исходном коде). В следующих разделах приводится краткое описание способов настройки &kdevelop;.</para>
<sect1 id="customizing-the-editor"
><title
>Настройка редактора</title>
<para
>Можно настроить несколько полезных параметров во встроенном редакторе и других компонентах &kdevelop;. Одна из общих вещей — включение нумерации строк с помощью пункта меню <menuchoice
><guimenu
>Редактор</guimenu
><guisubmenu
>Внешний вид</guisubmenu
><guimenuitem
>Показывать номера строк</guimenuitem
></menuchoice
>; это облегчает сопоставление сообщений об ошибках компиляции или сообщений отладки с местами в коде. В том же подменю можно включить параметр <emphasis
>Показывать метки</emphasis
> — это столбец слева от кода, в котором &kdevelop; отображает метки (например, метку точку останова на текущей строке).</para>
</sect1>
<sect1 id="customizing-code-indentation"
><title
>Настройка расстановки отступов в коде</title>
<para
>У многих программистов есть предпочитаемый стиль форматирования кода. Кроме того, во многих проектах есть собственные правила расстановки отступов. Вероятно, параметры &kdevelop; не будут соответствовать такому стилю и правилам. Но можно выполнить настройку: выберите пункт меню <menuchoice
><guimenu
>Настройка</guimenu
><guimenuitem
>Настроить &kdevelop;…</guimenuitem
></menuchoice
> и выберите в левой части окна раздел <guilabel
>Преобразователь форматирования</guilabel
>. Можно выбрать один из предустановленных общепринятых стилей расстановки отступов или задать свой собственный (для этого следует добавить новый стиль и отредактировать его). Вероятно, не удастся в точности воссоздать тот стиль, который раньше использовался для отступов в исходных файлах проекта, но получится приблизиться к нему, указав соответствующие параметры для нового стиля; на двух приведённых далее изображениях показан такой пример.</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-5.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-6.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
><note
><para
>В <guilabel
>&kdevelop; 4.2.2</guilabel
> возможно создать новый стиль для определённого типа MIME (например, для заголовочных файлов C++), но этот стиль не будет представлен в списке доступных вариантов для других типов MIME (например, для файлов исходного кода C++), хотя было бы удобно использовать один и тот же стиль для обоих типов файлов. Следовательно, потребуется задать стиль дважды: один раз для заголовочных файлов и один раз для файлов исходного кода. Разработчикам известно об этой проблеме: <ulink url="https://bugs.kde.org/show_bug.cgi?id=272335"
>&kdevelop;, ошибка 272335</ulink
>.</para
></note
></para>
</sect1>
<sect1 id="customizing-keyboard-shortcuts"
><title
>Настройка комбинаций клавиш</title>
<para
>В &kdevelop; почти безграничный список комбинаций клавиш (некоторые из них перечислены в <quote
>разделах «Некоторые полезные комбинации клавиш»</quote
> нескольких глав этого руководства). Эти комбинации можно изменить в соответствии с потребностями пользователя с помощью пункта меню <menuchoice
><guimenu
>Настройка</guimenu
><guimenuitem
>Комбинации клавиш…</guimenuitem
></menuchoice
>. В верхней части диалогового окна можно указать слово для поиска, чтобы отображались только соответствующие ему команды; затем можно будет изменить связанные с ними комбинации клавиш.</para>
<para
>Одним из двух полезных изменений будет установка для команды <guilabel
>Выровнять</guilabel
> клавиши &Tab; (многие люди обычно не вводят символы табуляции вручную, предпочитая форматирование кода редактором; если внести такое изменение, после нажатия клавиши &Tab; &kdevelop; будет добавлять отступы, убирать отступы или выравнивать код. Второе изменение — назначить команде <guilabel
>Поставить или убрать точку останова</guilabel
> комбинацию клавиш <keycombo
>&Ctrl;<keycap
>B</keycap
></keycombo
>, поскольку эту операцию требуется выполнять довольно часто.</para>
</sect1>
<sect1 id="customizing-code-auto-completion"
><title
>Настройка автодополнения кода</title>
<para
>О возможностях дополнения кода рассказывается в <link linkend="auto-completion"
>этом разделе руководства, посвящённом написанию исходного кода</link
>. В &kdevelop; автоматическое дополнение выполняется из двух источников: текстового редактора и движка синтаксического анализа. Текстовый редактор (&kate;) является компонентом окружения KDE и предоставляет возможности автодополнения на основе других частей того же самого документа. Такое автоматическое дополнение можно узнать по значку на панели подсказки, расположенному перед соответствующим вариантом:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-20.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Автодополнение кода текстовым редактором можно настроить с помощью пункта меню <menuchoice
><guimenu
>Настройка</guimenu
><guisubmenu
>Настроить редактор</guisubmenu
><guimenuitem
>Редактирование</guimenuitem
><guimenuitem
>Автодополнение</guimenuitem
></menuchoice
>. В частности, можно указать, сколько символов потребуется ввести перед срабатыванием автоматического дополнения.</para>
<para
>С другой стороны, собственное автодополнение &kdevelop; предоставляет гораздо более широкие возможности благодаря учёту семантической информации о контексте. Например, при вводе кода <varname
>object.</varname
> программа предлагает только те функции-члены, которые используются в соответствующем объекте, и так далее. Пример:</para>
<para>
<screenshot>
<screeninfo
></screeninfo>
  <mediaobject>
    <imageobject>
      <imagedata fileref="kdevelop-42.png" format="PNG"/>
    </imageobject>
    <textobject>
      <phrase
></phrase>
    </textobject>
    <caption>
      <para
></para>
    </caption>
  </mediaobject>
</screenshot
></para>
<para
>Информация о контексте поступает от различных модулей поддержки языков программирования, которыми можно воспользоваться после сохранения файла (среда определит язык программирования по типу сохранённого файла).</para>
<para
>Автодополнение &kdevelop; работает по мере набора кода пользователем (почти во всех местах, где может потребоваться дополнить код). Настройку автодополнения можно выполнить с помощью пункта меню <menuchoice
><guimenu
>Настройка</guimenu
><guisubmenu
>Настроить &kdevelop;…</guisubmenu
><guimenuitem
>Поддержка языков</guimenuitem
></menuchoice
>. Параметр <guilabel
>Вызывать автоматически</guilabel
> должен быть включён по умолчанию. Если это не так, обязательно установите соответствующий флажок.</para>
<para
>В &kdevelop; предусмотрено два способа показа вариантов дополнения: <guilabel
>Минимальное автоматическое дополнение</guilabel
> отображает базовую информацию во всплывающих подсказках (то есть пространство имён, класс, функцию или переменную). Такое дополнение похоже на дополнение в &kate; (за исключением значков).</para>
<para
>С другой стороны, при использовании <guilabel
>Полного дополнения</guilabel
> также можно будет увидеть тип каждой записи, а в случае функций — ещё и принимаемые ими аргументы. Кроме того, при вводе аргументов функции в режиме полного дополнения над курсором будет показана дополнительная информационная панель с текущим аргументом.</para>
<para
>При использовании как минимального, так и полного режимов &kdevelop; также выводит наверх и выделяет зелёным цветом все пункты дополнения, которые соответствуют текущему ожидаемому типу (наилучшие соответствия).</para>
<para
>В диалоге настройки доступны три варианта уровня дополнения:</para>
<itemizedlist>
<listitem
><para
><guilabel
>Всегда минимальное дополнение</guilabel
>: никогда не показывать <quote
>Полное дополнение</quote
> </para
></listitem>
<listitem
><para
><guilabel
>Минимальное автоматическое дополнение</guilabel
>: показывать <quote
>Полное дополнение</quote
> только при активации автодополнения вручную (то есть при использовании комбинации клавиш <keycombo
>&Ctrl;<keycap
>Пробел</keycap
></keycombo
>) </para
></listitem>
<listitem
><para
><guilabel
>Всегда полное дополнение</guilabel
>: всегда показывать <quote
>Полное дополнение</quote
> </para
></listitem>
</itemizedlist>
</sect1>
</chapter>
<!--userbase-content-->
<chapter id="credits">
<title
>Авторские права и лицензия</title>
    <para
>Авторские права на документацию указаны в <ulink url="https://userbase.kde.org/index.php?title=KDevelop4/Manual&amp;action=history"
>журнале страницы KDevelop4/Manual</ulink
> пользовательской базы знаний KDE.</para>
    <para
>Олеся Герасименко<email
>translation-team@basealt.ru</email
></para
> &underFDL; </chapter>
&documentation.index;
</book>
