ДляCMake включают команду, в чем разница между файлом и модуль?

я использую некоторые библиотеки, которые я не хочу, построенный как часть каждом проекте, который его использует их. Очень понятный пример LLVM, который имеет 78 статические библиотеки. Даже имея cmake код, чтобы найти и импортировать данные в каждой cmakefile является чрезмерной.

очевидным решением было бы использование "включить" команды, и вынести соответствующие куски cmake сценарий в *.cmake файлы и настроить CMAKE_MODULE_PATH переменной окружения.

за Исключением того, она просто не работает. Cmake не находит файл, укажите в команде include.

наудачу, я даже пытался указать путь в переменной окружения несколькими способами, один раз с обратной косой черты, как только с косая черта. - и я перезагрузки командной строке каждый раз и проверить, что переменная среды присутствовал и правильный.

В cmake руководство, это как бы подразумевает, что "файл" отличается от "модуль" - только модуль получает автоматического добавления-расширение и поиск-путь лечения. Но нет объяснения, в чем разница. Я догадался, что отсутствует расширение может быть достаточно (как со стандартными модулями), но очевидно, что это не так.

Поиск в руководстве "модуль" не очень поможет, как слово, кажется перегруженным. Например, модуль также динамическую библиотеку, загруженных с помощью функции LoadLibrary/dl_open.

кто-нибудь Может объяснить, в чем разница между файла модуля в этом контексте, и, как я создать свой собственный модуль, так что cmake включают команда может найти и использовать?

я с помощью cmake 2.8.1 на Windows.

я практически уверен в том, что проблема здесь не в том понимании, как cmake должна работать. Я думаю, что на должны делать что-то писал, что find_package .

Как обстоят дела, хотя, я еще не будучи в состоянии ответить на мой вопрос.

Программирование и игры: Как я CMake на SCons променял

Привет. Когда я начинал Tank Of Destiny я решил что буду использовать CMake. Тогда мне казалось что все что нужно он умеет, но когда мне понадобилось чуть больше, начались трудности. Я конечно попытался их решить, и честно убил на это пол дня.

В CMake почему-то решили что работать с pkg-config из коробки, это лишнее. Я не знаю как можно пренебречь такой классной программой, но есть модуль FindPkgConfig результат работы которого куча магических переменных, половину которых нельзя использовать в стандартных командах CMake. Наверняка это проблему можно решить, CMake хорошая система автоматизации сборки, но я выбираю SCons потому что он оказался для меня гораздо удобнее.

Что же такого крутого в SCons. Для меня это ParseConfig которому можно скормить pkg-config и все будет круто. Причем в ParseConfig можно передать простой набор флагов и все будет круто.

Типичное использование ParseConfig :

Еще одна на мой взгляд нужная для системы автоматизированной сборки фича. это умения хранить переменные окружения в файле. Что бы было понятнее что за ерунду я сказал, проиллюстрирую.

Речь пойдет о том, как запомнить что я велел SCons собрать мне версию для отладки не указывая постоянно это в виде аргумента при сборке.

Для этого существует Variables :

В итоге вызвав один раз scons debug=yes или scons debug=y. мы всегда будем собирать отладочную версию программы при вызове scons .

В build.conf будете храниться вот такой вот текст:

Мелочь, а приятно.

Как работает CMake? С для начинающих

Вы мне можете объяснить, чем занимается CMake конкретно на пальцах?

Получается, допустим, у нас есть папка с исходными файлами .cpp, мы можем выбрать конфигурацию, настроить для какой платформы будем компилить исходники, и т.о. мы можем скомпилить проект под Linux, Windows, MacOS и другие платформы как это делает Qt?

По сути содержит пути до компиляторов и просто выполняет .bat файл с надстройками, как что и где компилить?
Спрашиваю потому что сейчас пытаюсь установить библиотеку libTorrent, для нее нужно иметь установленные OpenSSL и Boost.

До этого имел опыт работы с CMake, когда делал проект с использованием OpenCV. Ее тоже нужно было собирать, но вместе с исходниками шли Prebuilt Binaries, заранее скомпиленные.

Другими словами, какое именно назначение у CMake? Можно ли пользоваться ей для простой компиляции своего исходника без IDE,
И является ли это кроссплатформенным решением

если я пишу на WinApi, разрабатываю в Windows7 x64, у меня есть .cpp и .h файлы,
я открываю CMake, прописываю настройки и пр. но хочу получить, например исполняемый файл или дрова для Linux, как происходит трансформация между функциями WinApi и функциями для линуксовых осей? Там же все это учтено? и все тоже самое для MacOS? я просто поверить не могу, что так все просто

хех. вы не поняли.
cmake - кросплатформенной средство построения файлов проектов для целевых ИДЕ,
либо сборки продукта из исходников.

но cmake за вас исходный код писать не будет.
и если ваш исходный код не кросс-платформа сам по себе,
то естественно под чужерожной платформой это не взлетит.

то есть, если вы использовали винапи,
значит прибили свой проект гвоздями к виндовс.

под виндовс вы сможете попросить cmake
собрать проект руками компиляторов вижал студии, или mingw

вы сможете получать файлы проекта для вижал студии, или работать в qtcreator

но поскольку винапи - то о линуксах уже речи не будет.

cmake сможет сгенерировать вам мэйк файл проекта для сборки линуксовым gcc
это не проблема.
просто линуксовый gcc пошлет нафиг ваше винапи.

обычно, с библиотекой идут файлы документации,
где описывается, как собирать библиотеку.

