Поиск по блогу

вторник, 26 августа 2014 г.

Готовимся к написанию Свежего приложения на Vala. Часть 1

Введение

Для начала нам следует продумать концепцию проекта. К примеру, вы заботитесь об OpenSource сообществе, и хотите написать новое приложение, которое позволяет решить задачу, ну к примеру, программу которая получает с определённого web-сервера цитату, каждый раз новую, и каждый раз случайную.

И не каждый знает с чего же ему начать... В действительности, само программирование, как вы знаете, отнимает лишь 10% времени разработки. Наибольшую часть времени разработки отнимает построение модели, и решение по поводу того какие инструменты использовать, какая мощность функционала будет присутствовать в приложении. Но есть ещё один очень важный аспект любого проекта: Поддержка и развитие. Продумывая приложение - необходимо рассмотреть развитие проекта как можно дальше - чтобы иметь представление о том во что выльется проект.

С чего начать?

Базовую цель мы поставили: "сделать программу которая получает с определённого web-сервера цитату", назовём это задачей-минимум. Именно данная цель будет нашей путеводной звездой, указывая на то куда нам идти.

Далее. Нам необходимо решить, а в какой среде должна существовать программа, какие инструменты использовать, и как нам хранить и публиковать код. На данном этапе воля ваша, в рамках моего блога, я в качестве инструмента выбираю Vala + Gtk3 и ОС Линукс. В качестве хранилища и публикации кода будет использовать публичный git (к примеру github.com).

Инструмент-то мы выбрали, но мы не решили в каком виде будем писать наш код (код можно писать многими способами, так же и интерфейс и структура программы может быть написана разными способами). Так как я любитель ООП в разумных приделах, то именно по структуре ООП мы и будем писать наше приложение на Vala. А по поводу построения окон и приложения с точки зрения Gtk и Gnome мы выберем модель "Application" которая активно развивается и уже нашла своё место в среде Gnome. Что я имею ввиду под моделью "Application" - ни что иное как построение приложения используя Класс Gtk.Application (и вспомогательный к нему Gtk.ApplicationWindow).

В чём же разница в использовании этого класса и того как писали раньше спросите вы?!, а разница в том, что теперь 1 приложение может иметь несколько окон, но управляться по типу того как это делается в MacOS. Тоесть каждое новое окно - это не второе приложение, а то же самое приложение, только с дополнительным Окном. Подобная практика позволяет очень сильно увеличить производительность за счёт снижения затрат ресурсов системы. К тому же даёт возможность реально обезапасить некоторые источники данных с которыми работает приложение. К примеру 2 одинаковых приложения работающих над одним и тем же источником - очень небезопасная структура, ибо некоторые данные могут потеряться по причине того что приложения даже не догадываются о существовании друг друга. К тому же, структура Базового Приложения (Application) значительно элегантнее и легче всякого рода костылей типа блокировки ресурса.

Как начать?

Мы будем использовать Анюту :), ну, нет, не в пошлом смысле этого слова :), мы будем использовать систему разработки кода "Anjuta" которая традиционно идёт в большинстве случаев, практически с самим "Gnome". Версия Gnome на момент написания статьи: 3.13.2 (по факту 3.12). ОС Arch Linux x86_64. Так же из инструментов мы будем пользоваться Glade. Как бы не было приятно всё создавать на чистом коде, но хороший тон диктует нам что типовые объекты нам лучше описать с помощью GtkBuilder (Gtk.Builder). То есть, часть интерфейса у нас будет содержаться в XML файле сгенерированным в Glade приложении по типу GtkBuilder.

Примечание

Даже самый последний Glade не даёт вам всех возможностей современного GtkBuilder, почему так происходит не знаю, но если вы научитесь дополнять интерфейс GtkBuilder вручную кодом XML - цены вам не будет! Ибо самые современные виджеты либо не работают в Glade либо очень хорошо спрятаны

Погружение

