Python GUI: создаём простое приложение с PyQt и Qt Designer. Кошелек Neo Gui: Как пользоваться, Ускорить синхронизацию, Импорт Онлайн кошелька

Главный писатель по вопросам технологий

Вам кто-то послал по электронной почте файл GUI, и вы не знаете, как его открыть? Может быть, вы нашли файл GUI на вашем компьютере и вас заинтересовало, что это за файл? Windows может сказать вам, что вы не можете открыть его, или, в худшем случае, вы можете столкнуться с соответствующим сообщением об ошибке, связанным с файлом GUI.

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

Tip: Incorrect GUI file association errors can be a symptom of other underlying issues within your Windows operating system. These invalid entries can also produce associated symptoms such as slow Windows startups, computer freezes, and other PC performance issues. Therefore, it highly recommended that you scan your Windows registry for invalid file associations and other issues related to a fragmented registry.

Ответ:

Файлы GUI имеют Файлы данных, который преимущественно ассоциирован с Doom User Interface Information (Id Software Inc.).

Файлы GUI также ассоциированы с GUI Design Studio Project File (Caretta Software Ltd.) и FileViewPro.

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

Как открыть ваш файл GUI:

Самый быстрый и легкий способ открыть свой файл GUI - это два раза щелкнуть по нему мышью. В данном случае система Windows сама выберет необходимую программу для открытия вашего файла GUI.

В случае, если ваш файл GUI не открывается, весьма вероятно, что на вашем ПК не установлена необходимая прикладная программа для просмотра или редактирования файлов с расширениями GUI.

Если ваш ПК открывает файл GUI, но в неверной программе, вам потребуется изменить настройки ассоциации файлов в вашем реестре Windows. Другими словами, Windows ассоциирует расширения файлов GUI с неверной программой.

Установить необязательные продукты - FileViewPro (Solvusoft) | | | |

GUI Инструмент анализа файлов™

Вы не уверены, какой тип у файла GUI? Хотите получить точную информацию о файле, его создателе и как его можно открыть?

Теперь можно мгновенно получить всю необходимую информацию о файле GUI!

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

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

Чтобы начать бесплатный анализ файла, просто перетащите ваш файл GUI внутрь пунктирной линии ниже или нажмите «Просмотреть мой компьютер» и выберите файл. Отчет об анализе файла GUI будет показан внизу, прямо в окне браузера.

Перетащите файл GUI сюда для начала анализа

Просмотреть мой компьютер »

Пожалуйста, также проверьте мой файл на вирусы

Ваш файл анализируется... пожалуйста подождите.

Для начала давайте ознакомимся с самим форматом, с которым нам предстоит работать. Формат Matroska (Матрёшка) изначально разрабатывался как открытый проект, призванный послужить альтернативой существующим проприетарным контейнерам. В итоге после нескольких лет разработки он вышел на рынок и стал быстро завоевывать популярность, особенно в интернет среде. Чем же был вызвал столь быстрый рост популярности? В первую очередь тем, что создатели прислушались к тому, что хотят видеть пользователи в своих видеофайлах и реализовали это. В подавляющем большинстве случаев от воспроизводимого видео файла требуется поддержка нескольких звуковых дорожек и субтитров. В формате mkv все это реализовано максимально просто и удобно. Вы можете поместить в контейнер сколько угодно альтернативных аудио файлов и субтитров а также переключаться между ними с помощью одного клика.

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

Добавление дополнительных звуковых дорог в mkv контейнер

Эту процедуру мы будет проводить на примере программы MKVtoolnix 5.9 и мультфильма Secret of Kells. У нас есть оригинальный контейнер с двумя звуковыми дорожками и 4 внешние дополнительные дороги. Которые мы добавим к первым двум, чтобы на выходе получить один файл.

Вот так выглядит основное окно программы.

Для того чтобы добавить файл с которым мы будем работать необходимо нажать кнопку "добавить" или просто перетащить его в область обозначенную как "Входные файлы". После чего у нас в ней появится информация о данном файле.

Как вы видите на скриншоте у нас в контейнере уже содержится 1 видеофайл в формате mpeg4, 2 аудиодороги (русская и английские комментарии), а также 21 файл субтитров и файл глав. Кроме этого мы хотим добавить в контейнер оригинальную английскую дорогу, еще 2 русских альтернативных перевода и 1 украинский. Для этого мы точно так же нажимаем кнопку добавить или перетаскиваем файлы мышью.

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

Как мы видим теперь английская дорожка находится под первыми двумя, у нее есть название - Original, язык выбран английский и стоит флаг дорожки по умолчанию. Будем считать что это все что нам надо было сделать и приступим к созданию файла. Для этого достаточно нажать кнопку "начать обработку". Кстати для того чтобы наш файл смотрелся симпатичнее мы еще зададим ему другое выходное имя. Рипперы часто указывают в названии файла массу ненужной пользователю информации, поэтому мы сократим ее и оставим только название и разрешение. Это можно сделать в пункте "имя выходного файла".

