Как сделать диалоговое окно qt
Обновлено: 16.05.2024
Первое оконное приложение на Qt (диалоговое окно)
В поле "Name" пишем: ИмяПроекта -> нажимаем кнопку "Browse…" и указываем путь, где будет создан наш проект -> нажимаем два раза кнопку "Next" и выбираем в списке "Base class" значение "QDialog" -> нажимаем последовательно: два раза "Next" -> нажимаем кнопку "Finish"
Запускаем приложение. Для этого нажимаем зелёный треугольник слева внизу (или Ctrl+R). Закрываем приложение
На панели слева вы видите папку "Forms" с файлом "Dialog.ui" -> нажимаем два раза по "Dialog.ui" -> мы видим форму, на которую мы можем перетаскивать элементы
Перетащим три "LineEdit" и одну кнопку "PushButton" (лучше всего вводить названия в поле "Filter")
Один раз кликаем на "LineEdit" (чтобы выделить его) -> затем справа на панели изменяем имя этого объекта с "lineEdit" на "firstNumberLineEdit"
Тоже самое проделываем со вторым "LineEdit " -> меняем ему имя с "lineEdit_2" на "secondNumberLineEdit"
У третьего "LineEdit " меняем имя с "lineEdit_3" на "resultLineEdit"
Два раза кликаем по кнопке и меняем её текст на: Показать Сумму
Меняем имя кнопки с "pushButton" на "showResultButton"
Примечание. Мы можем группировать и выравнивать элементы. Для этого надо выделить их и нажать либо кнопку с тремя вертикальными полосками или с тремя горизонтальными (на панели выше). Поэкспериментируйте немного с этими двумя кнопками (и остальными на этой панели) и вы разберётесь
Нажимаем правой кнопкой мыши по нашей кнопке на форме -> из выпадающего списка выбираем "Go to slot…" -> нажимаем "OK"
В отрывшемся окне мы видим функцию on_showResultButton_clicked() Это обработчик нажатия на кнопку. Копируем в этот обработчик код, чтобы он выглядел так:
Запускаем приложение. Для этого нажимаем зелёный треугольник слева внизу (или Ctrl+R)
Создание стандартных диалоговых окон в Qt
Использование стандартных окон значительно ускоряет разработку тех приложений, в которых необходимо использовать стандартные диалоговые окна выбора файлов, шрифта, цвета и т. д. Вместо того, чтобы тратить время на разработку своих собственных классов, можно воспользоваться готовыми классами библиотеки Qt. К достоинствам стандартных диалоговых окон можно отнести целостность пользовательского интерфейса, так как вид окон, во всех приложениях использующих их, будет один и тот же.
Диалоговое окно выбора файлов QFileDialog
Оно предназначено для выбора одного или нескольких файлов, а также файлов, находящихся на удаленном компьютере, включает в себя возможность переименования файлов и создания директорий. Класс QFileDialog предоставляет реализацию диалогового окна выбора файлов и отвечает за создание и работоспособность сразу трех диалоговых окон. Одно из них позволяет осуществлять выбор файла для открытия, второе – предназначено для выбора пути и имени файла для его сохранения, а третье — предназначено для выбора директории. Класс QFileDialog унаследован от класса QDialog. Его определение находится в файле QFileDialog.
Этот класс предоставляет следующие статические методы:
- getOpenFileName() создает диалоговое окно выбора одного файла. Этот метод возвращает значение типа QString, содержащее имя и путь выбранного файла;
- getOpenFileNames() создает диалоговое окно выбора нескольких файлов. Возвращает список строк типа QStringList, содержащих пути и имена файлов;
- getSaveFileName() создает диалоговое окно сохранения файла. Возвращает имя и путь файла в строковой переменной типа QString;
- getExistingDirectory() создает окно выбора директории. Этот метод возвращает значение типа QString, содержащее имя и путь выбранной директории.
- Первым параметром этих методов является указатель на объект-предок, вторым — передается текст заголовка окна, третьим — строка, представляющая собой рабочую директорию.
Вызов метода getOpenFileName() запустит диалоговое окно открытия файла. Четвертый параметр, передаваемый в этот метод, представляет собой фильтр (или маску), задающий расширение файлов. Например:
При помощи метода getExistingDirectory() можно предоставить пользователю возможность выбора директории. Например:
Создание собственного диалогового окна
Программа, показанная на рисунке, является результатом создания собственного диалогового окна. При запуске на экране окно с кнопкой Press Me (Нажми меня), нажатие на которую отображает диалоговое окно ввода имени First Name (Имя) и фамилии Last Name (Фамилия).
В файле main.cpp создается виджет класса StartDialog, предназначенный для запуска диалогового окна.
Класс StartDialog унаследован от класса кнопки нажатия. Сигнал clicked() соединяется в методе connect() со слотом slotButtonClicked(). В этом слоте создается объект диалогового окна InputDialog, который не имеет предка.
Примечание: Диалоговые окна, не имеющее предка, будут центрироваться по экрану. Окна с предками будут отцентрированы относительно предка.
В операторе if производится запуск диалогового окна. После его закрытия управление передается основной программе и метод exec() возвращает значение нажатой пользователем кнопки. В том случае, если пользователем была нажата кнопка Ok, произойдет отображение информационного окна с введенными в диалоговом окне данными. По завершении метода диалоговое окно нужно удалить самому, так как у него нет предка, который позаботится об этом.
Для создания своего собственного диалогового окна нужно унаследовать класс QDialog. Класс InputDialog содержит два атрибута — указатели m_ptxtFirstName и m_ptxtLastName на виджеты однострочного текстового поля, и два метода, возвращающие содержимое этих полей — firstName() и lastName().
По умолчанию область заголовка диалогового окна содержит кнопку ?, служащую для получения подробной информации о назначении виджетов.
В нашем примере я решил пренебречь ею — для этого необходимо установить флаги окна, поэтому вторым параметром передаются флаги Qt::WindowTitleHint и Qt::WindowSystemMenuHint, первый устанавливает заголовок окна, а второй — добавляет системное меню с возможностью закрытия окна.
Модальное диалоговое окно всегда должно содержать кнопку Cancel (Отмена). Сигналы clicked() кнопок Ok и Cancel (Отмена) соединяются со слотами accept() и rejected() соответственно. Это делается для того, чтобы метод exec() возвращал при нажатии кнопки Ok значение QDialog::Accepted, а при нажатии на кнопку Cancel (Отмена) — значение QDialog::Rejected.
Как сделать диалоговое окно qt
В статье описаны главные моменты при создании пользовательских окон.
1. Изменение внешнего вида окна
Чтобы изменить внешний вид диалогового окна, нужно при создании установить соответствующий тип окна. Например:
Для более тонкой настройки внешнего вида окна, следует комбинировать доступные флаги окна. Например, чтобы создать окно без каких либо кнопок в заголовке, нужно использовать такой код:
Список доступных типов и флагов, можно посмотреть здесь.
2. Изменение размера окна при открытии
Чтобы максимизировать диалоговое окно при открытии, следует изменить состояние окна с помощью такого кода:
Все доступные состояния окна можно посмотреть здесь.
3. Обработка событий кнопок QDialogButtonBox
При создании пользовательских диалоговых окон, часто приходится пользоваться классом QDialogButtonBox . Этот класс представляет из себя контейнер стандартных кнопок, таких как: Ok , Cancel , Save for all , Save , Ignore и т.п. В этой статье описано как узнать на какую именно кнопку нажал пользователь и как обработать это событие.
При нажатии кнопки на компоненте buttonBox посылается сигнал clicked(QAbstractButton*) . Нужно перехватить этот сигнал и обработать следующим кодом:
Диалоговые окна в Qt: Модальные и немодальные
Модальное диалоговое окно блокирует родительский виджет. Блокировка снимается только при закрытии диалогового окна. Такое поведение оказывается проще при реализации, поскольку оно ограничивает свободу пользователя и снижает количество возможных проблем. Однако пользователи могут счесть это недостатком.
Немодальное диалоговое окно обладает в точности противоположным поведением по сравнению с модальным. Пользователь может взаимодействовать и с родительским виджетом, и с диалоговым окном, переключаясь между ними. Управлять подобной логикой взаимодействия сложнее. Но в замен пользователь получает свободу, которой ему могло не хватать в модальном варианте.
Выбор типа диалогового окна основывается на здравом смысле и относится к этапу юзабилити-тестирования. Мы этого вопроса касаться не станем. Рассмотрим лишь технику создания и тех, и других диалоговых окон с помощью Qt.
Класс диалогового окна
Реализуем простой класс диалогового окна. Именно его мы попробуем вызывать в модальном и немодальном режимах.
На нашем диалоговом окне мы разместили одно поле ввода и три кнопки: OK , Apply и Cancel .
Кнопка OK предназначена для подтверждения ввода с последующим закрытием окна. Этого мы добились, связав сигнал щелчка по кнопке со стандартным слотом QDialog::accept() .
Кнопка Apply так же предназначена для подтверждения ввода. Но предполагает продолжение работы с диалоговым окном. Для реализации такой логики мы предусмотрели сигнал applied() .
Последняя кнопка Cancel просто закрывает диалоговое окно. Больше ничего не происходит. Введенные данные отклоняются. Для этого мы используем слот QDialog::reject() .
Других кодов в QDialog не предусмотрено (кроме Accepted и Rejected ). Поэтому существует слот QDialog::done( int ) . Он закрывает окно и возвращает в качестве результата вызова указанное целочисленное значение.
Нажатие клавиши Esc в диалоговом окне приводит к вызову QDialog::reject() , а Enter связывается с кнопкой по умолчанию. Такой кнопкой становится либо первая добавленная кнопка (в нашем случае OK ), либо кнопка, для которой вызвана функция btn->setDefault( true ) .
Чтобы извлечь введенное значение в текстовое поле, мы предусмотрели константную функцию-член getInput() .
Реклама
Модальное диалоговое окно
Реализуем виджет, который будет использовать наше диалоговое окно:
Виджет содержит текстовое поле и две кнопки. Первая предназначена для вызова модального диалогового окна, а вторая - для немодального. Сосредоточимся на первой.
Модальное диалоговое окно обеспечивает блокировку вызывающей функции с помощью вызова exec() (как у QApplication ). Это дает нам полное право создавать такой диалог в виде локальной переменной. Обращаю внимание, что в конструкторе диалогового окна мы передаем указать на виджет. Это обеспечивает необходимую привязку.
Мы должны не забыть привязать сигнал applied() нашего диалогового окна к специально созданному слоту onApplied() . В нем мы просто устанавливаем значение введенной строки в качестве значения текстового поля виджета.
Момент отображения диалогового окна соответствует строке с вызовом dlg.exec() . В качестве ответа возвращается код завершения работы окна. Единственный интересный для нас случай: QDialog::Accepted . Для него мы делаем то же самое, что и в слоте onApplied() .
Не забудьте убедиться, что родительский виджет становится неактивным, когда модальное диалоговое окно отображается.
Реклама
Немодальное диалоговое окно
Добавим реализацию слота onNonModalDemo() для вызова нашего диалогового окна в немодальном режиме:
Следует заметить, что для немодального диалогового окна мы завели отдельное поле класса в виджете. Это необходимо, поскольку немодальное окно не блокирует выполнение слота, поэтому локальная переменная оказалась бы уничтожена.
Для обработки ответа QDialog::Accepted мы делаем привязку к сигналу диалогового окна accepted() . Есть аналогичный сигнал для отрицательного ответа rejected() . А также для нашего собственного кода результата (на случай вызова слота done( int ) ): finished( int ) .
Важным отличием является то, что отображаем диалог мы не с помощью exec() , а путем вызова show() .
Освобождать указатель на немодальное диалоговое окно нам не нужно. Это произойдет автоматически при вызове деструктора родительского виджета. В этот же момент диалоговое окно закроется.
Если запустить немодальное диалоговое окно, то родительский виджет остается доступен. Например, мы можем открыть после этого еще и модальное диалоговое окно. Заметим, что в этом случае блокируется и родительский виджет, и немодальное диалоговое окно.
Выводы
Глава 2. Создание диалогов.
В этой главе мы расскажем -- как в Qt создаются диалоговые окна. Диалоговыми они называются потому, что обеспечивают способ общения (диалога) между пользователем и приложением.
Диалоги предоставляют пользователям возможность что-то изменить, что-то задать, в соответствии с их предпочтениями. В большинстве своем, программы с графическим интерфейсом имеют главное окно, с полосой меню и панелью инструментов, и множество диалоговых окон, каждое из которых предназначено для обмена информацией с пользователем или вывода ее в определенном формате. Зачастую приложение может быть оформлено как одно диалоговое окно, которое напрямую взаимодействует с пользователем, получая от него команды и выполняя соответствующие им действия. Такие приложения называются диалоговыми приложениями . Примером диалогового приложения может служить программа-калькулятор.
Для начала мы создадим диалоговое приложение "вручную", чтобы продемонстрировать основные принципы разработки диалогов. Затем покажем, как то же самое можно сделать значительно быстрее, с применением визуального построителя Qt Designer . С помощью этого инструмента разработка диалоговых окон проходит намного быстрее, к тому же с его помощью гораздо проще вносить изменения в визуальный дизайн во время доработки приложения.
2.1. Создание дочернего класса от QDialog.
Наш первый пример -- это диалог поиска. Диалог будет реализован в виде класса, со своей собственной функциональностью. Это будет независимый компонент со своими сигналами и слотами.
Рисунок 2.1. Диалог поиска в Linux (KDE).
Исходные тексты приложения будут размещаться в двух файлах: finddialog.h и finddialog.cpp. Начнем с файла finddialog.h.
Строки 1 и 2 (и 27) предотвращают множественное подключение файла-заголовка.
В строке 3 подключается определение класса QDialog -- базового для всех диалогов в Qt. QDialog порожден от класса QWidget.
Строки с 4 по 7 -- это опережающие описания классов Qt, которые используются в нашем диалоге. Опережающее описание сообщает компилятору C++ о том, что этот класс существует, но подробности описания класса (обычно расположенного в отдельном заголовочном файле) здесь использоваться не будут. Ниже мы еще вернемся к этой теме.
Теперь определим класс FindDialog, указав в качестве родительского класса QDialog:
Определение класса начинается с вызова макроса Q_OBJECT. Это обязательное требование для всех классов, которые определяют свои собственные сигналы и слоты.
Далее следует типичный, для всех виджетов в Qt, конструктор -- FindDialog. Параметр parent задает "владельца", т.е. виджет, на котором будет размещен данный компонент, а параметр name -- имя (название) виджета. Параметр name не является обязательным, в основном он используется для нужд отладки и тестирования.
В секции signals описаны два сигнала, которые может посылать наше диалоговое окно, при нажатии на кнопку Find. Если включен флажок "Search backward" (поиск в обратном направлении), то посылается сигнал findPrev(), иначе -- findNext().
Ключевое слово signals, фактически является макроопределением. Препроцессор C++ преобразует его в стандартное представление C++ и только потом оно будет передано компилятору.
В приватной секции класса мы объявили два слота. Они необходимы для обеспечения взаимодействия с подчиненными виджетами, указатели на которые описаны чуть ниже. Ключевое слово slots, так же как и signals, является макроопределением.
Поскольку все поля-переменные -- это указатели, нам нет нужды подключать заголовочные файлы, содержащие полные определения этих классов. Благодаря наличию опережающего описания, компилятор удовольствуется тем, что есть. Вместо опережающего описания классов мы могли бы подключить соответствующие заголовочные файлы (<qcheckbox.h>, <qlabel.h> и т.д.), но это отрицательно скажется на скорости компиляции. Для маленьких приложений это не так заметно, но для больших проектов опережающее описание может дать существенный выигрыш.
Перейдем к файлу finddialog.cpp, который содержит реализацию класса FindDialog:
Здесь подключаются заголовочные файлы с описаниями используемых классов Qt. В строке 6 подключается определение нашего класса. Для большинства классов Qt, их определения находятся в заголовочных файлах, имена которых повторяют имя класса (все символы в именах файлов переводятся в нижний регистр) и дополняются символами .h. В строке 8, конструктору базового класса передаются параметры parent и name.
В строке 10 задается надпись, которая будет выводиться в заголовке окна -- "Find". Функция tr() определена в классе QObject и любом другом подклассе, описание которого содержит вызов макроса Q_OBJECT. Она выполняет трансляцию текста, передаваемого ей, на другие языки человеческого общения. Считается хорошим тоном, все строки, которые будут выводиться на экран, передавать через эту функцию, даже в том случае, если вы не планируете интернационализацию своего приложения. Проблемы интернационализации будут подробно освещены в Главе 15.
В строке 17, вызовом метода setDefault(true) [1] , назначается кнопка по-умолчанию. Кнопка по-умолчанию -- это такая кнопка, которая будет активироваться при нажатии на клавишу Enter. В строке 18 накладывается запрет на кнопку Find. Когда виджет запрещен, он обычно отображается в серых тонах и не реагирует на действия пользователя.
Приватный слот enableFindButton(const QString &) вызывается при изменении содержимого поля ввода. Приватный слот findClicked() вызывается, когда пользователь щелкает по кнопке Find. Работа приложения завершается после щелчка по кнопке Close. Слот close() наследуется от класса QWidget и его поведение по-умолчанию -- сокрытие виджета. Реализация слотов findClicked() и enableFindButton(const QString &) будет приведена ниже.
Поскольку QObject является одним из предков класса FindDialog, то мы можем опустить префикс QObject:: перед именем метода connect().
На заключительном этапе выполняется выравнивание виджетов с помощью менеджеров размещения . Менеджер размещения (layout manager) -- это объект, который управляет размерами и положением виджетов. Qt предоставляет в наше распоряжение три менеджера размещения: QHBoxLayout выравнивает виджеты по горизонтали, QVBoxLayout -- по вертикали и QGridLayouts -- по сетке. Менеджеры размещения (или, если хотите, менеджеры компоновки) могут содержать как отдельные виджеты, так и другие менеджеры размещения. Вкладывая друг в друга QHBoxLayout, QVBoxLayout и QGridLayouts, в различных комбинациях, можно выстроить весьма замысловатый интерфейс диалога.
Рисунок 2.2. Компоновка диалога Find.
В нашем приложении мы использовали два QHBoxLayout и два QVBoxLayout, как это показано на Рисунке 2.2. Внешний менеджер компоновки (mainLayout) является главным, поскольку при создании ему был назначен, в качестве владельца, экземпляр класса FindDialog -- (this). Он отвечает за размещение всех визуальных компонентов в области окна приложения. Оставшиеся 3 менеджера размещения являются подчиненными. Маленькая "пружинка", которая видна в правом нижнем углу рисунка -- это распорка (spacer). Она заполняет пустое пространство под кнопками Find и Close, заставляя их держаться в верхней части области выравнивания.
Здесь есть один важный момент. Менеджеры компоновки не являются виджетами. Они порождены от класса QLayout, который в свою очередь порожден от класса QObject. На рисунке, контуры виджетов отрисованы сплошными линиями, а областей компоновки -- пунктирными, чтобы подчеркнуть различия, имеющиеся между ними. Во время работы приложения, менеджеры размещения (области выравнивания) не видны.
Хотя менеджеры компоновки и не являются виджетами (визуальными компонентами), тем не менее они могут иметь как владельца, так и подчиненные компоненты. Понятия термина "владелец", у менеджера размещения и виджета, различаются. Если менеджер размещения встраивается в виджет (который передается менеджеру в качестве владельца), как это происходит в случае с mainLayout, то он автоматически встраивается в этот виджет. Если менеджер создается без владельца (в данном случае это: topLeftLayout, leftLayout и rightLayout), то он должен быть включен в состав другого менеджера, вызовом addLayout().
Механизм "владелец-подчиненный" реализован в классе QObject, который является предком как для QWidget, так и для QLayout. Когда создается некий объект (виджет, менеджер компоновки или что-то еще), для которого явно указывается владелец, то он добавляется владельцем в свой список подчиненных компонентов. Когда владелец уничтожается, он проходит по списку подчиненных компонентов и уничтожает их одного за другим. Подчиненные компоненты, в свою очередь просматривают свои списки и уничтожают компоненты, подчиненные им и так до тех пор, пока дело не дойдет до компонентов, которые не имеют подчиненных объектов.
Этот механизм упрощает управление памятью в приложении, снижая риск "утечки". Единственные объекты, которые необходимо уничтожать явно -- это те, которые были созданы оператором new, и не имеют владельца. Если первым удаляется подчиненный компонент, то Qt автоматически исключит его из списка владельца.
Владелец имеет особое значение для виджетов. Подчиненные виджеты отображаются на экране внутри области, принадлежащей его владельцу. Когда удаляется какой-либо владелец, он не только удалит подчиненные объекты из памяти, но и сотрет их на экране.
Когда один менеджер размещения вставляется в другой, с помощью функции addLayout(), то вложенный менеджер автоматически делается подчиненным объемлющему. В противоположность этому, когда в менеджер размещения вставляется виджет, вызовом addWidget(), то последний не меняет своего владельца.
На рисунке 2.3 показано дерево "владелец-подчиненный" для приложения Find. Порядок взаимоотношений в этом дереве легко выводится из текста конструктора FindDialog, достаточно выделить строки, содержащие new и addLayout(). Важное замечание: Запомните, менеджеры размещения НЕ ЯВЛЯЮТСЯ владельцами виджетов, размещением которых они управляют.
Рисунок 2.3. Дерево "владелец-подчиненный" диалога Find.
В дополнение к менеджарам размещения, Qt предоставляет несколько виджетов размещения : QHBox (с которым мы уже встречались в Главе 1), QVBox и QGrid. Для своих подчиненных компонентов, эти классы выступают как в качестве владельцев так и в качестве менеджеров размещения. Для небольших приложений виджеты размещения более удобны, но они менее гибкие и требуют больший объем ресурсов, чем менеджеры.
На этом мы заканчиваем рассмотрение реализации конструктора FindDialog. Поскольку подчиненные виджеты и менеджеры размещения создавались нами с помощью оператора new, то, казалось бы, возникает необходимость в написании деструктора, который удалил бы из памяти все, созданные нами компоненты, во время завершения приложения. Однако в этом нет необходимости, поскольку Qt автоматически сделает это во время уничтожения владельца, т.е. во время уничтожения класса FindDialog.
Перейдем к рассмотрению слотов:
Слот findClicked() вызывается всякий раз, когда пользователь щелкает мышкой по кнопке Find. Кнопка выдает сигнал findPrev() или findNext(), в зависимости от состояния флажка Search backward. Ключевое слово emit является макросом, определенным в библиотеке Qt.
Слот enableFindButton() вызывается, когда пользователь изменяет содержимое поля ввода. Если оно содержит какие-либо символы, то разрешается кнопка Find, в противном случае она запрещается.
Реализацией этих двух слотов завершается разработка нашего диалога. Теперь создадим файл main.cpp, в котором разместим текст основной программы для тестирования нашего виджета:
дадим команду qmake, как обычно. На этот раз, поскольку наш класс FindDialog содержит вызов макроопределения Q_OBJECT, утилита qmake включит в Makefile правила, вызывающие утилиту moc -- компилятор метаобъектов.
Для корректной работы утилиты moc необходимо, чтобы описание класса размещалось в заголовочном файле, отдельно от файла с реализацией. Код, сгенерированный утилитой moc подключает этот заголовочный файл.
Visual C++ такое: Если это произошло, то перезапустите qmake еще раз, чтобы обновить Makefile, а затем пересоберите приложение.
Теперь запустите программу. Проверьте работу акселераторов Alt+W, Alt+C, Alt+B и Alt+F. Попробуйте "пройтись" по виджетам с помощью клавиши Tab. По-умолчанию, порядок навигации с помощью клавиши Tab, соответствует порядку, в котором создавались компоненты. Но он может быть изменен вызовом метода QWidget::setTabOrder(). Установку акселераторов и настройку порядка навигации по компонентам, с помощью клавиши Tab, можно считать дружественным жестом в сторону пользователей, которые не могут или не хотят пользоваться мышью. Удобное управление с клавиатуры высоко оценят опытные пользователи.
В Главе 3 мы будем использовать наш диалог в реально работающем приложении. Там сигналы findPrev() и findNext() будут подключаться к соответствующим слотам.
Примечания
Qt предоставляет в распоряжение программиста два макроопределения: TRUE и FALSE, которые могут использоваться взамен стандартных true и false. Не смотря на это, мы не видим достаточных причин, чтобы использовать макросы Qt, разве только в том случае, когда компилятор не поддерживает ключевые слова true и false.
Создание диалогового окна
Не до конца понимаю, как создать диалоговое окно с несколькими LineEdit 'ами, а затем по нажатию кнопки OK, получить с них значения. Если можно пример какой-нибудь? Класс диалога реализую так:
Окно появляется но на нём нет никаких элементов как добавить их? а потом по слику на кнопку считать данные?
23.4k 3 3 золотых знака 39 39 серебряных знаков 58 58 бронзовых знаков задан 29 июн '16 в 9:21 Никола Кривошея Никола Кривошея 1,447 2 2 золотых знака 29 29 серебряных знаков 61 61 бронзовый знакВиджеты в Qt построены таким образом, что в подавляющем большинстве случаев нет никакой необходимости наследовать базовые классы. Особенно это касается QDialog .
Ключевой особенностью виджетной системы в Qt является использование т.н. менеджеров размещения - наследников класса QLayout . В примере эту роль берёт на себя QFormLayout . Именно он, ровно и с подписями, отстоящими с левой стороны, расположит два текстовых поля внутри диалога.
Как создать не модальное диалоговое окно? (qt)
Моя идея: у меня есть 2 окна - main и settings, я хочу чтобы при нажатии на menu bar в main окне вызывалось диалоговое окно settings с выбором директории. При этом, чтобы окно settings не блокировало main окно, чтобы можно было работать и в одном окне и в другом. Хотелось бы, чтобы окно settings было не модальным окном.
Сейчас для этого я использую вызов, который создает модальное окно:
Я знаю, что QFileDialog::getExistingDirectory(): создает именно модальное окно.
Моя изначальная задача, чтобы пользователь вызвал меню выбора директории, через диалоговое окно, а потом уже была бы обработка файлов из этой директории.
Подскажите как можно по другому создать диалоговое окно для выбора директории, чтобы оно было не модальным? Может вместо QFileDialog можно использовать что-то еще? Или вовсе должен быть другой подход в моем случаем?
Как организовать дополнительное диалоговое окно
Смысл такой, при нажатии на кнопку создается дополнительно окошко, естественно первоначальное окно должно быть disableed при закрытии диалогового окна, первоначальное окно должно стать enabled, незнаю как из функции диалогового окна обратится к первоначальному, конкретно функция void qtDialog::closeEvent(QCloseEvent *e)
Помощь в написании контрольных, курсовых и дипломных работ здесь.
Лучшие ответы ( 1 ) 94731 / 64177 / 26122 Ответы с готовыми решениями:Как создать диалоговое окно
В приложении создал дополнительное окно через конструксор, изначально оно наследовалось от.
Как узнать отображается ли диалоговое окно на экране
плиз, помогите. Есть класс наследник от QMainWindow, у него есть член Dialog наследник QDialogx. .
Интеграция с БД, диалоговое окно, проверка или как реализовать авторизацию в аккаунте
Добрый день, форумчане. Передо мной стоит следующая задача: В данный момент я реализовал.
Организовать ввод текста. По нажатию Enter показать диалоговое окно с введенным текстом
помогите.плиз Организовать ввод текста. По нажатию Enter показать диалоговое окно с введенным.
Читайте также: