Как пользоваться программой MKVmerge GUI. Python GUI: создаём простое приложение с PyQt и Qt Designer

16.05.2019

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

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

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

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

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

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

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

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

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

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

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 требует, чтобы система работала предсказуемо, чтобы пользователь заранее интуитивно понимал, какое действие выполнит программа после получения его команды.

Достоинства

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

Недостатки

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

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

GNOME

Windows

Windows Vista
Windows 7
Windows 10

Mac OS X

Leopard

Ссылки

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
imtime [Электронный ресурс]: GUI (Graphical User Interface) – так кто же все-таки первый? / Дата обращения: 25.12.16. - Режим доступа:

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

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

Уже по традиции, перед тем, как перейти к примерам и работе с командой давайте рассмотрим ее основные опции и параметры. Синтаксис git очень прост:

$ git опции команда аргументы

Сначала рассмотрим опции, они влияют на работу всей утилиты:

-C - использовать указанную папку репозитория вместо текущей папки;
-c параметр=значение - использовать указанное значение параметра конфигурации;
-p - прокручивать весь вывод с помощью less;

Теперь рассмотрим команды git, их немного больше и именно с помощью них вы будете выполнять все основные действия:

add - добавить файл или папку в репозиторий git;
am - применить все патчи из email;
archive - создать архив файлов;
bisect - использовать бинарный поиск для поиска нужного коммита;
branch - управление ветками проекта;
bundle - перемещение объектов и ссылок в архиве;
checkout - переключение между ветками;
cherry-pick - внести изменения в уже существующие коммиты;
clean - удалить все неотслеживаемые файлы и папки проекта;
clone - создать копию удаленного репозитория в папку;
commit - сохранить изменения в репозиторий;
diff - посмотреть изменения между коммитами;
fetch - скачать удаленный репозиторий;
init - создать репозиторий;
merge - объединить две ветви;
pull - интегрировать удаленный репозиторий с локальным;
push - отправить изменения в удаленный репозиторий;
tag - управление тегами;
worktree - управление деревями разработки.

Аргументы зависят от используемой команды, поэтому более подробно мы будем разбирать их в примерах.

Как работает git?

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

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

Как пользоваться Git?

Обычно, структура проекта в Git будет зависеть от масштаба и сложности вашей программы. Но для начала мы будем использовать проект, состоящий только из одной ветви. Каждый проект содержит одну ветку по умолчанию, она называется master. Наш первый проект будет называться test.

Создание проекта

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

mkdir -p ~/git/testing ; cd ~/git/testing

Эта команда создаст нужную структуру папок и переводит текущий каталог в только что созданный. Теперь создадим первый файл нашего проекта:

Проект готов, но система контроля версий git еще не знает об этом.

Настройка проекта в git

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

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

Если все прошло хорошо, то команда ничего не выведет.

Фиксация изменений

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

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

git commit -m "Initial Commit" -a

Команде необходимо передать два параметра, первый - это -m, ваш комментарий, второй -a, означает, что нужно применить действие ко всем измененным файлам. Для первого раза используется этот параметр, но обычно вам нужно указать измененные файлы или каталоги. Например, можно делать так:

git commit -m "Changed file" file

Отправка изменений

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

Сначала нужно добавить удаленный репозиторий с помощью команды remote. Для этого нужно передать ей URL:

git remote add origin https://github.com/Seriyyy95/testing.git

Затем можно посмотреть список удаленных репозиториев:

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

git push origin master

Команда push указывает, что нужно отправить данные в удаленный репозиторий, origin - наш настроенный репозиторий, а master - ветвь.

Управление ветвями

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

Опция -a указывает что нужно вывести все ветви, даже не синхронизированные. Звездочка указывает на активную ветвь. Теперь создадим ветвь для разработки с помощью команды checkout:

git checkout -b develop

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

git checkout master
$ git checkout develop

Теперь создадим еще один файл:

И добавим его в нашу новую ветвь develop:

Сделаем коммит для внесенных изменений:

git commit -m "develop file" develop

git branch
$ ls

Затем переключаемся на ветку master и снова смотрим:

git checkout master
$ git branch
$ ls

Здесь файла нет, так и должно быть. В git есть такая полезная вещь, как слияние. С помощью нее вы можете объединить две ветви. Например, переместить код из рабочей ветки в стабильную. Для этого достаточно выполнить команду merge:

git merge develop --no-ff

Перед тем как будет выполнено слияние вам нужно ввести комментарий, зачем это нужно. Затем если вы еще раз выполните ls, то увидите, что здесь уже есть нужный файл. Наши примеры git подошли к концу.

Выводы

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

Давно не писал настольных приложений на Java вообще и с использовании Swing в частности. Однако, возникла необходимость немного по GUIть. В качестве инструмента выбрал IntelliJ IDEA Community edition, 2016.1 версии.

Взялся ваять и, естественно, первое, на что налетел - хотя со времён Borland Java Builder 2006 воды утекло немало, экранные интерфейсы создавать проще не стало, скорее наоборот. А одной из причин выбора IDEA было как раз наличие Swing дизайнера «из коробки», однако как им пользоваться с ходу решительно непонятно - форма генерится, класс создаётся, создаются переменные контролов из дизайнера… но и только: при создании нашего класса форма на экране не появляется

Пошарил интернет, информации приблизительно ноль. Народ говорит, мол, «создавай и - вперёд!». Хм…

По результатам небольших мытарств на эту тему решил опубликовать инструкцию, так как мне с учётом былого опыта было искать намного легче, чем новичку, который вообще в первый раз ваяет форму на Swing.

Создание Swing GUI форм средствами JetBrains IntelliJ IDEA 2016.1

Во-первых, для понимания процесса лучше начать с того. что зайти в меню IDEA «File -> Settings» - там «Editor -> GUI Designer» и установить флажок Generate GUI Into: в Java source code. (это немного поможет пониманию процесса на первом этапе - потом можно будет убрать обратно).

В итоге нам действительно сгенерили класс-наследник JDialog (который можно создать и использовать) и форма к нему.
Запускаем наш проект на выполнение и… о ужас чудо! при компиляции IDEA добавляет в конец нашего файла некоторый дополнительный код.

{ // GUI initializer generated by IntelliJ IDEA GUI Designer // >>> IMPORTANT!! <<< // DO NOT EDIT OR ADD ANY CODE HERE! $$$setupUI$$$(); } /** * Method generated by IntelliJ IDEA GUI Designer * >>> IMPORTANT!! <<< * DO NOT edit this method OR call it in your code! * * @noinspection ALL */ private void $$$setupUI$$$() { contentPane = new JPanel(); contentPane.setLayout(new com.intellij.uiDesigner.core.GridLayoutManager(2, 1, new Insets(10, 10, 10, 10), -1, -1)); .................... } /** * @noinspection ALL */ public JComponent $$$getRootComponent$$$() { return contentPane; }
Несложно догадаться, что вся наша Swing-овая форма конфигурируется в автогенерируемом методе $$$setupUI$$$.

Вспомните настройку, которую мы установили в самом начале - «GUI Into: -> Java source code». Если её не ставить, то этот метод просто будет появляться напрямую в _class_ файле, минуя java-файл (декомпилируйте его, если сомневаетесь - я это сделал). Соответственно, можете вернуть настройку «GUI Into:» к первоначальному виду, чтобы этот код (который всё равно редактировать настоятельно не рекомендуют) не мозолил глаза.

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

Опять правой кнопкой мыши кликаем на папку или файл исходного кода, выбираем «New -> GUI Form» - вводим имя класса для формы.

Генерится класс и форма к нему. Накидываем на форму несколько контролов. В GUI дизайнере смотрим имя корневого элемента (обычно panel1, если IDEA не задала имя, а такое бывает, задайте принудительно - я для наглядности назвал rootPanel).

Переходим к исходному коду нашего класса.

Итак:
1. Добавляем для нашего класса наследование «extends JFrame»;
2. Добавляем конструктор класса со строками:

SetContentPane(panel1); setVisible(true);

Итоговый код класса

public class GUIFrame extends JFrame{ private JButton button1; private JPanel rootPanel; public GUIFrame() { setContentPane(rootPanel); setVisible(true); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String args) { new GUIFrame(); } }

Всё. Форма готова к употреблению. Остальное смотрите в многочисленных инструкциях по Swing.

P.S. Как вариант, можно не наследовать наш класс от JFrame, а создать конструктор вида:

JFrame frame = new JFrame(); frame.setContentPane(panel1); frame.setVisible(true);
Такой вариант тоже работает - возможно, кому-то пригодится.

Теги: Добавить метки