На этом скриншоте вы видите программу в процессе обработки файла.

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

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

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

Приложение с графическим интерфейсом может быть написано и без применения среды GUIDE. В качестве примера, можно привести bspligui, входящее в состав Spline ToolBox. Желающим разобраться в создании приложений без среды GUIDE можно посоветовать запустить приложение bspligui в режиме отладки, проследить за созданием окна приложения, элементов управления и способе обработки событий (достаточно открыть файл bspligui.m, установить точку останова на первую исполняемую строку и запустить приложение). К этому вопросу мы со временем обратимся.

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

· "MATLAB: Creating Graphical User Interfaces".

· "MATLAB: Functions -- Categorical List: Creating Graphical User Interfaces"

· "MATLAB: Handle Graphics Property Browser" (справочник свойств графических объектов).

· В справочной системе MatLab 7 в разделе "Demo" есть 10-ти минутная демонстрация создания приложения с графическим интерфейсом в среде GUIDE.

В качестве простейшего примера рассмотрим создание в среде GUIDE приложения с кнопкой Hello , нажатие на которую приводит к выводу текста "Hello, World!" в окно приложения.

Создание приложения hello в среде GUIDE

Требуется создать приложение с графическим интерфейсом hello, запуск которого, например из командной строки

приводил бы к появлению окна приложения с кнопкой Hello (см. рис 1.a). После нажатия на Hello в окно приложения выводится текст "Hello, World!" (см. рис 1.b).

Рис. 1. Работа приложения hello

Перейдите в среду GUIDE, выполнив команду

При этом появляется диалоговое окно GUIDE Quick Start (см. рис. 2). У него две вкладки.

• Вкладка Create New GUI (создание нового приложения), которая нам сейчас понадобится. На ней можно выбрать четыре заготовки: Blank GUI (пустое окно приложения), GUI with Uicontrols (заготовка с кнопками, переключателями и областями ввода), GUI with Axes and Menu (заготовка с осями, меню, кнопкой и раскрывающимся списком), Modal Question Dialog (заготовка для модального окна).
• Вкладка Open Existing GUI (открытие существующего приложения).

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

Рис. 2. Диалоговое окно GUIDE Quick Start

Выберите на вкладке Create New GUI строку Blank GUI и нажмите OK. При этом появляется основное окно среды GUIDE, содержащее заготовку для окна приложения, панель инструментов для добавления элементов интерфейса, управляющую панель и меню (см. рис. 3).

Рис. 3. Среда GUIDE с заготовкой для окна приложения

Сначала добавьте кнопку на заготовку окна приложения. Для этого при помощи мыши выберите инструмент Push Button (его пиктограмма содержит кнопку OK, а имя появляется на всплывающей подсказке) и щелчком мыши поместите кнопку на заготовку окна приложения (см. рис. 4)

Рис. 4. Добавление кнопки на заготовку окна приложения

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

Для задания тега следует перейти к инспектору свойств. Проще всего это сделать двойным щелчком мыши по добавленной кнопке. При этом появляется окно инспектора свойств (Property Inspector), в котором отображены свойства кнопки (объекта Uicontrol). Найдите в левом столбце таблицы свойство Tag и в области ввода справа от него измените текущее значение pushbutton1 на btnHello и нажмите . Всегда лучше давать объектам содержательные теги!

Заметьте, что тег и надпись на кнопке не одно и то же. Сразу же в окне инспектора свойств измените надпись, обратившись к свойству String. Вместо Push Button должно быть Hello.

Наше приложение должно выводить текст. Но текст нельзя просто вывести в графическое окно, поскольку текстовый объект является потомком осей. Мы не будем сейчас размещать оси, а поступим по-другому. Расположите в окне приложения элемент управления - Static Text (статический текст, или область для вывода текста). Для этого воспользуйтесь инструментом Static Text так же, как и при добавлении кнопки (см. рис. 5).

Примечание

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

Рис. 5. Добавление области вывода текста

Задайте тег txtWin области вывода текста, а ее свойство String установите в пустую строку, просто удалив в инспекторе свойств то значение, которое присваивается по умолчанию.

Обратите внимание, что области вывода текста является графическим объектом Uicontrol, так же, как и кнопка (это написано вверху инспектора свойств). Вид элемента управления, т.е. объекта Uicontrol определяется значением его свойства Style. Для кнопки оно принимает значение "pushbutton", для области вывода текста "text".

Предположим, что наше приложение уже работает. При нажатии пользователем на кнопку Hello возникнет ее событие Callback, которое пока не запрограммировано. Очевидно, что при возникновении события Callback необходимо установить свойство String области вывода текста в значение "Hello, World!" и задать цвет и размер шрифта.