Начнём нашу работу с создания проекта в Anjuta. Описывать весь процесс не стану. Там слишком всё тривиально. Главное чтобы вы выбрали Vala как язык программирования, и создавали проект сразу на основе make/configure сборки. Всё таки цель у нас делать качественное приложение, а значит надо всё делать как грамотному человеку, не забывая упрощать жизнь вашим последователям.

Как создать проект в Anjuta

Модификация кода

Полученный код разделим на 3 части:

  1. Нужная часть
  2. Ненужная часть
  3. Лицензирование и Документация (комментарии)

В идеале программа у вас готова, точнее болванка, в которой создаётся окошко. Но, программа эта бесполезна и вы ничего не сделали, к тому же, программа создаётся по старым принципам, которые нас не устраивают. Следовательно мы будем менять данную болванку. То есть мы модифицируем код так, чтобы он соответствовал требованию (Application), был оптимален и делал тоже самое что и шаблонный код делал.

Для начала выправите код в том стиле в котором вам работать комфортно. Рекомендую не превышать длину строки в 80 - 100 символов. Всё таки приятно когда код читабельный и компактный. Далее. Придумайте название классу (к примеру WisdomBook), замените наследование вместо Object на Application. Создайте метод newWindow() и перенесите туда то что содержалось в конструкторе. Переименуйте конструктор согласно нового имени вашего Класса.

Теперь ваш конструктор должен содержать только вот такого рода строчку: Object(application_id: "org.valhalla.projects.myhandbookofwisdom"); где строковая переменная - это некоторое глобальное название для вашего приложения в системе. ваша функция main теперь должна одержать всего 2 строчки:
WisdomBook app = new WisdomBook();
return app.run(args);
Где вы ставите вместо WisdomBook своё название класса.

Последний шаг: Добавить метод activate
protected override void activate() {
this.newWindow();
}
И в методе newWindow необходимо добавить строчку: window.application = this; перед строчкой: window.show_all ();
Всё! все приготовления произведены. Ваше приложение готово впитывать вашу мудрость и превращаться в кусок прекрасного творения!

суббота, 23 августа 2014 г.

Возвращение Блудного Панды

Добрый день дорогие читатели. Прошу меня в очередной раз простить за настолько гигантский перерыв в публикациях. С одной стороны - это плохо. Я не описал подробно все интересные стороны языка. Однако, с другой стороны язык и технология приобрели очень сильные и даже крупные изменения в том как описывается программа. В данном скромном посте, я хотел бы показать вам профилирование 2 программ:
1. Vala с использованием Объектной Структуры
2. Наиболее примитивная программа на "чистом" C

Приложение SimpleExperiment1 - Это программа на Vala
Приложение SimpleExperiment2 - Это программа на C

Исходные файлы вы можете получить по этим ссылкам:
SimpleExperiment1.vala
SimpleExperiment2.с

Хочу заметить что обе программы были обрезаны с помощью утилиты strip Вот так выглядит приблизительное сравнение 2 программ:
Важно подметить что в производительности при минимальной нагрузке конечно же C программа выигрывает больше, чем программа на Vala. НО, так же важно заметить что возможности Vala увеличивают удобство создания программ и библиотек. Более, того, есть вероятность, что более сложные программы с более широкими возможностями - Vala будем иметь преимущество, за счёт удобства обслуживания. P.S. К чему я тут говорю о том что Vala может не быть столь эффективным?! - всё просто. Работая с любой технологией - вы должны понимать что есть и плохие и хорошие стороны у каждой технологии или языка программирования. Каждый из них выбирается исходя из целей и средств проекта.

четверг, 16 августа 2012 г.

Создание текстового просмотрщика (Встроенный)

Введение

Мы разберём один из важных, но не очень сложных примеров с официального сайта "Gnome", в котором показан пример создания Текстового просмотрщика, самого простейшего. Этот проект назовём "ГлупыйВаня" (SillyJohn)

Пример Кода

Сам код примера, после кода я объясню кратенько что, да как.

SillyJohn.vala

