Сразу оговорюсь, что C++ мой любимый язык, я на нем пишу практически «с детства» и отрицать его важность, как лучшего одного из лучших языков для написания программ для любых целей, не буду. Тем более не вижу смысла начинать очередной холивар или меряться «указками». Это статья - лишь описание неудачного опыта работы с языком, объясняющая некоторые его аспекты, знание которых поможет другим программистам в будущем.

Однажды я столкнулся с развивающейся библиотекой GUI класса. С точки зрения C++, а точнее его классов, экземпляров и иерархий, этот язык представляется невероятно близким к концепции управления GUI, в частности таким элементам, как виджеты, окна классов и подокна. OO модели C++ и оконной системы тем не менее разные. C++ был задуман как «статический» язык с охватом лексем, статической проверкой типов и иерархий определенных во время компиляции. Окна и их объекты с другой стороны, по своей природе динамичны, они обычно живут за рамкам отдельной процедуры или блока, с помощью которой были созданы; иерархии виджетов в значительной степени определены расположением, видимостью и потоками событий. Основы графического пользовательского интерфейса, такие как динамические и геометрические иерархии окон и управления, протекания событий, не поддерживаются непосредственно синтаксисом С++ либо его семантикой. Таким образом, эти функции должны быть воспроизведены в коде C++ GUI. Это приводит к дублированию графического инструментария, или функциональности оконного менеджера, код «раздувается», мы вынуждены отказываться от многих «сильных» особенностей C++ (например, проверки типов во время компиляции). В статье приведено несколько простых примеров C++ / GUI «не стыковок».

Не создавайте конструкторы (или, по крайней мере, не используйте их)

Когда полученный класс переопределяет виртуальный метод родительского класса, надо иметь в виду, что переопределение не вступает в силу, пока конструктор базового класса выполняется. Это особенно раздражает, когда объекты запрашивают виджеты, которые реагируют на события GUI. Предположим, что класс Basic_Window был предназначен для создания ванильного черно-белого окна на экране:

Class Basic_Window {
public:
Basic_Window(Rect rect) { gt_create_window(rect,visible,this); }
virtual void handle_create_event() { set_background(WHITE); }
};

Здесь gt_create_window() отвечает за низкоуровневый вызов основного графического инструментария (например, xvt_win_create() ). Эта функция выделяет место под данные инструментария, уведомляет оконный менеджер, регистрирует этот объект, как получателя событий, и в примере выше, инициализирует графический вывод в окно на экране.
Предположим, мы хотим создать экземпляр Basic_Window , но с красным фоном. Обычно, чтобы изменить поведение класса, надо извлечь из него и переопределить соответствующие виртуальные методы. Мы пишем:

Class RedWindow: public Basic_Window {
virtual void handle_create_event() { set_background(RED); }
public:
RedWindow(Rect rect) : Basic_Window(Rect rect) {}
};
RedWindow red_window(default_rect);

Но red_window появится белым, а не красным! Чтобы создать RedWindow , родительский объект должен быть создан первым. После завершения Basic_Window::Basic_Window() , виртуальные таблицы RedWindow вступают в силу, метод handle_create_event() становится неприменимым, и конструктор RedWindow() выполняется. Конструктор Basic_Window() регистрирует объект графического инструментария, который мгновенно начинает посылать события объекту (например, CREATE-событие). Конструктор Basic_Window() еще не закончен (это не гарантировано), поэтому переопределенный виртуальный метод еще не на месте. Таким образом, CREATE-событие будет обрабатываться Basic_Window::handle_create_event() . Виртуальные таблицы RedWindow класса будут созданы лишь тогда, когда базовый класс полностью построен, то есть, когда окно уже на экране. Изменение цвета окна на данном этапе приведет к досадной ошибке.