Перед программированием события сохраните приложение. Для этого в меню File среды GUIDE выберите пункт Save as, появляется диалоговое окно сохранения файла, в котором выберите папку или создайте новую и задайте имя файла hello (автоматически добавится расширение fig). Обратите внимание, что после сохранения приложения в редакторе M-файлов открылся файл hello.m. По умолчанию, приложение содержится в двух файлах: с расширением fig (графическое окно с размещенными на нем элементами управления) и с расширением m (файл-функция hello с подфункциями, которые обрабатывают различные события, возникающие в ходе взаимодействия приложения с пользователем).

Приступим к программированию события Callback кнопки Hello. Для этого перейдите к заготовке окна приложения и в контекстном меню кнопки выберите в пункте View Callbacks подпункт Callback. При этом происходит переход в редактор M-файлов к подфункции обработки события btnHello_Callback, заголовок которой и комментарии генерируется автоматически:

% --- Executes on button press in btnHello.
function btnHello_Callback(hObject, eventdata, handles)
% hObject handle to btnHello (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

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

Имя файл-функции состоит из тега объекта (btnHello), событие Callback которого будет обрабатываться и названия события Callback (есть и другие события). Смысл ее входных аргументов следующий.

· Аргумент hObject содержит указатель на кнопку Hello, т.е. объект Uicontrol с тегом btnHello (он нам сейчас не понадобится).

· Аргумент eventdata зарезервирован для использования в следующих версиях MatLab.

· Аргумент handles является структурой с указателями на все объекты приложения. Поля структуры handles являются тегами этих объектов. Так handles.btnHello содержит указатель на кнопку Hello, handles.figure1 - указатель на окно приложения, handles.txtWin - указатель на область вывода текста (как раз этот указатель нам сейчас и пригодится).

Приступим теперь к программированию события Callback кнопки Hello. После заголовка подфункции btnHello_Callback разместите операторы, которые изменяют значение свойства String области вывода текста (объекта Uicontrol), устанавливая его в "Hello, World!", а также цвета и размера шрифта. За цвет и размер шрифта отвечают свойства ForegroundColor и FontSize объекта Uicontrol. Размер шрифта указывается в единицах измерения, заданных свойством FontUnits (по умолчанию пункты, 1пт=1/72дюйма). Свойства графических объектов задаются при помощи функции set.

Итак, подфункция btnHello_Callback должна выглядеть так (автоматически сгенерированные комментарии убраны):

function btnHello_Callback(hObject, eventdata, handles)
% размещение текста
set(handles.txtWin,"String","Hello, World!")
% задание красного цвета текста
set(handles.txtWin,"ForegroundColor","r")
% задание размера шрифта 16пт
set(handles.txtWin,"FontSize",16)

Теперь приложение hello можно запустить, воспользовавшись кнопкой Run на панели управления среды GUIDE. Перед запуском может появится окно, приведенное на рис. 6, в котором говорится о том, что папка с файлами приложения не является текущей. В этом окне можно либо сделать ее текущей (переключатель Change MATLAB current directory), либо добавить папку в начало пути поиска MATLAB (переключатель Add directory to the top of the MATLAB path), либо в конец пути поиска (переключатель Add directory to the bottom of the MATLAB path). Установите верхний переключатель (как по умолчанию), вряд ли стоит добавлять папку с таким простым приложением в путь поиска. Скорее всего оно не часто будет нужно.

Рис. 6. Диалоговое окно с сообщением о том, что папка с файлами приложения не является текущей.

Нажатие на кнопку Hello в работающем приложении приводит к появлению надписи "Hello, World!" вверху окна. Закройте работающее приложение, нажав на кнопку с крестиком на заголовке окна. Вы снова находитесь в режиме редактирования. Можно добавлять элементы управления на заготовку окна приложения, задавать их теги и другие свойства, программировать события, запускать приложение и смотреть на результат. Например, уменьшите окно приложения в среде GUIDE (как на рис. 1) и запустите приложение снова.

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

Среда GUIDE предлагает ряд средств, которые облегчают проектирование приложения:

· сетку с возможностью привязки объектов к ней, линейки и линии выравнивания (меню Tools, пункт Grid and Rules);

· инструменты выравнивания объектов (меню Tools, пункт Align Objects или кнопка Align Objects на панели управления среды GUIDE);

В среду GUIDE входят также:

· редактор меню, который позволяет создавать меню приложения и контекстные меню (меню Tools, пункт Menu Editor или кнопка Menu Editor на панели управления среды GUIDE);

· браузер объектов для быстрого перехода к их свойствам (кнопка Object Browser на панели управления среды GUIDE)

· редактор порядка обхода элементов управления клавишей Tab (меню Tools, пункт Tab Order Editor или кнопка Tab Order Editor на панели управления среды GUIDE).

Вызов инспектора свойств происходит не только после двойного щелчка мышью по объекту, но также из контекстного меню объекта, или при помощи кнопки Property Inspector на панели управления среды GUIDE.

Запуск приложения без среды GUIDE и редактирование

Разумеется, созданное в предыдущем разделе приложение hello не требует для запуска среду GUIDE. Закройте окно среды GUIDE (если оно открыто) и перейдите в командное окно MatLab. Убедитесь, что папка с приложением является текущей (она должна быть выбрана в раскрывающемся списке Current Directory рабочей среды MatLab). Если это не так, то сделайте ее текущей, воспользовавшись кнопкой справа от раскрывающегося списка Current Directory, или окном Current Directory .

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

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

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

1. Запустить среду GUIDE командой guide и в появляющемся диалоговом окне GUIDE Quick Start (см. рис. 2 предыдущего раздела) перейти ко вкладке Open Existing GUI и выбрать приложение.

2. Вызвать guide, указав в качестве входного аргумента имя файла с приложением:

>> guide("hello.fig")

При таком способе папка с приложением должна быть текущей, или содержаться в пути поиска MatLab.

Как работает приложение, созданное в среде GUIDE?

Это важный вопрос для тех, кто хочет создавать сложные приложения. Если Ваша цель состоит в написании простых приложений, то достаточно научиться размещать элементы интерфейса и программировать их события в подфункциях так, как описано выше в разделе "Создание приложения hello в среде GUIDE". Простое приложение состоит из одного основного окна, которое содержит различные элементы управления, области вывода текстовой информации и оси. Использование стандартных диалоговых окон облегчает работу с файлами, ввод данных, выбор шрифта, цвета и печать результатов. Однако, если Вы планируете программировать многооконные приложения, то прочтите этот раздел сейчас, или вернитесь к нему по мере надобности.

Обсудим работу приложения с графическим интерфейсом пользователя hello, созданию которого посвящен раздел "Создание приложения hello в среде GUIDE". Перейдите в режим редактирования приложения одним из способов, приведенных в предыдущем разделе, например:

>> guide("hello.fig")

Откройте в редакторе M-файлов файл-функцию hello. Это функция с переменным числом входных и выходных аргументов, ниже она приведена без автоматически созданных комментариев и подфункций.

function varargout = hello(varargin)

Gui_Singleton = 1; gui_State = struct("gui_Name", mfilename, ... "gui_Singleton", gui_Singleton, ... "gui_OpeningFcn", @hello_OpeningFcn, ... "gui_OutputFcn", @hello_OutputFcn, ... "gui_LayoutFcn", , ... "gui_Callback", ); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end

Поставьте точку останова в редакторе M-файлов в строке с первым исполняемым оператором gui_Singleton = 1. Запустите приложение hello, например, из командной строки:

и выполните операторы hello по шагам используя F10 (или кнопку Step).

Сначала переменной gui_Singleton присваивается 1, затем формируется структура gui_State с полями:

• gui_Name - имя M-файла с работающей в данный момент файл-функцией приложения, которое возвращается функцией mfilename;
• gui_Singleton - сколько копий приложения может быть запущено одновременно, в нашем случае это поле содержит 1, это значит, что может быть запущена только одна копия приложения (0 означает, что может быть одновременно запущено несколько копий);
• gui_OpeningFcn - указатель на подфункцию hello_OpeningFcn (в файле hello.m), выполняющуюся перед тем, как окно приложения появится на экране;
• gui_OutputFcn - указатель на подфункцию hello_OutputFcn (в файле hello.m), которая определяет, что возвращает функция hello, вызванная с выходным аргументом (по умолчанию, указатель на графическое окно приложения);
• gui_LayoutFcn - по умолчанию пустой массив, может быть указателем на функцию, которая определяет способ появления приложения.
• gui_Callback - пока пустой массив, при возникновении события от некоторого элемента управления будет содержать указатель на функцию hello c необходимыми входными аргументами, которые и определят исполняемую подфункцию в hello.m.

После заполнения структуры gui_State проверяется, была ли функция hello вызвана со входными аргументами (nargin содержит число входных аргументов) и является ли первый из них строкой. При запуске приложения входных аргументов не было. Они появляются при возникновении событий от элементов управления. Действительно, если в инспекторе свойств отобразить свойства кнопки Hello и посмотреть значение ее свойства Callback, то станет понятно, что при возникновении события Callback кнопки вызывается функция hello: hello("btnHello_Callback",gcbo,,guidata(gcbo)). Тогда в поле gui_Callback структуры gui_State заносится соответствующий указатель при помощи функции str2func.

Примечание

Функция str2func конструирует указатель на функцию, заданную строкой, например:
>> f=str2func("exp")

F = @exp

Следующий оператор if проверяет, была ли функция hello вызвана со выходными аргументами (nargout содержит число входных аргументов) и вызывает специальную функцию gui_mainfcn от структуры gui_State и входных аргументов hello. При первом вызове входных аргументов не было и gui_mainfcn создаст окно приложения. Последующие вызовы hello со входными аргументами, вызванные возникновением событий от элементов управления, приведут к обращению к соответствующим подфункциям обработки событий в hello.m. Это можно проследить пошаговым выполнением в редакторе M-файлов.

Примечание

Функция gui_mainfcn имеет открытый код и расположена в подкаталоге \toolbox\matlab\uitools\ основного каталога MatLab.

Эта статья предназначена для тех, кто только начинает своё знакомство с созданием приложений с графическим интерфейсом (GUI) на Python. В ней мы рассмотрим основы использования PyQt в связке с Qt Designer. Шаг за шагом мы создадим простое Python GUI приложение, которое будет отображать содержимое выбранной директории.

Что нам потребуется

Нам понадобятся PyQt и Qt Designer, ну и Python, само собой.

В этой статье используется PyQt5 с Python 3, но особых различий между PyQt и PySide или их версиями для Python 2 нет.

Linux: Всё нужное, вероятно, есть в репозиториях вашего дистрибутива. Qt Designer можно установить из Центра Приложений, но PyQt придётся устанавливать через терминал. Установить всё, что нам понадобится, одной командой можно, например, так:

# для Fedora: $ sudo dnf install python3-qt5 qt-creator # для Debian/Ubuntu: $ sudo apt install python3-qt5 pyqt5-dev-tools qtcreator

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

$ pyuic5 Error: one input ui-file must be specified

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

Если вы используете Windows, то, скорее всего, путь C:\Python36\Scripts (измените 36 на вашу версию Python) не прописан в вашем PATH . Загляните в этот тред на Stack Overflow, чтобы узнать, как решить проблему.

Дизайн

Основы

Теперь, когда у нас всё готово к работе, давайте начнём с простого дизайна.

Откройте Qt Designer, где вы увидите диалог новой формы, выберите Main Window и нажмите Create .

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

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

Все элементы формы и их иерархия по умолчанию отображаются в правой части окна Qt Designer под названием Object Inspector . Вы с лёгкостью можете удалять объекты, кликая по ним правой кнопкой мыши в этом окне. Или же вы можете выбрать их в основной форме и нажать клавишу DEL на клавиатуре.

В итоге мы имеем почти пустую форму. Единственный оставшийся объект - centralwidget , но он нам понадобится, поэтому с ним мы ничего не будем делать.

Теперь перетащите куда-нибудь в основную форму List Widget (не List View ) и Push Button из Widget Box .

Макеты

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

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

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

Теперь в меню Qt Designer нажмите Form , затем выберите Preview и увидите что-то похожее на скриншот выше. Выглядит хорошо, не так ли? Но вот что случится, когда мы изменим размер окна:

Наши объекты остались на тех же местах и сохранили свои размеры, несмотря на то что размер основного окна изменился и кнопку почти не видно. Вот поэтому в большинстве случаев стоит использовать макеты. Конечно, бывают случаи, когда вам, например, нужна фиксированная или минимальная/максимальная ширина объекта. Но вообще при разработке приложения лучше использовать макеты.

Основное окно уже поддерживает макеты, поэтому нам ничего не нужно добавлять в нашу форму. Просто кликните правой кнопкой мыши по Main Window в Object Inspector и выберите Lay out → Lay out vertically . Также вы можете кликнуть правой кнопкой по пустой области в форме и выбрать те же опции:

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

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

Если у вас не получается переместить элемент в главном окне, вы можете сделать это в окне Object Inspector .

Последние штрихи

Теперь, благодаря вертикальному размещению, наши элементы выровнены правильно. Единственное, что осталось сделать (но не обязательно), - изменить имя элементов и их текст.

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

Свойства элементов можно изменить в разделе Property Editor .

Подсказка: вы можете менять размер, передвигать или добавлять часто используемые элементы в интерфейс Qt Designer для ускорения рабочего процесса. Вы можете добавлять скрытые/закрытые части интерфейса через пункт меню View .

Нажмите на кнопку, которую вы добавили в форму. Теперь в Property Editor вы должны видеть все свойства этого элемента. В данный момент нас интересуют objectName и text в разделе QAbstractButton . Вы можете сворачивать разделы в Property Editor нажатием по названию раздела.

Измените значение objectName на btnBrowse и text на Выберите папку .

Должно получиться так:

Именем объекта списка является listWidget , что вполне подходит в данном случае.

Сохраните дизайн как design.ui в папке проекта.

Превращаем дизайн в код

Конечно, можно использовать.ui -файлы напрямую из Python-кода, однако есть и другой путь, который может показаться легче. Можно конвертировать код.ui -файла в Python-файл, который мы потом сможем импортировать и использовать. Для этого мы используем команду pyuic5 из терминала/командной строки.

Чтобы конвертировать.ui -файл в Python-файл с названием design.py , используйте следующую команду:

$ pyuic5 path/to/design.ui -o output/path/to/design.py

Пишем код

Теперь у нас есть файл design.py с нужной частью дизайна нашего приложения и мы начинать работу над созданием его логики.

Создайте файл main.py в папке, где находится design.py .

Используем дизайн

Для Python GUI приложения понадобятся следующие модули:

Import sys # sys нужен для передачи argv в QApplication from PyQt5 import QtWidgets

Также нам нужен код дизайна, который мы создали ранее, поэтому его мы тоже импортируем:

Import design # Это наш конвертированный файл дизайна

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

Class ExampleApp(QtWidgets.QMainWindow, design.Ui_MainWindow): def __init__(self): # Это здесь нужно для доступа к переменным, методам # и т.д. в файле design.py super().__init__() self.setupUi(self) # Это нужно для инициализации нашего дизайна

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

Def main(): app = QtWidgets.QApplication(sys.argv) # Новый экземпляр QApplication window = ExampleApp() # Создаём объект класса ExampleApp window.show() # Показываем окно app.exec_() # и запускаем приложение

И чтобы выполнить эту функцию, мы воспользуемся привычной конструкцией:

If __name__ == "__main__": # Если мы запускаем файл напрямую, а не импортируем main() # то запускаем функцию main()

В итоге main.py выглядит таким образом:

Import sys # sys нужен для передачи argv в QApplication from PyQt5 import QtWidgets import design # Это наш конвертированный файл дизайна class ExampleApp(QtWidgets.QMainWindow, design.Ui_MainWindow): def __init__(self): # Это здесь нужно для доступа к переменным, методам # и т.д. в файле design.py super().__init__() self.setupUi(self) # Это нужно для инициализации нашего дизайна def main(): app = QtWidgets.QApplication(sys.argv) # Новый экземпляр QApplication window = ExampleApp() # Создаём объект класса ExampleApp window.show() # Показываем окно app.exec_() # и запускаем приложение if __name__ == "__main__": # Если мы запускаем файл напрямую, а не импортируем main() # то запускаем функцию main()

Если запустить этот код: $ python3 main.py , то наше приложение запустится!

Но нажатие на кнопку ничего не даёт, поэтому нам придётся с этим разобраться.

Добавляем функциональность в наше Python GUI приложение

Примечание Весь дальнейший код пишется внутри класса ExampleApp .

Начнём с кнопки Выберите папку . Привязать к функции событие вроде нажатия на кнопку можно следующим образом:

Self.btnBrowse.clicked.connect(self.browse_folder)

Добавьте эту строку в метод __init__ класса ExampleApp , чтобы выполнить привязку при запуске приложения. А теперь взглянем на неё поближе:

• self.btnBrowse: здесь btnBrowse - имя объекта, который мы определили в Qt Designer. self говорит само за себя и означает принадлежность к текущему классу;
• clicked - событие, которое мы хотим привязать. У разных элементов разные события, например, у виджетов списка есть itemSelectionChanged и т.д.;
• connect() - метод, который привязывает событие к вызову переданной функции;
• self.browse_folder - просто функция (метод), которую мы описали в классе ExampleApp .

Для открытия диалога выбора папки мы можем использовать встроенный метод QtWidgets.QFileDialog.getExistingDirectory:

Directory = QtWidgets.QFileDialog.getExistingDirectory(self, "Выберите папку")

Если пользователь выберет директорию, переменной directory присвоится абсолютный путь к выбранной директории, в противном случае она будет равна None . Чтобы не выполнять код дальше, если пользователь закроет диалог, мы используем команду if directory: .

Для отображения содержимого директории нам нужно импортировать os:

Import os

И получить список содержимого следующим образом:

Os.listdir(path)

Для добавления элементов в listWidget мы используем метод addItem() , а для удаления всех элементов у нас есть self.listWidget.clear() .

В итоге функция browse_folder должна выглядеть так:

Def browse_folder(self): self.listWidget.clear() # На случай, если в списке уже есть элементы directory = QtWidgets.QFileDialog.getExistingDirectory(self, "Выберите папку") # открыть диалог выбора директории и установить значение переменной # равной пути к выбранной директории if directory: # не продолжать выполнение, если пользователь не выбрал директорию for file_name in os.listdir(directory): # для каждого файла в директории self.listWidget.addItem(file_name) # добавить файл в listWidget

Теперь, если запустить приложение, нажать на кнопку и выбрать директорию, мы увидим:

Так выглядит весь код нашего Python GUI приложения:

Import sys # sys нужен для передачи argv в QApplication import os # Отсюда нам понадобятся методы для отображения содержимого директорий from PyQt5 import QtWidgets import design # Это наш конвертированный файл дизайна class ExampleApp(QtWidgets.QMainWindow, design.Ui_MainWindow): def __init__(self): # Это здесь нужно для доступа к переменным, методам # и т.д. в файле design.py super().__init__() self.setupUi(self) # Это нужно для инициализации нашего дизайна self.btnBrowse.clicked.connect(self.browse_folder) # Выполнить функцию browse_folder # при нажатии кнопки def browse_folder(self): self.listWidget.clear() # На случай, если в списке уже есть элементы directory = QtWidgets.QFileDialog.getExistingDirectory(self, "Выберите папку") # открыть диалог выбора директории и установить значение переменной # равной пути к выбранной директории if directory: # не продолжать выполнение, если пользователь не выбрал директорию for file_name in os.listdir(directory): # для каждого файла в директории self.listWidget.addItem(file_name) # добавить файл в listWidget def main(): app = QtWidgets.QApplication(sys.argv) # Новый экземпляр QApplication window = ExampleApp() # Создаём объект класса ExampleApp window.show() # Показываем окно app.exec_() # и запускаем приложение if __name__ == "__main__": # Если мы запускаем файл напрямую, а не импортируем main() # то запускаем функцию main()

Это были основы использования Qt Designer и PyQt для разработки Python GUI приложения. Теперь вы можете спокойно изменять дизайн приложения и использовать команду pyuic5 без страха потерять написанный код.

graphical user interface, GUI ) - разновидность пользовательского интерфейса, в котором элементы интерфейса (меню, кнопки, значки, списки и т. п.), представленные пользователю на дисплее, исполнены в виде графических изображений.

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