using Gtk;
public class SillyJohn : Window {

private TextView textView;

// Констурктор
public SillyJohn() {

// Заголово приложения
this.title = "Application to view text content";

// Размер по умолчанию
this.set_default_size(450, 450);

// Создаём объект "Панель инструментов"
var toolbar = new Toolbar();

// Указываем тип панели (Влияет на отображение)
toolbar.get_style_context().add_class(STYLE_CLASS_PRIMARY_TOOLBAR);

// Создаём кнопку на панели инструментов со свойствами из хранилища
var openButton = new ToolButton.from_stock(Stock.OPEN);
// Задаём параметр для кнопки, что кнопка важная и скрывать её нельзя
openButton.is_important = true;
// Добавляем кнопку на панель инструментов
toolbar.add(openButton);
// Присоединяем метод к событию "Щелчок"
openButton.clicked.connect(onOpenClicked);

// Создаём объект и помещаем его в поле класса
this.textView = new TextView();
// Устанавливаем запрет редактирования содержимого
this.textView.editable = false;
// Скрываем курсор
this.textView.cursor_visible = false;

// Создаём ячейку-прокрутку (необходимо для того чтобы если меняет размер ребёнка, появлялась полоса прокрутки)
var scroll = new ScrolledWindow(null, null);
// Задаём политику отображения полос прокрутки
scroll.set_policy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC);
// Добавляем элемент отображения текста в ячейку-прокрутку
scroll.add(this.textView);

// создаём вертикальный контейнер
var vbox = new Box(Orientation.VERTICAL, 0);
// Начинаем укладывать элементы с начала (сверху)
// Укладываем Панель инструментов
vbox.pack_start(toolbar, false, true, 0);
// Укладываем ячейку-прокрутку
vbox.pack_start(scroll, true, true, 0);
// А теперь контейнер в котором лежит всё укладываем в окно
this.add(vbox);
}

// Метод который будет вызван в ответ на событие "Щелчок"
private void onOpenClicked() {
// Создаём объект выбора файла
// Задаём ему параметры (Заголвок, Кто родитель объекта, Действие выбора файла, Кнопка 1 со свойствами из хранилища, Ответ кнопки 1 при нажатии, Кнопка 2 со свойствами из хранилища, Ответ кнопки 2 при нажатии)
var fileChooser = new FileChooserDialog("Open a document", this, FileChooserAction.OPEN, Stock.CANCEL, ResponseType.CANCEL, Stock.OPEN, ResponseType.ACCEPT);
// Запускаем выбор файла, при нажатии кнопки сранить возвращённый результат
if (fileChooser.run() == ResponseType.ACCEPT) {
// Если была нажата кнопка открыть, передаём имя файла в метод
this.openFile(fileChooser.get_filename());
}
// Уничтожаем окно выбора файла
fileChooser.destroy();
}

// Метод открытия файла
private void openFile(string filename) {
// Ставим ловушку на ошибку, в случае неверного файла
try {
string text;
// Получаем содержимое файла и выводим его в переменную text
FileUtils.get_contents(filename, out text);
// Загружаем полученное содержимое из переменной text в буфер объект-отображателя
this.textView.buffer.text = text;
} catch (Error e) {
// В случае возникновения ошибки - вывести сообщение в консоль об ошибке
stderr.printf("Error: %s\n", e.message);
}
}

public static int main(string[] args) {
Gtk.init(ref args);

var window = new SillyJohn();
window.destroy.connect(Gtk.main_quit);
window.show_all();
Gtk.main ();
return 0;
}
}


Разбор полётов

TextView - Это класс библиотеки Gtk.

Window - Это класс от которого мы наследуем наш класс SillyJohn, который нужен для создания окна.

Toolbar - Это класс для панели инструментов.