Есть простой обходной путь: запретить каждому конструктору регистрировать объект графического инструментария. Обработка событий будет построена таким образом, чтобы сдержать окончание инициализации до производных классов. Очень заманчиво рассматривать виджеты на экране, как «лицо» объекта GUI приложения в памяти. Как показывает приведенный выше пример, эта связь между экраном и C++ объектом реализовать не так просто: они рождаются отдельно.

Нет синтаксических средств переключения событий

Предположим, что библиотека классов включает в себя графический интерфейс класса PictWindow , который отображает фотографию в окно:

Class PictWindow {
Picture picture;
public:
virtual void repaint() { gt_draw_pict(picture); }
...
};

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

Rect rect;
virtual void repaint() { gt_draw_rect(rect); }
};

К сожалению, когда мы создадим экземпляр OvWindow , то увидим только прямоугольник в пустом окно, и никакого изображения. С того момента, как OvWindow::repaint() переопределяет PictWindow::repaint() , последняя функция не будет вызываться, когда окно должно быть отрисовано. Мы должны были реализовать OvWindow так:

Class OvWindow: public PictWindow {
Rect rect;
virtual void repaint() { PictWindow::repaint(); gt_draw_rect(rect); }
public:
OvWindow(void) : PictWindow() {}
};

Конструктор OvWindow изложен, чтобы подчеркнуть, что метод OvWindow::repaint() должен быть отложен до суперкласса, как делают конструкторы. В самом деле, конструктор производного объекта с начала вызывает конструктор корреспондирующего объекта. repaint() следует отложить его родитель: методу в базовом классе, который его переопределяет.

В итоге: Плохая совместимость C++ / GUI

C++ был разработан как «статический» язык:

• с отслеживанием лексем
• проверкой статических типов
• со статическими иерархиями классов
• без «сборки мусора»
• с системой сообщений без определенных иерархий времени компиляции

GUI объекты:

• характерны динамические объекты, а зачастую и единственные в своем роде
• как правило, живут далеко за рамками, в которых они были созданы
• иерархии определяются в значительной степени потоками событий и их расположением, а не наследованием классов
• иерархии строятся и разрушаются во время выполнения, зачастую в ответ на непредсказуемые действия пользователя

C + + не предназначен для поддержки динамической защиты обмена сообщениями и передачами (кроме исключений). Все это приводит к дублированию графического инструментария и функциональности оконного менеджера, разрастанию кода, использованию небезопасных функций и отказ от многих сильных сторон C++.

Выводы

Конечно, все эти «коряги» не являются фатальными. C++ является универсальным и мощным языком и, следовательно, способен выразить все возможные алгоритмы расчета. Поэтому, если приложение требует динамических функций, таких как те, что есть в Tcl / Tk , Scheme / Tk , Postscript и подобных; используя C++, Вы всегда можете сделать что-то по их примеру. С другой стороны, почему бы не использовать язык, где все эти черты присутствуют?

Всем здрасте. В своих прошлых уроках я рассказывал о создании консольных приложений в среде Borland C++ Builder. Начиная с этого урока мы будем изучать C++ на примере графических приложений. Кто хочет научится создавать консолки. Может прочитать книгу "Исскуство создания консольных приложений на C++". Первое наше приложение будет программа которая выводит случайное число. Открываем борландяю, только не создаем консольное приложение. После запуска на экране высвятится форма:

Сверху будет панель иснструментов:

Справа Инспектор Объектов и Список Форм:

Компоненты (в отличии от бейсика) уже разделены на вкладки. По названию не трудно догадаться компоненты какого типа размещены на вкладке. Откройте вкладку standart и разместите компоненты на форме как у меня:

На кнопке будет надпись Button1. Ее надо изменить. В нижнем левом окне борляндии приведены свойства компомнентов их надо изменить на наши:

У кнопки Caption (Надпись) меняем на Сгенерировать

У метки Label1 свойство Caption меняем на Число

В Edit1 свойство Text (текст в самом едите) просто сотрем.

После этих манипуляций форма будет похожа на мою:

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

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