Графический интерфейс пользователя является частью пользовательского интерфейса и определяет взаимодействие с пользователем на уровне визуализированной информации.

История

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

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

"Ламповые монстры"

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

Шаг в теорию - так что же такое пользовательский интерфейс? Известный российский программист М. Донской дает этому понятию такое определение: "Сюда входит не только, и даже не столько картинка на экране - трехмерная, анимированная или просто выполненная в модном дизайне, - сколько способы взаимодействия пользователя с системой". Один из главных теоретиков в данной области, Тео Мандрел кратко определил лучший интерфейс как такой, который "позволяет пользователю сделать то, что он хочет, когда он хочет и как он хочет". Если подходить к большинству современных программных средств с такой позиции, то значительную часть из них (если не все) придется признать крайне неудовлетворительными. Впрочем, к этому мы еще вернемся, а сейчас снова обратимся к истории - как все это начиналось?

Теоретические основы GUI были заложены в 1960-е годы работами сотрудника исследовательского центра SRI Дуга Энгельбарта - в активе этого человека числятся манипулятор "мышь", управляемый с помощью манипулятора курсор на экране дисплея и система экранных окон, ответственных за исполняемые компьютером приложения. А точкой роста для идей Энгельбарта, впоследствии реализованных в полноценный GUI, стал Xerox Palo Alto Research Center, Xerox PARC, организованный на рубеже 1960-70 годов - там экспериментировали с прототипом графического пользовательского интерфейса, в котором символьный терминал и командная строка были заменены точечно-растровым экраном с иконками и многочисленными окнами.

