Gtk-Rust by Example (GRBE) представляет собой неофициальную книгу по разработке GTK GUI, на языке программирования Rust, которая будет демонстрировать практическое использование библиотеки GTK на различных примерах.
90 |Перед тем как начать, укажите версию библиотеки в вашем Cargo.toml файле:
[dependencies.gtk]
92 | version = "0.3.0"
93 | features = ["v3_22"]
94 | Gtk-Rust by Example (GRBE) представляет собой неофициальную книгу по разработке GTK GUI, на языке программирования Rust, которая будет демонстрировать практическое использование библиотеки GTK на различных примерах.
91 |Перед тем как начать, укажите версию библиотеки в вашем Cargo.toml файле:
[dependencies.gtk]
93 | version = "0.3.0"
94 | features = ["v3_22"]
95 | Если вы нажмёте на кнопку Ударить, счётчик должен уменьшиться и сообщение должно измениться. Нажатие по кнопке Лечить должно увеличить счётчик и также изменить сообщение.После запуска вашей программы с помощью cargo run, вы должны увидеть окно, которое выглядит так:
На этом этапе, вы должны хорошо понимать как работают: GtkBox, GtkButton и GtkLabel. Вы можете вернуться к предыдущему разделу, чтобы ещё раз уточнить некоторые моменты.
93 |There isn't much that you can do with just buttons and labels. If you want a practice challenge, try creating a program that displays a simple random math problem, and asks the user to use buttons to set the value. If they get it correct, modify a label to tell the user that what they entered was correct. This is an incredibly annoying interface design, so don't do this in the real world! 96 | Bonus: Timed Answers
97 |Do the same as the above, but also take advantage of gtk::timeout_add() to decrement and update a timer label within the UI until the timer reaches zero.
К данному времени у вас должно сложиться хорошее представление о том, как писать 92 | программы с использованием библиотеки GTK на Rust. К текущему моменту вы должны 93 | знать, как делать следующее:
94 |Хотя это и не связано с разработкой c использованием GTK, пакет horrorshow
91 | предоставляет удобные макроопределения, которые дают возможность эффективно
92 | генерировать HTML-строки в памяти, используя DSL (domain-specific language)
93 | совместно с Rust, который может быть запущен посредством использования символа
94 | (sigil) @.
122 | 123 |96 | # #![allow(unused_variables)] 97 | #fn main() { 98 | #[macro_use] 99 | extern crate horrorshow; 100 | use horrorshow::helper::doctype; 101 | 102 | let title = "Title"; 103 | let content = "A string\nwith multiple\n\nlines"; 104 | let html_string = format!( 105 | "{}", 106 | html!{ 107 | : doctype::HTML, 108 | html { 109 | head { 110 | style { : "#style { }" } 111 | } 112 | body { 113 | h1(id="style") { : title } 114 | @ for line in content.lines().filter(|x| !x.is_empty()) { 115 | p { : line } 116 | } 117 | } 118 | } 119 | } 120 | ); 121 | #}
92 |94 |Исходный код для этой главы находится здесь.
93 |
В данной главе вы начнете писать полезные программы, используя поля для ввода
95 | и просмотра текста, для того чтобы дать возможность пользователю вводить нужные
96 | значения в текстовые поля и генерировать выходные значения из введенных
97 | значений после нажатия на кнопку. В добавок вы познакомитесь с
98 | макроопределением html!, который находится внутри пакета horrorshow. Вы
99 | будете писать программу, которая принимает введенные значения на левой панели
100 | и генерирует HTML на правом поле для просмотра текста.
102 |107 | 108 |Обратите внимание на то что, что в данной главе мы не рассматриваем вопрос 103 | хранения данных во внешнем источнике, как это было в прошлой главе. Все состояние, 104 | которое нас интересует, находится внутри GTK объектов, с которыми мы будем 105 | взаимодействовать.
106 |
Мы реализуем несколько вспомогательных методов, которые при необходимости 91 | будут использоваться в проекте. Это две функции: одна для извлечения текста из 92 | GtkSourceBuffer, другая для установки названия у GtkHeaderBar с 93 | заданным Path.
94 |118 | 119 |95 | # #![allow(unused_variables)] 96 | #fn main() { 97 | use gtk::*; 98 | use sourceview::*; 99 | use std::path::Path; 100 | 101 | /// Присвоить заголовку в заголовочной панели ссылку на строковое 102 | /// представление пути к файлу. 103 | pub fn set_title(headerbar: &HeaderBar, path: &Path) { 104 | if let Some(filename) = path.file_name() { 105 | let filename: &str = &filename.to_string_lossy(); 106 | headerbar.set_title(filename); 107 | } 108 | } 109 | 110 | /// Получить все внутреннее содержимое данного текстового буфера в виде 111 | /// строки. 112 | pub fn get_buffer(buffer: &Buffer) -> Option<String> { 113 | let start = buffer.get_start_iter(); 114 | let end = buffer.get_end_iter(); 115 | buffer.get_text(&start, &end, true) 116 | } 117 | #}
4 |
5 | > Исходный код программы для этой главы можно найти [здесь](https://github.com/ruRust/gtk-rust-by-example/tree/master/src/source_code/hello_world).
6 |
7 | В этой главе мы создадим простое GTK приложение с панелью заголовка. Этот пример познакомит Вас с основами создания структуры приложения, которое будет содержать виджет и окно с заголовком.
8 |
9 | ## Создание структуры приложения
10 |
11 | Следующая диаграмма показывает, как мы будет проектировать структуру для нашего GTK приложения.
12 | Можно и не следовать этой диаграмме для достижения главного результата, однако, проектирование структуры пользовательского интерфейса может быть полезной пищей для ума.
13 |
14 | 
15 |
16 | В примере ниже, мы создадим структуру с **GtkWindow** и **Header**:
17 |
18 | ```rust
19 | extern crate gtk;
20 |
21 | use gtk::*;
22 |
23 | // Объявим структуру `Application`.
24 | pub struct Application {
25 | pub window: Window,
26 | pub header: Header,
27 | }
28 | ```
29 |
30 | **Header** - это еще одна структура, которая будет содержать **GtkHeaderbar** и все виджеты внутри этой панели заголовка.
31 |
32 | ```rust
33 | // Объявим структуру `Header`.
34 | pub struct Header {
35 | pub container: HeaderBar,
36 | }
37 | ```
38 |
39 | ## Создание пользовательского интерфейса (UI)
40 |
41 | Далее, мы создадим интерфейс с помощью Rust и расположим его в "ново-объявленных" структурах.
42 |
43 | Во-первых, структура нашего приложения будет содержать в себе все другие структуры нашего пользовательского интерфейса. В примере ниже находится код с комментариями, описывающие каждый метод, который мы будем использовать для конфигурации.
44 |
45 | Мы создадим **GtkWindow** и "присоединим" каждый элемент UI. Структура `Header` будет располагать в себе другие **GtkHeaderBar**. Далее, напишем функцию для выхода из приложения.
46 | Важно также установить описание для окна и `wmclass`, который будет отображаться оконными менеджерами, а с помощью функции `Window::set_default_icon_name()` настроим отображаемую иконку.
47 |
48 | ```rust
49 | // Блок реализации.
50 | impl Application {
51 | fn new() -> Application {
52 | // Создадим новое окно с типом `Toplevel`.
53 | let window = Window::new(WindowType::Toplevel);
54 | // Создадим панель заголовка и связанный с ним контент.
55 | let header = Header::new();
56 |
57 | // Укажем название заголовка виджета.
58 | window.set_titlebar(&header.container);
59 | // Укажем название для окна приложения.
60 | window.set_title("Простая программа");
61 | // Установим класс для оконного менеджера.
62 | window.set_wmclass("simple-gtk", "Простая программа");
63 | // Установим иконку, отображаемую приложением.
64 | Window::set_default_icon_name("имя_иконки");
65 |
66 | // Программа закроется, если нажата кнопка выхода.
67 | window.connect_delete_event(move |_, _| {
68 | main_quit();
69 | Inhibit(false)
70 | });
71 |
72 | // Возвращаем основное состояние приложения.
73 | Application { window, header }
74 | }
75 | }
76 | ```
77 | Здесь располагается блок реализации для структуры **Header**, которая на данный момент содержит только **GtkHeaderBar**. Важно указать описание для этой панели заголовка, чтобы она отображалась, а также сделать активными элементы управления окном, поскольку они отключены по-умолчанию.
78 |
79 | ```rust
80 | impl Header {
81 | fn new() -> Header {
82 | // Создадим виджет контейнера для главной панели заголовка.
83 | let container = HeaderBar::new();
84 | // Установим отображаемый тект в секции для названия.
85 | container.set_title("Simple GTK");
86 | // Делаем активными элементы управления окна в этой панели.
87 | container.set_show_close_button(true);
88 |
89 | // Возвращаем заголовок и его состояние.
90 | Header { container }
91 | }
92 | }
93 | ```
94 | ## Инициализация и запуск приложения
95 |
96 | Теперь, когда мы готовы, нам нужно просто инициализировать GTK, создать структуру приложения, показать все виджеты внутри этой структуры и запустить главный цикл событий GTK.
97 |
98 | ```rust
99 | fn main() {
100 | // Инициализация GTK.
101 | if gtk::init().is_err() {
102 | eprintln!("Не удалось инициализировать GTK приложение.");
103 | return;
104 | }
105 |
106 | // Инициализация начального состояния UI.
107 | let app = Application::new();
108 |
109 | // Делаем видимыми все виджеты с UI.
110 | app.window.show_all();
111 |
112 | // Запуск основного цикла GTK.
113 | gtk::main();
114 | }
115 | ```
116 |
117 | После того, как основной поток вошёл в цикл событий, он будет взаимодействовать с каждым вызванным виджетом для действий, например: метод `connect_delete_event()`, который мы использовали выше, чтобы запрограммировать кнопку выхода для закрытия программы.
118 |
119 | ## Результат
120 |
121 | После того, как вы написали код, соберите и запустите программу, которая выглядит вот так:
122 | ```bash
123 | cargo build && cargo run
124 | ```
125 |
126 |
127 |
--------------------------------------------------------------------------------
/src/pages/3/index.md:
--------------------------------------------------------------------------------
1 | # Боксирующие кнопки
2 |
3 |
4 |
5 | > Исходный код программы для этой главы можно найти [здесь](https://github.com/ruRust/gtk-rust-by-example/tree/master/src/source_code/button_boxer).
6 |
7 | В этом разделе мы рассмотрим, как структурировать ваш UI с помощью `упаковок` (box), изменять `метку` (label) и запрограммировать нажатие по кнопке. А также, к концу вы поймёте, как:
8 |
9 | 1. Добавлять дочерние элементы в панель заголовка;
10 | 2. Добавлять классы стилей к кнопке;
11 | 3. Управлять состоянием приложения с помощью атомарных счётчиков **Arc** и выравнивать виджеты внутри контейнера.
12 |
13 | > Напомним, что каждый GTK объект, который можно получить из контейнера **gtk** - заворачивают,
14 | > так что не стоит беспокоится о правилах заимствования Rust. Объекты GTK считают ссылки,
15 | > поэтому, когда вам нужно передать GTK объект через несколько замыканий, вы можете
16 | > сделать это с помощью клонирования новой ссылки.
17 |
18 | ## Необходимые знания
19 |
20 | Прежде чем продолжить изучение урока, убедитесь что вы понимаете что такое атомарность и атомарный счётчик ссылок (**Arc**). Эти понятия критически важны для возможности разделять состояние между несколькими замыканиями или потоками.
21 | Изучить этот вопрос можно в документации модулей `std::sync` и `std::sync::atomic`. Так же, вы можете ознакомиться с безблокировочной конкурентностью (lockless concurrency) [в этом документе](https://assets.bitbashing.io/papers/lockless.pdf).
22 |
--------------------------------------------------------------------------------
/src/pages/3/objects.md:
--------------------------------------------------------------------------------
1 | # Упаковки, кнопки и метки
2 |
3 | Цель этого раздела заключается в том, чтобы дать объяснение объектам, которые будут использованы до того, как мы применим их на практике в следующих разделах.
4 |
5 | ## GtkBox
6 |
7 | **GtkBox** является фактически эквивалентом UI вектора в Rust и должен быть объявлен с помощью **Orientation**, который определяет, что должны ли элементы быть выровнены слева направо или сверху вниз. Для тех, кто имеет опыт разработки с современным дизайном HTML5/CSS3, **GtkBox** эквивалентен гибким упаковкам -- они могут расширяться на всё пространство, а виджеты, содержащиеся внутри, тоже могут расширяться в соответствии с правилами, применяемыми при дочерней упаковке.
8 |
9 | ## Создание упаковки
10 |
11 | В следующем примере, мы создадим горизонтальную и вертикальную упаковку с нулевым отступом между дочерними элементами, содержащимися в упаковке. После создания упаковки, вы можете задать виджеты, используя метод `pack_*`.
12 |
13 | ```rust
14 | let padding_between_children = 0;
15 | let horizontal_box = Box::new(Orientation::Horizontal, padding_between_children);
16 | let vertical_box = Box::new(Orientation::Vertical, padding_between_children);
17 | ```
18 |
19 | ## Упаковка упаковки
20 |
21 | Вы могли заметить, что метод `pack_*` принимает большое количество параметров. Первым параметром должна быть ссылка на виджет, которую вы добавляете в контейнер. Вторым и третьим параметрами объявляют параметры заполнения соответственно. Последним параметром объявляют - как много единиц пространства должно быть между дочерними элементами в упаковке.
22 |
23 | > To further elaborate on the expand and fill parameters, expand defines whether the
24 | > given widget should attempt to use all of the extra space that it can. Each widget that has
25 | > the expand parameter set will equally share that extra space. Meanwhile, fill defines whether
26 | > the extra spaced should actually have that widget fill to cover that extra space, or should
27 | > merely use that extra space as padding.
28 |
29 | ```rust
30 | health_info.pack_start(&health_label, false, false, 5);
31 | health_info.pack_start(&health, true, true, 5);
32 | ```
33 |
34 |
35 | ## GtkLabel
36 |
37 | **GtkLabel** - это простой виджет, который состоит исключительно из текста. Название говорит само за себя. Всё, что вам нужно запомнить - это как создать метку (label) и изменить её.
38 |
39 | ```rust
40 | let information_label = Label::new("Specific Information: ");
41 | let value = Label::new("Linux");
42 | value.set_label("Redox");
43 |
44 | let horizontal_box = Box::new(Orientation::Horizontal, 5);
45 | horizontal_box.pack_start(&information_label, false, false, 0);
46 | horizontal_box.pack_start(&value, true, false, 0);
47 | ```
48 |
49 | ## GtkButton
50 |
51 | ### Создание кнопок
52 |
53 | **GtkButton** - это простая кнопка, содержащая текстовую метку (label) и/или изображения для представления действия, которое должно быть выполнено при нажатии кнопки.
54 |
55 | ```rust
56 | let text_button = Button::new_with_label("Ok");
57 | let image_button = Button::new_from_icon_name("имя-иконки", 32);
58 | ```
59 |
60 | ### Дизайн кнопок
61 |
62 | Виджеты в GTK можно оформить так, чтобы они отличались от других виджетов в пользовательском интерфейсе (UI). В частности, кнопки поддерживают два класса стилей: destructive-action и suggested-action. Если в вашем UI есть особенная кнопка, которая должна отличаться, вы можете установить её так:
63 |
64 | ```rust
65 | // Добавьте соответствующие классы стилей к этим кнопкам.
66 | delete_button.get_style_context().map(|c| c.add_class("destructive-action"));
67 | new_button.get_style_context().map(|c| c.add_class("suggested-action"));
68 | ```
69 |
70 | Каждый **GtkWidget** предоставляет метод **get_style_context()**, который возвращает
71 | **Option
6 |
7 | На этом этапе, вы должны хорошо понимать как работают: **GtkBox**, **GtkButton** и **GtkLabel**. Вы можете вернуться к предыдущему разделу, чтобы ещё раз уточнить некоторые моменты.
8 |
9 | ## Практическое занятие
10 | ### Setting Inputs w/ Buttons
11 |
12 | There isn't much that you can do with just buttons and labels. If you want a practice challenge, try creating a program that displays a simple random math problem, and asks the user to use buttons to set the value. If they get it correct, modify a label to tell the user that what they entered was correct. This is an incredibly annoying interface design, so don't do this in the real world!
13 | Bonus: Timed Answers
14 |
15 | Do the same as the above, but also take advantage of `gtk::timeout_add()` to decrement and update a timer label within the UI until the timer reaches zero.
--------------------------------------------------------------------------------
/src/pages/3/state.md:
--------------------------------------------------------------------------------
1 | # Сопровождение внешнего состояния
2 |
3 | В этой главе у нас будет некоторое состояние, которым мы будем управлять с помощью UI. Поэтому нам необходим способ хранения и загрузки значения из этого состояния. Программа, которую мы хотим написать, имеет один компонент: значение здоровья.
4 |
5 | Как оказалось, мы напрямую можем воспользоваться атомарными примитивами, таким как **AtomicUsize**, чтобы хранить значение для совместного использования нескольких неизменяемых замыканий. Этим атомарным значением можно управлять, не требуя изменяемого доступа к внутреннему значению. Таким образом, мы можем передавать неизменяемые ссылки на это значение и изменять его даже когда оно уже одолжено в нескольких местах одновременно.
6 |
7 | ```rust
8 | pub struct HealthComponent(AtomicUsize);
9 | ```
10 |
11 | Пока мы здесь, можем продолжить и написать некоторую логику для этой структуры в блоке реализации, используя следующие методы для здоровья:`initializing`,`subtracting` и `healing`.
12 |
13 | ```rust
14 | impl HealthComponent {
15 | fn new(initial: usize) -> HealthComponent { HealthComponent(AtomicUsize::new(initial)) }
16 |
17 | fn get_health(&self) -> usize { self.0.load(Ordering::SeqCst) }
18 |
19 | fn subtract(&self, value: usize) -> usize {
20 | let current = self.0.load(Ordering::SeqCst);
21 | let new = if current < value { 0 } else { current - value };
22 | self.0.store(new, Ordering::SeqCst);
23 | new
24 | }
25 |
26 | fn heal(&self, value: usize) -> usize {
27 | let original = self.0.fetch_add(value, Ordering::SeqCst);
28 | original + value
29 | }
30 | }
31 | ```
32 |
--------------------------------------------------------------------------------
/src/pages/3/ui.md:
--------------------------------------------------------------------------------
1 | # Создание структуры пользовательского интерфейса (UI)
2 |
3 | Используя структуру предыдущей главы в качестве образца, мы можем расширить её, чтобы включить новые элементы UI, которые будем использовать в нашей программе. Важно отметить, что необходимо хранить только те элементы, которые вы собираетесь запрограммировать позже, после создания структуры UI.
4 |
5 | В этой программе мы добавим два виджета **GtkButtons** к панели заголовка и воспользуемся вертикальным и горизонтальным элементом **GtkBox** с некоторыми метками (labels), чтобы отобразить информацию о текущем состоянии нашего приложения. Следующее изображение является нашей новой диаграммой структур.
6 |
7 | 
8 |
9 | Что означает следующее в Rust:
10 |
11 | ```rust
12 | pub struct App {
13 | pub window: Window,
14 | pub header: Header,
15 | pub content: Content,
16 | }
17 |
18 | pub struct Header {
19 | pub container: HeaderBar,
20 | pub hit: Button,
21 | pub heal: Button,
22 | }
23 |
24 | pub struct Content {
25 | pub container: Box,
26 | pub health: Label,
27 | pub message: Label,
28 | }
29 | ```
30 |
31 | ## Создание структуры App
32 |
33 | Следуя последнему уроку, начнём с нашей структуры **App**. Метод **new()** должен принимать ссылку на **&HealthComponent** в качестве вводимого значения в UI. Заметим, что мы добавили новую переменную **content** типа **Context**, которая принимает эту ссылку на health.
34 |
35 | ```rust
36 | impl App {
37 | fn new(health: &HealthComponent) -> App {
38 | // Создадим новое окно с типом `Toplevel`.
39 | let window = Window::new(WindowType::Toplevel);
40 | // Создадим заголовок и связанное с ним содержимое.
41 | let header = Header::new();
42 | // Расположим содержимое в окне.
43 | let content = Content::new(health);
44 |
45 | // Установим панель заголовка как описание виджета.
46 | window.set_titlebar(&header.container);
47 | // Установим описание для окна.
48 | window.set_title("Боксирующие кнопки");
49 | // Установим класс для оконного менеджера.
50 | window.set_wmclass("app-name", "Боксирующие кнопки");
51 | // Установим иконку, отображаемую приложением.
52 | Window::set_default_icon_name("имя-иконки");
53 | // Добавим коробку с содержимым в окно.
54 | window.add(&content.container);
55 |
56 | // Запрограммируем выход из программы при нажатии кнопки.
57 | window.connect_delete_event(move |_, _| {
58 | main_quit();
59 | Inhibit(false)
60 | });
61 |
62 | // Вернём состояние нашего приложения.
63 | App {
64 | window,
65 | header,
66 | content,
67 | }
68 | }
69 | }
70 | ```
71 |
72 | ## Создание Header
73 |
74 | Затем мы так же реализуем метод для нашего заголовка, который должен содержать два элемента **GtkButtons** -- кнопка удара и лечения. Также обратите внимание, что мы устанавливаем некоторые классы стилей этим кнопкам, чтобы дать им более информативную визуальную способность.
75 |
76 | ```rust
77 | impl Header {
78 | fn new() -> Header {
79 | // Создадим главный заголовочный бар содержащий виджет.
80 | let container = HeaderBar::new();
81 |
82 | // Установим текст для отображения в секции для названия.
83 | container.set_title("Боксирующие кнопки");
84 | // Сделаем активными элементы управления окна в этой панели.
85 | container.set_show_close_button(true);
86 |
87 | // Создадим кнопки: `ударить` и `лечить`.
88 | let hit = Button::new_with_label("Ударить");
89 | let heal = Button::new_with_label("Лечить");
90 |
91 | // Добавим соответствующие классы стилей к этим кнопкам.
92 | hit.get_style_context()
93 | .map(|c| c.add_class("destructive-action"));
94 | heal.get_style_context()
95 | .map(|c| c.add_class("suggested-action"));
96 |
97 | // Теперь добавим их в панель заголовка.
98 | container.pack_start(&hit);
99 | container.pack_end(&heal);
100 |
101 | // Вернём the header and all of it's state
102 | Header {
103 | container,
104 | hit,
105 | heal,
106 | }
107 | }
108 | }
109 | ```
110 |
111 | ## Создание Content
112 |
113 | Теперь пришло время создать содержимое для нашего окна. При создании своего интерфейса (UI) с древовидной диаграммой, вы почти достигните **GtkBoxes**. При инициализации, эта упаковка должна быть указана с **Horizontal** или **Vertical** ориентацией.
114 |
115 | Безусловно, вы достигните виджета **GtkBoxes** для настройки UI. Он может быть создан с **Horizontal** или **Vertical** выравниванием. В эти упаковки вы добавите все ваши виджеты, где они будут сложены в соответствии с выравниванием упаковки, к которой они присоединены.
116 |
117 | Мы должны создать вертикальную упаковку, которая содержит два дочерних элемента: вертикальный виджет **GtkBox** содержащий метку и значение, а затем ниже простой виджет **GtkLabel**.
118 |
119 | ```rust
120 | impl Content {
121 | fn new(health: &HealthComponent) -> Content {
122 | // Создадим вертикальную упаковку, чтобы хранить там все дочерние элементы.
123 | let container = Box::new(Orientation::Vertical, 0);
124 |
125 | // Информация о здоровье будет храниться в горизонтальной упаковке вместе с вертикальной.
126 | let health_info = Box::new(Orientation::Horizontal, 0);
127 | let health_label = Label::new("Текущее значение здоровья:");
128 | let health = Label::new(health.get_health().to_string().as_str());
129 |
130 | // Установим горизонтальное выравнивание для наших объектов.
131 | health_info.set_halign(Align::Center);
132 | health_label.set_halign(Align::Start);
133 | health.set_halign(Align::Start);
134 |
135 | // Добивим информацию о здоровье в дочернюю коробку.
136 | health_info.pack_start(&health_label, false, false, 5);
137 | health_info.pack_start(&health, true, true, 5);
138 |
139 | /*
140 | * Создадим метку, которая будет изменяться приложением
141 | * при выполнении удара или лечения.
142 | */
143 | let message = Label::new("Привет");
144 |
145 | // Добавим все в нашу вертикальную коробку.
146 | container.pack_start(&health_info, true, false, 0);
147 | container.pack_start(&Separator::new(Orientation::Horizontal), false, false, 0);
148 | container.pack_start(&message, true, false, 0);
149 |
150 | Content {
151 | container,
152 | health,
153 | message,
154 | }
155 | }
156 | }
157 | ```
158 |
159 | ### Устанавливаем выравнивание
160 |
161 | Возможно, вы заметили, что приведённый код выше устанавливает горизонтальные выравнивания.
162 | По желанию, с помощью методов `set_halign()` и `set_valign()`, можно установить выравнивание для виджетов.
163 |
164 | ```rust
165 | // Установим горизонтальное выравнивание для наших объектов.
166 | health_info.set_halign(Align::Center);
167 | health_label.set_halign(Align::Start);
168 | health.set_halign(Align::Start);
169 | ```
--------------------------------------------------------------------------------
/src/pages/4/concl.md:
--------------------------------------------------------------------------------
1 | Заключение и обзор
2 | ==========
3 | 
4 |
5 | К данному времени у вас должно сложиться хорошее представление о том, как писать
6 | программы с использованием библиотеки GTK на Rust. К текущему моменту вы должны
7 | знать, как делать следующее:
8 | - создавать, получать, присваивать значения объектам **Label**
9 | - создавать, получать, присваивать значения объектам **Entries**
10 | - создавать, получать, присваивать значения объектам **TextBuffer**
11 | - создавать, присваивать буферы объектам **TextViews**
12 | - создавать, настраивать стили внешнего вида, программировать объекты **Button**
13 | - присваивать элементы объектам **Box** и контейнерам **Paned**
14 | - устанавливать отступы и поля на виджетах
15 | - работать с внешним состоянием
16 |
17 | ## Практические задачи
--------------------------------------------------------------------------------
/src/pages/4/entries.md:
--------------------------------------------------------------------------------
1 | # Поля, панели, прокручиваемые окна и просмотр текста
2 |
3 | ## GtkPaned
4 |
5 | Это контейнеры, которые могут быть ориентированы вертикально или горизонтально,
6 | представляют собой два элемента, размер которых может изменяться.
7 | Размер этих двух элементов может быть изменен простым нажатием и перемещением
8 | разделяющей полосы между ними.
9 |
10 | ```rust
11 | let container = Paned::new(Orientation::Horizontal);
12 | let left_widget = ...;
13 | let right_widget = ...;
14 | container.pack1(&left_widget, true, true);
15 | container.pack2(&right_widget, true, true);
16 | ```
17 |
18 | ## GtkEntry
19 | Элементы позволяют пользовательскому интерфейсу принимать строку текста как
20 | входное значение, что может быть использовано другими виджетами для выполнения
21 | некоторых действий, используя данный текст как входные данные.
22 | ```rust
23 | let entry = Entry::new();
24 | entry.set_text("Some Text");
25 | if let Some(text) = entry.get_text() {
26 | println!("{}", text);
27 | }
28 | ```
29 | ## GtkTextView
30 |
31 | Текстовые панели нужны для двух вещей:
32 | - способность показывать многострочный текст
33 | - возможность пользователю вводить многострочный текст
34 | Текстовая панель может быть настроена так, что ее содержимое нельзя
35 | редактировать, если есть такая необходимость. Также есть возможность
36 | настраивать работу с переносами текста. Текстовые панели не умеют работать
37 | с форматированным текстом, однако вполне могут быть использованы как
38 | редактор кода. Если вы хотите, чтобы текст был показан в виде HTML, смотрите
39 | **GtkWebView**, если же вы хотите получить редактор кода, смотрите
40 | **GtkSourceView**.
41 |
42 | > Заметьте, что часто бывает лучше создать и привязать **GtkTextBuffer**
43 | к вашему текстовому полю вручную, чтобы получить указатель на буфер,
44 | который вы можете хранить, и избежать непрямого обращения, когда вы
45 | программируете ваш пользовательский интерфейс (UI). Имея указатель на буфер,
46 | можно легко получить доступ к тексту, который содержится в текстовой панели.
47 |
48 | ```rust
49 | // Буфер для текстовой панели с None в качестве параметра, потому что мы не
50 | // собираемся определять никаких текстовых тэгов для этого буфера.
51 | let text_buffer = TextBuffer::new(None);
52 | // После этого мы должны присвоить буфер новой текстовой панели, которая будет
53 | // самостоятельно обновлять себя при добавлении или удалении текста из буфера.
54 | let text_view = TextView::new_with_buffer(&text_buffer);
55 | ```
56 |
57 | Извлечение текста из **GtkTextBuffer** требует некоторой сноровки, так что
58 | мы привели пример функции, которую вы можете использовать для того, чтобы
59 | получить содержимое буфера в виде строки (String). Вы можете указать
60 | определенный участок текста, который будет извлечен из буфера.
61 | ```rust
62 | /// Получить все содержимое буфера в строковом представлении.
63 | fn get_buffer(buffer: &TextBuffer) -> Option