<?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 % Ukrainian "INCLUDE">
]>
<book id="kdevelop" lang="&language;">
<bookinfo>
<title
>Підручник з &kdevelop;</title>
<authorgroup>
<author>
<personname
><firstname
>Цю документацію було створено на основі сторінки UserBase KDE <ulink url="https://userbase.kde.org/KDevelop4/Manual"
>KDevelop4/Manual</ulink
>.</firstname
> <surname
></surname
> </personname>
</author>
<othercredit role="translator"
><firstname
>Юрій</firstname
><surname
>Чорноіван</surname
><affiliation
><address
><email
>yurchor@ukr.net</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
> — сучасне комплексне середовище для розробки (IDE) мовою C++ та іншими мовами. Це середовище є частиною проєкту з розробки <ulink url="https://kde.org"
>стільничного середовища 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
>, назва якої починається з «ge». Замість введення повної назви функції вам достатньо натиснути &Enter;, щоб отримати ціле слово. Таким чином, ви можете зекономити час і уникнути неприємних друкарських помилок, крім того, вам не потрібно буде запам’ятовувати точні назви тисяч функцій і класів, з яких складаються великі проєкти.</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; не лише редактор коду з елементами штучного інтелекту, &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 вам не потрібен доступ до функцій ядра або драйверів пристроїв, вам не потрібне автоматичне доповнення назв класів KDE під час роботи над ядром &Linux;. Нарешті, збирання бібліотек 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; вже створений каталог з кодом, ви також можете наказати &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
>Виберіть адресу розташування сховища з кодом проєкту. </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
>Під час оброби ви можете побачити повідомлення щодо помилки: «Вам слід вказати коректне розташування проєкту». Можете не зважати на це повідомлення.</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< dim>::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
>Дані, які показано для всього файла, є тими самими, які буде показано у режимі «Огляд», обговорення якого у контексті навігації кодом викладено далі. Відмінність полягає у тому, що у режимі огляду ці дані буде показано лише на тимчасовій панелі підказки.</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
>У &kdevelop; для підсвічування об’єктів у коді використовується ціла палітра кольорів. Якщо вам відоме значення цих кольорів, ви можете дуже швидко отримати доволі багато інформації щодо коду, просто подивившись на кольори, навіть не розбираючи кожен із символів коду окремо. Використано такі правила підсвічування: </para>
<itemizedlist>
<listitem
><para
>Об’єкти типів Class / Struct, Enum (значенні і тип), (загальні) функції та учасники класів буде позначено власним кольором (класи — зеленим, переліки (enum) — темно-червоним, а учасники — темно-жовтим або фіолетовим, (загальні) функції — завжди фіолетовим).</para
></listitem>
<listitem
><para
>Всі загальні змінні буде позначено темно-зеленим кольором.</para
></listitem>
<listitem
><para
>Ідентифікатори, які є визначеннями інших типів, буде позначено синьо-зеленим кольором.</para
></listitem>
<listitem
><para
>Всі оголошення та визначення об’єктів буде позначено напівжирним шрифтом.</para
></listitem>
<listitem
><para
>Якщо доступ до учасника класу здійснюється з контексту його визначення (базового або похідного класу), запису буде позначено жовтим кольором. Якщо ж доступ здійснюється поза цим контекстом, запису буде позначено фіолетовим кольором.</para
></listitem>
<listitem
><para
>Якщо учасник позначено як закритий (private) або захищений (protected), колір запису буде трохи темнішим, ніж зазвичай.</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
>Як ми вже бачили з розділу щодо <ulink url="http://userbase.kde.org/Special:myLanguage/KDevelop4/Manual/Working with source code#Exploring source code"
>навігації кодом</ulink
>, ви можете отримати панель з поясненнями щодо окремого простору назв, класу, функції або змінної наведенням вказівника миші на відповідний запис у коді або утримуванням натиснутою клавіші &Alt;. Ось приклад: <screenshot
> <screeninfo
></screeninfo
> <mediaobject
> <imageobject
> <imagedata fileref="kdevelop-14.png" format="PNG"/> </imageobject
> <textobject
> <phrase
></phrase
> </textobject
> <caption
> <para
></para
> </caption
> </mediaobject
> </screenshot
> Натискання посилань на оголошення символу або розгортання списку використань надає вам змогу перейти до відповідних місць коду. Подібного ефекту можна досягти за допомогою панелі перегляду <guilabel
>Перегляд коду</guilabel
>, яку ми вже обговорювали. </para
></listitem>
<listitem
><para
>Швидшим способом переходу до оголошення символу без натискання посилань у підказці є тимчасове вмикання <guilabel
>Режиму навігації кодом</guilabel
> утримуванням натиснутою клавіші &Alt; або &Ctrl;. У цьому режимі можна безпосередньо натиснути будь-який символ у редакторі для переходу до його оголошення. </para
></listitem>
<listitem
><para
><guilabel
>Швидке відкриття</guilabel
>: дуже потужним способом пересування файлами у &kdevelop; є різноманітні інструменти <emphasis
>швидкого відкриття</emphasis
>. Передбачено чотири різновиди таких інструментів: <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
>У останньому рядку &kdevelop; запам’ятає, що змінна <varname
>my_ride</varname
> належить до типу <varname
>Car</varname
> і буде автоматично пропонувати доповнення назви вбудованої функції <varname
>ge</varname
> у форматі <varname
>get_color</varname
>. Фактично, вам достатньо вводити назву, аж доки список знайдених відповідників не починатиметься з потрібного вам виразу, а потім натиснути клавішу &Enter;:</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
>Зауважте, що ви можете клацнути на панелі підказки, щоб отримати більше даних щодо функції, окрім типу даних, які вона повертає, і те, чи є ця функція відкритою (public):</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++ можна створити за допомогою основного шаблону 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
>.) Давайте виберемо «3 - private unsigned int» (за допомогою миші або натискання комбінації клавіш <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
>Доки редагування відбуватиметься у коментарі текст коментаря буде позначено зеленим кольором (колір буде знято, щойно ви виведете курсор за межі коментаря). Коли ви наприкінці рядка натиснете клавішу &Enter;, &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)
... якісь дії над cell ...
</programlisting>
</para>
<para
>Замість введення таких фрагментів тексту раз за разом, що може призвести до супутніх друкарських помилок ви можете скористатися інструментом <guilabel
>Фрагменти</guilabel
> &kdevelop;. Для цього відкрийте панель інструментів (див. розділ <ulink url="http://userbase.kde.org/Special:myLanguage/KDevelop4/Manual/Working with source code#Tools and views"
>Інструменти і панелі перегляду</ulink
>, якщо відповідної кнопки ще немає на панелях навколо панелі редагування). Натисніть кнопку <guilabel
>Додати сховище</guilabel
> (трохи невдала назва: за допомогою цієї кнопки ви можете створити іменовану збірку фрагментів коду певного типу, наприклад, фрагментів коду 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
>Щоб скористатися таким чином визначеним фрагментом, вам слід просто почати вводити у коді його назву, як ви це робите для будь-яких інших функцій або змінних. Для введених літер буде відкрито панель автоматичного доповнення (це означає, що можна використовувати будь-які достатньо довгі для розрізнення назви фрагментів, зокрема назви, подібні до використаної нами), якщо ви виберете відповідний пункт фрагмента на панелі підказки автоматичного доповнення (наприклад, натисканням клавіші &Enter;), вже введену частину назви фрагмента буде замінено повним текстом фрагмента з відповідними відступами:</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
>, але використання теки проєкту має перевагу встановлення базової адреси для вихідних файлів. Виберіть <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</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. Крім того, аргументи функцій встановлення передано з посиланнями на сталі там, де це потрібно. Крім того, оголошено закритий клас (private) та створено закритий вказівник з 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 і PHPUnit, слід назви варіантів перевірки мають починатися з особливого префікса. У &kdevelop; за додавання префіксів відповідає шаблон, отже вам не потрібно вказувати префікс для варіантів. Після натискання кнопки <guilabel
>Далі</guilabel
> вкажіть умови ліцензування і розташування файлів виведених даних. &kdevelop; виконає решту роботи у автоматичному режимі. </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="http://techbase.kde.org/Projects/KDevelop4/File_template_specification"
>довідковий документ</ulink
>. Щоб скопіювати встановлений шаблон, відкрийте вікно керування шаблонами за допомогою пункту меню <menuchoice
><guimenu
>Параметри</guimenu
><guisubmenu
>Налаштувати &kdevelop;...</guisubmenu
><guimenuitem
>Шаблони</guimenuitem
></menuchoice
>, виберіть шаблон, який слід скопіювати, потім натисніть кнопку <guilabel
>Видобути шаблон</guilabel
>. Виберіть теку призначення, потім натисніть кнопку <guilabel
>Гаразд</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
>, розташованої у лівій частині головного вікна &kdevelop; (якщо цього заголовка немає у вікні вашої програми, вище наведено настанови щодо додавання кнопки відповідного інструмента). Панель <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
>. Наприклад, виконання цих дій для цілі «clean» призведе до виконання команди «make clean». Повідомлення щодо виконання дій можна буде побачити у підвікні <guilabel
>Збирання</guilabel
>. Це вікно відповідає інструменту <guilabel
>Зібрати</guilabel
>, отже його можна закрити і пізніше відкрити за допомогою пункту <guilabel
>Зібрати</guilabel
>, розташованої на панелі інструментів головного вікна. На нашому знімку цю кнопку розташовано праворуч внизу.</para>
</sect1>
<sect1 id="selecting-a-collection-of-makefile-targets-for-repeated-building"
><title
>Вибір збірки цілей з Makefile для регулярного збирання</title>
<para
>Клацання правою кнопкою миші на окремих пунктах цілей швидко втомлює. Набагато простіше було б створити для одного або декількох проєктів окремі цілі, які постійно збираються протягом розробки. З цією метою у середовищі реалізовано «збирання позначених цілей»: збирання наборів цілей 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
>. У налаштуваннях ви, наприклад, можете визначити кількість завдань, які «make» може виконувати одночасно (якщо на вашому комп’ютері встановлено, скажімо, 8 процесорних ядер, введення числа 8 у відповідне поле буде доречним вибором). У діалоговому вікні <guilabel
>Типовою ціллю make</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
> складається з назви виконуваного файла, набору параметрів командного рядка та середовища виконання (наприклад, «запустити програму у командній оболонці» або «запустити цю програму за допомогою інструменту для усування вад»).</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
>Якщо вами було налаштовано декілька інструментів запуску, ви можете вибрати той з них, який запускатиметься у відповідь на натискання комбінації клавіш <keycombo
>&Shift;<keycap
>F9</keycap
></keycombo
>: скористайтеся пунктом меню <menuchoice
><guimenu
>Виконання</guimenu
><guimenuitem
>Поточні налаштування запуску</guimenuitem
></menuchoice
>. Існує неочевидний спосіб зміни назви налаштувань: у діалоговому вікні, яке можна відкрити за допомогою пункту меню <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
>Після того, як запуск програми буде налаштовано (див. <ulink url="http://userbase.kde.org/Special:myLanguage/KDevelop4/Manual/Running programs"
>Запуск програм</ulink
>), ви зможете запускати програму під керуванням інструмента налагоджування: скористайтеся пунктом меню <menuchoice
><guimenu
>Виконання</guimenu
><guimenuitem
>Налагоджувальний запуск</guimenuitem
></menuchoice
> або натисніть комбінацію клавіш <keycombo
>&Alt;<keycap
>F9</keycap
></keycombo
>. Якщо ви знайомі з роботою <application
>gdb</application
>, результат буде той самий, що і після запуску <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
>, команда «next» <application
>gdb</application
>), увійти до функції (<keycap
>F11</keycap
>, команда «step» у <application
>gdb</application
>) або виконати інструкції до кінця функції (<keycap
>F12</keycap
>, команда «finish» <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
>Перейти до наступної інструкції ("next" у gdb)</entry>
</row>
<row>
<entry
><keycap
>F11</keycap
></entry>
<entry
>Увійти у наступну інструкцію ("step" у gdb)</entry>
</row>
<row>
<entry
><keycap
>F12</keycap
></entry>
<entry
>Вийти з інструкції ("finish" у 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;, що середовищу слід отримати код з системи керування версіями самостійно, — достатньо вказати &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
>Порівняти з Базовим</guilabel
>, щоб переглянути відмінності між редагованою вами версією і версією, яка зберігається у сховищі (версією <quote
>base</quote
>). На панелі перегляду, яку буде відкрито, ви зможете переглянути відмінності (<quote
>diff</quote
>) для всіх файлів у каталозі. </para
></listitem>
<listitem
><para
>Якщо зміни було внесено лише до одного файла, ви можете відкрити меню <guilabel
>Subversion</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
>. У такому режимі простіше буде визначати рядки з помилками під час компіляції або визначати відповідність діагностичних повідомлень позиціям у коді. У тому ж підменю ви можете увімкнути <quote
>Рамку для піктограм</quote
> — стовпчик у лівій частині панелі редактора, у якому &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
>У &kdevelop; 4.2.2 ви можете створити стиль для файлів окремого типу 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; передбачено майже безмежний список клавіатурних скорочень (деякі з них можна знайти у списках «Корисні клавіатурні скорочення» у декількох частинах цього підручника). Ці клавіатурні скорочення можна змінити за вашими потребами за допомогою пункту меню <menuchoice
><guimenu
>Параметри</guimenu
><guimenuitem
>Налаштувати скорочення</guimenuitem
></menuchoice
>. У верхній частині діалогового вікна ви можете вказати ключ пошуку, щоб переглянути лише відповідні ключу скорочення. Після цього ви можете змінити клавіатурні скорочення для бажаних команд.</para>
<para
>Однією з двох корисних змін буде встановлення для <guilabel
>Вирівняти</guilabel
> скорочення 	 (багато хто звичайно не додає табуляції вручну і віддає перевагу вибору форматування коду редактором; якщо скорочення буде змінено, після натискання 	 &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
>: ніколи не показувати «повного доповнення». </para
></listitem>
<listitem
><para
><guilabel
>Мінімальне автоматичне доповнення</guilabel
>: показувати «повне доповнення», якщо автоматичне доповнення було викликано вручну (тобто було натиснуто <keycombo
>&Ctrl;<keycap
>Пробіл</keycap
></keycombo
>) </para
></listitem>
<listitem
><para
><guilabel
>Завжди повне доповнення</guilabel
>: завжди показувати «повне доповнення». </para
></listitem>
</itemizedlist>
</sect1>
</chapter>
<!--userbase-content-->
<chapter id="credits">
<title
>Подяки і ліцензія</title>
<para
>Список власників авторських прав на документацію до програми можна знайти у <ulink url="https://userbase.kde.org/index.php?title=KDevelop4/Manual&action=history"
>журналі сторінки KDevelop4/Manual</ulink
> UserBase.</para>
<para
>Переклад українською: Юрій Чорноіван <email
>yurchor@ukr.net</email
></para
>
&underFDL; </chapter>
&documentation.index;
</book>
Generated by dwww version 1.15 on Thu Jun 27 09:06:09 CEST 2024.