В то время корпорация Xerox добилась всемирной известности, став почти монополистом на рынке копировальной офисной техники, и решила диверсифицировать свой бизнес, распространив его в область зарождающихся компьютерных технологий. Примечательно, что никто тогда точно не знал, что же следует делать - Xerox собрала под одной крышей хиппующую талантливую молодежь из университетских леваков, не желавших по политическим соображениям работать на правительство, и обеспечила своим подопечным относительную свободу. Разумеется, обстановка студенческой вольницы доставила немало головной боли администрации, но при этом весьма способствовала возникновению огромного количества передовых идей (в качестве примера можно назвать созданные именно в PARC первый ПК и лазерный принтер). Одной из них была так называемая парадигма WIMP (Windows, Icons, Menus, Point-and-click - окна, пиктограммы, меню, "укажи и щелкни"), которая и переросла позже в GUI.

В 1980 г. GUI из исследовательских лабораторий вышел на рынок, а годом позже Xerox представила оснащенную графическим интерфейсом, систему 8010 STAR Information System. Последовавшие затем реализации пользовались популярностью главным образом на рынке ПК, и только Sun с самого начала стала оснащать графическим интерфейсом свои рабочие станции. А вот GUI, реализованный Xerox PARC в компьютерах Alto и Star (коммерческая версия первого) успеха на рынке не получил.

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

Первый GUI: скриншот Alto

В нашем случае действительно оглушительный коммерческий успех достался совсем другой фирме - "фруктовой компании" под вывеской Apple Computers, где на основе идей Xerox создавалась аналогичная разработка. Не без помощи перешедших на работу в Apple сотрудников PARC здесь к 1984 году удалось выпустить знаменитый Apple Macintosh. Значительная часть его популярности приходилась на долю очень удачного GUI Lisa, реализованному в MacOS.

GUI Lisa: практически также выглядели первые версии MacOS

Огромное количество непрофессиональных пользователей, купивших себе Macintosh Classic - красноречивое тому подтверждение. Но именно Lisa компании Apple был первым ПЕРСОНАЛЬНЫМ компьютером, оснащенным графическим пользовательским интерфейсом.

К слову сказать, через девять лет Apple в какой-то мере удалось повторить этот успех, втиснув полноценный оконный интерфейс в принципиально новое устройство - наладонник Newton Message Pad с операционной системой Newton OS 1.0 (1993).

Однако во многом опередившая свое время компания не всегда оказывалась в состоянии в полной мере воспользоваться собственными достижениями - в ноябре 1985 года компания Microsoft выпустила первую версию своего графического интерфейса для собственной операционной системы MS-DOS - Windows 1.0 (рабочий лейбл Interface Manager). Наверное, это была первая операционная система, которую никто не заказывал, а Гейтс взялся разрабатывать ее на свой страх и риск. Окна в ней не перекрывались, а по причине явного отсутствия оптимизации под процессор 8086 не по-детски глючило ядро. Основной платформой для Windows 1.0 становились знаменитые машины IBM 286 PC/AT. Ровно два года спустя, в ноябре 1987-го, на свет появилась Windows 2.0, еще через полтора года вышла версия 2.10. Ничего особо нового в этих релизах не было, если не считать появление перекрывающихся окон.