Сегодня быдем пользоваться только событием Click. Жмем два раза на кнопку и поподаем в окно кода:

Автоматически создалось событие Click для кнопки. Код как и консольном приложении размещается между фигурными скобками. Пишем код:

Void __fastcall TForm1::Button1Click(TObject *Sender) { double aaa; //Сюда поместим число сегенерированное процессором String count; //Запишем это же число, но приведенное к строчному виду randomize; //Это нужно чтобы числа не повторялись aaa=random(34)*43646; //Генерируем любое число count=FloatToStr (aaa); //Переводим число в строку c помощью функции FloatToString Edit1->Text=count; //Выводим в текстовое окно строковую переменную }

Алгоритм простой, мы объявляем переменную для храненения в ней дробного числа, и переменную для числа в строковом виде. Дело в том, что сразу сгенерированное чилсо нельзя вывести в текстбокс (будет ошибка Ожидался текст а получено число), поэтому с помощью функции FloatToStr мы переводим число в строку и выводим ее в текстовое окно. Для вывода обращаемся(с помощью знака -> (аналогично точке в vb)) к свойству текст Edit1 и выводим туда текст. Вот пока все.

Кстати вопрос на засыпку: кто размножается быстрее компьютерные вирусы, китайцы, или кролики?

Комментарии ()

Vitay

артёмка

"randomize; //Это нужно чтобы числа не повторялись." У меня все равно повторяются. че делать?

Андрей

Есть 2 варианта 1-использовать "randomize();" или в строке 6 усложнить функцию напр. прибавлять еще и число секун

Андрей

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

артёмка Алексей(alex13sh)

randomize
это что бы числа не повторялись при включение програмы
ну то есть. включил прогу жмёшь кнопку несколько раз
1)5
2)47
3)86
это я целыми числами
ну и если выключишь прогу и заного включишь при серийного нажатие кнопки будет теже самые числа с тойжей последованостей
это без randomize а сним такого небудет

А то что повторяются таким образом
1)3
2)69
3)1
4)3
5)8
6)1
ЭТО НЕ ОТНОСИТСЯ К randomize
чтобы такого избежать Андрей уже ответил))

Begzod

у меня на компе visual c++.net . Не могу найти учебники,исходники по нему. Помогите пжс.

Ali05

Видел в книжном магазине учебник по Visual C++.Net "Никита Культин Основы программирования в Microsoft Visual C++ 2010", там как раз показано, как создавать графические приложения под Windows (WinForms).

Кулхацкер Нинтендо

интересно, в чем же заключается его "плохость" ?

Кулхацкер

В отсутствии умения нормально излагать материал и приучении вас, господ, к плохому стилю программирования, а-ля имена переменных/функций транслитом.

Edward Кулхацкер

Министерство образования и науки Российской Федерации

Федеральное государственное бюджетное образовательное учреждение

высшего профессионального образования

«УФИМСКИЙ ГОСУДАРСТВЕННЫЙ НЕФТЯНОЙ

ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ»

Кафедра вычислительной техники и инженерной кибернетики

Создание приложения c графическим интерфейсом пользователя в среде microsoft visual studio 2010

Учебно-методическое пособие

для проведения лабораторных и практических занятий

со студентами направления

230100 (09.03.01) «Информатика и вычислительная техника»

В учебно-методическом пособии приведены теоретические сведения, задания для практических и лабораторных работ курса «Программирование».

Пособие адресовано преподавателям дисциплины, а так же студентам направления: 230100 «Информатика и вычислительная техника».

Составители: Габдуллина А.А., ст. преподаватель каф. ВТИК

Дружинская Е.В., ст. преподаватель каф. ВТИК

Рецензент: Филиппов В.Н., к.т.н., доцент каф. ВТИК.

1.Теоретические сведения 4

1.1. Основные понятия 4

1.2. Знакомство с приложением Windows Form в Microsoft Visual Studio 2010 4