toolbar.get_style_context().add_class(STYLE_CLASS_PRIMARY_TOOLBAR); - Данная строчка говорит что необходимо взять объект который представляет стилевой контекст панели управления и добавляет к нему стилевой класс "STYLE_CLASS_PRIMARY_TOOLBAR" (Скорее всего эта строчка будет работать только с GTK+-3.0, дело в том что начиная с версии 3, графическая среда GTK использует CSS, для построения интерфейсов. И скорее всего здесь мы добавляем к объекту класс, буд-то работаем с DHTML (DOM-структурой)).

ToolButton - Это класс для кнопки панели инструментов.

from_stock(Stock.OPEN) - Этот именованный конструктор позволяет создать кнопку с предустановленными параметрами (текстом и иконкой), данные берутся общесистемные.

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

this.textView.editable = false; - задавая данный параметр как ложный, мы запрещаем изменять текст загруженный из файла в textView.

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

scroll.set_policy(PolicyType.AUTOMATIC, PolicyType.AUTOMATIC); - задаются параметры для прокрутки, 2 параметра автоматической прокрутки: для вертикальной и горизонтальной.

var vbox = new Box(Orientation.VERTICAL, 0); - В новых версиях GTK, имеется только один класс Коробок (Боксов), но он имеет параметры, быть ли ему вертикальным или горизонтальным, или решётчатым. Мы выбираем вертикальный

FileChooserDialog - Класс диалога выбора файлов

fileChooser.run() - Запускается окно, в данном месте произойдёт показ окна, и после того как пользователь нажмёт какую-нибудь кнопку, метод закончит выполнение и вернёт некоторый результат (В зависимости от кнопки, вернёт то что указывалось в конструкторе: ResponseType.CANCEL или ResponseType.ACCEPT)

this.openFile(fileChooser.get_filename()); - Передаём имя выбранного файла в метод openFile

fileChooser.destroy(); - уничтожается диалоговое-окно выбора файла (почему этим занимается не само окошко, а главное окно?!, это связанно с правилами ООП, следуя им, уничтожать объект должен тот же объект что его породил)

try - начало конструкции попытайся-поймай (try-catch), эта конструкция используется для вылавливания и выправления работы программы в местах где вероятнее всего может произойти ошибка, самый простой вариант - например если происходит деление на ноль, или пытаются открыть файл которого не существует, в этом случае конструкция try прекратит работу и тут же начнётся конструкция catch, в которой обычно выводится сообщение о том что произошла ошибка

FileUtils.get_contents(filename, out text); - Статический метод класса FileUtils (Который как вы могли догадаться занимается именно работой с файлами). В метод передаются 2 параметра, первый это имя файла, а второй передаётся с аннотацией (командой) "out". Данная команда скорее всего аналог использования в языке "C" указателей (&), это позволяет передать ссылку на память в области с которой нужно работать, следовательно позволяет вытащить результат из метода, без команды "return"

this.textView.buffer.text = text; - текст помещается в форму "textView" только через буфер, это связанно с особенностями структуры компонента.

stderr.printf("Error: %s\n", e.message); - вывод ошибки в консоль. Но вывод происходит не в потоке "stdout" - всё связанно с тем что для вывода ошибок имеется свой специальный поток "stderr", эта методика удобна, потому что сразу можно понять что является ошибкой критической, а что незначительным сообщением хода выполнения программы.

Умозаключения

Для компиляции программы нужно использовать пакет gtk+-3.0.
Компиляция: "valac --pkg gtk+-3.0 SillyJohn.vala"

суббота, 26 мая 2012 г.

Пре-выпуск про Vala + GTK3