вам лишь нужно запустить cmake, скормив ему нужные параметры.

пример батника для запуска из командной строки:

SOURCE_DIRECTORY - путь к файлу CMakeLists.txt

PATH_BUILD - путь к каталогу, в котором будет созданы файлы проекта целевой ИДЕ.
например, в этом каталоге cmake может создать проект вижал студии

GENERATOR - определяет что именно за файлы проекта хотим получить.
например, Visual Studio 14 - означает, что нужны файлы проекта для 2015 вижал студии

-DCMAKE_BUILD_TYPE=%BUILD_TYPE%
позволяет установить стартовые значения некоторых переменных.
в данном случае, переменная CMAKE_BUILD_TYPE отвечает за конфигурацию
(Debug/Release/etc)

-T"имя-тулчейна" позволяет указать тулчейн, которым нужно осуществлять сборку.
например, для вижал студии можно указать
CTP_Nov2013 - экспериментальный компилятор 2013 студии с улучшенной поддержкой разных фич c++1y
v120_xp - компилятор с поддержкой windows xp
ну и тп, их там множество может быть самых разных.

в общем, вам нужно почитать документацию к вашей библиотеке,
понять какие могут быть параметры сборки.
и запустить cmake указав эти параметры.

так же, вы можете воспользоваться cmakeGUI,
и в удобном гуевом интерфейсе прописать все необходимые параметры.
тогда вам не придется вводить их из командной строки.

собрал 32 битный релиз в 2013 вижал студии.

но что характерно - ни ошибок,
ни даже предупреждений.
неужели, в кои то веки, кто-то оформил цивильную сборку?

2.
распаковываем архив.
я распаковал в каталог по имени cef:
D:/dev/workspace/deploy/cef
вы можете распаковать по любому другому пути.

3.
в корень проекта закидываем батник
по имени launchcmake.bat:

его путь у меня получился:
D:\dev\workspace\deploy\cef\launchcmake.bat

4.
батник содержит скрипт:

BUILD_TYPE отвечает за тип конфигурации (Debug/Relese)

ADDRESSMODEL определяет адресную модель:
32 или 64 битная сборка.

в комплекте со сборкой идут предкомпилированные библиотеки.
поэтому есть четкое разделение на 32 и 64 битную сборку.

данный архив не поддерживает 64 сборку,
поэтому выставлять 64 не имеет смысла.

но если скачаете 64 архив,
тогда этот же батник сможет настроить вам сборку для 64 битных продуктов

5.
заходим в каталог с проектом, и запускаем батник.
я работаю в FAR`e, и просто жмакаю enter на батничек

через пару-тройку секунд у вас появиться подкаталог _build
который будет содержать файлы проекта для 2013 вижал студии.

6.
заходим в подкаталог _build
и жмакаем enter на cef.sln

запустится вижал студия,
с уже открытым солюшеном.
в нем будет 5 проектов:

ALL_BUILD //<--- симейковская ботва
cefclient
cefsimple
libcef_dll_wrapper
ZERO_CHECK //<--- симейковская ботва

7.
поскольку в батнике мы указали,
что хотим Release,
то в студии переключаем конфигурацию сборки на Release
(по умолчанию студия всегда показывает Debug при запуске).

8.
нажимаем на клавишу f7

9.
наливаем чайку.
компилять будет минуты 3 не меньше.

Добавлено через 14 минут

1>C:\Users\neo\Downloads\cef_binary_3.2494.1321.ge343da7_windows32(1)\cef_binary_3.2494.1321.ge343da7_windows32\include/base/internal/cef_bind_internal.h(2557): error C2146: синтаксическая ошибка: отсутствие ";" перед идентификатором "final"

такое впечатление, что у вас компилятор старый.
не держит с++11.

а вообще из документации к сборке:

Это типо на халяву вместо экспресс? А там и MFC есть, в экспресс не было? Или там все есть только программы комерческие нельзя создавать?

Мб. пора windows7 сменить на windows10. У меня 48 гигабайт на диске С, ни на что не хватает места. От подумываю переустанавливать и 100 выделить. Какую виндовс лучше выбрать, чтобы ресурсов не больше семерки жрала или 7 норм?

24.09.2015, 01:57 Как работает CMake?

Текущее время: 12:25. Часовой пояс GMT +3.

Приступая к работе

Добро пожаловать в руководство для разработчиков elementary OS! Эта книга была создана, чтобы научить вас создавать и распространять приложения для elementary. Вступление расскажет вам об инструментах, необходимых для работы, а также даст понять, о чем эта книга. Чувствуете себя достаточно уверенно, чтобы сразу приступить к программированию? Пропустите вступление и перейдите к созданию своего первого приложения!

Тем не менее, мы советуем вам хотя бы пробежаться по этому подготовительному тексту. Наличие подходящих инструментов поможет вам достичь своих целей быстрее, а также создаст твердый фундамент, который поможет вам в понимании остальных частей книги.

Вам не требуется иметь какой-либо опыт в разработке приложений для elementary. Но мы ожидаем знания основ программирования или хотя бы небольшого опыта в работе с объектно-ориентированным языком программирования Vala или схожих по синтаксису языках. Если вы не знакомы с подобным, советуем вам изучить Vala и вернуться позже.

Мы не будем обращать много внимания на дизайн в этом руководстве, поскольку для этого есть соответствующие рекомендации по дизайну интерфейса. Тем не менее, мы предполагаем, что вы освоите их самостоятельно, прежде чем начнете работу над своим первым приложением. Дизайн и непротиворечивость интерфейсов чрезвычайно важны для elementary.

В этой книге мы будем говорить о разработке приложений с использованием GTK+, Granite и других технологий, доступных в elementary; о настройке системы сборки, публикации вашего кода для совместной разработки, работе с переводами; о нескольких других полезных вещах и, наконец, об упаковке и распространении вашего нового приложения.

Прежде чем приступить к написанию кода, вам потребуются определенные базовые настройки, и эта глава поможет вам их осуществить. Мы рассмотрим следующие темы:

• Создание аккаунта на launchpad.net и импорт SSH ключей
• Настройка системы управления версиями Bazaar
• Установка и использование комплекта средств разработчика "SDK" (Software Development Kit)

Мы рассчитываем на то, что вы используете чистую elementary OS редакции Freya или более поздней. Это важно потому, что будут использованы приложения, которые недоступны для других дистрибутивов Linux (например Ubuntu). Применить данное руководство возможно для разработки на Ubuntu, но оно может отличаться и быть намного сложнее в некоторых моментах.

Launchpad это бесплатный сервис, предоставляемый компанией Canonical, которая также создала Ubuntu. Он используется в качестве платформы для хостинга кода, ведения ключевых моментов, отслеживания ошибок, реализации переводов и многого другого. Launchpad - это мощный ресурс для командной работы разработчиков. Мы будем использовать его для различных задач на протяжении всей книги, так что лучше всего, чтобы вы завели аккаунт на данном сайте. Если у вас уже есть аккаунт, то смело переходите к следующему разделу.

Чтобы завести аккаунт Launchpad:

Перейдите на Launchpad.net. Кликните на Log in/Register в правом верхнем углу страницы.

Выберете Я новый пользователь Ubuntu One у левой стороны.

После подтверждения адреса электронной почты, ваша учетная запись на Launchpad готова, и мы можем перейти к следующему разделу. Помните, что в данной книге мы не будем отвлекаться на разные мелочи. На Launchpad мы вернемся немного позже, когда приступим к работе с более специфичными пунктами. Но если вы действительно хотите узнать о сервисе подробнее, вы можете прочитать больше о нём в Сети. Так что вперед!

Проекты elementary размещены на Launchpad. Для работы с кодом на Launchpad мы используем распределенную систему контроля версий Bazaar. Она позволяет множеству разработчиков совместно разрабатывать и поддерживать код, сохраняя при этом историю каждого изменения.

Вы готовы? Приступим к настройке Bazaar:

Откройте терминал. Будем работать с Bazaar через консольную программу bzr.

Вам нужно будет установить bzr. Просто введите в терминале:

Для аутентификации и безопасной передачи кода, вам понадобится сгенерировать пару ключей SSH (наподобие отпечатков пальца, но только для компьютера) и импортировать публичный ключ в Launchpad. В терминале введите следующие команды:

При появлении запроса, нажмите Enter, чтобы принять используемое по умолчанию название для вашего ключа.

Далее, введите пароль для защиты вашего SSH ключа. У вас запросят ввести его ещё раз, для того чтобы удостовериться, что вы не ошиблись. Вам надо будет вводить этот пароль всякий раз, когда вы попытаетесь опубликовать код на Launchpad, поэтому не забудте его и наберитесь терпения.

Теперь мы собираемся рассказать о вашем SSH ключе сервису Launchpad. С помощью следующей команды откройте файл с вашим SSH ключом в текстовом редакторе Scratch, а затем скопируйте его содержимое.

Перейдите на страницу с вашими SSH ключами и вставьте скопированный текст в текстовое поле и нажмите Import public key .

Теперь вы можете подключить bzr к своему Launchpad аккаунту. Для этого вам потребуется Launchpad ID, который вы можете найти на своей странице .

Вот и все! Теперь вы можете скачивать исходный код, размещенный на Launchpad, и загружать свой. Для более детального изучения Bazaar вы можете использовать Руководство пользователя по Bazaar. предоставляемое Canonical.

На момент написания этой статьи elementary не имел собственного SDK, как Android или iOS. Но к счастью, для того, чтобы нам начать писать код, нужно совсем немного приложений.

Итак, первой частью нашего небольшого и простого пазла станет Scratch, в которо вы будете "выцарапывать" исходный код будущих приложений. Это стандартное приложение в elemntary OS. Scratch предоставляет чрезвычайно полезные функции, такие как подсветка синтаксиса, автосохранение документов и расширение к файловому менеджеру. Кроме этого существует достаточно много расширений, как Outline, Terminal или Devhelp. Установите необходимые для и продолжите путь!

Использование консоли терминала будет важной частью вашей работы, ведь именно это поможет вам скомпилировать и отправить ваше приложение на Bazaar (bzr). К тому же, терминал - важная утилита, на которую опирается вся наша книга. Удостоверьтесь, что все команды исполняются из папки “Projects” в вашей домашней папке, которую необходимо предварительно создать.

Откройте терминал и введите следующую команду:

Для создания и сборки ваших приложений, понадобятся некоторые библиотеки. Установите их:

Команда apt-get build-dep узнаёт, от каких других библиотек зависит исследуемое приложение. Ради примера узнаем зависимости простого приложения - Granite Demo. О Granite поговорим немного позже, но помните: легче всего получить приложение из исходных кодов или узнать о зависимостях приложения из apt-get build-dep .

И вот теперь мы полностью готовы погрузиться в разработку! Поехали!

Первым приложением, которое обязан создать каждый уважающий себя разработчик, станет привычный "Hello World". Мы пройдем через каждый этап, начиная с создания рабочей папки и заканчивая отправлением кода в ветку bzr. Итак.

Приложения на начальной OS организованы в стандартные каталоги, содержащихся в "корневой" папке вашего проекта. Для начала создадим несколько из них:

1. Создайте вашу корневую папку под названием "gtk-hello"
2. Создайте папку внутри данной под названием "src". Эта папка будет содержать весь ваш исходный код.

Позже мы поговорим о добавлении таких папок как "po" и "data". На данный момент этого вполне достаточно.

И теперь, то, чего вы ждали! Мы создадим окно с активными кнопками. Когда на кнопку нажать, то она отобразит сообщение "Привет, Мир!". Чтобы это осуществить, мы используем виджет GTK+ и язык программирования Vala.Прежде, чем мы начнем, мы настоятельно рекомендуем вам не заниматься копипастом! Пропечатывание каждой стадии поможет вам укрепить свое знание. Давайте начнем:

Создайте новый файл в Scratch и сохраните его как "gtk-hello.vala" внутри папки "src"

Во-первых, мы должны создать основную функцию нашего нового GTK приложения. Введите следующее в вашем "gtk-hello.vala".

Теперь, когда мы инициализировали Gtk, мы создадим новое окно и объявим некоторые его свойства. Вы заметите, что большинство имен этих свойств довольно просты. Попробуйте догадаться, что делает каждое из них, а мы через секунду объясним. Введите следующее после строки Gtk.init. но перед последней скобкой:

Первая строка создает новое "окно" Gtk.Window. Вторая строка устанавливает заголовок окна, который вы видите в его верхней части. Далее мы создаем отступ внутри этого окна, так что виджеты не натыкаются на его края. Затем мы говорим оконному менеджеру, что хотим разместить окно в центре экрана вместо позиции по умолчанию (которая обычно в верхнем левом углу). Мы также должны дать нашему окну размер по умолчанию, чтобы оно не оказалось слишком маленьким. И наконец, мы объясняем, что делать с этим процессом, если главное окно закрылось; в нашем случае мы хотим выйти.

Теперь, когда мы определили хорошее окно, давайте поместим в него кнопку. После кода нашего окна (но перед строкой Gtk.main ), оставьте пустую строку и наберите следующее:

Есть идеи о том, что здесь произошло? Мы создали новую Gtk.Button с надписью "Click me!". Затем мы сказали, что при нажатии на кнопку мы хотим изменить ее надпись на "Hello World!". Еще мы сказали, что хотим сделать кнопку нечувствительной; мы сделали это, потому что повторное нажатие на кнопку не имеет визуального эффекта. И наконец, мы добавили кнопку в наше Gtk.Window и заявили, что хотим показать все содержимое окна.

Готовы протестировать его? Запускайте свой терминал и убедитесь, что вы в "

/Projects/gtk-hello/src". После, запускайте следующие команды для того, чтобы скомпилировать и запустить ваше первое приложение GTK.

Сработало? Если да, наши поздравления! Если нет, прочтите исходный код и отыщите в нем ошибки. Так же проверьте выход терминала. Обычно в нем есть полезная информация, которая поможет отследить вашу ошибку.

После внесения существенных изменений, мы должны за'pushить наш код. Это особенно важно в совместной разработке, когда недостаточно оперативный push кода может привести к непредусмотренным форкам, а push слишком большого количества кода за раз может затруднить отслеживание внесённых с ним багов. Так что уделите минутку на очередное посещение нашего друга bzr :

Откройте Терминал и убедитесь, что вы в корневой папке вашего проекта "

Этими командами мы сказали bzr отслеживать данную папку как ветвь, в которой мы хотим

Давайте повторим, что мы успели изучить в первой секции

• Мы создали новый проект, в котором содержится папка "src"
• Мы создали наш главный файл и внутри него создали новые Gtk.Window и Gtk.Button
• Мы построим и запустим наше приложение, чтобы убедиться, что все работает, как надо
• Наконец, мы совершили нашу первую ревизию и продвинули код в Launchpad

Свободно поиграйтесь с этим примером. Измените размер окна, установите разные границы, заставьте кнопку делать различные вещи. Когда Вы почувствуйте, что готовы, двигайтесь дальше.

Помните как мы использовали команду valac с параметром --pkg gtk+-3.0. когда компилировали наш код? Так мы использовали "библиотеку". Если вы не знакомы с идеей библиотек, то библиотека - это набор методов, которые может использовать ваша программа. Таким образом, этот параметр говорит valac включить библиотеку GTK+ (версии 3.0) при компиляции приложения.

В нашем коде мы использовали "пространство имен" Gtk. чтобы объявить, что мы хотим использовать методы из GTK+ (а именно Gtk.Window и Gtk.Button.with_label ). Обратите внимание на то, что существует иерархия. Если вы хотите изучить эту иерархию более подробно, обратитесь к Valadoc .

В предыдущей главе мы создали простое приложение "Hello World!", чтобы похвастаться нашими навыками Vala и Gtk. Но что, если бы мы хотели поделиться нашим приложением с другом? Они должны были бы знать какие пакеты включить командой valac. которой мы собрали приложение, а после собрать его и запустить из папки build, как делали это мы. Очевидно, нам нужно сделать еще некоторые вещи, чтобы приложение было пригодно к использованию людьми, сделать его настоящим приложением.

Чтобы создать первую настоящую программу, нам понадобится все то, что мы использовали в последнем примере. Только, пожалуйста, не занимайтесь простым копированием! Давайте уделим некоторое время тренировке навыков и убедимся, что вы можете повторить то, что вы сделали в последнем задании по памяти. Кроме того, сейчас, когда вы усвоили основы, мы попробуем усложнить задачу и быть немного более последовательны:

Создайте новую папку в "

/Projects", назовите её "hello-again" и перенесите туда наш последний проект. Теперь создайте еще одну папку уже внутри "

/Projects/hello-again" так же назвав её "hello-again". Мы поступаем так потому, что наш первый проект "gtk-hello" и текущий "hello-again" оба являются ветками проекта "hello-world". (Как только вы займетесь совместной разработкой, у вас появится множество таких веток.) Такая структура папок поможет вам сохранить удобную организацию.

Теперь зайдите в "hello-again" и создайте в ней нужную структуру папок, включая папку "src".

Создайте "hello-again.vala" в папке "src". На этот раз мы добавим в начало файла немного информации о лицензии. Далее мы рассмотрим эту тему подробнее, а пока, просто скопируйте и вставьте данный текст, заменив YourName на ваше настоящее имя:

Теперь давайте создадим нашу главную функцию Gtk.Window и настроим стандартные параметры окна. Вернитесь к предыдущей главе, если вам нужно освежить в памяти, как это делается.

Чтобы сэкономить время давайте используем Gtk.Label вместо Gtk.Button. Чтобы не настраивать действие по щелчку.

Не забудьте включить созданную переменную в окно и позаботьтесь о его вызове:

Соберите "hello-again.vala" чтобы убедиться, что все работает. Если что то пошло не так, вернитесь к предыдущей главе и не забудьте прочитать вывод терминала чтобы понять причину.

Инициализируйте ветку, добавьте свои файлы в проект и напишите commit-сообщение, используя полученные в предыдущей главе знания. И, наконец, заpush'те свою первую ревизию с bzr :

Все работает, как надо? Отлично. Теперь наше приложение готово к использованию другими людьми.

Каждое приложение сопровождается с файлом формата .desktop. Этот файл содержит всю информацию, необходимую для отображения приложения в главном меню и панели быстрого запуска. Давайте двигаться вперед и создадим первое:

В корне вашего проекта создайте папку с названием "data".

Создайте новый файл в scratch и сохраните его в папку "data" в "hello.desktop".

Введите следующее в "hello.desktop". Как и прежде, попробуйте догадаться, что делает каждая строка.

Первая строка объявляет, что этот файл является файлом "Desktop Entry". Следующие три строки представляют собой описания нашего приложения: фирменное название, общее название, и комментарий, который описывает назначение нашего приложения. Далее мы классифицируем наше приложение. Потом мы сообщаем, какая команда будет выполнять его. И, наконец, мы присваиваем для приложения значок (application-default-icon включен в elementary OS), и пусть система знает, что это не приложение командной строки. Для получения дополнительной информации о разработке .desktop файлов, просмотрите эту HIG запись .

Наконец, давайте добавим файл в bzr и зафиксируем версию:

Так как мы будем помещать наше приложение в мировое информационное пространство мы должны включить какую-то информацию о том, кто написал это приложение, а также указать юридические права на использование данного исходного кода. Для этого нам нужны два новых файла в корневой папке нашего проекта: AUTHORS и COPYING.

Файл AUTHORS довольно простой. Файл содержит ваше имя и адрес электронной почты, а также имя и электронную почту тех, кто помог сделать ваше приложение. Как правило, он выглядит так:

Файл COPYING содержит копию лицензии, под которой выпущен ваш код. Для приложений elementary это как правило GNU Public License (GPL). Помните заголовок, который мы добавили в наш исходный код? Этот заголовок напоминает людям о том, что ваше приложение лицензировано и принадлежит вам. Вы можете выбрать другую лицензию, такую как MIT, но в этом примере давайте придерживаться GPL .

Вы не забыли добавить эти файлы в bzr и закоммитить ревизию? Каждый раз, когда мы добавляем новый файл или вносим существенные изменения, хорошей идеей будет закоммитить новую ревизию и заpush'ить на Launchpad. Помните, что это работает также как система бекапов; когда мы пушим нашу работу на Launchpad, мы знаем, что это безопасно и мы всегда можем откатиться на хорошую ревизию, если ошибёмся позднее.

Теперь, когда мы получили все эти файлы, нам нужно сказать компьютеру, что делать с ними. Готовы к следующей главе? Давайте сделаем это!

Следующее, что нам нужно - это система сборки. Система сборки, которую мы собираемся использовать, называется CMake. Мы уже установили программу cmake в начале книги, когда собирали зависимости для Granite Demo. На этом шаге нам нужно получить копию некоторых дополнительных модулей для Cmake (поддержка Vala, переводы и т.д.) и создать файлы, которые объяснят Cmake как установить вашу программу. Это включает все правила сборки вашего исходного кода. а также правильную установку файла .desktop и бинарное приложение, полученное после процесса сборки.

Команда разработчиков приложений elementary поддерживает копию модулей CMake, которые нам потребуются. Убедитесь, что вы находитесь в "

/Projects" (а не в каталоге hello-again) и заберите последнюю копию этих модулей с bzr. Удостоверьтесь, что мы не в "

/Projects/hello-world". Дело в том, что наши модули cmake не являются веткой нашего приложения Hello World:

Вы увидите папку с названием "cmake". Скопируйте её в папку "hello-again". Это просто.

Создайте новый файл в корневой папке проекта под названием "CMakeLists.txt". Так как этот файл очень обширен, мы включили некоторые комментарии, чтобы объяснить каждую секцию. Вам не нужно полностью копировать его, но включите все основное в этот файл:

И вы сделали! Ваше приложение теперь имеет реальную систему сборки. Не забудьте добавить эти файлы в Bzr и нажмите на Launchpad. Это является важным этапом в разработке вашего приложения!

Теперь, когда мы собрали систему, давайте попробуем её в действии:

В корне вашего проекта создайте папку с названием "build"

Перейдите в эту директорию в терминале и выполните следующую команду:

Эта команда сообщает cmake, что нужно приготовиться собрать наше приложение, используя префикс "/usr". Команда cmake по умолчанию устанавливает наше приложение локально, но мы хотим установить его для всех пользователей компьютера.

Соберите приложение с помощью make и в случае успеха установите его командой sudo make install :

Если всё прошло хорошо, теперь ваше приложение должно открываться из меню Приложений и цепляться на панель. Если вы собираетесь добавить каталог "build" в вашу ветку bzr и запушить, остановитесь! Этот бинарник был собран для вашего компьютера и мы не хотим его распространять. Фактически, мы собрали ваше приложение в отдельном каталоге, так что мы можем спокойно удалить или проигнорировать каталог "build", и это не повлияет на исходные коды приложения.

Мы вернемся к CMake позже, чтобы добавить некоторые более сложные задачи, но на данный момент это все, что вам нужно знать, для того чтобы ваше приложение получило правильную систему сборки. Если вы хотите изучить CMake немного больше, вы всегда можете обратиться к CMake в документации .

Давайте рассмотрим все, что мы научились делать:

• Создавать новое Gtk приложение, используя Gtk.Window. Gtk.Button и Gtk.Label
• Организовывать наши проекты в ветви
• Лицензировать наше приложение лицензией GPL и объявлять авторов приложения стандартизированным способом
• Создайте файл формата .desktop, который указывает компьютеру как отображать наше приложение в главном меню и панели быстрого запуска
• Настраивать систему сборки CMake, которая содержит все правила сборки нашего приложения и его аккуратной установки

That's a lot! You're well on your way to becoming a bonified app developer for elementary OS. Give yourself a pat on the back, then take some time to play around with this example. Change the names of files and see if you can still build and install them properly. Ask another developer to branch your project from launchpad and see if it builds and installs cleanly on their computer. If so, you've just distributed your first app! When you're ready, we'll move onto the next section: Packaging.

Теперь, когда вы узнали о CMake, следующий шаг - сделать ваше приложение переводимым на другие языки. Первая вещь, которую вам нужно знать - как преобразовать строки в вашем коде в переводимые строки. Вот пример:

Видите разницу? Мы только добавили _() вокруг строки! Что ж, это было просто!

Вернитесь в проект и сделайте все строки переводимыми, добавив _()

Добавьте следующие строки в только что созданный файл "CMakeLists.txt":

Создайте папку с именем "po" в корневой папке проекта. Внутри нее вам нужно будет создать другой файл CMakeLists.txt. В этот раз его содержимое будет таким:

В Вашей рабочей директории выполните следующие комманды:

Не забудьте добавить эту новую папку и ее содержимое в bzr

И всё! CMake автоматически добавит все строки выделенные при помощи _() в шаблонный файл .pos и файл для каждого доступного языка, куда вы поместите переведённые строки.

Несмотря на наличие системы сборки, наше приложение все еще не готово для обычных пользователей. Мы хотим убедиться, что наше приложение можно собрать и установить без использования Терминала. Что нам нужно, так это упаковать приложение. Для этого мы используем формат пакетов Debian (.deb) в elementary OS. Этот раздел научит вас как упаковать приложение в .deb файл и разместить его в архиве персональных пакетов (PPA) на Launchpad. Это позволит обычным людям установить ваше приложение и даже получать обновления для него в Менеджере Обновлений.

Если вы хотите получить действительно хорошее очень быстро, вы захотите попрактиковаться. Повторение-лучший способ что-то запомнить. Так давайте воссоздадим программу "Hello world" с нуля :

1. Создать новую отдельную папку "hello-packaging"
2. Установите нашу структуру каталогов которая включает в себя "src" и "data" папки.
3. Добавьте файлы Authors, Copying. desktop и исходный код.
4. Теперь давайте настроим систему сборки CMake.
5. Проверьте все!

Возможно, вы фиксируете и нажимаете на Launchpad для каждого шага? Держитесь этой хорошей привычки и давайте перейдем к упаковке этого приложения!

Пришло время создать правила, которые позволят собрать ваше приложение в .deb пакет. Давайте погрузимся в это:

Как и CMake, elementary поддерживает простую версию папки "debian", которая содержит все файлы, необходимые нам для упаковки. Давайте возьмем ее копию с помощью bzr:

Скопируйте папку "debian" c этой ветки в Вашу папку "hello-packaging"

Откройте файл с именем "changelog" и сделайте его как показано ниже:

Первая строка содержит бинарное имя приложения, версию, кодовое имя ОС и срочность сборки вашего пакета. Запомните, что бинарное имя пишется в нижнем регистре и не содержит пробелов. После символа * находится список ваших изменений. Наконец, вы включаете ваше имя, электронную почту и дату. Для более подробной информации о файле списка изменений Debian обязательно прочитайте документацию .

Откройте файл с именем "control" и сделайте его как показано ниже:

Откройте файл с именем "copyright". Нам нужно изменить только верхнюю часть:

Было не так уж плохо, правда? Мы настроим более сложную упаковку в будущем, но сейчас это все, что вам нужно. Если вы хотите, то всегда можете прочитать больше о создании пакетов в Debian .

Теперь когда наша папка "debian" в порядке, пришло время зайти на launchpad и создать рецепт: инструкции о том, какой код собирать, как часто его собирать и куда складывать полученные пакеты.

Щелкните по ссылке или зайдите на Launchpad, найдите вашу ветку hello-packaging и выберите Create packaging recipe .

Ознакомьтесь с доступными настройками. Вы можете пойти дальше, оставив для полей Name, Description (оно пустое), Owner, Daily builds и PPA значения по умолчанию, а можете изменить их, если хотите.

Когда вы дойдете до набора галочек с заголовком "Default distribution series", убедитесь, что выбрали "Trusty". elementary OS Freya разделяет свое ядро с Ubuntu Trusty, поэтому пакеты, собранные на Trusty будут работать и на Freya.

Мы собираемся лишь немного изменить текст рецепта для лучшего соответствия официальным правилам Debian. Измените первую строку на такую:

Заметьте, что она не сильно отличается от строки по умолчанию, которая включает -0

Теперь, когда вы создали рецепт, вам нужно только дождаться пока Launchpad закончит создание! Если все пойдет по плану, ваш новый PPA будет содержать упакованное приложение, которое другие люди могут с легкостью устанавливать и запускать. Кроме того, любому пользователю вашего PPA будут доступны обновления для вашего приложения, если вы загрузите новую версию. Мы еще поговорим об этом позже.

Теперь, когда вы знаете, как писать код, создавать и распространять приложения с помощью Vala, Gtk, CMake, и Launchpad PPA, настало время, чтобы узнать немного больше о том, как превратить ваше приложение в нечто действительно полезное. Первое, что мы должны научиться - это выкладывать виджеты в наши окна. Но у нас есть фундаментальная проблема: мы можем добавить только один виджет (один “ребенок”) в Gtk.Window. Так как же нам обойти это, чтобы поместить сложные макеты в окно? Мы должны добавить виджет, который может содержать несколько «детей». Один из этих виджетов Gtk.Grid .

Before we get into Gtk.Grid. let’s stop for a second and take some time to understand Gtk a little better. At the lower level, Gtk has classes that define some pretty abstract traits of widgets such as Gtk.Container and Gtk.Orientable. These aren’t widgets that we’re going to use directly in our code, but they’re used as building blocks to create the widgets that we do use. It’s important that we understand this, because it means that when we understand how to add children to a Gtk.Container like Gtk.Grid. we also understand how to add children to a Gtk.Container like Gtk.Toolbar. Both Grid and Toolbar are widgets that are subclasses of the more abstract class Gtk.Container .

If you want to understand more about these widgets and the parts of Gtk that they subclass, jump over to Valadoc and search for a widget like Gtk.Grid. See that big tree at the top of the page? It shows you every component of Gtk that Gtk.Grid subclasses and even what those components subclass. Having a lower level knowledge of Gtk will help you to implement widgets you haven’t worked with before since you will understand how their parent classes work.

Now that we’ve gotten that out of the way, let’s get back to our Window and Gtk.Grid. Since you’re a master developer now, you can probably set up a new project complete with CMake, push it to Launchpad, and build a PPA in your sleep. If you want the practice, go ahead and do all of that again. Otherwise, it’s probably convenient for our testing purposes to just play around locally and build from Terminal. So code up a nice Gtk.Window without anything in it and make sure that builds. Ready? Let’s add a Grid.

Когда мы добавляем кнопку или ярлык, нужно создавать наши Gtk.Grid. Как всегда, не скопировать и вставить! Практика делает совершенным. Мы создаем новую Gtk.Grid как эту:

Remember that Button and Label accepted an argument (a String) in the creation method (that’s the stuff in parentheses and quotes). As shown above, Gtk.Grid doesn’t accept any arguments in the creation method. However, you can still change the grid’s properties (like orientation ) as we did on the second line. Here, we’ve declared that when we add widgets to our grid, they should stack vertically.

Давайте добавим что-нибудь в Grid:

Супер удобная штука, да? Мы можем добавить grid к нам в окно, используя тот же метод, который мы только что использовали, чтобы добавить виджеты в grid:

Now build your app and see what it looks like. Since we’ve given our grid a Gtk.Orientation of VERTICAL the labels stack up on top of each other. Try creating a Gtk.Grid without giving it an orientation. By default, Gtk.Grid ’s orientation is horizontal. You really only ever have to give it an orientation if you need it to be vertical.

Okay, so you know all about using a Gtk.Grid to pack multiple children into a Window. What about using it to lay out some functionality in our app? Let’s try building an app that shows a message when we click a button. Remember in our first “Hello World” how we changed the label of the button with button.clicked.connect. Let’s use that method again, but instead of just changing the label of the button, we’re going to use it to change an empty label to a message.

Давайте создадим окно с вертикальной сеткой, которая содержит кнопки и ярлыки:

This time when we created our grid, we gave it another property: row_spacing. We can also add column_spacing. but since we’re stacking widgets vertically we’ll only see the effect of row_spacing. Notice how we can create new widgets outside the grid and then pack them into the grid by name. This is really helpful when you start using different methods to change the properties of your widgets.

Now, let’s hook up the button to change that label. To keep our code logically separated, we’re going to add it below this.add (grid);. In this way, the first portion of our code defines the UI and the next portion defines the functions that we associated with the UI:

Remember, we set the button as insensitive here because clicking it again has no effect. Now compile your app and marvel at your newfound skills. Play around with orientation and spacing until you feel comfortable.

While we can use Gtk.Grid simply to create single row or single column layouts with the add method, we can also use it to create row-and-column-based layouts with the attach method. First we’re going to create a new Gtk.Grid and set both column and row spacing, then we’ll create all the widgets we want to attach to our grid, and finally we’ll attach them.

Make sure to give the Grid, Buttons, and Labels unique names that you’ll remember. It’s best practice to use descriptive names so that people who are unfamiliar with your code can understand what a widget is for without having to know your app inside and out.

Обратите внимание, что метод attach принимает 5 аргументов

1. Виджет, который вы хотите прикрепить к сетке.
2. Номер колонки, которую нужно прикрепить, начинается с 0.
3. Номер ряда, который нужно прикрепить, начинается с 0.
4. Число столбцов, который виджет должен охватить.
5. Число рядов, который виджет должен охватить.

You can also use attach_next_to to place a widget next to another one on all four sides. Don’t forget to add the functionality associated with our buttons:

You’ll notice in the example code above that we’ve created a 2 x 2 grid with buttons on the left and labels on the right. The top label goes from blank to “Hello World!” and the button label is rotated 90 degrees. Notice how we gave the buttons labels that directly call out what they do to the other labels.

Давайте резюмируем то, что мы выучили в этом разделе:

• Мы узнали о блоках в Gtk и важность подклассов
• Мы собрали несколько "детей" в одно окно при помощи Gtk.Grid
• Мы добавили свойства Gtk.Grid включающие его ориентацию и расположение
• Мы добавили несколько виджетов в один Gtk.Grid, используя его для создания сложных макетов, содержащих кнопки и надписи, которые сделают материал интересным.

Now that you understand more about Gtk, Grids, and using Buttons to alter the properties of other widgets, try packing other kinds of widgets into a window like a Toolbar and changing other properties of Labels like width_chars and ellipsize. Don’t forget to play around with the attach method and widgets that span across multiple rows and columns. Remember that Valadoc is super helpful for learning more about the methods and properties associated with widgets.

By now you've probably already seen the white notification bubbles that appear on the top right of the screen. Notifications are a simple way to notify a user about the state of your app. For example, they can inform the user that a long process has been completed or a new message has arrived. In this section we are going to show you just how to get them to work in your app. Let's begin by making a new project!

1. Создайте внутри новую папку "

When using notifications, it's important that your desktop file has the same name as your application's ID. This is because elementary uses desktop files to find extra information about the app who sends the notification such as a default icon, or the name of the app. If you don't have a desktop file whose name matches the application id, your notification might not be displayed.

In order to display notifications, you're going to need your app to subclass Gtk.Application. Gtk.Application is a class that handles many important aspects of a Gtk app like app uniqueness and the application ID you need to identify your app to the notifications server. If you want some more details about Gtk.Application. check out Valadoc .

Теперь, когда вы знаете, что такое Gtk.Application. давайте сделаем его:

Initiating your app with Gtk.Application is a little different from what we did a few sections back. This time, in main you are starting your app with app.run and you have a new function called activate inside of your class; This activate function will be the one that executes when you invoke app.run. We are also creating a Gtk.ApplicationWindow. this is where you will place all the widgets your app needs. Now that we have a simple window, let's use what we learned in creating layouts and make a grid containing one button that will show a notification.

Между var app_window. и app_window.show ();. напишите следующие строки кода:

Поскольку мы добавляем переводимые строки, не забудьте обновить ваш шаблон перевода, запустив make pot .

Now that we have a Gtk.Application we can send notifications. Let's connect a function to the button we created and use it to send a notification:

Okay, now compile your new app. if everythink works, you should see your new app. Click the "Send" button. Did you see the notification? Great! Don't forget to commit and push your project in order to save your branch for later.

Now that you know how to send basic notifications, lets talk about a couple ways to make your notifications better. Notifications are most useful when users can indentify where they came from and they contain relevant information. In order to make sure your notifications are useful, there are three important features you should know about: setting an icon, replacing a notification, and setting priority.

Чтобы пользователи могли с лёгкостью распознать оповещение, нам нужно поставить соответствующую иконку. Сразу после строки var notification = New Notification добавьте:

That's it. Compile your app again, and press the "Send" button. As you can see, the notification now has an icon. Using this method, you can set the icon to anything you'd like. You can use gtk3-icon-browser to see what system icons are available.

We now know how to send a notification, but what if you need to update it with new information? Thanks to the notification ID, we can easily replace a notification. The notification ID should be the same as the app ID that we set in Gtk.Application .

Let's make the replace button. This button will replace the current notification with one with different information. Let's create a new button for it, and add it to the grid:

Very easy right? Let's compile and run your app again. Click on the buttons, first on "Show", then "Replace". See how the text on your notification changes without making a new one appear?

Notifications also have priority. When a notification is set as URGENT it will stay on the screen until either the user interacts with it, or you withdraw it. To make an urgent notification, add the following line before the this.send_notification () function

URGENT notifications should really only be used on the most extreme cases. There are also other notification priorities .

Давайте рассмотрим все, что мы научились делать:

• Мы узнали, что такое Gtk.Application и как сделать из него подкласс.
• Мы создали приложение, которое отправляет и обновляет уведомления.
• Мы также узнали о других функциях уведомления, таких как установка значка и приоритета уведомления.

As you could see, sending notifications is very easy thanks to Gtk.Application. If you need some further reading on notifications, Check out the page about Glib.Notification in Valadoc .