1.3. Элемент управления Form 7

1.5. Функция MessageBox 9

1.6. Элемент управления TextBox 10

2.Практическое задание. Знакомство с приложением Windows Form в Microsoft Visual Studio 2010 12

2.1. Структура оценивания выполненной работы 12

2.2. Порядок выполнения практической работы 12

3.Лабораторная работа. Разработка приложений в среде Microsoft Visual Studio 2010 16

3.1. Порядок выполнения лабораторной работы 16

3.2. Задание 1. Табулирование функции и вычисление её значений в указанном интервале с заданным шагом 16

3.3. Индивидуальные задания 19

3.4. Задание 2. Обработка двумерных массивов 21

3.5. Индивидуальные задания 27

1. Теоретические сведения

1. 1.1. Основные понятия

Автоматизация информационных процессов в настоящее время представляется, в первую очередь, разработкой программного приложения с графическим интерфейсом пользователя (GUI), управляющего потоками данных.

Графический интерфейс пользователя (Graphical User Interface, GUI) это система средств для взаимодействия пользователя с устройством, основанная на представлении всех доступных пользователю системных объектов и функций в виде графических компонентов экрана (окон, кнопок, полос прокрутки и т. п.).

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

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

Поддерживать информационную технологию работы пользователя с программным продуктом;

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

Удовлетворять принципу «шести», когда в одну линейку меню включают не более 6 понятий, каждое из которых содержит не более 6 опций;

сохранять стандартизованное назначение графических объектов и, по возможности, их местоположение на экране.

В объектно-ориентированном программировании мы имеем дело с классами и объектами. Объекты – это составные типы данных: они объединяют несколько значений в единый модуль и позволяют нам записывать и сохранять эти значения по имени. Другими словами, объект – это неупорядоченная коллекция свойств, каждое из которых имеет имя и значение. Именованные значения, содержащиеся в объекте, могут быть как элементарными типами, например числами или строками, так и другими объектами.

При разработке не консольных приложений, основным понятием является Форма.

Форма – это контейнер для размещения элементов управления среды разработки.

Свойства – возможность получения доступа к информации, которая хранится в этом элементе.

Методами называют набор действий, которые может совершать объект.

Событие – действие, распознаваемое объектом (например, щелчок мышью, нажатие клавиши), для которого можно запрограммировать отклик, т.е. реакцию объекта на произошедшее событие.

Последнее обновление: 26.05.2019

В Xamarin.Forms визуальный интерфейс состоит из страниц. Страница представляет собой объект класса Page , она занимает все пространство экрана. То есть то, что мы видим на экране мобильного устройства - это страница. Приложение может иметь одну или несколько страниц.

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

Возьмем созданный в прошлой теме проект HelloApp (или создадим новый). По умолчанию весь интерфейс создается в классе App, который располагается в файле App.xaml.cs и который представляет текущее приложение:

Его код по умолчанию:

Using System; using Xamarin.Forms; using Xamarin.Forms.Xaml; namespace HelloApp { public partial class App: Application { public App() { InitializeComponent(); MainPage = new MainPage(); } protected override void OnStart() { // Handle when your app starts } protected override void OnSleep() { // Handle when your app sleeps } protected override void OnResume() { // Handle when your app resumes } } }

Работа класса App начинается с конструктора, где сначала вызывается метод InitializeComponent() , который выполняет инициализацию объекта, а потом устанавливается свойство MainPage . Через это свойство класс App устанавливает главную страницу приложения. В данном случае она определяется классом HelloApp.MainPage, то есть тем классом, который определен в файлах MainPage.xaml и MainPage.xaml.cs.

Но данный путь не единственный. Xamarin.Forms позволяет создавать визуальный интерфейс как с помощью кода C#, так и декларативным путем с помощью языка xaml, аналогично html, либо комбинируя эти подходы.

Создание интерфейса из кода C#

Добавим в проект HelloApp обычный класс на языке C#, который назовем StartPage .

И определим в этом классе следующее содержимое:

Using Xamarin.Forms; namespace HelloApp { class StartPage: ContentPage { public StartPage() { Label header = new Label() { Text = "Привет из Xamarin Forms" }; this.Content = header; } } }

Данный класс представляет страницу, поэтому наследуется от класса ContentPage . В конструкторе создается метка с текстом, которая задается в качестве содержимого страницы (this.Content = header).

Чтобы обозначить MainPage в качестве стартовой страницы, изменим класс App:

Using Xamarin.Forms; namespace HelloApp { public partial class App: Application { public App() { InitializeComponent(); MainPage = new StartPage(); } protected override void OnStart() { // Handle when your app starts } protected override void OnSleep() { // Handle when your app sleeps } protected override void OnResume() { // Handle when your app resumes } } }

Теперь свойство MainPage указывает на только что созданную страницу StartPage.

Также стоит отметить, что в Visual Studio есть готовый шаблон для добавления новых классов страниц с простейшим кодом. Так, чтобы добавить новую страницу, надо при добавлении нового элемента выбрать шаблон Content Page (C#) :

Данный класс добавляется в главный проект решения (в данном случае это HelloApp).

Добавленный класс страницы будет иметь следующий код:

Using System; using System.Collections.Generic; using System.Linq; using System.Reflection.Emit; using System.Text; using Xamarin.Forms; namespace HelloApp { public class Page1: ContentPage { public Page1() { Content = new StackLayout { Children = { new Label { Text = "Hello Page" } } }; } } }

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

И также в классе приложения мы можем установить эту страницу в качестве стартовой:

Using Xamarin.Forms; namespace HelloApp { public partial class App: Application { public App() { InitializeComponent(); MainPage = new Page1(); } //........... } }

1.1. Hello, Qt!

Ниже приводится текст простейшей Qt программы:

1 #include 2 #include 3 int main(int argc, char *argv) 4 { 5 QApplication app(argc, argv); 6 QLabel *label = new QLabel("Hello, Qt!", 0); 7 app.setMainWidget(label); 8 label->show(); 9 return app.exec(); 10 } Здесь, в строках 1 и 2, подключаются определения классов QApplication и QLabel .

В строке 5 создается экземпляр класса QApplication , который управляет ресурсами приложения. Конструктору QApplication передаются аргументы argc и argv , поскольку Qt имеет возможность обрабатывать аргументы командной строки.

В строке 6 создается визуальный компонент QLabel , который отображает надпись "Hello, Qt!". В терминологии Qt, все визуальные компоненты, из которых строится графический интерфейс, называются виджетами (widgets). Кнопки, меню, полосы прокрутки и разнообразные рамки -- все это виджеты. Одни виджеты могут содержать в себе другие виджеты, например, главное окно приложения -- это самый обычный виджет, который может содержать QMenuBar , QToolBar , QStatusBar и др. Аргумент 0, передаваемый конструктору QLabel (в строке 6) -- это "пустой" (null) указатель, который сообщает о том, что этот виджет не имеет "хозяина", т.е. не включается в другой виджет.

В строке 7 назначается "главный" виджет приложения. Когда пользователь закрывает "главный" виджет приложения (например, нажатием на кнопку "X" в заголовке окна), то программа завершает свою работу. Если в программе не назначить главный виджет, то она продолжит исполнение в фоновом режиме даже после того, как пользователь закроет окно.

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

В строке 9 выполняется передача управления библиотеке Qt. С этого момента программа переходит в режим ожидания, когда она ничего не делает, а просто ждет действий пользователя, например, нажатие на клавишу или кнопку мыши.

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

Рисунок 1.1. Окно приложения в Windows XP

Теперь самое время проверить работу нашего приложения. Но прежде всего -- необходимо, чтобы у вас была установлена Qt 3.2 (или более поздняя версия), а переменная окружения PATH содержала корректный путь к каталогу bin . (В Windows настройка переменной PATH выполняется автоматически, в процессе установки библиотеки Qt)

Скопируйте текст программы в файл, с именем hello.cpp , в каталог hello .

Перейдите в этот каталог и дайте команду:

Qmake -project она создаст платформо-независимый файл проекта (hello.pro), а затем дайте следующую команду: qmake hello.pro Эта команда создаст Makefile , на основе файла проекта. Дайте команду make , чтобы скомпилировать программу и затем запустите ее, набрав в командной строке hello (в Windows) или ./hello (в Unix) или open hello.app (в Mac OS X). Если вы работаете в Windows и используете Microsoft Visual C++, то вместо команды make вы должны дать команду nmake . Как альтернативный вариант -- вы можете создать проект Visual Studio из файла hello.pro , запустив команду: qmake -tp vc hello.pro и затем скомпилировать программу в Visual Studio.

Рисунок 1.2. Метка с форматированным текстом.

А теперь немного развлечемся. Изменим внешний вид метки, добавив форматирование текста в стиле HTML. Для этого, замените строку

QLabel *label = new QLabel("Hello, Qt!", 0); на QLabel *label = new QLabel("

Hello " "Qt!

", 0); и пересоберите приложение.

1.2. Обработка сигналов.

Следующий пример показывает -- как организовать реакцию приложения на действия пользователя. Это приложение содержит кнопку, при нажатии на которую программа закрывается. Исходный текст очень похож на предыдущий пример, за исключением того, что теперь, в качестве главного виджета, вместо QLabel используется QPushButton , и добавлен код, который обслуживает факт ее нажатия.

Рисунок 1.3. Приложение Quit.

1 #include 2 #include 3 int main(int argc, char *argv) 4 { 5 QApplication app(argc, argv); 6 QPushButton *button = new QPushButton("Quit", 0); 7 QObject::connect(button, SIGNAL(clicked()), 8 &app, SLOT(quit())); 9 app.setMainWidget(button); 10 button->show(); 11 return app.exec(); 12 } Виджеты Qt имеют возможность посылать приложению сигналы , извещая его о том, что пользователь произвел какое-либо действие или о том, что виджет изменил свое состояние . Например, экземпляры класса QPushButton посылают приложению сигнал clicked() , когда пользователь нажимает на кнопку. Сигнал может быть "подключен" к функции-обработчику (такие функции-обработчики в Qt называются слотами ). Таким образом, когда виджет посылает сигнал, автоматически вызывается слот. В нашем примере мы подключили сигнал clicked() , от кнопки, к слоту quit() , экземпляра класса QApplication . Вызовы SIGNAL() и SLOT() -- это макроопределения, более подробно мы остановимся на них в следующей главе.

Теперь соберем приложение. Надеемся, что вы уже создали каталог quit и разместили в нем файл quit.cpp . Дайте команду qmake , для создания файла проекта, а затем второй раз -- для создания Makefile:

Qmake -project qmake quit.pro Теперь соберите приложение командой make и запустите его. Если вы щелкнете по кнопке "Quit" или нажмете на клавиатуре клавишу "Пробел", то приложение завершит свою работу.

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

Рисунок 1.4. Приложение Age.

Приложение содержит три виджета: QSpinBox , QSlider и QHBox (область горизонтальной разметки). Главным виджетом приложения назначен QHBox . Компоненты QSpinBox и QSlider помещены внутрь QHBox и являются подчиненными , по отношению к нему.

Рисунок 1.5. Виджеты приложения Age.

1 #include 2 #include 3 #include 4 #include 5 int main(int argc, char *argv) 6 { 7 QApplication app(argc, argv); 8 QHBox *hbox = new QHBox(0); 9 hbox->setCaption("Enter Your Age"); 10 hbox->setMargin(6); 11 hbox->setSpacing(6); 12 QSpinBox *spinBox = new QSpinBox(hbox); 13 QSlider *slider = new QSlider(Qt::Horizontal, hbox); 14 spinBox->setRange(0, 130); 15 slider->setRange(0, 130); 16 QObject::connect(spinBox, SIGNAL(valueChanged(int)), 17 slider, SLOT(setValue(int))); 18 QObject::connect(slider, SIGNAL(valueChanged(int)), 19 spinBox, SLOT(setValue(int))); 20 spinBox->setValue(35); 21 app.setMainWidget(hbox); 22 hbox->show(); 23 return app.exec(); 24 } В строках с 8 по 11 создается и настраивается QHBox . Чтобы вывести текст в заголовке окна, вызывается setCaption() . А затем устанавливается размер пустого пространства (6 пикселей) вокруг и между подчиненными виджетами.

В строках 12 и 13 создаются QSpinBox и QSlider , которым, в качестве владельца, назначается QHBox .

Не смотря на то, что мы явно не задали ни положение, ни размеры виджетов QSpinBox и QSlider , тем менее они очень аккуратно расположились внутри QHBox . Собственно для этого и предназначен QHBox . Он выполняет автоматическое размещение подчиненных виджетов, назначая им координаты размещения и размеры, в зависимости от их требований и собственных настроек. В Qt имеется много классов, подобных QHBox , которые избавляют нас от рутинной работы по ручной подгонке положения и размеров визуальных компонентов.

В строках 14 и 15 устанавливаются допустимые пределы изменения счетчика и ползунка. (Мы можем смело предположить, что возраст нашего пользователя едва ли превысит 130 лет.) Два вызова connect() , в строках с 16 по 19 синхронизируют ползунок и счетчик, благодаря чему они всегда будут отображать одно и то же значение. Всякий раз, когда значение одного из виджетов изменяется, он посылает сигнал valueChanged(int) , который поступает в слот setValue(int) другого виджета.

В строке 20 устанавливается первоначальное значение (35) счетчика. Когда это происходит, счетчик посылает сигнал valueChanged(int) , со значением входного аргумента, равным 35. Это число передается в слот setValue(int) виджета QSlider , который устанавливает значение этого виджета равным 35. После этого уже QSlider посылает сигнал valueChanged(int) , поскольку его значение только что изменилось, вызывая таким образом слот setValue(int) виджета QSpinBox . Но на этот раз счетчик не посылает сигнал, поскольку его значение и так было равно 35. Таким образом предотвращается бесконечная рекурсия. Рисунок 1.6 иллюстрирует эту ситуацию.

Рисунок 1.6. Изменение одного значения вызывает изменение другого.

В строке 22 QHBox делается видимым (вместе со всеми подчиненными виджетами).

Подход к формированию интерфейса в Qt очень прост для понимания и чрезвычайно гибок. В общем случае, программист выбирает необходимые ему виджеты, размещает их внутри областей выравнивания (layouts), которые в свою очередь принимают на себя обязанности по размещению виджетов, и настраивает свойства виджетов. На заключительном этапе устанавливаются взаимосвязи виджетов, через механизм сигналов и слотов, которые обусловливают поведение пользовательского интерфейса.

1.3. Работа со справочной системой.

Справочная система в Qt -- это пожалуй самый основной инструмент любого разработчика. Она описывает все классы и функции в этой библиотеке. (Документация к Qt 3.2 включает в себя описанее более 400 классов и 6000 функций.) В этой книге вы встретитесь с большим количеством классов и функций Qt, но далеко не со всеми. Поэтому совершенно необходимо, чтобы вы самостоятельно ознакомились со справочной системой Qt.

Стили виджетов
Скриншоты, которые мы до сих пор видели, были получены в Windows XP. Однако внешний вид виджетов изменяется, в зависимости от платформы, на которой запускается приложение. С другой стороны, Qt в состоянии эмулировать внешний вид любой из поддерживаемых платформ.