Здравствуйте уважаемые читатели моего блога. Я к сожалению сильно подзатянул с новыми интересными статьями, однако в ближайшее время исправлюсь. у меня в ближайшие пару недель будет защита дипломной работы, поэтому максимум к концу июня я обновлю данные в старых статьях, а так же у меня уже набралось идей для новых статей. Более того, статьи будут посвящены разработке под GTK3. а учитывая что эта библиотека, по мему мнению, является весьма инновационной. то и разработка под неё будет интересной и даже захватывающей.
Уважаемые друзья, одно хочу подметить. мы часто встречаемся с некачественным софтом, и к сожалению он преобладает, даже в достаточно популярных и мощных системах. Поэтому я призываю вас, совместно с моим блогом участвовать в разработке "Правильного ПО". И вдруг вы увидели в моих постах ошибки, пожалуйста пишите мне об этом. Я придерживаюсь концепции что лучше сделать маленький малофункциональный код, но бессомненно стабильный, нежели писать громадный запарвленный функционалом код, но который, уж простите, работает как KDE, аль того хуже, словно виндовозный.
Все кто будет заинтересован, мои статьи и код распространяются под лицензией GPL3, поэтому будьте вольны в свободе использования моих классов, библиотек и информации публикуемой в статьях данного блога.
Всего вам доброго.

понедельник, 30 апреля 2012 г.

Уважаемые друзья, прошу прощения за длительную задержку, но скоро будет выпущена статья о работе с Vala + GTK3.

среда, 25 мая 2011 г.

Создание графической программы (Встроенный)

Введение

О библиотеках. Необходимой областью имён (namespace) будет Gtk. Для добавления нового пространства имён надо использовать команду "using".


Пример Кода

Сам код примера, после кода я объясню кратенько что, да как.

GUISimple1.vala

using Gtk;

public class GUISimple1 {
private static void action_function(Button source) {
// Задаём новое название кнопке
source.label = "Кнопка была нажата";
}

public static int main(string[] args) {
// Инициализация GTK
Gtk.init (ref args);

// Создание переменной-окна
var window = new Window(WindowType.TOPLEVEL);
// Задаём заголовок окна
window.title = "Программа, Програмочка моя";
// Задаём размер окна
window.set_default_size (300, 50);
// Задаём положение на экране
window.position = WindowPosition.CENTER;
// Эта строка задаёт выключение программы по нажати на "выход"
window.destroy.connect(Gtk.main_quit);

// Создаём переменную-кнопку
var button = new Button.with_label("Нажмите, Или не жмите... Как хотите :)");
// Задаём функцию, которая будет выполнятся по нажати на кнопку
button.clicked.connect(action_function);

// Вставляем кнопку в окно, важно: в один контейнер можно вставить только один объект
window.add(button);
// Показать окно
window.show_all();

// Цикл GTK
Gtk.main();

return 0;
}
}


Разбор полётов

using - Это команда добавления пространства имён, эквивалент в "Java" - "import".

Gtk - Это название пространства имён которое будет нам нужно для создания окон (Присоединение библиотеки Gtk+-3.0).

Button - Это название класса-кнопки.

Gtk.init (ref args) - Эта строка с функцией инициализацией библиотеки GTK. (Подготовка к использованию библиотеки GTK).

var window = new Window(WindowType.TOPLEVEL) - Эта строка создаёт переменную с окном (С самыми простыми параметрами).

window.destroy += Gtk.main_quit - Эта строка указывает - какая функция должна выполняться при событии "destroy" (Это событие происходит при закрытие окна). Здесь " += " - это специальный оператор который означает "подключение", то есть с помощью него вы указываете имя функции которую хотите использовать по происхождении сего события. Важно не писать скобочек после указания имени функции (Здесь происходит делегирование функции).

var button = new Button.with_label("Нажмите, Или не жмите... Как хотите :)") - Создание кнопки с названием.

window.add(button) - Вставляем созданную кнопку в окно

window.show_all() - Функция, при выполнении которой появляется окно.

Gtk.main() - Запуск основного цикла окна (Необходимо использовать как аксиому)


Умозаключения

Для компиляции программы нужно использовать пакет gtk+-3.0.
Компиляция: "valac --pkg gtk+-3.0 GUISimple1.vala"

суббота, 30 апреля 2011 г.

Резкое погружение

Введение

Здравствуйте, я очень вас прошу простить меня за сложность того примера который составил, и за малую долю разъяснений. Я рассчитываю что те кто будет рассматривать этот язык программирования, должен представлять себе что такое ООП (Объектно Ориентированное Программирование).