Руководству Apple выход Windows 1.0 чрезвычайно не понравился, а Стив Джобс подытожил недовольство топ-менеджмента следующей фразой: "Графический интерфейс - это, конечно, всеобщее будущее, но если впереди лежит так много всего нового, то почему же Microsoft попросту скопировала нашу Lisa?!.." В итоге оскорбленная "фруктовая" компания в 1988 году подала в суд иск на Microsoft - за посягательство на внешний вид MacOS. Судебная тяжба затянулась на несколько лет, постепенно сумма иска выросла до астрономических для начала девяностых пяти с лишним миллиардов долларов, что превратило это и без того малоперспективное дело в практически безнадежное - безнадежное прежде всего по той причине, что Microsoft, приступая к разработке Windows, купила у Apple лицензию на GUI. Объективно оценить степень "недопустимости" заимствования элементов интерфейса у Apple стало делом крайне проблематичным, а упрятанный за окнами GUI исходный код был совершенно разным.

Скриншот Windows 1.0 - рабочего стола нет, иконок файлов и ярлыков нет.

В конце концов Гейтс согласился подписать соглашение о том, что его компания не станет использовать интерфейс Apple для своей Windows 1.0, но при этом в документе ничего не говорилось о следующих версиях данного продукта. Это невинное обстоятельство в полной мере аукнулось в 1995 году, когда в продаже появилась "чикага" - знаменитая Windows 95 с дизайном интерфейса, больше других версий похожим на оригинальный дизайн GUI Apple (правда, при этом он несколько мимикрировал в умелых руках сотрудников Microsoft). А в августе 1997 года, после полутора лет серьезнейших коммерческих неудач Apple, процветающая Microsoft помогла компании выкарабкаться из финансовой пропасти, приобретя 100 тысяч "яблочных" акций за 150 млн. долларов. Явный политический шаг, после которого изрядно затянувшаяся тяжба вокруг GUI была наконец-то прекращена. Вообще-то история не терпит сослагательных наклонений, но если бы Apple вдруг удалось быстро выиграть это дело, стал ли мир свидетелем феноменально-взрывного роста открытой архитектуры IBM-совместимых ПК в 1990-х годах?..