Пример Кода

Пример представляет из себя не оптимизированный, демонстрационный пример.

Сам код примера, после кода я объясню кратенько что, да как.

SimpleExample2.vala

namespace org {
namespace newnauka {
namespace examples {
public class SimpleExample2 {

private int property_x = 0;
private int property_y = 1;
private int property_z = 2;

public SimpleExample2.first(int x) {
this.property_x = x;
}

public SimpleExample2.second(int x, int y) {
this.property_x = x;
this.property_y = y;
}

public SimpleExample2.third(int x, int y, int z) {
this.property_x = x;
this.property_y = y;
this.property_z = z;
}

public int X {
get { return property_x; }
set { property_x = value; }
}
public int Y {
get { return property_y; }
set { property_y = value; }
}
public int Z {
get { return property_z; }
set { property_z = value; }
}

public int calculateALL() {
return X * Y * Z;
}

static int main(string[] args) {
SimpleExample2 example = new SimpleExample2.second(23, 54);
stdout.printf("Первый результат:\t%d\n", example.calculateALL());
example.Z = 100;
stdout.printf("Второй результат:\t%d\n", example.calculateALL());

return 0;
}
}
}
}
}


Разбор полётов

namespace - Это команда определения пространства Имён, эквивалент в "Java" - "Пакеты".

public class - Это две команды означающие что вы описываете "Класс", описываете его доступным для использования из вне Пространства Имён "org.newnauka.examples".

private и public - Это модификаторы доступа, если у вас private - то значит что только соседние методы смогут использовать такую конструкцию. Еже ли у вас стоит модификатор доступа public, это значит что эту конструкцию будет видеть кто угодно из любого пространства Имён.

public SimpleExample2.first - И подобные конструкции, это разного рода "Конструкторы", в отличии от "Java", здесь конструкторы должны отличаться друг от друга и по имени, Это важно. Их обычно делают по имени одинаковыми, но добавляют дополнительный определитель через точку.


Конструкция для задания правила "Чтение и Запись" свойству

public int X {
get { return property_x; }
set { property_x = value; }
}

Эта конструкция предназначена для задания правил для свойств, в "Java" они задавались с помощью специальных getter и setter методов, здесь это реализовано гораздо проще. Если Вы хотите чтобы ваше свойство было только "Читабельным", но не "Писабельным", то вам необходимо использовать такую конструкцию:


Конструкция для задания правила "Только для чтения" свойству

public int X {
get { return property_x; }
}


Это описание простейшего метода (Функции):


Пример простого метода

public int calculateALL() {
return X * Y * Z;
}


SimpleExample2 example = new SimpleExample2.second(23, 54); - Данная строчка создаёт объект типа "SimpleExample2" (Так у нас называется весь наш класс) ссылка на этот объект будет помещена в переменную "example". Заметьте что используется именно конструктор с пометкой "second", в этот конструктор нам необходимо передавать 2 аргумента (параметра), из-за того что мы его таковым описали в теле класса.

static - Это специальный модификатор означающий что наш метод (функция), в данному случае "main" не требует создание объекта, то есть этот метод можно использовать сразу при выполнении программы, так как "main" - это точка входа для программы, нам необходимо чтобы он был доступным с самого начала существования программы.


Умозаключения

Данный пример поможет более-менее понять суть программирования в классах под Vala. Этот пример сложен, однако, люди знакомые с ООП, не увидят здесь затруднительного материала.
Хочу напомнить, что синтаксис в Vala и идея построения используется языка "C#".
Эта сухая и неинтересная теория скоро сойдёт на нет, и следующие свои посты я уже буду писать в более интересном ключе.
Я постараюсь осветить вопросы:

  • Создания Графических программ (С внешним и Внутренним интерфейсом)
  • Работа с "Коллекциями"
  • Создание своих библиотек
  • Создание приложений сразу под Windows и Linux
  • Рисование на "Холсте"
  • Работа с БД