Возможное будущее GUI -трехмерные операционные системы

Современный среднестатистический пользователь уже не мыслит своей работы с компьютером без многочисленных окошек, кнопочек, стрелочек - того самого "дружественного и понятного интерфейса", и только когорта продвинутых профессионалов до сих пор предпочитает пользоваться неизменной командной строкой. В принципе, кому как удобно и какие цели преследуются - даже при современном развитии пользовательского интерфейса многие функции оказываются либо недоступным, либо неудобными при использовании графического оконного режима, а сам по себе GUI зачастую оставляет желать лучшего… Но факт остается фактом - именно графический интерфейс стал одной из главных причин продвижения компьютеров в широкие потребительские массы.

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

Классификация

Можно выделить следующие виды GUI:

• простой: типовые экранные формы и стандартные элементы интерфейса, обеспечиваемые самой подсистемой GUI;
• истинно-графический, двумерный: нестандартные элементы интерфейса и оригинальные метафоры, реализованные собственными средствами приложения или сторонней библиотекой;
• трёхмерный.

DWIM

Одним из требований к хорошему графическому интерфейсу программной системы является концепция «делай то, что я имею в виду» или DWIM (англ. Do What I Mean). DWIM требует, чтобы система работала предсказуемо, чтобы пользователь заранее интуитивно понимал, какое действие выполнит программа после получения его команды.

Достоинства

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

Недостатки

• Большее потребление памяти в сравнении с текстовым интерфейсом
• Сложнее организовать удаленную работу
• Невозможность автоматизации, если она не была заложена автором программы
• Графический интерфейс не является «дружелюбным» для пользователей, которые начали знакомство с компьютером с интерфейса командной строки.
• Графический интерфейс сложнее в использовании для незрячих людей.

Список популярных графических интерфейсов

1. GNOME

• Windows

1. Windows Vista
2. Windows 7
3. Windows 10

• Mac OS X

1. Leopard

Ссылки

1. Graphical user interface. (2016, December 22). In Wikipedia, The Free Encyclopedia. Retrieved 00:07, December 22, 2016, from https://en.wikipedia.org/w/index.php?title=Graphical_user_interface&oldid=756097302
2. imtime [Электронный ресурс]: GUI (Graphical User Interface) – так кто же все-таки первый? / Дата обращения: 25.12.16. - Режим доступа: