Embed application icon as a resource and refactor icon usage

Replaced the external `icon.png` file with an embedded resource using Go's embed functionality. Updated all references to use the new resource, eliminating the need for the standalone icon file.

.gitignore

@@ -0,0 +1,2 @@
+fyne-cross/*
+ffmpeg/*

FyneApp.toml

@@ -0,0 +1,6 @@
+[Details]
+  Icon = "icon.png"
+  Name = "GUI for FFmpeg"
+  ID = "net.kor-elf.projects.gui-for-ffmpeg"
+  Version = "0.9.0"
+  Build = 11

README.md

@@ -1,5 +1,31 @@
-# ffmpeg-gui
+# GUI for FFmpeg
 
-Простенький интерфейс к программе ffmpeg.
+<p>Простенький интерфейс для консольной утилиты FFmpeg. Но я <strong>не являюсь</strong> автором самой утилиты <strong>FFmpeg</strong>.</p>
+<p><strong>FFmpeg</strong> — торговая марка <strong><a href="http://bellard.org/" target="_blank">Fabrice Bellard</a></strong>, создателя проекта <strong><a href="https://ffmpeg.org/about.html" target="_blank">FFmpeg</a></strong>.</p>
 
-<img src="images/screenshot-ffmpeg-gui.png">
+<p>Программное обеспечение является MIT (см. <a href="https://git.kor-elf.net/kor-elf/gui-for-ffmpeg/src/branch/main/LICENSE">LICENSE</a>) и использует сторонние библиотеки, которые распространяются на их собственных условиях (см. <a href="https://git.kor-elf.net/kor-elf/gui-for-ffmpeg/src/branch/main/LICENSE-3RD-PARTY.txt">LICENSE-3RD-PARTY.txt</a>).</p>
+
+<img src="images/screenshot-gui-for-ffmpeg.png">
+
+<p>Скачать скомпилированные готовые версии можно тут: <a href="https://git.kor-elf.net/kor-elf/gui-for-ffmpeg/releases">https://git.kor-elf.net/kor-elf/gui-for-ffmpeg/releases</a>.</p>
+
+## Установка через fyne:
+1. go install fyne.io/fyne/v2/cmd/fyne@latest
+2. fyne get git.kor-elf.net/kor-elf/gui-for-ffmpeg
+
+## Скомпилировать через исходники:
+1. git clone https://git.kor-elf.net/kor-elf/gui-for-ffmpeg.git
+2. Переходим в папку проекта и там переходим в папку src: **cd gui-for-ffmpeg**
+3. Ознакамливаемся, что нужно ещё установить для Вашей ОС для простого запуска (через go run) тут: https://docs.fyne.io/started/
+4. *(не обязательный шаг)* Просто запустить можно так: **go run main.go**
+5. go install github.com/fyne-io/fyne-cross@latest
+   * У Вас так же должен быть установлен docker
+   * О fyne-cross можно по подробней почитать тут: https://github.com/fyne-io/fyne-cross
+6. * fyne-cross windows --icon icon.png --app-id "." -name "gui-for-ffmpeg"
+   * fyne-cross linux --icon icon.png --app-id "." -name "gui-for-ffmpeg"
+7. Создаться папка **fyne-cross/bin** и там будет созданна папка с тем названием под которую Вы компилировали приложения (linux-amd64 или windows-amd64).
+8. В папку **fyne-cross/bin/linux-amd64** или **fyne-cross/bin/windows-amd64** копируете:
+   * LICENSE
+   * LICENSE-3RD-PARTY.txt
+<p><strong>Структура должна получиться такая:</strong></p>
+<img src="images/screenshot-folder-structure.png">

convertor/repository.go

@@ -0,0 +1,46 @@
+package convertor
+
+import (
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/setting"
+)
+
+type RepositoryContract interface {
+	GetPathFfmpeg() string
+	SavePathFfmpeg(code string) setting.Setting
+	GetPathFfprobe() string
+	SavePathFfprobe(code string) setting.Setting
+	GetPathFfplay() string
+	SavePathFfplay(code string) setting.Setting
+}
+
+type Repository struct {
+	settingRepository setting.RepositoryContract
+}
+
+func NewRepository(settingRepository setting.RepositoryContract) *Repository {
+	return &Repository{settingRepository: settingRepository}
+}
+
+func (r Repository) GetPathFfmpeg() string {
+	return r.settingRepository.GetValue("ffmpeg")
+}
+
+func (r Repository) SavePathFfmpeg(path string) setting.Setting {
+	return r.settingRepository.CreateOrUpdate("ffmpeg", path)
+}
+
+func (r Repository) GetPathFfprobe() string {
+	return r.settingRepository.GetValue("ffprobe")
+}
+
+func (r Repository) SavePathFfprobe(path string) setting.Setting {
+	return r.settingRepository.CreateOrUpdate("ffprobe", path)
+}
+
+func (r Repository) GetPathFfplay() string {
+	return r.settingRepository.GetValue("ffplay")
+}
+
+func (r Repository) SavePathFfplay(path string) setting.Setting {
+	return r.settingRepository.CreateOrUpdate("ffplay", path)
+}

convertor/view.go

@@ -0,0 +1,60 @@
+package convertor
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor/view"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"image/color"
+)
+
+type ViewContract interface {
+	Main(
+		formConversion view.ConversionContract,
+	)
+	SelectFFPath(
+		ffmpegPath string,
+		ffprobePath string,
+		ffplayPath string,
+		save func(ffmpegPath string, ffprobePath string, ffplayPath string) error,
+		cancel func(),
+		donwloadFFmpeg func(progressBar *widget.ProgressBar, progressMessage *canvas.Text) error,
+	)
+}
+
+type View struct {
+	app            kernel.AppContract
+	downloadFFmpeg *downloadFFmpeg
+}
+
+type downloadFFmpeg struct {
+	isDownloadFFmpeg             bool
+	blockDownloadFFmpegContainer *fyne.Container
+}
+
+func NewView(app kernel.AppContract) *View {
+	return &View{
+		app: app,
+		downloadFFmpeg: &downloadFFmpeg{
+			blockDownloadFFmpegContainer: nil,
+		},
+	}
+}
+
+func (v View) Main(formConversion view.ConversionContract) {
+	converterVideoFilesTitle := v.app.GetLocalizerService().GetMessage("converterVideoFilesTitle")
+	v.app.GetWindow().SetContent(widget.NewCard(converterVideoFilesTitle, "", container.NewVScroll(formConversion.GetContent())))
+	formConversion.AfterViewContent()
+}
+
+func setStringErrorStyle(text *canvas.Text) {
+	text.Color = color.RGBA{R: 255, G: 0, B: 0, A: 255}
+	text.Refresh()
+}
+
+func setStringSuccessStyle(text *canvas.Text) {
+	text.Color = color.RGBA{R: 49, G: 127, B: 114, A: 255}
+	text.Refresh()
+}

convertor/view/conversion.go

@@ -0,0 +1,515 @@
+package view
+
+import (
+	"errors"
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/storage"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor/view/form_items"
+	encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/setting"
+	"image/color"
+	"os"
+	"path/filepath"
+)
+
+type ConversionContract interface {
+	GetContent() fyne.CanvasObject
+	AfterViewContent()
+}
+
+type Conversion struct {
+	app                   kernel.AppContract
+	form                  *form
+	conversionMessage     *canvas.Text
+	fileForConversion     *fileForConversion
+	directoryForSaving    *directoryForSaving
+	overwriteOutputFiles  *overwriteOutputFiles
+	selectEncoder         *selectEncoder
+	runConvert            func(setting HandleConvertSetting)
+	itemsToConvertService kernel.ItemsToConvertContract
+}
+
+type HandleConvertSetting struct {
+	DirectoryForSave     string
+	OverwriteOutputFiles bool
+	Format               string
+	Encoder              encoder2.EncoderContract
+}
+
+func NewConversion(app kernel.AppContract, formats encoder.ConvertorFormatsContract, runConvert func(setting HandleConvertSetting), settingDirectoryForSaving setting.DirectoryForSavingContract, itemsToConvertService kernel.ItemsToConvertContract) *Conversion {
+	conversionMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	conversionMessage.TextSize = 16
+	conversionMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	fileForConversion := newFileForConversion(app, itemsToConvertService)
+	directoryForSaving := newDirectoryForSaving(app, settingDirectoryForSaving)
+	overwriteOutputFiles := newOverwriteOutputFiles(app)
+	selectEncoder := newSelectEncoder(app, formats)
+
+	items := []*widget.FormItem{
+		{
+			Text:   app.GetLocalizerService().GetMessage("fileForConversionTitle"),
+			Widget: fileForConversion.button,
+		},
+		{
+			Widget: container.NewHScroll(fileForConversion.message),
+		},
+		{
+			Text:   app.GetLocalizerService().GetMessage("buttonForSelectedDirTitle"),
+			Widget: directoryForSaving.button,
+		},
+		{
+			Widget: container.NewHScroll(directoryForSaving.message),
+		},
+		{
+			Widget: overwriteOutputFiles.checkbox,
+		},
+		{
+			Widget: selectEncoder.SelectFileType,
+		},
+		{
+			Text:   app.GetLocalizerService().GetMessage("selectFormat"),
+			Widget: selectEncoder.SelectFormat,
+		},
+		{
+			Text:   app.GetLocalizerService().GetMessage("selectEncoder"),
+			Widget: selectEncoder.SelectEncoder,
+		},
+	}
+	form := newForm(app, items)
+
+	return &Conversion{
+		app:                   app,
+		form:                  form,
+		conversionMessage:     conversionMessage,
+		fileForConversion:     fileForConversion,
+		directoryForSaving:    directoryForSaving,
+		overwriteOutputFiles:  overwriteOutputFiles,
+		selectEncoder:         selectEncoder,
+		runConvert:            runConvert,
+		itemsToConvertService: itemsToConvertService,
+	}
+}
+
+func (c Conversion) GetContent() fyne.CanvasObject {
+	c.form.form.OnSubmit = c.submit
+	c.fileForConversion.AddChangeCallback(c.selectFileForConversion)
+	c.selectEncoder.AddChangeCallback(c.changeEncoder)
+	if c.selectEncoder.Encoder != nil {
+		c.selectEncoder.SelectEncoder.SetSelectedIndex(c.selectEncoder.SelectEncoder.SelectedIndex())
+	}
+
+	return container.NewVBox(
+		c.form.form,
+		c.conversionMessage,
+	)
+}
+
+func (c Conversion) changeEncoder(encoder encoder2.EncoderContract) {
+	items := []*widget.FormItem{}
+
+	if form_items.Views[encoder.GetName()] != nil {
+		items = form_items.Views[encoder.GetName()](encoder, c.app)
+	}
+
+	c.form.ChangeItems(items)
+}
+
+func (c Conversion) AfterViewContent() {
+	if len(c.itemsToConvertService.GetItems()) == 0 {
+		c.form.form.Disable()
+	}
+}
+
+func (c Conversion) selectFileForConversion(err error) {
+	c.conversionMessage.Text = ""
+	if len(c.itemsToConvertService.GetItems()) == 0 {
+		if err != nil {
+			c.form.form.Disable()
+			return
+		}
+	}
+
+	c.form.form.Enable()
+}
+
+func (c Conversion) submit() {
+	if len(c.itemsToConvertService.GetItems()) == 0 {
+		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage("errorNoFilesAddedForConversion")))
+		c.enableFormConversion()
+		return
+	}
+
+	if len(c.directoryForSaving.path) == 0 {
+		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage("errorSelectedFolderSave")))
+		c.enableFormConversion()
+		return
+	}
+	if len(c.selectEncoder.SelectFormat.Selected) == 0 {
+		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage("errorSelectedFormat")))
+		return
+	}
+	if c.selectEncoder.Encoder == nil {
+		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage("errorSelectedEncoder")))
+		return
+	}
+	c.conversionMessage.Text = ""
+
+	c.fileForConversion.button.Disable()
+	c.directoryForSaving.button.Disable()
+	c.form.form.Disable()
+
+	c.runConvert(HandleConvertSetting{
+		DirectoryForSave:     c.directoryForSaving.path,
+		OverwriteOutputFiles: c.overwriteOutputFiles.IsChecked(),
+		Format:               c.selectEncoder.SelectFormat.Selected,
+		Encoder:              c.selectEncoder.Encoder,
+	})
+	c.enableFormConversion()
+
+	if len(c.itemsToConvertService.GetItems()) == 0 {
+		c.form.form.Disable()
+	}
+}
+
+func (c Conversion) enableFormConversion() {
+	c.fileForConversion.button.Enable()
+	c.directoryForSaving.button.Enable()
+	c.form.form.Enable()
+}
+
+type fileForConversion struct {
+	button  *widget.Button
+	message *canvas.Text
+	file    *kernel.File
+
+	changeCallbacks map[int]func(err error)
+}
+
+func newFileForConversion(app kernel.AppContract, itemsToConvertService kernel.ItemsToConvertContract) *fileForConversion {
+	message := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	fileForConversion := &fileForConversion{
+		message: message,
+
+		changeCallbacks: map[int]func(err error){},
+	}
+
+	buttonTitle := app.GetLocalizerService().GetMessage("choose") + "\n" +
+		app.GetLocalizerService().GetMessage("or") + "\n" +
+		app.GetLocalizerService().GetMessage("dragAndDropFiles")
+
+	var locationURI fyne.ListableURI
+
+	fileForConversion.button = widget.NewButton(buttonTitle, func() {
+		app.GetWindow().NewFileOpen(func(r fyne.URIReadCloser, err error) {
+			fyne.Do(func() {
+				fileForConversion.message.Text = ""
+				fileForConversion.message.Refresh()
+			})
+
+			if err != nil {
+				fyne.Do(func() {
+					fileForConversion.message.Text = err.Error()
+					fileForConversion.message.Refresh()
+				})
+				fileForConversion.eventSelectFile(err)
+				return
+			}
+			if r == nil {
+				return
+			}
+			app.GetWindow().GetLayout().GetRightTabs().SelectAddedFilesTab()
+
+			itemsToConvertService.Add(&kernel.File{
+				Path: r.URI().Path(),
+				Name: r.URI().Name(),
+				Ext:  r.URI().Extension(),
+			})
+
+			fileForConversion.eventSelectFile(nil)
+
+			listableURI := storage.NewFileURI(filepath.Dir(r.URI().Path()))
+			locationURI, _ = storage.ListerForURI(listableURI)
+		}, locationURI)
+	})
+
+	app.GetWindow().SetOnDropped(func(position fyne.Position, uris []fyne.URI) {
+		if len(uris) == 0 {
+			return
+		}
+
+		isError := false
+		for _, uri := range uris {
+			info, err := os.Stat(uri.Path())
+			if err != nil {
+				isError = true
+				continue
+			}
+			if info.IsDir() {
+				isError = true
+				continue
+			}
+
+			itemsToConvertService.Add(&kernel.File{
+				Path: uri.Path(),
+				Name: uri.Name(),
+				Ext:  uri.Extension(),
+			})
+
+			fileForConversion.eventSelectFile(nil)
+
+			listableURI := storage.NewFileURI(filepath.Dir(uri.Path()))
+			locationURI, _ = storage.ListerForURI(listableURI)
+		}
+		app.GetWindow().GetLayout().GetRightTabs().SelectAddedFilesTab()
+		if isError {
+			fileForConversion.message.Text = app.GetLocalizerService().GetMessage("errorDragAndDropFile")
+			setStringErrorStyle(fileForConversion.message)
+			fileForConversion.eventSelectFile(errors.New(fileForConversion.message.Text))
+		} else {
+			fyne.Do(func() {
+				fileForConversion.message.Text = ""
+				fileForConversion.message.Refresh()
+			})
+		}
+	})
+
+	return fileForConversion
+}
+
+func (c fileForConversion) AddChangeCallback(callback func(err error)) {
+	c.changeCallbacks[len(c.changeCallbacks)] = callback
+}
+
+func (c fileForConversion) eventSelectFile(err error) {
+	for _, changeCallback := range c.changeCallbacks {
+		changeCallback(err)
+	}
+}
+
+type directoryForSaving struct {
+	button  *widget.Button
+	message *canvas.Text
+	path    string
+}
+
+func newDirectoryForSaving(app kernel.AppContract, settingDirectoryForSaving setting.DirectoryForSavingContract) *directoryForSaving {
+	directoryForSaving := &directoryForSaving{
+		path: "",
+	}
+
+	directoryForSaving.message = canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	directoryForSaving.message.TextSize = 16
+	directoryForSaving.message.TextStyle = fyne.TextStyle{Bold: true}
+
+	buttonTitle := app.GetLocalizerService().GetMessage("choose")
+
+	var locationURI fyne.ListableURI
+
+	location, err := getDirectoryForSaving(settingDirectoryForSaving)
+	if err == nil {
+		directoryForSaving.path = location.Path()
+		directoryForSaving.message.Text = location.Path()
+		setStringSuccessStyle(directoryForSaving.message)
+	}
+
+	directoryForSaving.button = widget.NewButton(buttonTitle, func() {
+		app.GetWindow().NewFolderOpen(func(r fyne.ListableURI, err error) {
+			if err != nil {
+				directoryForSaving.message.Text = err.Error()
+				setStringErrorStyle(directoryForSaving.message)
+				return
+			}
+			if r == nil {
+				return
+			}
+
+			directoryForSaving.path = r.Path()
+
+			directoryForSaving.message.Text = r.Path()
+			setStringSuccessStyle(directoryForSaving.message)
+			locationURI, err = storage.ListerForURI(r)
+
+			if err == nil {
+				_ = settingDirectoryForSaving.SaveDirectoryForSaving(locationURI.Path())
+			}
+
+		}, locationURI)
+	})
+
+	return directoryForSaving
+}
+
+func getDirectoryForSaving(settingDirectoryForSaving setting.DirectoryForSavingContract) (fyne.ListableURI, error) {
+	path := settingDirectoryForSaving.GetDirectoryForSaving()
+
+	if len(path) > 0 {
+		path = "file://" + path
+	}
+
+	uri, err := storage.ParseURI(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return storage.ListerForURI(uri)
+}
+
+type overwriteOutputFiles struct {
+	checkbox  *widget.Check
+	isChecked bool
+}
+
+func newOverwriteOutputFiles(app kernel.AppContract) *overwriteOutputFiles {
+	overwriteOutputFiles := &overwriteOutputFiles{
+		isChecked: false,
+	}
+	checkboxOverwriteOutputFilesTitle := app.GetLocalizerService().GetMessage("checkboxOverwriteOutputFilesTitle")
+	overwriteOutputFiles.checkbox = widget.NewCheck(checkboxOverwriteOutputFilesTitle, func(b bool) {
+		overwriteOutputFiles.isChecked = b
+	})
+
+	return overwriteOutputFiles
+}
+
+func (receiver overwriteOutputFiles) IsChecked() bool {
+	return receiver.isChecked
+}
+
+type selectEncoder struct {
+	SelectFileType *widget.RadioGroup
+	SelectFormat   *widget.Select
+	SelectEncoder  *widget.Select
+	Encoder        encoder2.EncoderContract
+
+	changeCallbacks map[int]func(encoder encoder2.EncoderContract)
+}
+
+func newSelectEncoder(app kernel.AppContract, formats encoder.ConvertorFormatsContract) *selectEncoder {
+	selectEncoder := &selectEncoder{
+		changeCallbacks: map[int]func(encoder encoder2.EncoderContract){},
+	}
+
+	encoders := map[int]encoder2.EncoderDataContract{}
+	selectEncoder.SelectEncoder = widget.NewSelect([]string{}, func(s string) {
+		if encoders[selectEncoder.SelectEncoder.SelectedIndex()] == nil {
+			return
+		}
+		selectEncoderData := encoders[selectEncoder.SelectEncoder.SelectedIndex()]
+		selectEncoder.ChangeEncoder(selectEncoderData.NewEncoder())
+	})
+
+	formatSelected := ""
+	selectEncoder.SelectFormat = widget.NewSelect([]string{}, func(s string) {
+		if formatSelected == s {
+			return
+		}
+		formatSelected = s
+		format, err := formats.GetFormat(s)
+		if err != nil {
+			return
+		}
+		encoderOptions := []string{}
+		encoders = map[int]encoder2.EncoderDataContract{}
+		for _, e := range format.GetEncoders() {
+			encoders[len(encoders)] = e
+			encoderOptions = append(encoderOptions, app.GetLocalizerService().GetMessage("encoder_"+e.GetTitle()))
+		}
+		selectEncoder.SelectEncoder.SetOptions(encoderOptions)
+		selectEncoder.SelectEncoder.SetSelectedIndex(0)
+	})
+
+	fileTypeOptions := []string{}
+	for _, fileType := range encoder2.GetListFileType() {
+		fileTypeOptions = append(fileTypeOptions, fileType.Name())
+	}
+
+	encoderGroupVideo := app.GetLocalizerService().GetMessage("encoderGroupVideo")
+	encoderGroupAudio := app.GetLocalizerService().GetMessage("encoderGroupAudio")
+	encoderGroupImage := app.GetLocalizerService().GetMessage("encoderGroupImage")
+	encoderGroup := map[string]string{
+		encoderGroupVideo: "video",
+		encoderGroupAudio: "audio",
+		encoderGroupImage: "image",
+	}
+	selectEncoder.SelectFileType = widget.NewRadioGroup([]string{encoderGroupVideo, encoderGroupAudio, encoderGroupImage}, func(s string) {
+		groupCode := encoderGroup[s]
+
+		formatOptions := []string{}
+		for _, f := range formats.GetFormats() {
+			if groupCode != f.GetFileType().Name() {
+				continue
+			}
+			formatOptions = append(formatOptions, f.GetTitle())
+		}
+		selectEncoder.SelectFormat.SetOptions(formatOptions)
+		if groupCode == encoder2.FileType(encoder2.Video).Name() {
+			selectEncoder.SelectFormat.SetSelected("mp4")
+		} else {
+			selectEncoder.SelectFormat.SetSelectedIndex(0)
+		}
+	})
+	selectEncoder.SelectFileType.Horizontal = true
+	selectEncoder.SelectFileType.Required = true
+	selectEncoder.SelectFileType.SetSelected(encoderGroupVideo)
+
+	return selectEncoder
+}
+
+func (e *selectEncoder) ChangeEncoder(encoder encoder2.EncoderContract) {
+	e.Encoder = encoder
+	e.eventSelectEncoder(e.Encoder)
+}
+
+func (e *selectEncoder) AddChangeCallback(callback func(encoder encoder2.EncoderContract)) {
+	e.changeCallbacks[len(e.changeCallbacks)] = callback
+}
+
+func (e *selectEncoder) eventSelectEncoder(encoder encoder2.EncoderContract) {
+	for _, changeCallback := range e.changeCallbacks {
+		changeCallback(encoder)
+	}
+}
+
+func setStringErrorStyle(text *canvas.Text) {
+	text.Color = color.RGBA{R: 255, G: 0, B: 0, A: 255}
+	text.Refresh()
+}
+
+func setStringSuccessStyle(text *canvas.Text) {
+	text.Color = color.RGBA{R: 49, G: 127, B: 114, A: 255}
+	text.Refresh()
+}
+
+func showConversionMessage(conversionMessage *canvas.Text, err error) {
+	conversionMessage.Text = err.Error()
+	setStringErrorStyle(conversionMessage)
+}
+
+type form struct {
+	form  *widget.Form
+	items []*widget.FormItem
+}
+
+func newForm(app kernel.AppContract, items []*widget.FormItem) *form {
+	f := widget.NewForm()
+	f.SubmitText = app.GetLocalizerService().GetMessage("converterVideoFilesSubmitTitle")
+	f.Items = items
+
+	return &form{
+		form:  f,
+		items: items,
+	}
+}
+
+func (f form) ChangeItems(items []*widget.FormItem) {
+	f.form.Items = f.items
+	f.form.Refresh()
+	f.form.Items = append(f.form.Items, items...)
+	f.form.Refresh()
+}

convertor/view/form_items/form.go

@@ -0,0 +1,16 @@
+package form_items
+
+import (
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor/view/form_items/h264_nvenc"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor/view/form_items/libx264"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor/view/form_items/libx265"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+)
+
+var Views = map[string]func(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem{
+	"libx264":    libx264.View,
+	"h264_nvenc": h264_nvenc.View,
+	"libx265":    libx265.View,
+}

convertor/view/form_items/h264_nvenc/view.go

@@ -0,0 +1,64 @@
+package h264_nvenc
+
+import (
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/h264_nvenc"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+)
+
+func View(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem {
+	items := []*widget.FormItem{}
+
+	items = append(items, presetParameter(encoder, app)...)
+
+	return items
+}
+
+func presetParameter(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem {
+	parameter, err := encoder.GetParameter("preset")
+	if err != nil {
+		return nil
+	}
+
+	presets := map[string]string{}
+	presetsForSelect := []string{}
+	presetDefault := ""
+
+	for _, name := range h264_nvenc.Presets {
+		title := name
+		presetsForSelect = append(presetsForSelect, name)
+		presets[title] = name
+		if name == parameter.Get() {
+			presetDefault = title
+		}
+	}
+
+	elementSelect := widget.NewSelect(presetsForSelect, func(s string) {
+		if presets[s] == "" {
+			return
+		}
+		parameter.Set(presets[s])
+	})
+	elementSelect.SetSelected(presetDefault)
+	elementSelect.Hide()
+
+	checkboxTitle := app.GetLocalizerService().GetMessage("parameterCheckbox")
+	elementCheckbox := widget.NewCheck(checkboxTitle, func(b bool) {
+		if b == true {
+			parameter.SetEnable()
+			elementSelect.Show()
+			return
+		}
+		parameter.SetDisable()
+		elementSelect.Hide()
+	})
+
+	return []*widget.FormItem{
+		{
+			Text:   app.GetLocalizerService().GetMessage("formPreset"),
+			Widget: container.NewVBox(elementCheckbox, elementSelect),
+		},
+	}
+}

convertor/view/form_items/libx264/view.go

@@ -0,0 +1,64 @@
+package libx264
+
+import (
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libx264"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+)
+
+func View(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem {
+	items := []*widget.FormItem{}
+
+	items = append(items, presetParameter(encoder, app)...)
+
+	return items
+}
+
+func presetParameter(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem {
+	parameter, err := encoder.GetParameter("preset")
+	if err != nil {
+		return nil
+	}
+
+	presets := map[string]string{}
+	presetsForSelect := []string{}
+	presetDefault := ""
+
+	for _, name := range libx264.Presets {
+		title := app.GetLocalizerService().GetMessage("preset_" + name)
+		presetsForSelect = append(presetsForSelect, title)
+		presets[title] = name
+		if name == parameter.Get() {
+			presetDefault = title
+		}
+	}
+
+	elementSelect := widget.NewSelect(presetsForSelect, func(s string) {
+		if presets[s] == "" {
+			return
+		}
+		parameter.Set(presets[s])
+	})
+	elementSelect.SetSelected(presetDefault)
+	elementSelect.Hide()
+
+	checkboxTitle := app.GetLocalizerService().GetMessage("parameterCheckbox")
+	elementCheckbox := widget.NewCheck(checkboxTitle, func(b bool) {
+		if b == true {
+			parameter.SetEnable()
+			elementSelect.Show()
+			return
+		}
+		parameter.SetDisable()
+		elementSelect.Hide()
+	})
+
+	return []*widget.FormItem{
+		{
+			Text:   app.GetLocalizerService().GetMessage("formPreset"),
+			Widget: container.NewVBox(elementCheckbox, elementSelect),
+		},
+	}
+}

convertor/view/form_items/libx265/view.go

@@ -0,0 +1,64 @@
+package libx265
+
+import (
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libx265"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+)
+
+func View(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem {
+	items := []*widget.FormItem{}
+
+	items = append(items, presetParameter(encoder, app)...)
+
+	return items
+}
+
+func presetParameter(encoder encoder.EncoderContract, app kernel.AppContract) []*widget.FormItem {
+	parameter, err := encoder.GetParameter("preset")
+	if err != nil {
+		return nil
+	}
+
+	presets := map[string]string{}
+	presetsForSelect := []string{}
+	presetDefault := ""
+
+	for _, name := range libx265.Presets {
+		title := app.GetLocalizerService().GetMessage("preset_" + name)
+		presetsForSelect = append(presetsForSelect, title)
+		presets[title] = name
+		if name == parameter.Get() {
+			presetDefault = title
+		}
+	}
+
+	elementSelect := widget.NewSelect(presetsForSelect, func(s string) {
+		if presets[s] == "" {
+			return
+		}
+		parameter.Set(presets[s])
+	})
+	elementSelect.SetSelected(presetDefault)
+	elementSelect.Hide()
+
+	checkboxTitle := app.GetLocalizerService().GetMessage("parameterCheckbox")
+	elementCheckbox := widget.NewCheck(checkboxTitle, func(b bool) {
+		if b == true {
+			parameter.SetEnable()
+			elementSelect.Show()
+			return
+		}
+		parameter.SetDisable()
+		elementSelect.Hide()
+	})
+
+	return []*widget.FormItem{
+		{
+			Text:   app.GetLocalizerService().GetMessage("formPreset"),
+			Widget: container.NewVBox(elementCheckbox, elementSelect),
+		},
+	}
+}

convertor/view_setting.go

@@ -0,0 +1,128 @@
+package convertor
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/storage"
+	"fyne.io/fyne/v2/widget"
+	"image/color"
+	"net/url"
+	"path/filepath"
+)
+
+func (v View) SelectFFPath(
+	currentPathFfmpeg string,
+	currentPathFfprobe string,
+	currentPathFfplay string,
+	save func(ffmpegPath string, ffprobePath string, ffplayPath string) error,
+	cancel func(),
+	donwloadFFmpeg func(progressBar *widget.ProgressBar, progressMessage *canvas.Text) error,
+) {
+	errorMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	errorMessage.TextSize = 16
+	errorMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	ffmpegPath, buttonFFmpeg, buttonFFmpegMessage := v.getButtonSelectFile(currentPathFfmpeg)
+	ffprobePath, buttonFFprobe, buttonFFprobeMessage := v.getButtonSelectFile(currentPathFfprobe)
+	ffplayPath, buttonFFplay, buttonFFplayMessage := v.getButtonSelectFile(currentPathFfplay)
+
+	link := widget.NewHyperlink("https://ffmpeg.org/download.html", &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "download.html",
+	})
+
+	form := &widget.Form{
+		Items: []*widget.FormItem{
+			{
+				Text:   v.app.GetLocalizerService().GetMessage("titleDownloadLink"),
+				Widget: link,
+			},
+			{
+				Text:   v.app.GetLocalizerService().GetMessage("pathToFfmpeg"),
+				Widget: buttonFFmpeg,
+			},
+			{
+				Widget: container.NewHScroll(buttonFFmpegMessage),
+			},
+			{
+				Text:   v.app.GetLocalizerService().GetMessage("pathToFfprobe"),
+				Widget: buttonFFprobe,
+			},
+			{
+				Widget: container.NewHScroll(buttonFFprobeMessage),
+			},
+			{
+				Text:   v.app.GetLocalizerService().GetMessage("pathToFfplay"),
+				Widget: buttonFFplay,
+			},
+			{
+				Widget: container.NewHScroll(buttonFFplayMessage),
+			},
+			{
+				Widget: errorMessage,
+			},
+		},
+		SubmitText: v.app.GetLocalizerService().GetMessage("save"),
+		OnSubmit: func() {
+			err := save(*ffmpegPath, *ffprobePath, *ffplayPath)
+			if err != nil {
+				errorMessage.Text = err.Error()
+			}
+		},
+	}
+	if cancel != nil {
+		form.OnCancel = cancel
+		form.CancelText = v.app.GetLocalizerService().GetMessage("cancel")
+	}
+	selectFFPathTitle := v.app.GetLocalizerService().GetMessage("selectFFPathTitle")
+
+	if v.downloadFFmpeg.blockDownloadFFmpegContainer == nil {
+		v.downloadFFmpeg.blockDownloadFFmpegContainer = v.blockDownloadFFmpeg(donwloadFFmpeg)
+	}
+
+	v.app.GetWindow().SetContent(widget.NewCard(selectFFPathTitle, "", container.NewVBox(
+		form,
+		v.downloadFFmpeg.blockDownloadFFmpegContainer,
+	)))
+}
+
+func (v View) getButtonSelectFile(path string) (filePath *string, button *widget.Button, buttonMessage *canvas.Text) {
+	filePath = &path
+
+	buttonMessage = canvas.NewText(path, color.RGBA{R: 49, G: 127, B: 114, A: 255})
+	buttonMessage.TextSize = 16
+	buttonMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	buttonTitle := v.app.GetLocalizerService().GetMessage("choose")
+
+	var locationURI fyne.ListableURI
+	if len(path) > 0 {
+		listableURI := storage.NewFileURI(filepath.Dir(path))
+		locationURI, _ = storage.ListerForURI(listableURI)
+	}
+
+	button = widget.NewButton(buttonTitle, func() {
+		v.app.GetWindow().NewFileOpen(func(r fyne.URIReadCloser, err error) {
+			if err != nil {
+				buttonMessage.Text = err.Error()
+				setStringErrorStyle(buttonMessage)
+				return
+			}
+			if r == nil {
+				return
+			}
+
+			path = r.URI().Path()
+
+			buttonMessage.Text = r.URI().Path()
+			setStringSuccessStyle(buttonMessage)
+
+			listableURI := storage.NewFileURI(filepath.Dir(r.URI().Path()))
+			locationURI, _ = storage.ListerForURI(listableURI)
+		}, locationURI)
+	})
+
+	return
+}

convertor/view_setting_button_download_ffmpeg_anyos.go

@@ -0,0 +1,17 @@
+//go:build !windows && !linux
+// +build !windows,!linux
+
+package convertor
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+)
+
+func (v View) blockDownloadFFmpeg(
+	donwloadFFmpeg func(progressBar *widget.ProgressBar, progressMessage *canvas.Text) error,
+) *fyne.Container {
+	return container.NewVBox()
+}

convertor/view_setting_button_download_ffmpeg_linux.go

@@ -0,0 +1,61 @@
+//go:build linux
+// +build linux
+
+package convertor
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"golang.org/x/image/colornames"
+	"image/color"
+)
+
+func (v View) blockDownloadFFmpeg(
+	donwloadFFmpeg func(progressBar *widget.ProgressBar, progressMessage *canvas.Text) error,
+) *fyne.Container {
+
+	errorDownloadFFmpegMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	errorDownloadFFmpegMessage.TextSize = 16
+	errorDownloadFFmpegMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	progressDownloadFFmpegMessage := canvas.NewText("", color.RGBA{R: 49, G: 127, B: 114, A: 255})
+	progressDownloadFFmpegMessage.TextSize = 16
+	progressDownloadFFmpegMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	progressBar := widget.NewProgressBar()
+
+	var buttonDownloadFFmpeg *widget.Button
+
+	buttonDownloadFFmpeg = widget.NewButton(v.app.GetLocalizerService().GetMessage("download"), func() {
+		fyne.Do(func() {
+			buttonDownloadFFmpeg.Disable()
+		})
+		go func() {
+			err := donwloadFFmpeg(progressBar, progressDownloadFFmpegMessage)
+			if err != nil {
+				errorDownloadFFmpegMessage.Text = err.Error()
+			}
+			fyne.Do(func() {
+				buttonDownloadFFmpeg.Enable()
+			})
+		}()
+
+	})
+
+	downloadFFmpegFromSiteMessage := v.app.GetLocalizerService().GetMessage("downloadFFmpegFromSite")
+
+	return container.NewVBox(
+		canvas.NewLine(colornames.Darkgreen),
+		widget.NewCard(v.app.GetLocalizerService().GetMessage("buttonDownloadFFmpeg"), "", container.NewVBox(
+			widget.NewRichTextFromMarkdown(
+				downloadFFmpegFromSiteMessage+" [https://github.com/BtbN/FFmpeg-Builds/releases](https://github.com/BtbN/FFmpeg-Builds/releases)",
+			),
+			buttonDownloadFFmpeg,
+			errorDownloadFFmpegMessage,
+			progressDownloadFFmpegMessage,
+			progressBar,
+		)),
+	)
+}

convertor/view_setting_button_download_ffmpeg_windows.go

@@ -0,0 +1,61 @@
+//go:build windows
+// +build windows
+
+package convertor
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"golang.org/x/image/colornames"
+	"image/color"
+)
+
+func (v View) blockDownloadFFmpeg(
+	donwloadFFmpeg func(progressBar *widget.ProgressBar, progressMessage *canvas.Text) error,
+) *fyne.Container {
+
+	errorDownloadFFmpegMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	errorDownloadFFmpegMessage.TextSize = 16
+	errorDownloadFFmpegMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	progressDownloadFFmpegMessage := canvas.NewText("", color.RGBA{R: 49, G: 127, B: 114, A: 255})
+	progressDownloadFFmpegMessage.TextSize = 16
+	progressDownloadFFmpegMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	progressBar := widget.NewProgressBar()
+
+	var buttonDownloadFFmpeg *widget.Button
+
+	buttonDownloadFFmpeg = widget.NewButton(v.app.GetLocalizerService().GetMessage("download"), func() {
+
+		go func() {
+			fyne.Do(func() {
+				buttonDownloadFFmpeg.Disable()
+			})
+			err := donwloadFFmpeg(progressBar, progressDownloadFFmpegMessage)
+			if err != nil {
+				errorDownloadFFmpegMessage.Text = err.Error()
+			}
+			fyne.Do(func() {
+				buttonDownloadFFmpeg.Enable()
+			})
+		}()
+	})
+
+	downloadFFmpegFromSiteMessage := v.app.GetLocalizerService().GetMessage("downloadFFmpegFromSite")
+
+	return container.NewVBox(
+		canvas.NewLine(colornames.Darkgreen),
+		widget.NewCard(v.app.GetLocalizerService().GetMessage("buttonDownloadFFmpeg"), "", container.NewVBox(
+			widget.NewRichTextFromMarkdown(
+				downloadFFmpegFromSiteMessage+" [https://github.com/BtbN/FFmpeg-Builds/releases](https://github.com/BtbN/FFmpeg-Builds/releases)",
+			),
+			buttonDownloadFFmpeg,
+			errorDownloadFFmpegMessage,
+			progressDownloadFFmpegMessage,
+			progressBar,
+		)),
+	)
+}

encoder/apng/encoder.go

@@ -0,0 +1,19 @@
+package apng
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "apng"}
+	}
+
+	return encoder2.NewEncoder("apng", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "apng"
+	formats := []string{"apng"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/bmp/encoder.go

@@ -0,0 +1,19 @@
+package bmp
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "bmp"}
+	}
+
+	return encoder2.NewEncoder("bmp", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "bmp"
+	formats := []string{"bmp"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/encoder.go

@@ -0,0 +1,169 @@
+package encoder
+
+import "errors"
+
+type EncoderContract interface {
+	GetName() string
+	GetParams() []string
+	GetParameter(name string) (ParameterContract, error)
+}
+
+type ParameterContract interface {
+	GetName() string
+	Set(string) error
+	Get() string
+	IsEnabled() bool
+	SetEnable()
+	SetDisable()
+}
+
+type EncoderDataContract interface {
+	GetTitle() string
+	GetFormats() []string
+	GetFileType() FileTypeContract
+	NewEncoder() EncoderContract
+}
+
+type Data struct {
+	title    string
+	formats  []string
+	fileType FileTypeContract
+	encoder  func() EncoderContract
+}
+
+func NewData(title string, formats []string, fileType FileTypeContract, encoder func() EncoderContract) *Data {
+	return &Data{
+		title:    title,
+		formats:  formats,
+		fileType: fileType,
+		encoder:  encoder,
+	}
+}
+
+func (data Data) GetTitle() string {
+	return data.title
+}
+
+func (data Data) GetFormats() []string {
+	return data.formats
+}
+
+func (data Data) NewEncoder() EncoderContract {
+	return data.encoder()
+}
+
+func (data Data) GetFileType() FileTypeContract {
+	return data.fileType
+}
+
+type FileTypeContract interface {
+	Name() string
+	Ordinal() int
+}
+
+const (
+	Video = iota
+	Audio
+	Image
+)
+
+type FileType uint
+
+var fileTypeStrings = []string{
+	"video",
+	"audio",
+	"image",
+}
+
+func (fileType FileType) Name() string {
+	return fileTypeStrings[fileType]
+}
+
+func (fileType FileType) Ordinal() int {
+	return int(fileType)
+}
+
+func GetListFileType() []FileTypeContract {
+	return []FileTypeContract{
+		FileType(Video),
+		FileType(Audio),
+		FileType(Image),
+	}
+}
+
+type Encoder struct {
+	name       string
+	parameters map[string]ParameterContract
+	getParams  func(parameters map[string]ParameterContract) []string
+}
+
+func NewEncoder(name string, parameters map[string]ParameterContract, getParams func(parameters map[string]ParameterContract) []string) *Encoder {
+	return &Encoder{
+		name:       name,
+		parameters: parameters,
+		getParams:  getParams,
+	}
+}
+
+func (e *Encoder) GetName() string {
+	return e.name
+}
+
+func (e *Encoder) GetParams() []string {
+	return e.getParams(e.parameters)
+}
+
+func (e *Encoder) GetParameter(name string) (ParameterContract, error) {
+	if e.parameters[name] == nil {
+		return nil, errors.New("parameter not found")
+	}
+
+	return e.parameters[name], nil
+}
+
+type Parameter struct {
+	name         string
+	isEnabled    bool
+	parameter    string
+	setParameter func(string) (string, error)
+}
+
+func NewParameter(name string, isEnabled bool, defaultParameter string, setParameter func(string) (string, error)) *Parameter {
+	return &Parameter{
+		name:         name,
+		isEnabled:    isEnabled,
+		parameter:    defaultParameter,
+		setParameter: setParameter,
+	}
+}
+
+func (p *Parameter) GetName() string {
+	return p.name
+}
+
+func (p *Parameter) Set(s string) (err error) {
+	if p.setParameter != nil {
+		s, err = p.setParameter(s)
+		if err != nil {
+			return err
+		}
+	}
+	p.parameter = s
+	return nil
+}
+
+func (p *Parameter) Get() string {
+	return p.parameter
+}
+
+func (p *Parameter) IsEnabled() bool {
+	return p.isEnabled
+}
+
+func (p *Parameter) SetEnable() {
+	p.isEnabled = true
+}
+
+func (p *Parameter) SetDisable() {
+	p.isEnabled = false
+}

encoder/flv/encoder.go

@@ -0,0 +1,19 @@
+package flv
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "flv"}
+	}
+
+	return encoder2.NewEncoder("flv", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "flv"
+	formats := []string{"flv"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/gif/encoder.go

@@ -0,0 +1,19 @@
+package gif
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "gif"}
+	}
+
+	return encoder2.NewEncoder("gif", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "gif"
+	formats := []string{"gif"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/h264_nvenc/encoder.go

@@ -0,0 +1,58 @@
+package h264_nvenc
+
+import (
+	"errors"
+	encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+)
+
+var Presets = []string{
+	"default",
+	"slow",
+	"medium",
+	"fast",
+	"hp",
+	"hq",
+	"bd",
+	"ll",
+	"llhq",
+	"llhp",
+	"lossless",
+	"losslesshp",
+}
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{
+		"preset": newParameterPreset(),
+	}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		params := []string{"-c:v", "h264_nvenc"}
+
+		if parameters["preset"] != nil && parameters["preset"].IsEnabled() {
+			params = append(params, "-preset", parameters["preset"].Get())
+		}
+
+		return params
+	}
+
+	return encoder2.NewEncoder("h264_nvenc", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "h264_nvenc"
+	formats := []string{"mp4"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}
+
+func newParameterPreset() encoder2.ParameterContract {
+	setParameter := func(s string) (string, error) {
+		for _, value := range Presets {
+			if value == s {
+				return value, nil
+			}
+		}
+
+		return "", errors.New("preset not found")
+	}
+	return encoder2.NewParameter("preset", false, "default", setParameter)
+}

encoder/libmp3lame/encoder.go

@@ -0,0 +1,19 @@
+package libmp3lame
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "libmp3lame"}
+	}
+
+	return encoder2.NewEncoder("libmp3lame", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libmp3lame"
+	formats := []string{"mp3"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libshine/encoder.go

@@ -0,0 +1,19 @@
+package libshine
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "libshine"}
+	}
+
+	return encoder2.NewEncoder("libshine", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libshine"
+	formats := []string{"mp3"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libtwolame/encoder.go

@@ -0,0 +1,19 @@
+package libtwolame
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "libtwolame"}
+	}
+
+	return encoder2.NewEncoder("libtwolame", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libtwolame"
+	formats := []string{"mp2"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libvpx/encoder.go

@@ -0,0 +1,19 @@
+package libvpx
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "libvpx"}
+	}
+
+	return encoder2.NewEncoder("libvpx", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libvpx"
+	formats := []string{"webm", "mkv"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libvpx_vp9/encoder.go

@@ -0,0 +1,19 @@
+package libvpx_vp9
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "libvpx-vp9"}
+	}
+
+	return encoder2.NewEncoder("libvpx_vp9", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libvpx-vp9"
+	formats := []string{"webm", "mkv"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libwebp/encoder.go

@@ -0,0 +1,19 @@
+package libwebp
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "libwebp"}
+	}
+
+	return encoder2.NewEncoder("libwebp", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libwebp"
+	formats := []string{"webp"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libwebp_anim/encoder.go

@@ -0,0 +1,19 @@
+package libwebp_anim
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "libwebp_anim"}
+	}
+
+	return encoder2.NewEncoder("libwebp_anim", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libwebp_anim"
+	formats := []string{"webp"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/libx264/encoder.go

@@ -0,0 +1,56 @@
+package libx264
+
+import (
+	"errors"
+	encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+)
+
+var Presets = []string{
+	"ultrafast",
+	"superfast",
+	"veryfast",
+	"faster",
+	"fast",
+	"medium",
+	"slow",
+	"slower",
+	"veryslow",
+	"placebo",
+}
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{
+		"preset": newParameterPreset(),
+	}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		params := []string{"-c:v", "libx264"}
+
+		if parameters["preset"] != nil && parameters["preset"].IsEnabled() {
+			params = append(params, "-preset", parameters["preset"].Get())
+		}
+
+		return params
+	}
+
+	return encoder2.NewEncoder("libx264", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libx264"
+	formats := []string{"mp4"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}
+
+func newParameterPreset() encoder2.ParameterContract {
+	setParameter := func(s string) (string, error) {
+		for _, value := range Presets {
+			if value == s {
+				return value, nil
+			}
+		}
+
+		return "", errors.New("preset not found")
+	}
+	return encoder2.NewParameter("preset", false, "medium", setParameter)
+}

encoder/libx265/encoder.go

@@ -0,0 +1,56 @@
+package libx265
+
+import (
+	"errors"
+	encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+)
+
+var Presets = []string{
+	"ultrafast",
+	"superfast",
+	"veryfast",
+	"faster",
+	"fast",
+	"medium",
+	"slow",
+	"slower",
+	"veryslow",
+	"placebo",
+}
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{
+		"preset": newParameterPreset(),
+	}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		params := []string{"-c:v", "libx265"}
+
+		if parameters["preset"] != nil && parameters["preset"].IsEnabled() {
+			params = append(params, "-preset", parameters["preset"].Get())
+		}
+
+		return params
+	}
+
+	return encoder2.NewEncoder("libx265", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libx265"
+	formats := []string{"mp4"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}
+
+func newParameterPreset() encoder2.ParameterContract {
+	setParameter := func(s string) (string, error) {
+		for _, value := range Presets {
+			if value == s {
+				return value, nil
+			}
+		}
+
+		return "", errors.New("preset not found")
+	}
+	return encoder2.NewParameter("preset", false, "medium", setParameter)
+}

encoder/libxvid/encoder.go

@@ -0,0 +1,19 @@
+package libxvid
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "libxvid"}
+	}
+
+	return encoder2.NewEncoder("libxvid", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "libxvid"
+	formats := []string{"avi"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/mjpeg/encoder.go

@@ -0,0 +1,19 @@
+package mjpeg
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "mjpeg"}
+	}
+
+	return encoder2.NewEncoder("mjpeg", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "mjpeg"
+	formats := []string{"jpg"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/mp2/encoder.go

@@ -0,0 +1,19 @@
+package mp2
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "mp2"}
+	}
+
+	return encoder2.NewEncoder("mp2", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "mp2"
+	formats := []string{"mp2"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/mp2fixed/encoder.go

@@ -0,0 +1,19 @@
+package mp2fixed
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "mp2fixed"}
+	}
+
+	return encoder2.NewEncoder("mp2fixed", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "mp2fixed"
+	formats := []string{"mp2"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/mpeg1video/encoder.go

@@ -0,0 +1,19 @@
+package mpeg1video
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "mpeg1video"}
+	}
+
+	return encoder2.NewEncoder("mpeg1video", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "mpeg1video"
+	formats := []string{"mpg", "mpeg"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/mpeg2video/encoder.go

@@ -0,0 +1,19 @@
+package mpeg2video
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "mpeg2video"}
+	}
+
+	return encoder2.NewEncoder("mpeg2video", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "mpeg2video"
+	formats := []string{"mpg", "mpeg"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/mpeg4/encoder.go

@@ -0,0 +1,19 @@
+package mpeg4
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "mpeg4"}
+	}
+
+	return encoder2.NewEncoder("mpeg4", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "mpeg4"
+	formats := []string{"avi"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/msmpeg4/encoder.go

@@ -0,0 +1,19 @@
+package msmpeg4
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "msmpeg4"}
+	}
+
+	return encoder2.NewEncoder("msmpeg4", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "msmpeg4"
+	formats := []string{"avi"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/msmpeg4v2/encoder.go

@@ -0,0 +1,19 @@
+package msmpeg4v2
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "msmpeg4v2"}
+	}
+
+	return encoder2.NewEncoder("msmpeg4v2", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "msmpeg4v2"
+	formats := []string{"avi"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/msvideo1/encoder.go

@@ -0,0 +1,19 @@
+package msvideo1
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "msvideo1"}
+	}
+
+	return encoder2.NewEncoder("msvideo1", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "msvideo1"
+	formats := []string{"avi"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/png/encoder.go

@@ -0,0 +1,19 @@
+package png
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "png"}
+	}
+
+	return encoder2.NewEncoder("png", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "png"
+	formats := []string{"png"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/qtrle/encoder.go

@@ -0,0 +1,19 @@
+package qtrle
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "qtrle"}
+	}
+
+	return encoder2.NewEncoder("qtrle", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "qtrle"
+	formats := []string{"mov"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/sgi/encoder.go

@@ -0,0 +1,19 @@
+package sgi
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "sgi"}
+	}
+
+	return encoder2.NewEncoder("sgi", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "sgi"
+	formats := []string{"sgi"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/tiff/encoder.go

@@ -0,0 +1,19 @@
+package tiff
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "tiff"}
+	}
+
+	return encoder2.NewEncoder("tiff", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "tiff"
+	formats := []string{"tiff"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/wmav1/encoder.go

@@ -0,0 +1,19 @@
+package wmav1
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "wmav1"}
+	}
+
+	return encoder2.NewEncoder("wmav1", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "wmav1"
+	formats := []string{"wma"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/wmav2/encoder.go

@@ -0,0 +1,19 @@
+package wmav2
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:a", "wmav2"}
+	}
+
+	return encoder2.NewEncoder("wmav2", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "wmav2"
+	formats := []string{"wma"}
+	fileType := encoder2.FileType(encoder2.Audio)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/wmv1/encoder.go

@@ -0,0 +1,19 @@
+package wmv1
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "wmv1"}
+	}
+
+	return encoder2.NewEncoder("wmv1", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "wmv1"
+	formats := []string{"wmv"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/wmv2/encoder.go

@@ -0,0 +1,19 @@
+package wmv2
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "wmv2"}
+	}
+
+	return encoder2.NewEncoder("wmv2", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "wmv2"
+	formats := []string{"wmv"}
+	fileType := encoder2.FileType(encoder2.Video)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

encoder/xbm/encoder.go

@@ -0,0 +1,19 @@
+package xbm
+
+import encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+
+func NewEncoder() encoder2.EncoderContract {
+	parameters := map[string]encoder2.ParameterContract{}
+	getParams := func(parameters map[string]encoder2.ParameterContract) []string {
+		return []string{"-c:v", "xbm"}
+	}
+
+	return encoder2.NewEncoder("xbm", parameters, getParams)
+}
+
+func NewData() encoder2.EncoderDataContract {
+	title := "xbm"
+	formats := []string{"xbm"}
+	fileType := encoder2.FileType(encoder2.Image)
+	return encoder2.NewData(title, formats, fileType, NewEncoder)
+}

error/view.go

@@ -0,0 +1,39 @@
+package error
+
+import (
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/localizer"
+)
+
+type ViewContract interface {
+	PanicError(err error)
+}
+
+type View struct {
+	app kernel.AppContract
+}
+
+func NewView(app kernel.AppContract) *View {
+	return &View{
+		app: app,
+	}
+}
+
+func (v View) PanicError(err error) {
+	messageHead := v.app.GetLocalizerService().GetMessage("error")
+
+	v.app.GetWindow().SetContent(container.NewBorder(
+		container.NewVBox(
+			widget.NewLabel(messageHead),
+			widget.NewLabel(err.Error()),
+		),
+		nil,
+		nil,
+		nil,
+		localizer.LanguageSelectionForm(v.app.GetLocalizerService(), func(lang kernel.Lang) {
+			v.PanicError(err)
+		}),
+	))
+}

go.mod

@@ -0,0 +1,45 @@
+module git.kor-elf.net/kor-elf/gui-for-ffmpeg
+
+go 1.23.0
+
+toolchain go1.23.9
+
+require (
+	fyne.io/fyne/v2 v2.6.1
+	github.com/ulikunitz/xz v0.5.12
+	golang.org/x/image v0.27.0
+)
+
+require (
+	fyne.io/systray v1.11.0 // indirect
+	github.com/BurntSushi/toml v1.5.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/fredbi/uri v1.1.0 // indirect
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/fyne-io/gl-js v0.1.0 // indirect
+	github.com/fyne-io/glfw-js v0.2.0 // indirect
+	github.com/fyne-io/image v0.1.1 // indirect
+	github.com/fyne-io/oksvg v0.1.0 // indirect
+	github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71 // indirect
+	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728 // indirect
+	github.com/go-text/render v0.2.0 // indirect
+	github.com/go-text/typesetting v0.3.0 // indirect
+	github.com/godbus/dbus/v5 v5.1.0 // indirect
+	github.com/hack-pad/go-indexeddb v0.3.2 // indirect
+	github.com/hack-pad/safejs v0.1.1 // indirect
+	github.com/jeandeaual/go-locale v0.0.0-20250421151639-a9d6ed1b3d45 // indirect
+	github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
+	github.com/nicksnyder/go-i18n/v2 v2.6.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rymdport/portal v0.4.1 // indirect
+	github.com/srwiley/oksvg v0.0.0-20221011165216-be6e8873101c // indirect
+	github.com/srwiley/rasterx v0.0.0-20220730225603-2ab79fcdd4ef // indirect
+	github.com/stretchr/testify v1.10.0 // indirect
+	github.com/yuin/goldmark v1.7.11 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,82 @@
+fyne.io/fyne/v2 v2.6.1 h1:kjPJD4/rBS9m2nHJp+npPSuaK79yj6ObMTuzR6VQ1Is=
+fyne.io/fyne/v2 v2.6.1/go.mod h1:YZt7SksjvrSNJCwbWFV32WON3mE1Sr7L41D29qMZ/lU=
+fyne.io/systray v1.11.0 h1:D9HISlxSkx+jHSniMBR6fCFOUjk1x/OOOJLa9lJYAKg=
+fyne.io/systray v1.11.0/go.mod h1:RVwqP9nYMo7h5zViCBHri2FgjXF7H2cub7MAq4NSoLs=
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/felixge/fgprof v0.9.3 h1:VvyZxILNuCiUCSXtPtYmmtGvb65nqXh2QFWc0Wpf2/g=
+github.com/felixge/fgprof v0.9.3/go.mod h1:RdbpDgzqYVh/T9fPELJyV7EYJuHB55UTEULNun8eiPw=
+github.com/fredbi/uri v1.1.0 h1:OqLpTXtyRg9ABReqvDGdJPqZUxs8cyBDOMXBbskCaB8=
+github.com/fredbi/uri v1.1.0/go.mod h1:aYTUoAXBOq7BLfVJ8GnKmfcuURosB1xyHDIfWeC/iW4=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/fyne-io/gl-js v0.1.0 h1:8luJzNs0ntEAJo+8x8kfUOXujUlP8gB3QMOxO2mUdpM=
+github.com/fyne-io/gl-js v0.1.0/go.mod h1:ZcepK8vmOYLu96JoxbCKJy2ybr+g1pTnaBDdl7c3ajI=
+github.com/fyne-io/glfw-js v0.2.0 h1:8GUZtN2aCoTPNqgRDxK5+kn9OURINhBEBc7M4O1KrmM=
+github.com/fyne-io/glfw-js v0.2.0/go.mod h1:Ri6te7rdZtBgBpxLW19uBpp3Dl6K9K/bRaYdJ22G8Jk=
+github.com/fyne-io/image v0.1.1 h1:WH0z4H7qfvNUw5l4p3bC1q70sa5+YWVt6HCj7y4VNyA=
+github.com/fyne-io/image v0.1.1/go.mod h1:xrfYBh6yspc+KjkgdZU/ifUC9sPA5Iv7WYUBzQKK7JM=
+github.com/fyne-io/oksvg v0.1.0 h1:7EUKk3HV3Y2E+qypp3nWqMXD7mum0hCw2KEGhI1fnBw=
+github.com/fyne-io/oksvg v0.1.0/go.mod h1:dJ9oEkPiWhnTFNCmRgEze+YNprJF7YRbpjgpWS4kzoI=
+github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71 h1:5BVwOaUSBTlVZowGO6VZGw2H/zl9nrd3eCZfYV+NfQA=
+github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728 h1:RkGhqHxEVAvPM0/R+8g7XRwQnHatO0KAuVcwHo8q9W8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20250301202403-da16c1255728/go.mod h1:SyRD8YfuKk+ZXlDqYiqe1qMSqjNgtHzBTG810KUagMc=
+github.com/go-text/render v0.2.0 h1:LBYoTmp5jYiJ4NPqDc2pz17MLmA3wHw1dZSVGcOdeAc=
+github.com/go-text/render v0.2.0/go.mod h1:CkiqfukRGKJA5vZZISkjSYrcdtgKQWRa2HIzvwNN5SU=
+github.com/go-text/typesetting v0.3.0 h1:OWCgYpp8njoxSRpwrdd1bQOxdjOXDj9Rqart9ML4iF4=
+github.com/go-text/typesetting v0.3.0/go.mod h1:qjZLkhRgOEYMhU9eHBr3AR4sfnGJvOXNLt8yRAySFuY=
+github.com/go-text/typesetting-utils v0.0.0-20241103174707-87a29e9e6066 h1:qCuYC+94v2xrb1PoS4NIDe7DGYtLnU2wWiQe9a1B1c0=
+github.com/go-text/typesetting-utils v0.0.0-20241103174707-87a29e9e6066/go.mod h1:DDxDdQEnB70R8owOx3LVpEFvpMK9eeH1o2r0yZhFI9o=
+github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
+github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/google/pprof v0.0.0-20211214055906-6f57359322fd h1:1FjCyPC+syAzJ5/2S8fqdZK1R22vvA0J7JZKcuOIQ7Y=
+github.com/google/pprof v0.0.0-20211214055906-6f57359322fd/go.mod h1:KgnwoLYCZ8IQu3XUZ8Nc/bM9CCZFOyjUNOSygVozoDg=
+github.com/hack-pad/go-indexeddb v0.3.2 h1:DTqeJJYc1usa45Q5r52t01KhvlSN02+Oq+tQbSBI91A=
+github.com/hack-pad/go-indexeddb v0.3.2/go.mod h1:QvfTevpDVlkfomY498LhstjwbPW6QC4VC/lxYb0Kom0=
+github.com/hack-pad/safejs v0.1.1 h1:d5qPO0iQ7h2oVtpzGnLExE+Wn9AtytxIfltcS2b9KD8=
+github.com/hack-pad/safejs v0.1.1/go.mod h1:HdS+bKF1NrE72VoXZeWzxFOVQVUSqZJAG0xNCnb+Tio=
+github.com/jeandeaual/go-locale v0.0.0-20250421151639-a9d6ed1b3d45 h1:vFdvrlsVU+p/KFBWTq0lTG4fvWvG88sawGlCzM+RUEU=
+github.com/jeandeaual/go-locale v0.0.0-20250421151639-a9d6ed1b3d45/go.mod h1:ZDXo8KHryOWSIqnsb/CiDq7hQUYryCgdVnxbj8tDG7o=
+github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25 h1:YLvr1eE6cdCqjOe972w/cYF+FjW34v27+9Vo5106B4M=
+github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25/go.mod h1:kLgvv7o6UM+0QSf0QjAse3wReFDsb9qbZJdfexWlrQw=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/nicksnyder/go-i18n/v2 v2.6.0 h1:C/m2NNWNiTB6SK4Ao8df5EWm3JETSTIGNXBpMJTxzxQ=
+github.com/nicksnyder/go-i18n/v2 v2.6.0/go.mod h1:88sRqr0C6OPyJn0/KRNaEz1uWorjxIKP7rUUcvycecE=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA=
+github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rymdport/portal v0.4.1 h1:2dnZhjf5uEaeDjeF/yBIeeRo6pNI2QAKm7kq1w/kbnA=
+github.com/rymdport/portal v0.4.1/go.mod h1:kFF4jslnJ8pD5uCi17brj/ODlfIidOxlgUDTO5ncnC4=
+github.com/srwiley/oksvg v0.0.0-20221011165216-be6e8873101c h1:km8GpoQut05eY3GiYWEedbTT0qnSxrCjsVbb7yKY1KE=
+github.com/srwiley/oksvg v0.0.0-20221011165216-be6e8873101c/go.mod h1:cNQ3dwVJtS5Hmnjxy6AgTPd0Inb3pW05ftPSX7NZO7Q=
+github.com/srwiley/rasterx v0.0.0-20220730225603-2ab79fcdd4ef h1:Ch6Q+AZUxDBCVqdkI8FSpFyZDtCVBc2VmejdNrm5rRQ=
+github.com/srwiley/rasterx v0.0.0-20220730225603-2ab79fcdd4ef/go.mod h1:nXTWP6+gD5+LUJ8krVhhoeHjvHTutPxMYl5SvkcnJNE=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
+github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/yuin/goldmark v1.7.11 h1:ZCxLyDMtz0nT2HFfsYG8WZ47Trip2+JyLysKcMYE5bo=
+github.com/yuin/goldmark v1.7.11/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
+golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
+golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

handler/convertor.go

@@ -0,0 +1,178 @@
+package handler
+
+import (
+	"errors"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor/view"
+	error2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/error"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/helper"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/setting"
+)
+
+type ConvertorHandlerContract interface {
+	MainConvertor()
+	FfPathSelection()
+	GetFfmpegVersion() (string, error)
+	GetFfprobeVersion() (string, error)
+	GetFfplayVersion() (string, error)
+}
+
+type ConvertorHandler struct {
+	app                       kernel.AppContract
+	convertorView             convertor.ViewContract
+	errorView                 error2.ViewContract
+	convertorRepository       convertor.RepositoryContract
+	settingDirectoryForSaving setting.DirectoryForSavingContract
+	itemsToConvertService     kernel.ItemsToConvertContract
+}
+
+func NewConvertorHandler(
+	app kernel.AppContract,
+	convertorView convertor.ViewContract,
+	errorView error2.ViewContract,
+	convertorRepository convertor.RepositoryContract,
+	settingDirectoryForSaving setting.DirectoryForSavingContract,
+	itemsToConvertService kernel.ItemsToConvertContract,
+) *ConvertorHandler {
+	return &ConvertorHandler{
+		app:                       app,
+		convertorView:             convertorView,
+		errorView:                 errorView,
+		convertorRepository:       convertorRepository,
+		settingDirectoryForSaving: settingDirectoryForSaving,
+		itemsToConvertService:     itemsToConvertService,
+	}
+}
+
+func (h ConvertorHandler) MainConvertor() {
+	if h.checkingFFPathUtilities() == true {
+		formats, err := h.app.GetConvertorService().GetSupportFormats()
+		if err != nil {
+			h.errorView.PanicError(err)
+			return
+		}
+		conversion := view.NewConversion(h.app, formats, h.runConvert, h.settingDirectoryForSaving, h.itemsToConvertService)
+		h.convertorView.Main(conversion)
+		return
+	}
+	h.convertorView.SelectFFPath("", "", "", h.saveSettingFFPath, nil, h.downloadFFmpeg)
+}
+
+func (h ConvertorHandler) FfPathSelection() {
+	ffmpeg := h.convertorRepository.GetPathFfmpeg()
+	ffprobe := h.convertorRepository.GetPathFfprobe()
+	ffplay := h.convertorRepository.GetPathFfplay()
+	h.convertorView.SelectFFPath(ffmpeg, ffprobe, ffplay, h.saveSettingFFPath, h.MainConvertor, h.downloadFFmpeg)
+}
+
+func (h ConvertorHandler) GetFfmpegVersion() (string, error) {
+	return h.app.GetConvertorService().GetFFmpegVesrion()
+}
+
+func (h ConvertorHandler) GetFfprobeVersion() (string, error) {
+	return h.app.GetConvertorService().GetFFprobeVersion()
+}
+
+func (h ConvertorHandler) GetFfplayVersion() (string, error) {
+	return h.app.GetConvertorService().GetFFplayVersion()
+}
+
+func (h ConvertorHandler) runConvert(setting view.HandleConvertSetting) {
+	h.app.GetWindow().GetLayout().GetRightTabs().SelectFileQueueTab()
+
+	for _, item := range h.itemsToConvertService.GetItems() {
+		file := item.GetFile()
+		if file == nil {
+			continue
+		}
+
+		h.app.GetQueue().Add(&kernel.ConvertSetting{
+			VideoFileInput: *file,
+			VideoFileOut: kernel.File{
+				Path: setting.DirectoryForSave + helper.PathSeparator() + file.Name + "." + setting.Format,
+				Name: file.Name,
+				Ext:  "." + setting.Format,
+			},
+			OverwriteOutputFiles: setting.OverwriteOutputFiles,
+			Encoder:              setting.Encoder,
+		})
+	}
+	h.itemsToConvertService.AfterAddingQueue()
+}
+
+func (h ConvertorHandler) checkingFFPathUtilities() bool {
+	if h.checkingFFPath() == true {
+		return true
+	}
+
+	pathsToFF := getPathsToFF()
+	for _, item := range pathsToFF {
+		ffmpegChecking, _ := h.app.GetConvertorService().ChangeFFmpegPath(item.FFmpeg)
+		if ffmpegChecking == false {
+			continue
+		}
+		ffprobeChecking, _ := h.app.GetConvertorService().ChangeFFprobePath(item.FFprobe)
+		if ffprobeChecking == false {
+			continue
+		}
+
+		ffplayChecking, _ := h.app.GetConvertorService().ChangeFFplayPath(item.FFplay)
+		if ffplayChecking == false {
+			continue
+		}
+		_ = h.convertorRepository.SavePathFfmpeg(item.FFmpeg)
+		_ = h.convertorRepository.SavePathFfprobe(item.FFprobe)
+		_ = h.convertorRepository.SavePathFfplay(item.FFplay)
+		return true
+	}
+
+	return false
+}
+
+func (h ConvertorHandler) saveSettingFFPath(ffmpegPath string, ffprobePath string, ffplayPath string) error {
+	ffmpegChecking, _ := h.app.GetConvertorService().ChangeFFmpegPath(ffmpegPath)
+	if ffmpegChecking == false {
+		errorText := h.app.GetLocalizerService().GetMessage("errorFFmpeg")
+		return errors.New(errorText)
+	}
+
+	ffprobeChecking, _ := h.app.GetConvertorService().ChangeFFprobePath(ffprobePath)
+	if ffprobeChecking == false {
+		errorText := h.app.GetLocalizerService().GetMessage("errorFFprobe")
+		return errors.New(errorText)
+	}
+
+	ffplayChecking, _ := h.app.GetConvertorService().ChangeFFplayPath(ffplayPath)
+	if ffplayChecking == false {
+		errorText := h.app.GetLocalizerService().GetMessage("errorFFplay")
+		return errors.New(errorText)
+	}
+
+	_ = h.convertorRepository.SavePathFfmpeg(ffmpegPath)
+	_ = h.convertorRepository.SavePathFfprobe(ffprobePath)
+	_ = h.convertorRepository.SavePathFfplay(ffplayPath)
+
+	h.MainConvertor()
+
+	return nil
+}
+
+func (h ConvertorHandler) checkingFFPath() bool {
+	_, err := h.app.GetConvertorService().GetFFmpegVesrion()
+	if err != nil {
+		return false
+	}
+
+	_, err = h.app.GetConvertorService().GetFFprobeVersion()
+	if err != nil {
+		return false
+	}
+
+	_, err = h.app.GetConvertorService().GetFFplayVersion()
+	if err != nil {
+		return false
+	}
+
+	return true
+}

handler/convertor_anyos.go

@@ -0,0 +1,18 @@
+//go:build !windows && !linux
+// +build !windows,!linux
+
+package handler
+
+import (
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+)
+
+func getPathsToFF() []kernel.FFPathUtilities {
+	return []kernel.FFPathUtilities{{FFmpeg: "ffmpeg/bin/ffmpeg", FFprobe: "ffmpeg/bin/ffprobe", FFplay: "ffmpeg/bin/ffplay"}, {FFmpeg: "ffmpeg", FFprobe: "ffprobe", FFplay: "ffplay"}}
+}
+
+func (h ConvertorHandler) downloadFFmpeg(progressBar *widget.ProgressBar, progressMessage *canvas.Text) (err error) {
+	return nil
+}

handler/convertor_linux.go

@@ -0,0 +1,231 @@
+//go:build linux
+// +build linux
+
+package handler
+
+import (
+	"archive/tar"
+	"errors"
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"github.com/ulikunitz/xz"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+func getPathsToFF() []kernel.FFPathUtilities {
+	return []kernel.FFPathUtilities{{FFmpeg: "ffmpeg/bin/ffmpeg", FFprobe: "ffmpeg/bin/ffprobe", FFplay: "ffmpeg/bin/ffplay"}, {FFmpeg: "ffmpeg", FFprobe: "ffprobe", FFplay: "ffplay"}}
+}
+
+func (h ConvertorHandler) downloadFFmpeg(progressBar *widget.ProgressBar, progressMessage *canvas.Text) (err error) {
+	isDirectoryFFmpeg := isDirectory("ffmpeg")
+	if isDirectoryFFmpeg == false {
+		err = os.Mkdir("ffmpeg", 0777)
+		if err != nil {
+			return err
+		}
+	}
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("downloadRun")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+	err = downloadFile("ffmpeg/ffmpeg.tar.xz", "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz", progressBar)
+	if err != nil {
+		return err
+	}
+
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("unzipRun")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+	err = unTarXz("ffmpeg/ffmpeg.tar.xz", "ffmpeg", progressBar)
+	if err != nil {
+		return err
+	}
+	_ = os.Remove("ffmpeg/ffmpeg.tar.xz")
+
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("testFF")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+
+	err = h.saveSettingFFPath(
+		"ffmpeg/ffmpeg-master-latest-linux64-gpl/bin/ffmpeg",
+		"ffmpeg/ffmpeg-master-latest-linux64-gpl/bin/ffprobe",
+		"ffmpeg/ffmpeg-master-latest-linux64-gpl/bin/ffplay",
+	)
+	if err != nil {
+		return err
+	}
+
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("completedQueue")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+
+	return nil
+}
+
+func downloadFile(filepath string, url string, progressBar *widget.ProgressBar) (err error) {
+	progressBar.Value = 0
+	progressBar.Max = 100
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	f, err := os.OpenFile(filepath, os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	buf := make([]byte, 32*1024)
+	var downloaded int64
+	for {
+		n, err := resp.Body.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		if n > 0 {
+			f.Write(buf[:n])
+			downloaded += int64(n)
+			progressBar.Value = float64(downloaded) / float64(resp.ContentLength) * 100
+			fyne.Do(func() {
+				progressBar.Refresh()
+			})
+		}
+	}
+	return nil
+}
+
+func unTarXz(fileTar string, directory string, progressBar *widget.ProgressBar) error {
+	progressBar.Value = 0
+	progressBar.Max = 100
+
+	fyne.Do(func() {
+		progressBar.Refresh()
+	})
+
+	f, err := os.Open(fileTar)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	xzReader, err := xz.NewReader(f)
+	if err != nil {
+		return err
+	}
+
+	tarReader := tar.NewReader(xzReader)
+
+	totalFiles := 0
+	for {
+		_, err := tarReader.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+		totalFiles++
+	}
+
+	// Rewind back to the beginning of the file to re-process
+	_, err = f.Seek(0, 0)
+	if err != nil {
+		return err
+	}
+
+	xzReader, err = xz.NewReader(f)
+	if err != nil {
+		return err
+	}
+
+	tarReader = tar.NewReader(xzReader)
+
+	// We count the number of files already unpacked
+	unpackedFiles := 0
+
+	for {
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		targetPath := filepath.Join(directory, header.Name)
+		switch header.Typeflag {
+		case tar.TypeDir:
+			err := os.MkdirAll(targetPath, 0755)
+			if err != nil {
+				return err
+			}
+		case tar.TypeReg:
+			outFile, err := os.Create(targetPath)
+			if err != nil {
+				return err
+			}
+			defer outFile.Close()
+
+			_, err = io.Copy(outFile, tarReader)
+
+			if err != nil {
+				return err
+			}
+		default:
+			return errors.New("unsupported file type")
+		}
+
+		unpackedFiles++
+		progressBar.Value = float64(unpackedFiles) / float64(totalFiles) * 100
+		fyne.Do(func() {
+			progressBar.Refresh()
+		})
+	}
+
+	ffmpegPath := filepath.Join(directory, "ffmpeg-master-latest-linux64-gpl", "bin", "ffmpeg")
+	err = os.Chmod(ffmpegPath, 0755)
+	if err != nil {
+		return err
+	}
+
+	ffprobePath := filepath.Join(directory, "ffmpeg-master-latest-linux64-gpl", "bin", "ffprobe")
+	err = os.Chmod(ffprobePath, 0755)
+	if err != nil {
+		return err
+	}
+
+	ffplayPath := filepath.Join(directory, "ffmpeg-master-latest-linux64-gpl", "bin", "ffplay")
+	err = os.Chmod(ffplayPath, 0755)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func isDirectory(path string) bool {
+	fileInfo, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+
+	return fileInfo.IsDir()
+}

handler/convertor_windows.go

@@ -0,0 +1,185 @@
+//go:build windows
+// +build windows
+
+package handler
+
+import (
+	"archive/zip"
+	"errors"
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func getPathsToFF() []kernel.FFPathUtilities {
+	return []kernel.FFPathUtilities{{FFmpeg: "ffmpeg\\bin\\ffmpeg.exe", FFprobe: "ffmpeg\\bin\\ffprobe.exe", FFplay: "ffmpeg\\bin\\ffplay.exe"}}
+}
+
+func (h ConvertorHandler) downloadFFmpeg(progressBar *widget.ProgressBar, progressMessage *canvas.Text) (err error) {
+	isDirectoryFFmpeg := isDirectory("ffmpeg")
+	if isDirectoryFFmpeg == false {
+		err = os.Mkdir("ffmpeg", 0777)
+		if err != nil {
+			return err
+		}
+	}
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("downloadRun")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+	err = downloadFile("ffmpeg/ffmpeg.zip", "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-win64-gpl.zip", progressBar)
+	if err != nil {
+		return err
+	}
+
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("unzipRun")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+	err = unZip("ffmpeg/ffmpeg.zip", "ffmpeg", progressBar)
+	if err != nil {
+		return err
+	}
+	_ = os.Remove("ffmpeg/ffmpeg.zip")
+
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("testFF")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+	err = h.saveSettingFFPath(
+		"ffmpeg/ffmpeg-master-latest-win64-gpl/bin/ffmpeg.exe",
+		"ffmpeg/ffmpeg-master-latest-win64-gpl/bin/ffprobe.exe",
+		"ffmpeg/ffmpeg-master-latest-win64-gpl/bin/ffplay.exe",
+	)
+	if err != nil {
+		return err
+	}
+
+	progressMessage.Text = h.app.GetLocalizerService().GetMessage("completedQueue")
+	fyne.Do(func() {
+		progressMessage.Refresh()
+	})
+
+	return nil
+}
+
+func downloadFile(filepath string, url string, progressBar *widget.ProgressBar) (err error) {
+	progressBar.Value = 0
+	progressBar.Max = 100
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	f, err := os.OpenFile(filepath, os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	buf := make([]byte, 32*1024)
+	var downloaded int64
+	for {
+		n, err := resp.Body.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		if n > 0 {
+			f.Write(buf[:n])
+			downloaded += int64(n)
+			progressBar.Value = float64(downloaded) / float64(resp.ContentLength) * 100
+			fyne.Do(func() {
+				progressBar.Refresh()
+			})
+		}
+	}
+	return nil
+}
+
+func unZip(fileZip string, directory string, progressBar *widget.ProgressBar) error {
+	progressBar.Value = 0
+	progressBar.Max = 100
+
+	fyne.Do(func() {
+		progressBar.Refresh()
+	})
+
+	archive, err := zip.OpenReader(fileZip)
+	if err != nil {
+		return err
+	}
+	defer archive.Close()
+
+	totalBytes := int64(0)
+	for _, f := range archive.File {
+		totalBytes += int64(f.UncompressedSize64)
+	}
+
+	unpackedBytes := int64(0)
+
+	for _, f := range archive.File {
+		filePath := filepath.Join(directory, f.Name)
+
+		if !strings.HasPrefix(filePath, filepath.Clean(directory)+string(os.PathSeparator)) {
+			return errors.New("invalid file path")
+		}
+		if f.FileInfo().IsDir() {
+			os.MkdirAll(filePath, os.ModePerm)
+			continue
+		}
+
+		if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
+			return err
+		}
+
+		dstFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
+		if err != nil {
+			return err
+		}
+
+		fileInArchive, err := f.Open()
+		if err != nil {
+			return err
+		}
+
+		bytesRead, err := io.Copy(dstFile, fileInArchive)
+		if err != nil {
+			return err
+		}
+
+		unpackedBytes += bytesRead
+		progressBar.Value = float64(unpackedBytes) / float64(totalBytes) * 100
+		fyne.Do(func() {
+			progressBar.Refresh()
+		})
+
+		dstFile.Close()
+		fileInArchive.Close()
+	}
+
+	return nil
+}
+
+func isDirectory(path string) bool {
+	fileInfo, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+
+	return fileInfo.IsDir()
+}

handler/main.go

@@ -0,0 +1,32 @@
+package handler
+
+import (
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+)
+
+type MainHandler struct {
+	app              kernel.AppContract
+	convertorHandler ConvertorHandlerContract
+	menuHandler      MenuHandlerContract
+}
+
+func NewMainHandler(
+	app kernel.AppContract,
+	convertorHandler ConvertorHandlerContract,
+	menuHandler MenuHandlerContract,
+) *MainHandler {
+	return &MainHandler{
+		app:              app,
+		convertorHandler: convertorHandler,
+		menuHandler:      menuHandler,
+	}
+}
+
+func (h MainHandler) Start() {
+	if h.app.GetLocalizerService().IsStartWithLanguageSelection() {
+		h.menuHandler.LanguageSelection()
+		return
+	}
+
+	h.convertorHandler.MainConvertor()
+}

handler/menu.go

@@ -0,0 +1,143 @@
+package handler
+
+import (
+	"fyne.io/fyne/v2"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/localizer"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/menu"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/theme"
+)
+
+type MenuHandlerContract interface {
+	GetMainMenu() *fyne.MainMenu
+	LanguageSelection()
+}
+
+type MenuHandler struct {
+	app              kernel.AppContract
+	convertorHandler ConvertorHandlerContract
+	menuView         menu.ViewContract
+	menuViewSetting  menu.ViewSettingContract
+	localizerView    localizer.ViewContract
+	themeService     theme.ThemeContract
+}
+
+func NewMenuHandler(
+	app kernel.AppContract,
+	convertorHandler ConvertorHandlerContract,
+	menuView menu.ViewContract,
+	menuViewSetting menu.ViewSettingContract,
+	localizerView localizer.ViewContract,
+	themeService theme.ThemeContract,
+) *MenuHandler {
+	return &MenuHandler{
+		app:              app,
+		convertorHandler: convertorHandler,
+		menuView:         menuView,
+		menuViewSetting:  menuViewSetting,
+		localizerView:    localizerView,
+		themeService:     themeService,
+	}
+}
+
+func (h MenuHandler) GetMainMenu() *fyne.MainMenu {
+	settings := h.getMenuSettings()
+	help := h.getMenuHelp()
+
+	return fyne.NewMainMenu(settings, help)
+}
+
+func (h MenuHandler) getMenuSettings() *fyne.Menu {
+	quit := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage("exit"), nil)
+	quit.IsQuit = true
+	h.app.GetLocalizerService().AddChangeCallback("exit", func(text string) {
+		quit.Label = text
+	})
+
+	settingsSelection := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage("settings"), h.settingsSelection)
+	h.app.GetLocalizerService().AddChangeCallback("settings", func(text string) {
+		settingsSelection.Label = text
+	})
+
+	ffPathSelection := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage("changeFFPath"), h.convertorHandler.FfPathSelection)
+	h.app.GetLocalizerService().AddChangeCallback("changeFFPath", func(text string) {
+		ffPathSelection.Label = text
+	})
+
+	settings := fyne.NewMenu(h.app.GetLocalizerService().GetMessage("settings"), settingsSelection, ffPathSelection, quit)
+	h.app.GetLocalizerService().AddChangeCallback("settings", func(text string) {
+		settings.Label = text
+		settings.Refresh()
+	})
+
+	return settings
+}
+
+func (h MenuHandler) getMenuHelp() *fyne.Menu {
+	about := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage("about"), h.openAbout)
+	h.app.GetLocalizerService().AddChangeCallback("about", func(text string) {
+		about.Label = text
+	})
+
+	gratitude := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage("gratitude"), h.menuView.Gratitude)
+	h.app.GetLocalizerService().AddChangeCallback("gratitude", func(text string) {
+		gratitude.Label = text
+	})
+
+	helpFFplay := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage("helpFFplay"), h.menuView.HelpFFplay)
+	h.app.GetLocalizerService().AddChangeCallback("helpFFplay", func(text string) {
+		helpFFplay.Label = text
+	})
+
+	help := fyne.NewMenu(h.app.GetLocalizerService().GetMessage("help"), helpFFplay, about, gratitude)
+	h.app.GetLocalizerService().AddChangeCallback("help", func(text string) {
+		help.Label = text
+		help.Refresh()
+	})
+
+	return help
+}
+
+func (h MenuHandler) openAbout() {
+	ffmpeg, err := h.convertorHandler.GetFfmpegVersion()
+	if err != nil {
+		ffmpeg = h.app.GetLocalizerService().GetMessage("errorFFmpegVersion")
+	}
+	ffprobe, err := h.convertorHandler.GetFfprobeVersion()
+	if err != nil {
+		ffprobe = h.app.GetLocalizerService().GetMessage("errorFFprobeVersion")
+	}
+	ffplay, err := h.convertorHandler.GetFfplayVersion()
+	if err != nil {
+		ffplay = h.app.GetLocalizerService().GetMessage("errorFFplayVersion")
+	}
+
+	h.menuView.About(ffmpeg, ffprobe, ffplay)
+}
+
+func (h MenuHandler) LanguageSelection() {
+	h.localizerView.LanguageSelection(func(lang kernel.Lang) {
+		h.convertorHandler.MainConvertor()
+	})
+}
+
+func (h MenuHandler) settingsSelection() {
+	save := func(setting *menu.SettingForm) error {
+		err := h.app.GetLocalizerService().SetCurrentLanguage(setting.Language, true)
+		if err != nil {
+			return err
+		}
+
+		err = h.themeService.SetCurrentTheme(setting.ThemeInfo)
+		if err != nil {
+			return err
+		}
+
+		h.convertorHandler.MainConvertor()
+		return nil
+	}
+	cancel := func() {
+		h.convertorHandler.MainConvertor()
+	}
+	h.menuViewSetting.Main(save, cancel)
+}

internal/resources/icon.go

@@ -0,0 +1,13 @@
+package resources
+
+import (
+	_ "embed"
+	"fyne.io/fyne/v2"
+)
+
+//go:embed icons/logo.png
+var iconAppLogo []byte
+
+func IconAppLogoResource() *fyne.StaticResource {
+	return fyne.NewStaticResource("icon.png", iconAppLogo)
+}

kernel/app.go

@@ -0,0 +1,132 @@
+package kernel
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/app"
+	"time"
+)
+
+type AppContract interface {
+	GetAppFyne() fyne.App
+	GetWindow() WindowContract
+	GetQueue() QueueListContract
+	GetLocalizerService() LocalizerContract
+	GetConvertorService() ConvertorContract
+	GetFFplayService() FFplayContract
+	AfterClosing()
+	RunConvertor()
+}
+
+type App struct {
+	AppFyne fyne.App
+	Window  WindowContract
+	Queue   QueueListContract
+
+	localizerService        LocalizerContract
+	convertorService        ConvertorContract
+	blockProgressbarService BlockProgressbarContract
+	ffplayService           FFplayContract
+}
+
+func NewApp(
+	metadata *fyne.AppMetadata,
+	queue QueueListContract,
+	ffplayService FFplayContract,
+	convertorService ConvertorContract,
+) *App {
+	app.SetMetadata(*metadata)
+	a := app.New()
+
+	localizerService, err := newLocalizer(a)
+	if err != nil {
+		panicErrorLang(a, err)
+		return nil
+	}
+
+	statusesText := GetBlockProgressbarStatusesText(localizerService)
+	blockProgressbarService := NewBlockProgressbar(statusesText, ffplayService)
+	rightTabsService := NewRightTabs(localizerService)
+	queueLayoutObject := NewQueueLayoutObject(queue, localizerService, ffplayService, rightTabsService, blockProgressbarService.GetContainer())
+
+	return &App{
+		AppFyne: a,
+		Window:  newWindow(a.NewWindow("GUI for FFmpeg"), NewLayout(queueLayoutObject, localizerService, rightTabsService)),
+		Queue:   queue,
+
+		localizerService:        localizerService,
+		convertorService:        convertorService,
+		blockProgressbarService: blockProgressbarService,
+		ffplayService:           ffplayService,
+	}
+}
+
+func (a App) GetAppFyne() fyne.App {
+	return a.AppFyne
+}
+
+func (a App) GetQueue() QueueListContract {
+	return a.Queue
+}
+
+func (a App) GetWindow() WindowContract {
+	return a.Window
+}
+
+func (a App) GetLocalizerService() LocalizerContract {
+	return a.localizerService
+}
+
+func (a App) GetConvertorService() ConvertorContract {
+	return a.convertorService
+}
+
+func (a App) GetFFplayService() FFplayContract {
+	return a.ffplayService
+}
+
+func (a App) AfterClosing() {
+	for _, cmd := range a.convertorService.GetRunningProcesses() {
+		_ = cmd.Process.Kill()
+	}
+}
+
+func (a App) RunConvertor() {
+	go func() {
+		for {
+			time.Sleep(time.Millisecond * 3000)
+			queueId, queue := a.Queue.Next()
+			if queue == nil {
+				continue
+			}
+			queue.Status = StatusType(InProgress)
+			a.Window.GetLayout().ChangeQueueStatus(queueId, queue)
+			if a.blockProgressbarService.GetContainer().Hidden {
+				a.blockProgressbarService.GetContainer().Show()
+			}
+
+			totalDuration, err := a.convertorService.GetTotalDuration(&queue.Setting.VideoFileInput)
+			if err != nil {
+				totalDuration = 0
+			}
+
+			progress := a.blockProgressbarService.GetProgressbar(
+				totalDuration,
+				queue.Setting.VideoFileInput.Path,
+				a.localizerService,
+			)
+
+			err = a.convertorService.RunConvert(*queue.Setting, progress)
+			if err != nil {
+				queue.Status = StatusType(Error)
+				queue.Error = err
+				a.Window.GetLayout().ChangeQueueStatus(queueId, queue)
+				a.blockProgressbarService.ProcessEndedWithError(err.Error())
+
+				continue
+			}
+			queue.Status = StatusType(Completed)
+			a.Window.GetLayout().ChangeQueueStatus(queueId, queue)
+			a.blockProgressbarService.ProcessEndedWithSuccess(queue.Setting.VideoFileOut.Path)
+		}
+	}()
+}

kernel/convertor.go

@@ -0,0 +1,290 @@
+package kernel
+
+import (
+	"bufio"
+	"errors"
+	encoder2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/helper"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel/encoder"
+	"io"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+type File struct {
+	Path string
+	Name string
+	Ext  string
+}
+
+type ConvertSetting struct {
+	VideoFileInput       File
+	VideoFileOut         File
+	OverwriteOutputFiles bool
+	Encoder              encoder2.EncoderContract
+}
+
+type ConvertorContract interface {
+	RunConvert(setting ConvertSetting, progress ProgressContract) error
+	GetTotalDuration(file *File) (float64, error)
+	GetFFmpegVesrion() (string, error)
+	GetFFprobeVersion() (string, error)
+	GetFFplayVersion() (string, error)
+	ChangeFFmpegPath(path string) (bool, error)
+	ChangeFFprobePath(path string) (bool, error)
+	ChangeFFplayPath(path string) (bool, error)
+	GetRunningProcesses() map[int]*exec.Cmd
+	GetSupportFormats() (encoder.ConvertorFormatsContract, error)
+}
+
+type ProgressContract interface {
+	GetProtocole() string
+	Run(stdOut io.ReadCloser, stdErr io.ReadCloser) error
+}
+
+type FFPathUtilities struct {
+	FFmpeg  string
+	FFprobe string
+	FFplay  string
+}
+
+type runningProcesses struct {
+	items          map[int]*exec.Cmd
+	numberOfStarts int
+}
+
+type Convertor struct {
+	ffPathUtilities  *FFPathUtilities
+	runningProcesses runningProcesses
+}
+
+type ConvertData struct {
+	totalDuration float64
+}
+
+func NewService(ffPathUtilities *FFPathUtilities) *Convertor {
+	return &Convertor{
+		ffPathUtilities:  ffPathUtilities,
+		runningProcesses: runningProcesses{items: map[int]*exec.Cmd{}, numberOfStarts: 0},
+	}
+}
+
+func (s Convertor) RunConvert(setting ConvertSetting, progress ProgressContract) error {
+	overwriteOutputFiles := "-n"
+	if setting.OverwriteOutputFiles == true {
+		overwriteOutputFiles = "-y"
+	}
+	args := []string{overwriteOutputFiles, "-i", setting.VideoFileInput.Path}
+	args = append(args, setting.Encoder.GetParams()...)
+	args = append(args, "-progress", progress.GetProtocole(), setting.VideoFileOut.Path)
+	cmd := exec.Command(s.ffPathUtilities.FFmpeg, args...)
+	helper.PrepareBackgroundCommand(cmd)
+
+	stdOut, err := cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+	stdErr, err := cmd.StderrPipe()
+	if err != nil {
+		return err
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		return err
+	}
+	index := s.runningProcesses.numberOfStarts
+	s.runningProcesses.numberOfStarts++
+	s.runningProcesses.items[index] = cmd
+
+	errProgress := progress.Run(stdOut, stdErr)
+
+	err = cmd.Wait()
+	delete(s.runningProcesses.items, index)
+	if errProgress != nil {
+		return errProgress
+	}
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s Convertor) GetTotalDuration(file *File) (duration float64, err error) {
+	args := []string{"-v", "error", "-select_streams", "v:0", "-count_packets", "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0", file.Path}
+	cmd := exec.Command(s.ffPathUtilities.FFprobe, args...)
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		errString := strings.TrimSpace(string(out))
+		if len(errString) > 1 {
+			return 0, errors.New(errString)
+		}
+		return 0, err
+	}
+	frames := strings.TrimSpace(string(out))
+	if len(frames) == 0 {
+		return s.getAlternativeTotalDuration(file)
+	}
+
+	duration, err = strconv.ParseFloat(frames, 64)
+	if err != nil {
+		// fix .mts duration
+		return strconv.ParseFloat(getFirstDigits(frames), 64)
+	}
+	return duration, err
+}
+
+func (s Convertor) getAlternativeTotalDuration(file *File) (duration float64, err error) {
+	args := []string{"-v", "error", "-select_streams", "a:0", "-count_packets", "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0", file.Path}
+	cmd := exec.Command(s.ffPathUtilities.FFprobe, args...)
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		errString := strings.TrimSpace(string(out))
+		if len(errString) > 1 {
+			return 0, errors.New(errString)
+		}
+		return 0, err
+	}
+	frames := strings.TrimSpace(string(out))
+	if len(frames) == 0 {
+		return 0, errors.New("error getting number of frames")
+	}
+	return strconv.ParseFloat(frames, 64)
+}
+
+func (s Convertor) GetFFmpegVesrion() (string, error) {
+	cmd := exec.Command(s.ffPathUtilities.FFmpeg, "-version")
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", err
+	}
+	text := regexp.MustCompile("\r?\n").Split(strings.TrimSpace(string(out)), -1)
+	return text[0], nil
+}
+
+func (s Convertor) GetFFprobeVersion() (string, error) {
+	cmd := exec.Command(s.ffPathUtilities.FFprobe, "-version")
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", err
+	}
+	text := regexp.MustCompile("\r?\n").Split(strings.TrimSpace(string(out)), -1)
+	return text[0], nil
+}
+
+func (s Convertor) GetFFplayVersion() (string, error) {
+	cmd := exec.Command(s.ffPathUtilities.FFplay, "-version")
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", err
+	}
+	text := regexp.MustCompile("\r?\n").Split(strings.TrimSpace(string(out)), -1)
+	return text[0], nil
+}
+
+func (s Convertor) ChangeFFmpegPath(path string) (bool, error) {
+	cmd := exec.Command(path, "-version")
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return false, err
+	}
+	if strings.Contains(strings.TrimSpace(string(out)), "ffmpeg") == false {
+		return false, nil
+	}
+	s.ffPathUtilities.FFmpeg = path
+	return true, nil
+}
+
+func (s Convertor) ChangeFFprobePath(path string) (bool, error) {
+	cmd := exec.Command(path, "-version")
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return false, err
+	}
+	if strings.Contains(strings.TrimSpace(string(out)), "ffprobe") == false {
+		return false, nil
+	}
+	s.ffPathUtilities.FFprobe = path
+	return true, nil
+}
+
+func (s Convertor) ChangeFFplayPath(path string) (bool, error) {
+	cmd := exec.Command(path, "-version")
+	helper.PrepareBackgroundCommand(cmd)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return false, err
+	}
+	if strings.Contains(strings.TrimSpace(string(out)), "ffplay") == false {
+		return false, nil
+	}
+	s.ffPathUtilities.FFplay = path
+	return true, nil
+}
+
+func (s Convertor) GetSupportFormats() (encoder.ConvertorFormatsContract, error) {
+	formats := encoder.NewConvertorFormats()
+	cmd := exec.Command(s.ffPathUtilities.FFmpeg, "-encoders")
+	helper.PrepareBackgroundCommand(cmd)
+
+	stdOut, err := cmd.StdoutPipe()
+	if err != nil {
+		return formats, err
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		return formats, err
+	}
+
+	scannerErr := bufio.NewReader(stdOut)
+	for {
+		line, _, err := scannerErr.ReadLine()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			continue
+		}
+		text := strings.Split(strings.TrimSpace(string(line)), " ")
+		encoderType := string(text[0][0])
+		if len(text) < 2 || (encoderType != "V" && encoderType != "A") {
+			continue
+		}
+		formats.NewEncoder(text[1])
+	}
+
+	err = cmd.Wait()
+	if err != nil {
+		return formats, err
+	}
+
+	return formats, nil
+}
+
+func (s Convertor) GetRunningProcesses() map[int]*exec.Cmd {
+	return s.runningProcesses.items
+}
+
+func getFirstDigits(s string) string {
+	result := ""
+	for _, r := range s {
+		if unicode.IsDigit(r) {
+			result += string(r)
+		} else {
+			break
+		}
+	}
+	return result
+}

kernel/encoder/encoder.go

@@ -0,0 +1,84 @@
+package encoder
+
+import (
+	"errors"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+)
+
+type ConvertorFormatContract interface {
+	GetTitle() string
+	AddEncoder(encoder encoder.EncoderDataContract)
+	GetFileType() encoder.FileTypeContract
+	GetEncoders() map[int]encoder.EncoderDataContract
+}
+
+type ConvertorFormat struct {
+	title    string
+	fileType encoder.FileTypeContract
+	encoders map[int]encoder.EncoderDataContract
+}
+
+func NewConvertorFormat(title string, fileType encoder.FileTypeContract) *ConvertorFormat {
+	return &ConvertorFormat{
+		title:    title,
+		fileType: fileType,
+		encoders: map[int]encoder.EncoderDataContract{},
+	}
+}
+
+func (f ConvertorFormat) GetTitle() string {
+	return f.title
+}
+
+func (f ConvertorFormat) AddEncoder(encoder encoder.EncoderDataContract) {
+	f.encoders[len(f.encoders)] = encoder
+}
+
+func (f ConvertorFormat) GetEncoders() map[int]encoder.EncoderDataContract {
+	return f.encoders
+}
+
+func (f ConvertorFormat) GetFileType() encoder.FileTypeContract {
+	return f.fileType
+}
+
+type ConvertorFormatsContract interface {
+	NewEncoder(encoderName string) bool
+	GetFormats() map[string]ConvertorFormatContract
+	GetFormat(format string) (ConvertorFormatContract, error)
+}
+
+type ConvertorFormats struct {
+	formats map[string]ConvertorFormatContract
+}
+
+func NewConvertorFormats() *ConvertorFormats {
+	return &ConvertorFormats{
+		formats: map[string]ConvertorFormatContract{},
+	}
+}
+
+func (f ConvertorFormats) NewEncoder(encoderName string) bool {
+	if supportEncoders[encoderName] == nil {
+		return false
+	}
+	data := supportEncoders[encoderName]()
+	for _, format := range data.GetFormats() {
+		if f.formats[format] == nil {
+			f.formats[format] = NewConvertorFormat(format, data.GetFileType())
+		}
+		f.formats[format].AddEncoder(data)
+	}
+	return true
+}
+
+func (f ConvertorFormats) GetFormats() map[string]ConvertorFormatContract {
+	return f.formats
+}
+
+func (f ConvertorFormats) GetFormat(format string) (ConvertorFormatContract, error) {
+	if f.formats[format] == nil {
+		return ConvertorFormat{}, errors.New("not found ConvertorFormat")
+	}
+	return f.formats[format], nil
+}

kernel/encoder/encoders.go

@@ -0,0 +1,74 @@
+package encoder
+
+import (
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/apng"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/bmp"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/flv"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/gif"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/h264_nvenc"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libmp3lame"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libshine"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libtwolame"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libvpx"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libvpx_vp9"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libwebp"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libwebp_anim"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libx264"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libx265"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/libxvid"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/mjpeg"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/mp2"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/mp2fixed"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/mpeg1video"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/mpeg2video"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/mpeg4"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/msmpeg4"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/msmpeg4v2"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/msvideo1"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/png"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/qtrle"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/sgi"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/tiff"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/wmav1"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/wmav2"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/wmv1"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/wmv2"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/encoder/xbm"
+)
+
+var supportEncoders = map[string]func() encoder.EncoderDataContract{
+	"libx264":      libx264.NewData,
+	"h264_nvenc":   h264_nvenc.NewData,
+	"libx265":      libx265.NewData,
+	"png":          png.NewData,
+	"gif":          gif.NewData,
+	"flv":          flv.NewData,
+	"apng":         apng.NewData,
+	"bmp":          bmp.NewData,
+	"mjpeg":        mjpeg.NewData,
+	"mpeg1video":   mpeg1video.NewData,
+	"mpeg2video":   mpeg2video.NewData,
+	"mpeg4":        mpeg4.NewData,
+	"libxvid":      libxvid.NewData,
+	"msmpeg4v2":    msmpeg4v2.NewData,
+	"msmpeg4":      msmpeg4.NewData,
+	"msvideo1":     msvideo1.NewData,
+	"qtrle":        qtrle.NewData,
+	"tiff":         tiff.NewData,
+	"sgi":          sgi.NewData,
+	"libvpx":       libvpx.NewData,
+	"libvpx-vp9":   libvpx_vp9.NewData,
+	"libwebp_anim": libwebp_anim.NewData,
+	"libwebp":      libwebp.NewData,
+	"wmv1":         wmv1.NewData,
+	"wmv2":         wmv2.NewData,
+	"xbm":          xbm.NewData,
+	"mp2":          mp2.NewData,
+	"mp2fixed":     mp2fixed.NewData,
+	"libtwolame":   libtwolame.NewData,
+	"libmp3lame":   libmp3lame.NewData,
+	"libshine":     libshine.NewData,
+	"wmav1":        wmav1.NewData,
+	"wmav2":        wmav2.NewData,
+}

kernel/error.go

@@ -0,0 +1,17 @@
+package kernel
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+)
+
+func panicErrorLang(a fyne.App, err error) {
+	window := a.NewWindow("GUI for FFmpeg")
+	window.SetContent(container.NewVBox(
+		widget.NewLabel("Произошла ошибка!"),
+		widget.NewLabel("произошла ошибка при получении языковых переводах. \n\r"+err.Error()),
+	))
+	window.ShowAndRun()
+	panic(err.Error())
+}

kernel/ffplay.go

@@ -0,0 +1,28 @@
+package kernel
+
+import (
+	"os/exec"
+)
+
+type FFplay struct {
+	ffPathUtilities *FFPathUtilities
+}
+
+type FFplaySetting struct {
+	PathToFile string
+}
+
+type FFplayContract interface {
+	Run(setting FFplaySetting) error
+}
+
+func NewFFplay(ffPathUtilities *FFPathUtilities) *FFplay {
+	return &FFplay{ffPathUtilities: ffPathUtilities}
+}
+
+func (ffplay FFplay) Run(setting FFplaySetting) error {
+	args := []string{setting.PathToFile}
+	cmd := exec.Command(ffplay.ffPathUtilities.FFplay, args...)
+
+	return cmd.Start()
+}

kernel/items_to_convert.go

@@ -0,0 +1,152 @@
+package kernel
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+)
+
+type ItemsToConvertContract interface {
+	Add(file *File)
+	GetItems() map[int]ItemToConvertContract
+	AfterAddingQueue()
+}
+
+type ItemsToConvert struct {
+	nextId         int
+	items          map[int]ItemToConvertContract
+	itemsContainer *fyne.Container
+	ffplayService  FFplayContract
+	isAutoRemove   bool
+}
+
+func NewItemsToConvert(itemsContainer *fyne.Container, ffplayService FFplayContract, localizerService LocalizerContract) *ItemsToConvert {
+	containerForItems := container.NewVBox()
+	ItemsToConvert := &ItemsToConvert{
+		nextId:         0,
+		items:          map[int]ItemToConvertContract{},
+		itemsContainer: containerForItems,
+		ffplayService:  ffplayService,
+		isAutoRemove:   true,
+	}
+
+	line := canvas.NewLine(theme.Color(theme.ColorNameFocus))
+	line.StrokeWidth = 5
+	checkboxAutoRemove := widget.NewCheck(
+		localizerService.GetMessage("autoClearAfterAddingToQueue"),
+		func(checked bool) {
+			ItemsToConvert.isAutoRemove = checked
+		},
+	)
+	checkboxAutoRemove.SetChecked(ItemsToConvert.isAutoRemove)
+	localizerService.AddChangeCallback("autoClearAfterAddingToQueue", func(text string) {
+		checkboxAutoRemove.Text = text
+	})
+
+	buttonClear := widget.NewButton(
+		localizerService.GetMessage("clearAll"),
+		func() {
+			ItemsToConvert.clear()
+		},
+	)
+	buttonClear.Importance = widget.DangerImportance
+	localizerService.AddChangeCallback("clearAll", func(text string) {
+		buttonClear.Text = text
+	})
+
+	itemsContainer.Add(container.NewVBox(
+		container.NewPadded(),
+		container.NewBorder(nil, nil, nil, buttonClear, container.NewHScroll(checkboxAutoRemove)),
+		container.NewPadded(),
+		line,
+		container.NewPadded(),
+		containerForItems,
+	))
+
+	return ItemsToConvert
+}
+
+func (items *ItemsToConvert) Add(file *File) {
+	nextId := items.nextId
+	var content *fyne.Container
+	var buttonPlay *widget.Button
+
+	buttonPlay = widget.NewButtonWithIcon("", theme.Icon(theme.IconNameMediaPlay), func() {
+		buttonPlay.Disable()
+		go func() {
+			_ = items.ffplayService.Run(FFplaySetting{
+				PathToFile: file.Path,
+			})
+			fyne.Do(func() {
+				buttonPlay.Enable()
+			})
+		}()
+	})
+
+	buttonRemove := widget.NewButtonWithIcon("", theme.Icon(theme.IconNameDelete), func() {
+		items.itemsContainer.Remove(content)
+		items.itemsContainer.Refresh()
+		delete(items.items, nextId)
+	})
+	buttonRemove.Importance = widget.DangerImportance
+
+	content = container.NewVBox(
+		container.NewBorder(
+			nil,
+			nil,
+			buttonPlay,
+			buttonRemove,
+			container.NewHScroll(widget.NewLabel(file.Name)),
+		),
+		container.NewHScroll(widget.NewLabel(file.Path)),
+		container.NewPadded(),
+		canvas.NewLine(theme.Color(theme.ColorNameFocus)),
+		container.NewPadded(),
+	)
+
+	items.itemsContainer.Add(content)
+	items.items[nextId] = NewItemToConvert(file, content)
+	items.nextId++
+}
+
+func (items *ItemsToConvert) GetItems() map[int]ItemToConvertContract {
+	return items.items
+}
+
+func (items *ItemsToConvert) AfterAddingQueue() {
+	if items.isAutoRemove {
+		items.clear()
+	}
+}
+
+func (items *ItemsToConvert) clear() {
+	items.itemsContainer.RemoveAll()
+	items.items = map[int]ItemToConvertContract{}
+}
+
+type ItemToConvertContract interface {
+	GetFile() *File
+	GetContent() *fyne.Container
+}
+
+type ItemToConvert struct {
+	file    *File
+	content *fyne.Container
+}
+
+func NewItemToConvert(file *File, content *fyne.Container) *ItemToConvert {
+	return &ItemToConvert{
+		file:    file,
+		content: content,
+	}
+}
+
+func (item ItemToConvert) GetFile() *File {
+	return item.file
+}
+
+func (item ItemToConvert) GetContent() *fyne.Container {
+	return item.content
+}

kernel/layout.go

@@ -0,0 +1,481 @@
+package kernel
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+	"image/color"
+	"strconv"
+	"strings"
+)
+
+type LayoutContract interface {
+	SetContent(content fyne.CanvasObject) *fyne.Container
+	ChangeQueueStatus(queueId int, queue *Queue)
+	GetRightTabs() RightTabsContract
+}
+
+type Layout struct {
+	layout            *fyne.Container
+	queueLayoutObject QueueLayoutObjectContract
+	localizerService  LocalizerContract
+	rightTabsService  RightTabsContract
+}
+
+func NewLayout(queueLayoutObject QueueLayoutObjectContract, localizerService LocalizerContract, rightTabsService RightTabsContract) *Layout {
+	layout := container.NewAdaptiveGrid(2, widget.NewLabel(""), queueLayoutObject.GetCanvasObject())
+
+	return &Layout{
+		layout:            layout,
+		queueLayoutObject: queueLayoutObject,
+		localizerService:  localizerService,
+		rightTabsService:  rightTabsService,
+	}
+}
+
+func (l Layout) SetContent(content fyne.CanvasObject) *fyne.Container {
+	l.layout.Objects[0] = content
+	return l.layout
+}
+
+func (l Layout) ChangeQueueStatus(queueId int, queue *Queue) {
+	l.queueLayoutObject.ChangeQueueStatus(queueId, queue)
+}
+
+func (l Layout) GetRightTabs() RightTabsContract {
+	return l.rightTabsService
+}
+
+type QueueLayoutObjectContract interface {
+	GetCanvasObject() fyne.CanvasObject
+	ChangeQueueStatus(queueId int, queue *Queue)
+}
+
+type QueueLayoutObject struct {
+	QueueListContract QueueListContract
+
+	queue                 QueueListContract
+	container             *fyne.Container
+	containerItems        *fyne.Container
+	items                 map[int]QueueLayoutItem
+	localizerService      LocalizerContract
+	queueStatisticsFormat *queueStatisticsFormat
+	ffplayService         FFplayContract
+}
+
+type QueueLayoutItem struct {
+	CanvasObject      fyne.CanvasObject
+	BlockMessageError *container.Scroll
+	StatusMessage     *canvas.Text
+	MessageError      *canvas.Text
+	buttonPlay        *widget.Button
+
+	status *StatusContract
+}
+
+func NewQueueLayoutObject(queue QueueListContract, localizerService LocalizerContract, ffplayService FFplayContract, rightTabsService RightTabsContract, blockProgressbar *fyne.Container) *QueueLayoutObject {
+	title := widget.NewLabel(localizerService.GetMessage("queue"))
+	title.TextStyle.Bold = true
+
+	localizerService.AddChangeCallback("queue", func(text string) {
+		title.Text = text
+		title.Refresh()
+	})
+
+	items := map[int]QueueLayoutItem{}
+	queueStatisticsFormat := newQueueStatisticsFormat(localizerService, &items)
+
+	line := canvas.NewLine(theme.Color(theme.ColorNameFocus))
+	line.StrokeWidth = 5
+
+	rightTabsService.GetFileQueueContainer().Add(container.NewVBox(
+		container.NewPadded(),
+		container.NewHBox(title, queueStatisticsFormat.completed.widget, queueStatisticsFormat.error.widget),
+		container.NewHBox(queueStatisticsFormat.inProgress.widget, queueStatisticsFormat.waiting.widget, queueStatisticsFormat.total.widget),
+		container.NewPadded(),
+		line,
+		container.NewPadded(),
+	))
+	queueLayoutObject := &QueueLayoutObject{
+		queue: queue,
+		container: container.NewBorder(
+			container.NewVBox(
+				blockProgressbar,
+				widget.NewSeparator(),
+			),
+			nil, nil, nil, container.NewVScroll(rightTabsService.GetTabs()),
+		),
+		containerItems:        rightTabsService.GetFileQueueContainer(),
+		items:                 items,
+		localizerService:      localizerService,
+		queueStatisticsFormat: queueStatisticsFormat,
+		ffplayService:         ffplayService,
+	}
+
+	queue.AddListener(queueLayoutObject)
+
+	return queueLayoutObject
+}
+
+func (o QueueLayoutObject) GetCanvasObject() fyne.CanvasObject {
+	return o.container
+}
+
+func (o QueueLayoutObject) Add(id int, queue *Queue) {
+	statusMessage := canvas.NewText(o.getStatusTitle(queue.Status), theme.Color(theme.ColorNamePrimary))
+	messageError := canvas.NewText("", theme.Color(theme.ColorNameError))
+	buttonPlay := widget.NewButtonWithIcon("", theme.Icon(theme.IconNameMediaPlay), func() {
+
+	})
+	buttonPlay.Hide()
+	blockMessageError := container.NewHScroll(messageError)
+	blockMessageError.Hide()
+
+	content := container.NewVBox(
+		container.NewHScroll(widget.NewLabel(queue.Setting.VideoFileInput.Name)),
+		container.NewHBox(
+			buttonPlay,
+			statusMessage,
+		),
+		blockMessageError,
+		container.NewPadded(),
+		canvas.NewLine(theme.Color(theme.ColorNameFocus)),
+		container.NewPadded(),
+	)
+
+	o.queueStatisticsFormat.addQueue()
+	if o.queueStatisticsFormat.isChecked(queue.Status) == false {
+		content.Hide()
+	}
+
+	o.items[id] = QueueLayoutItem{
+		CanvasObject:      content,
+		StatusMessage:     statusMessage,
+		BlockMessageError: blockMessageError,
+		MessageError:      messageError,
+		buttonPlay:        buttonPlay,
+		status:            &queue.Status,
+	}
+	o.containerItems.Add(content)
+}
+
+func (o QueueLayoutObject) Remove(id int) {
+	if item, ok := o.items[id]; ok {
+		o.container.Remove(item.CanvasObject)
+		o.queueStatisticsFormat.removeQueue(*item.status)
+		o.items[id] = QueueLayoutItem{}
+	}
+}
+
+func (o QueueLayoutObject) ChangeQueueStatus(queueId int, queue *Queue) {
+	if item, ok := o.items[queueId]; ok {
+		statusColor := o.getStatusColor(queue.Status)
+		item.StatusMessage.Text = o.getStatusTitle(queue.Status)
+		item.StatusMessage.Color = statusColor
+		fyne.Do(func() {
+			item.StatusMessage.Refresh()
+		})
+		if queue.Error != nil {
+			item.MessageError.Text = queue.Error.Error()
+			item.MessageError.Color = statusColor
+			fyne.Do(func() {
+				item.BlockMessageError.Show()
+				item.MessageError.Refresh()
+			})
+		}
+		if queue.Status == StatusType(Completed) {
+			item.buttonPlay.Show()
+			item.buttonPlay.OnTapped = func() {
+				item.buttonPlay.Disable()
+				go func() {
+					_ = o.ffplayService.Run(FFplaySetting{
+						PathToFile: queue.Setting.VideoFileOut.Path,
+					})
+					fyne.Do(func() {
+						item.buttonPlay.Enable()
+					})
+				}()
+			}
+		}
+		if o.queueStatisticsFormat.isChecked(queue.Status) == false && item.CanvasObject.Visible() == true {
+			item.CanvasObject.Hide()
+		} else if item.CanvasObject.Visible() == false {
+			item.CanvasObject.Show()
+		}
+		o.queueStatisticsFormat.changeQueue(queue.Status)
+	}
+}
+
+func (o QueueLayoutObject) getStatusColor(status StatusContract) color.Color {
+	if status == StatusType(Error) {
+		return theme.Color(theme.ColorNameError)
+	}
+
+	if status == StatusType(Completed) {
+		return color.RGBA{R: 49, G: 127, B: 114, A: 255}
+	}
+
+	return theme.Color(theme.ColorNamePrimary)
+}
+
+func (o QueueLayoutObject) getStatusTitle(status StatusContract) string {
+	return o.localizerService.GetMessage(status.Name() + "Queue")
+}
+
+type queueStatistics struct {
+	widget *widget.Check
+	title  string
+	count  *int64
+}
+type queueStatisticsFormat struct {
+	waiting    *queueStatistics
+	inProgress *queueStatistics
+	completed  *queueStatistics
+	error      *queueStatistics
+	total      *queueStatistics
+}
+
+func newQueueStatisticsFormat(localizerService LocalizerContract, queueItems *map[int]QueueLayoutItem) *queueStatisticsFormat {
+	checkWaiting := newQueueStatistics("waitingQueue", localizerService)
+	checkInProgress := newQueueStatistics("inProgressQueue", localizerService)
+	checkCompleted := newQueueStatistics("completedQueue", localizerService)
+	checkError := newQueueStatistics("errorQueue", localizerService)
+	checkTotal := newQueueStatistics("total", localizerService)
+
+	queueStatisticsFormat := &queueStatisticsFormat{
+		waiting:    checkWaiting,
+		inProgress: checkInProgress,
+		completed:  checkCompleted,
+		error:      checkError,
+		total:      checkTotal,
+	}
+
+	checkTotal.widget.OnChanged = func(b bool) {
+		if b == true {
+			queueStatisticsFormat.allCheckboxChecked()
+		} else {
+			queueStatisticsFormat.allUnCheckboxChecked()
+		}
+		queueStatisticsFormat.redrawingQueueItems(queueItems)
+	}
+
+	queueStatisticsFormat.waiting.widget.OnChanged = func(b bool) {
+		if b == true {
+			queueStatisticsFormat.checkboxChecked()
+		} else {
+			queueStatisticsFormat.unCheckboxChecked()
+		}
+		queueStatisticsFormat.redrawingQueueItems(queueItems)
+	}
+
+	queueStatisticsFormat.inProgress.widget.OnChanged = func(b bool) {
+		if b == true {
+			queueStatisticsFormat.checkboxChecked()
+		} else {
+			queueStatisticsFormat.unCheckboxChecked()
+		}
+		queueStatisticsFormat.redrawingQueueItems(queueItems)
+	}
+
+	queueStatisticsFormat.completed.widget.OnChanged = func(b bool) {
+		if b == true {
+			queueStatisticsFormat.checkboxChecked()
+		} else {
+			queueStatisticsFormat.unCheckboxChecked()
+		}
+		queueStatisticsFormat.redrawingQueueItems(queueItems)
+	}
+
+	queueStatisticsFormat.error.widget.OnChanged = func(b bool) {
+		if b == true {
+			queueStatisticsFormat.checkboxChecked()
+		} else {
+			queueStatisticsFormat.unCheckboxChecked()
+		}
+		queueStatisticsFormat.redrawingQueueItems(queueItems)
+	}
+
+	return queueStatisticsFormat
+}
+
+func (f queueStatisticsFormat) redrawingQueueItems(queueItems *map[int]QueueLayoutItem) {
+	for _, item := range *queueItems {
+		if f.isChecked(*item.status) == true && item.CanvasObject.Visible() == false {
+			item.CanvasObject.Show()
+			continue
+		}
+		if f.isChecked(*item.status) == false && item.CanvasObject.Visible() == true {
+			item.CanvasObject.Hide()
+		}
+	}
+}
+
+func (f queueStatisticsFormat) isChecked(status StatusContract) bool {
+	if status == StatusType(InProgress) {
+		return f.inProgress.widget.Checked
+	}
+	if status == StatusType(Completed) {
+		return f.completed.widget.Checked
+	}
+	if status == StatusType(Error) {
+		return f.error.widget.Checked
+	}
+	if status == StatusType(Waiting) {
+		return f.waiting.widget.Checked
+	}
+
+	return true
+}
+
+func (f queueStatisticsFormat) addQueue() {
+	f.waiting.add()
+	f.total.add()
+}
+
+func (f queueStatisticsFormat) changeQueue(status StatusContract) {
+	if status == StatusType(InProgress) {
+		f.waiting.remove()
+		f.inProgress.add()
+		return
+	}
+
+	if status == StatusType(Completed) {
+		f.inProgress.remove()
+		f.completed.add()
+		return
+	}
+
+	if status == StatusType(Error) {
+		f.inProgress.remove()
+		f.error.add()
+		return
+	}
+}
+
+func (f queueStatisticsFormat) removeQueue(status StatusContract) {
+	f.total.remove()
+
+	if status == StatusType(Completed) {
+		f.completed.remove()
+		return
+	}
+
+	if status == StatusType(Error) {
+		f.error.remove()
+		return
+	}
+
+	if status == StatusType(InProgress) {
+		f.inProgress.remove()
+		return
+	}
+
+	if status == StatusType(Waiting) {
+		f.waiting.remove()
+		return
+	}
+}
+
+func (f queueStatisticsFormat) checkboxChecked() {
+	if f.total.widget.Checked == true {
+		return
+	}
+
+	if f.waiting.widget.Checked == false {
+		return
+	}
+
+	if f.inProgress.widget.Checked == false {
+		return
+	}
+
+	if f.completed.widget.Checked == false {
+		return
+	}
+
+	if f.error.widget.Checked == false {
+		return
+	}
+
+	f.total.widget.Checked = true
+	f.total.widget.Refresh()
+}
+
+func (f queueStatisticsFormat) unCheckboxChecked() {
+	if f.total.widget.Checked == false {
+		return
+	}
+
+	f.total.widget.Checked = false
+	f.total.widget.Refresh()
+}
+
+func (f queueStatisticsFormat) allCheckboxChecked() {
+	f.waiting.widget.Checked = true
+	f.waiting.widget.Refresh()
+	f.inProgress.widget.Checked = true
+	f.inProgress.widget.Refresh()
+	f.completed.widget.Checked = true
+	f.completed.widget.Refresh()
+	f.error.widget.Checked = true
+	f.error.widget.Refresh()
+}
+
+func (f queueStatisticsFormat) allUnCheckboxChecked() {
+	f.waiting.widget.Checked = false
+	f.waiting.widget.Refresh()
+	f.inProgress.widget.Checked = false
+	f.inProgress.widget.Refresh()
+	f.completed.widget.Checked = false
+	f.completed.widget.Refresh()
+	f.error.widget.Checked = false
+	f.error.widget.Refresh()
+}
+
+func newQueueStatistics(messaigeID string, localizerService LocalizerContract) *queueStatistics {
+	checkbox := widget.NewCheck("", nil)
+	checkbox.Checked = true
+
+	count := int64(0)
+
+	title := localizerService.GetMessage(messaigeID)
+	queueStatistics := &queueStatistics{
+		widget: checkbox,
+		title:  strings.ToLower(title),
+		count:  &count,
+	}
+
+	queueStatistics.formatText(false)
+
+	localizerService.AddChangeCallback(messaigeID, func(text string) {
+		queueStatistics.title = strings.ToLower(text)
+		queueStatistics.formatText(true)
+		queueStatistics.widget.Refresh()
+	})
+
+	return queueStatistics
+}
+
+func (s queueStatistics) add() {
+	*s.count += 1
+	s.formatText(true)
+}
+
+func (s queueStatistics) remove() {
+	if *s.count == 0 {
+		return
+	}
+	*s.count -= 1
+	s.formatText(true)
+}
+
+func (s queueStatistics) formatText(refresh bool) {
+	s.widget.Text = s.title + ": " + strconv.FormatInt(*s.count, 10)
+	if refresh == true {
+		fyne.Do(func() {
+			s.widget.Refresh()
+		})
+	}
+}

kernel/localizer.go

@@ -0,0 +1,194 @@
+package kernel
+
+import (
+	"embed"
+	"encoding/json"
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/lang"
+	"golang.org/x/text/language"
+)
+
+//go:embed translations
+var translations embed.FS
+
+var supportedLanguages = map[string]Lang{
+	"ru": {Code: "ru", Title: "Русский"},
+	"kk": {Code: "kk", Title: "Қазақ Тілі"},
+	"en": {Code: "en", Title: "English"},
+}
+
+type LocalizerContract interface {
+	IsStartWithLanguageSelection() bool
+	GetMessage(key string, data ...any) string
+	GetLanguages() []Lang
+	GetCurrentLanguage() Lang
+	SetCurrentLanguage(selectLang Lang, isSaveSetting bool) error
+	AddChangeCallback(messageID string, callback func(text string))
+}
+
+type Lang struct {
+	Code  string
+	Title string
+}
+
+type changeCallback struct {
+	messageID string
+	callback  func(text string)
+}
+
+type Localizer struct {
+	setting                      SettingLanguageContract
+	currentLang                  Lang
+	changeCallbacks              map[int]*changeCallback
+	isStartWithLanguageSelection bool
+}
+
+func newLocalizer(app fyne.App) (*Localizer, error) {
+	setting := newSettingLanguage(app)
+	currentLanguage, isLanguageNotSupported := setting.GetLang()
+
+	localizer := &Localizer{
+		setting:                      setting,
+		changeCallbacks:              map[int]*changeCallback{},
+		isStartWithLanguageSelection: isLanguageNotSupported,
+	}
+
+	err := localizer.SetCurrentLanguage(currentLanguage, false)
+	if err != nil {
+		return nil, err
+	}
+
+	return localizer, nil
+}
+
+func (l *Localizer) IsStartWithLanguageSelection() bool {
+	return l.isStartWithLanguageSelection
+}
+
+func (l *Localizer) GetMessage(key string, data ...any) string {
+	return lang.L(key, data...)
+}
+
+func (l *Localizer) GetLanguages() []Lang {
+	return getLanguages()
+}
+
+func (l *Localizer) GetCurrentLanguage() Lang {
+	return l.currentLang
+}
+
+func (l *Localizer) SetCurrentLanguage(selectLang Lang, isSaveSetting bool) error {
+	l.currentLang = selectLang
+
+	translationsData, err := l.getTranslations(selectLang)
+	if err != nil {
+		return err
+	}
+
+	name := lang.SystemLocale().LanguageString()
+	err = lang.AddTranslations(fyne.NewStaticResource(name+".json", translationsData))
+	if err != nil {
+		return err
+	}
+
+	if isSaveSetting {
+		l.setting.SetLang(selectLang)
+	}
+
+	l.eventSetCurrentLanguage()
+	return nil
+}
+
+func (l *Localizer) AddChangeCallback(messageID string, callback func(text string)) {
+	l.changeCallbacks[len(l.changeCallbacks)] = &changeCallback{messageID: messageID, callback: callback}
+}
+
+func (l *Localizer) eventSetCurrentLanguage() {
+	for _, changeCallback := range l.changeCallbacks {
+		text := l.GetMessage(changeCallback.messageID)
+		changeCallback.callback(text)
+	}
+}
+
+func (l *Localizer) getTranslations(language Lang) ([]byte, error) {
+	baseJson, err := translations.ReadFile("translations/base." + language.Code + ".json")
+	if err != nil {
+		return nil, err
+	}
+	appJson, err := translations.ReadFile("translations/app." + language.Code + ".json")
+	if err != nil {
+		return nil, err
+	}
+
+	return l.mergeTranslations(baseJson, appJson)
+}
+
+func (l *Localizer) mergeTranslations(baseJson []byte, appJson []byte) ([]byte, error) {
+	base := map[string]interface{}{}
+	custom := map[string]interface{}{}
+	err := json.Unmarshal(baseJson, &base)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(appJson, &custom)
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range custom {
+		base[k] = v
+	}
+	return json.Marshal(base)
+}
+
+func getLanguages() []Lang {
+	items := []Lang{}
+	for _, item := range supportedLanguages {
+		items = append(items, item)
+	}
+	return items
+}
+
+type SettingLanguageContract interface {
+	GetLang() (currentLang Lang, isLanguageNotSupported bool)
+	SetLang(language Lang)
+}
+
+type SettingLanguage struct {
+	app fyne.App
+}
+
+func newSettingLanguage(app fyne.App) *SettingLanguage {
+	return &SettingLanguage{
+		app: app,
+	}
+}
+
+func (s *SettingLanguage) GetLang() (currentLang Lang, isLanguageNotSupported bool) {
+	languageCode := s.app.Preferences().String("language")
+	currentLang = supportedLanguages["ru"]
+
+	if languageCode == "" {
+		languageTag, err := language.Parse(lang.SystemLocale().LanguageString())
+		if err != nil {
+			return currentLang, true
+		}
+		base, _ := languageTag.Base()
+		languageCode = base.String()
+	}
+
+	if findLang, ok := findSupportedLanguage(languageCode); ok {
+		return findLang, false
+	}
+
+	return currentLang, true
+}
+
+func (s *SettingLanguage) SetLang(language Lang) {
+	s.app.Preferences().SetString("language", language.Code)
+}
+
+func findSupportedLanguage(code string) (Lang, bool) {
+	lang, ok := supportedLanguages[code]
+	return lang, ok
+}

kernel/progressbar.go

@@ -0,0 +1,245 @@
+package kernel
+
+import (
+	"bufio"
+	"errors"
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+	"image/color"
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type BlockProgressbarContract interface {
+	GetContainer() *fyne.Container
+	GetProgressbar(totalDuration float64, filePath string, localizerService LocalizerContract) Progress
+	ProcessEndedWithError(errorText string)
+	ProcessEndedWithSuccess(filePath string)
+}
+
+type BlockProgressbar struct {
+	container     *fyne.Container
+	label         *widget.Label
+	progressbar   *widget.ProgressBar
+	errorBlock    *container.Scroll
+	messageError  *canvas.Text
+	statusMessage *canvas.Text
+	buttonPlay    *widget.Button
+	statusesText  *BlockProgressbarStatusesText
+	ffplayService FFplayContract
+}
+
+func NewBlockProgressbar(statusesText *BlockProgressbarStatusesText, ffplayService FFplayContract) *BlockProgressbar {
+	label := widget.NewLabel("")
+	progressbar := widget.NewProgressBar()
+
+	statusMessage := canvas.NewText("", theme.Color(theme.ColorNamePrimary))
+	messageError := canvas.NewText("", theme.Color(theme.ColorNameError))
+	buttonPlay := widget.NewButtonWithIcon("", theme.Icon(theme.IconNameMediaPlay), func() {
+
+	})
+	buttonPlay.Hide()
+
+	errorBlock := container.NewHScroll(messageError)
+	errorBlock.Hide()
+
+	content := container.NewVBox(
+		container.NewHScroll(label),
+		progressbar,
+		container.NewHScroll(container.NewHBox(
+			buttonPlay,
+			statusMessage,
+		)),
+		errorBlock,
+	)
+	content.Hide()
+
+	return &BlockProgressbar{
+		container:     content,
+		label:         label,
+		progressbar:   progressbar,
+		errorBlock:    errorBlock,
+		messageError:  messageError,
+		statusMessage: statusMessage,
+		buttonPlay:    buttonPlay,
+		statusesText:  statusesText,
+		ffplayService: ffplayService,
+	}
+}
+
+func (block BlockProgressbar) GetContainer() *fyne.Container {
+	return block.container
+}
+
+func (block BlockProgressbar) GetProgressbar(totalDuration float64, filePath string, localizerService LocalizerContract) Progress {
+	block.label.Text = filePath
+	block.statusMessage.Color = theme.Color(theme.ColorNamePrimary)
+	block.statusMessage.Text = block.statusesText.inProgress
+	block.messageError.Text = ""
+	fyne.Do(func() {
+		block.buttonPlay.Hide()
+		if block.errorBlock.Visible() {
+			block.errorBlock.Hide()
+		}
+		block.statusMessage.Refresh()
+		block.container.Refresh()
+		block.errorBlock.Refresh()
+	})
+
+	block.progressbar.Value = 0
+	return NewProgress(totalDuration, block.progressbar, localizerService)
+}
+
+func (block BlockProgressbar) ProcessEndedWithError(errorText string) {
+	fyne.Do(func() {
+		block.statusMessage.Color = theme.Color(theme.ColorNameError)
+		block.statusMessage.Text = block.statusesText.error
+		block.messageError.Text = errorText
+		block.errorBlock.Show()
+	})
+}
+
+func (block BlockProgressbar) ProcessEndedWithSuccess(filePath string) {
+	fyne.Do(func() {
+		block.statusMessage.Color = color.RGBA{R: 49, G: 127, B: 114, A: 255}
+		block.statusMessage.Text = block.statusesText.completed
+		block.buttonPlay.Show()
+		block.buttonPlay.OnTapped = func() {
+			block.buttonPlay.Disable()
+			go func() {
+				_ = block.ffplayService.Run(FFplaySetting{
+					PathToFile: filePath,
+				})
+				fyne.Do(func() {
+					block.buttonPlay.Enable()
+				})
+			}()
+		}
+	})
+}
+
+type Progress struct {
+	totalDuration    float64
+	progressbar      *widget.ProgressBar
+	protocol         string
+	localizerService LocalizerContract
+}
+
+func NewProgress(totalDuration float64, progressbar *widget.ProgressBar, localizerService LocalizerContract) Progress {
+	return Progress{
+		totalDuration:    totalDuration,
+		progressbar:      progressbar,
+		protocol:         "pipe:",
+		localizerService: localizerService,
+	}
+}
+
+func (p Progress) GetProtocole() string {
+	return p.protocol
+}
+
+func (p Progress) Run(stdOut io.ReadCloser, stdErr io.ReadCloser) error {
+	isProcessCompleted := false
+	var errorText string
+
+	p.progressbar.Value = 0
+	p.progressbar.Max = p.totalDuration
+	fyne.Do(func() {
+		p.progressbar.Refresh()
+	})
+	progress := 0.0
+
+	go func() {
+		scannerErr := bufio.NewReader(stdErr)
+		for {
+			line, _, err := scannerErr.ReadLine()
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				continue
+			}
+			data := strings.TrimSpace(string(line))
+			errorText = data
+		}
+	}()
+
+	scannerOut := bufio.NewReader(stdOut)
+	for {
+		line, _, err := scannerOut.ReadLine()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			continue
+		}
+		data := strings.TrimSpace(string(line))
+		if strings.Contains(data, "progress=end") {
+			p.progressbar.Value = p.totalDuration
+			fyne.Do(func() {
+				p.progressbar.Refresh()
+			})
+			isProcessCompleted = true
+			break
+		}
+
+		re := regexp.MustCompile(`frame=(\d+)`)
+		a := re.FindAllStringSubmatch(data, -1)
+
+		if len(a) > 0 && len(a[len(a)-1]) > 0 {
+			c, err := strconv.Atoi(a[len(a)-1][len(a[len(a)-1])-1])
+			if err != nil {
+				continue
+			}
+			progress = float64(c)
+		}
+		if p.progressbar.Value != progress {
+			p.progressbar.Value = progress
+			fyne.Do(func() {
+				p.progressbar.Refresh()
+			})
+		}
+	}
+
+	if isProcessCompleted == false {
+		if len(errorText) == 0 {
+			errorText = p.localizerService.GetMessage("errorConverter")
+		}
+		return errors.New(errorText)
+	}
+
+	return nil
+}
+
+type BlockProgressbarStatusesText struct {
+	inProgress string
+	completed  string
+	error      string
+}
+
+func GetBlockProgressbarStatusesText(localizerService LocalizerContract) *BlockProgressbarStatusesText {
+	statusesText := &BlockProgressbarStatusesText{
+		inProgress: localizerService.GetMessage("inProgressQueue"),
+		completed:  localizerService.GetMessage("completedQueue"),
+		error:      localizerService.GetMessage("errorQueue"),
+	}
+
+	localizerService.AddChangeCallback("inProgressQueue", func(text string) {
+		statusesText.inProgress = text
+	})
+
+	localizerService.AddChangeCallback("completedQueue", func(text string) {
+		statusesText.completed = text
+	})
+
+	localizerService.AddChangeCallback("errorQueue", func(text string) {
+		statusesText.error = text
+	})
+
+	return statusesText
+}

kernel/queue.go

@@ -0,0 +1,125 @@
+package kernel
+
+import (
+	"errors"
+)
+
+type Queue struct {
+	Setting *ConvertSetting
+	Status  StatusContract
+	Error   error
+}
+
+type StatusContract interface {
+	Name() string
+	Ordinal() int
+}
+
+const (
+	Waiting = iota
+	InProgress
+	Completed
+	Error
+)
+
+type StatusType uint
+
+var statusTypeStrings = []string{
+	"waiting",
+	"inProgress",
+	"completed",
+	"error",
+}
+
+func (status StatusType) Name() string {
+	return statusTypeStrings[status]
+}
+
+func (status StatusType) Ordinal() int {
+	return int(status)
+}
+
+type QueueListenerContract interface {
+	Add(key int, queue *Queue)
+	Remove(key int)
+}
+
+type QueueListContract interface {
+	AddListener(queueListener QueueListenerContract)
+	GetItems() map[int]*Queue
+	Add(setting *ConvertSetting)
+	Remove(key int)
+	GetItem(key int) (*Queue, error)
+	Next() (key int, queue *Queue)
+}
+
+type QueueList struct {
+	currentKey    *int
+	items         map[int]*Queue
+	queueListener map[int]QueueListenerContract
+}
+
+func NewQueueList() *QueueList {
+	currentKey := 0
+	return &QueueList{
+		currentKey:    &currentKey,
+		items:         map[int]*Queue{},
+		queueListener: map[int]QueueListenerContract{},
+	}
+}
+
+func (l QueueList) GetItems() map[int]*Queue {
+	return l.items
+}
+
+func (l QueueList) Add(setting *ConvertSetting) {
+	queue := Queue{
+		Setting: setting,
+		Status:  StatusType(Waiting),
+	}
+
+	*l.currentKey += 1
+	l.items[*l.currentKey] = &queue
+	l.eventAdd(*l.currentKey, &queue)
+}
+
+func (l QueueList) Remove(key int) {
+	if _, ok := l.items[key]; ok {
+		delete(l.items, key)
+		l.eventRemove(key)
+	}
+}
+
+func (l QueueList) GetItem(key int) (*Queue, error) {
+	if item, ok := l.items[key]; ok {
+		return item, nil
+	}
+
+	return nil, errors.New("key not found")
+}
+
+func (l QueueList) AddListener(queueListener QueueListenerContract) {
+	l.queueListener[len(l.queueListener)] = queueListener
+}
+
+func (l QueueList) eventAdd(key int, queue *Queue) {
+	for _, listener := range l.queueListener {
+		listener.Add(key, queue)
+	}
+}
+
+func (l QueueList) eventRemove(key int) {
+	for _, listener := range l.queueListener {
+		listener.Remove(key)
+	}
+}
+
+func (l QueueList) Next() (key int, queue *Queue) {
+	statusWaiting := StatusType(Waiting)
+	for key, item := range l.items {
+		if item.Status == statusWaiting {
+			return key, item
+		}
+	}
+	return -1, nil
+}

kernel/right_tabs.go

@@ -0,0 +1,75 @@
+package kernel
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/container"
+)
+
+type RightTabsContract interface {
+	GetTabs() *container.AppTabs
+	GetAddedFilesContainer() *fyne.Container
+	GetFileQueueContainer() *fyne.Container
+	SelectFileQueueTab()
+	SelectAddedFilesTab()
+}
+
+type RightTabs struct {
+	tabs *container.AppTabs
+
+	addedFilesContainer *fyne.Container
+	addedFilesTab       *container.TabItem
+
+	fileQueueContainer *fyne.Container
+	fileQueueTab       *container.TabItem
+}
+
+func NewRightTabs(localizerService LocalizerContract) *RightTabs {
+	addedFilesContainer := container.NewVBox()
+	addedFilesTab := container.NewTabItem(localizerService.GetMessage("addedFilesTitle"), addedFilesContainer)
+	localizerService.AddChangeCallback("addedFilesTitle", func(text string) {
+		addedFilesTab.Text = text
+	})
+
+	fileQueueContainer := container.NewVBox()
+	fileQueueTab := container.NewTabItem(localizerService.GetMessage("fileQueueTitle"), fileQueueContainer)
+	localizerService.AddChangeCallback("fileQueueTitle", func(text string) {
+		fileQueueTab.Text = text
+	})
+
+	tabs := container.NewAppTabs(
+		addedFilesTab,
+		fileQueueTab,
+	)
+
+	return &RightTabs{
+		tabs:                tabs,
+		addedFilesContainer: addedFilesContainer,
+		addedFilesTab:       addedFilesTab,
+		fileQueueContainer:  fileQueueContainer,
+		fileQueueTab:        fileQueueTab,
+	}
+}
+
+func (t RightTabs) GetTabs() *container.AppTabs {
+	return t.tabs
+}
+
+func (t RightTabs) GetAddedFilesContainer() *fyne.Container {
+	return t.addedFilesContainer
+}
+
+func (t RightTabs) GetFileQueueContainer() *fyne.Container {
+	return t.fileQueueContainer
+}
+
+func (t RightTabs) SelectFileQueueTab() {
+	fyne.Do(func() {
+		t.tabs.Select(t.fileQueueTab)
+	})
+}
+
+func (t RightTabs) SelectAddedFilesTab() {
+	fyne.Do(func() {
+		t.tabs.Select(t.addedFilesTab)
+	})
+}

kernel/translations/app.en.json

@@ -0,0 +1,143 @@
+{
+  "AlsoUsedProgram": "The program also uses:",
+  "about": "About",
+  "aboutText": "A simple interface for the FFmpeg console utility. \nBut I am not the author of the FFmpeg utility itself.",
+  "addedFilesTitle": "Added files",
+  "autoClearAfterAddingToQueue": "Auto-clear after adding to queue",
+  "buttonDownloadFFmpeg": "Download FFmpeg automatically",
+  "buttonForSelectedDirTitle": "Save to folder:",
+  "cancel": "Cancel",
+  "changeFFPath": "FFmpeg, FFprobe and FFplay",
+  "changeLanguage": "Change language",
+  "checkboxOverwriteOutputFilesTitle": "Allow file to be overwritten",
+  "choose": "choose",
+  "clearAll": "Clear List",
+  "completedQueue": "Completed",
+  "converterVideoFilesSubmitTitle": "Convert",
+  "converterVideoFilesTitle": "Video, audio and picture converter",
+  "download": "Download",
+  "downloadFFmpegFromSite": "Will be downloaded from the site:",
+  "downloadRun": "Downloading...",
+  "dragAndDropFiles": "drag and drop files",
+  "encoderGroupAudio": "Audio",
+  "encoderGroupImage": "Images",
+  "encoderGroupVideo": "Video",
+  "encoder_apng": "APNG image",
+  "encoder_bmp": "BMP image",
+  "encoder_flv": "FLV",
+  "encoder_gif": "GIF image",
+  "encoder_h264_nvenc": "H.264 with NVIDIA support",
+  "encoder_libmp3lame": "libmp3lame MP3 (MPEG audio layer 3)",
+  "encoder_libshine": "libshine MP3 (MPEG audio layer 3)",
+  "encoder_libtwolame": "libtwolame MP2 (MPEG audio layer 2)",
+  "encoder_libvpx": "libvpx VP8 (codec vp8)",
+  "encoder_libvpx-vp9": "libvpx VP9 (codec vp9)",
+  "encoder_libwebp": "libwebp WebP image",
+  "encoder_libwebp_anim": "libwebp_anim WebP image",
+  "encoder_libx264": "H.264 libx264",
+  "encoder_libx265": "H.265 libx265",
+  "encoder_libxvid": "libxvidcore MPEG-4 part 2",
+  "encoder_mjpeg": "MJPEG (Motion JPEG)",
+  "encoder_mp2": "MP2 (MPEG audio layer 2)",
+  "encoder_mp2fixed": "MP2 fixed point (MPEG audio layer 2)",
+  "encoder_mpeg1video": "MPEG-1",
+  "encoder_mpeg2video": "MPEG-2",
+  "encoder_mpeg4": "MPEG-4 part 2",
+  "encoder_msmpeg4": "MPEG-4 part 2 Microsoft variant version 3",
+  "encoder_msmpeg4v2": "MPEG-4 part 2 Microsoft variant version 2",
+  "encoder_msvideo1": "Microsoft Video-1",
+  "encoder_png": "PNG image",
+  "encoder_qtrle": "QuickTime Animation (RLE) video",
+  "encoder_sgi": "SGI image",
+  "encoder_tiff": "TIFF image",
+  "encoder_wmav1": "Windows Media Audio 1",
+  "encoder_wmav2": "Windows Media Audio 2",
+  "encoder_wmv1": "Windows Media Video 7",
+  "encoder_wmv2": "Windows Media Video 8",
+  "encoder_xbm": "XBM (X BitMap) image",
+  "error": "An error has occurred!",
+  "errorConverter": "Couldn't convert video",
+  "errorDragAndDropFile": "Not all files were added",
+  "errorFFmpeg": "this is not FFmpeg",
+  "errorFFmpegVersion": "Could not determine FFmpeg version",
+  "errorFFplay": "this is not FFplay",
+  "errorFFplayVersion": "Could not determine FFplay version",
+  "errorFFprobe": "this is not FFprobe",
+  "errorFFprobeVersion": "Failed to determine FFprobe version",
+  "errorNoFilesAddedForConversion": "There are no files to convert",
+  "errorQueue": "Error",
+  "errorSelectedEncoder": "Converter not selected",
+  "errorSelectedFolderSave": "No save folder selected!",
+  "errorSelectedFormat": "File extension not selected",
+  "exit": "Exit",
+  "ffmpegLGPL": "This software uses libraries from the **FFmpeg** project under the **[LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html)**.",
+  "ffmpegTrademark": "**FFmpeg** is a trademark of **[Fabrice Bellard](http://bellard.org/)**, originator of the **[FFmpeg](https://ffmpeg.org/about.html)** project.",
+  "fileForConversionTitle": "File:",
+  "fileQueueTitle": "Queue",
+  "formPreset": "Preset",
+  "gratitude": "Gratitude",
+  "gratitudeText": "I sincerely thank you for your invaluable\n\r and timely assistance:",
+  "help": "Help",
+  "helpFFplay": "FFplay Player Keys",
+  "helpFFplayActivateFrameStepMode": "Activate frame-by-frame mode.",
+  "helpFFplayCycleVideoFiltersOrShowModes": "A cycle of video filters or display modes.",
+  "helpFFplayDecreaseVolume": "Decrease the volume.",
+  "helpFFplayDescription": "Description",
+  "helpFFplayDoubleClickLeftMouseButton": "double click\nleft mouse button",
+  "helpFFplayIncreaseVolume": "Increase the volume.",
+  "helpFFplayKeyDown": "down",
+  "helpFFplayKeyHoldS": "hold S",
+  "helpFFplayKeyLeft": "left",
+  "helpFFplayKeyRight": "right",
+  "helpFFplayKeySpace": "SPACE",
+  "helpFFplayKeyUp": "up",
+  "helpFFplayKeys": "Keys",
+  "helpFFplayPause": "Pause or continue playing.",
+  "helpFFplayQuit": "Close the player.",
+  "helpFFplaySeekBForward10Minutes": "Fast forward 10 minutes.",
+  "helpFFplaySeekBForward1Minute": "Fast forward 1 minute.",
+  "helpFFplaySeekBackward10Minutes": "Rewind 10 minutes.",
+  "helpFFplaySeekBackward10Seconds": "Rewind 10 seconds.",
+  "helpFFplaySeekBackward1Minute": "Rewind 1 minute.",
+  "helpFFplaySeekForward10Seconds": "Fast forward 10 seconds.",
+  "helpFFplayToggleFullScreen": "Switch to full screen or exit full screen.",
+  "helpFFplayToggleMute": "Mute or unmute.",
+  "inProgressQueue": "In Progress",
+  "languageSelectionFormHead": "Switch language",
+  "languageSelectionHead": "Choose language",
+  "licenseLink": "License information",
+  "licenseLinkOther": "Licenses from other products used in the program",
+  "menuSettingsLanguage": "Language",
+  "menuSettingsTheme": "Theme",
+  "or": "or",
+  "parameterCheckbox": "Enable option",
+  "pathToFfmpeg": "Path to FFmpeg:",
+  "pathToFfplay": "Path to FFplay:",
+  "pathToFfprobe": "Path to FFprobe:",
+  "preset_fast": "fast (slower than \"faster\", but the file will weigh less)",
+  "preset_faster": "faster (slower than \"veryfast\", but the file will weigh less)",
+  "preset_medium": "medium (slower than \"fast\", but the file will weigh less)",
+  "preset_placebo": "placebo (not recommended)",
+  "preset_slow": "slow (slower than \"medium\", but the file will weigh less)",
+  "preset_slower": "slower (slower than \"slow\", but the file will weigh less)",
+  "preset_superfast": "superfast (slower than \"ultrafast\", but the file will weigh less)",
+  "preset_ultrafast": "ultrafast (fast, but the file will weigh a lot)",
+  "preset_veryfast": "veryfast (slower than \"superfast\", but the file will weigh less)",
+  "preset_veryslow": "veryslow (slower than \"slower\", but the file will weigh less)",
+  "programmLink": "Project website",
+  "programmVersion": "**Program version:** {{.Version}}",
+  "queue": "Queue",
+  "save": "Save",
+  "selectEncoder": "Encoder:",
+  "selectFFPathTitle": "Specify the path to FFmpeg and FFprobe",
+  "selectFormat": "File extension:",
+  "settings": "Settings",
+  "testFF": "Checking FFmpeg for serviceability...",
+  "themesNameDark": "Dark",
+  "themesNameDefault": "Default",
+  "themesNameLight": "Light",
+  "titleDownloadLink": "You can download it from here",
+  "total": "Total",
+  "unzipRun": "Unpacked...",
+  "waitingQueue": "Waiting"
+}

kernel/translations/app.kk.json

@@ -0,0 +1,143 @@
+{
+  "AlsoUsedProgram": "Бағдарлама сонымен қатар пайдаланады:",
+  "about": "Бағдарлама туралы",
+  "aboutText": "FFmpeg консоль утилитасы үшін қарапайым интерфейс. \nБірақ мен FFmpeg утилитасының авторы емеспін.",
+  "addedFilesTitle": "Қосылған файлдар",
+  "autoClearAfterAddingToQueue": "Кезекке қосқаннан кейін тазалаңыз",
+  "buttonDownloadFFmpeg": "FFmpeg автоматты түрде жүктеп алыңыз",
+  "buttonForSelectedDirTitle": "Қалтаға сақтаңыз:",
+  "cancel": "Болдырмау",
+  "changeFFPath": "FFmpeg, FFprobe және FFplay",
+  "changeLanguage": "Тілді өзгерту",
+  "checkboxOverwriteOutputFilesTitle": "Файлды қайта жазуға рұқсат беріңіз",
+  "choose": "таңдау",
+  "clearAll": "Тізімді өшіру",
+  "completedQueue": "Дайын",
+  "converterVideoFilesSubmitTitle": "Файлды түрлендіру",
+  "converterVideoFilesTitle": "Бейне, аудио және суретті түрлендіргіш",
+  "download": "Жүктеп алу",
+  "downloadFFmpegFromSite": "Сайттан жүктеледі:",
+  "downloadRun": "Жүктеп алынуда...",
+  "dragAndDropFiles": "файлдарды сүйреп апарыңыз",
+  "encoderGroupAudio": "Аудио",
+  "encoderGroupImage": "Суреттер",
+  "encoderGroupVideo": "Бейне",
+  "encoder_apng": "APNG image",
+  "encoder_bmp": "BMP image",
+  "encoder_flv": "FLV",
+  "encoder_gif": "GIF image",
+  "encoder_h264_nvenc": "NVIDIA қолдауымен H.264",
+  "encoder_libmp3lame": "libmp3lame MP3 (MPEG audio layer 3)",
+  "encoder_libshine": "libshine MP3 (MPEG audio layer 3)",
+  "encoder_libtwolame": "libtwolame MP2 (MPEG audio layer 2)",
+  "encoder_libvpx": "libvpx VP8 (codec vp8)",
+  "encoder_libvpx-vp9": "libvpx VP9 (codec vp9)",
+  "encoder_libwebp": "libwebp WebP image",
+  "encoder_libwebp_anim": "libwebp_anim WebP image",
+  "encoder_libx264": "H.264 libx264",
+  "encoder_libx265": "H.265 libx265",
+  "encoder_libxvid": "libxvidcore MPEG-4 part 2",
+  "encoder_mjpeg": "MJPEG (Motion JPEG)",
+  "encoder_mp2": "MP2 (MPEG audio layer 2)",
+  "encoder_mp2fixed": "MP2 fixed point (MPEG audio layer 2)",
+  "encoder_mpeg1video": "MPEG-1",
+  "encoder_mpeg2video": "MPEG-2",
+  "encoder_mpeg4": "MPEG-4 part 2",
+  "encoder_msmpeg4": "MPEG-4 part 2 Microsoft variant version 3",
+  "encoder_msmpeg4v2": "MPEG-4 part 2 Microsoft variant version 2",
+  "encoder_msvideo1": "Microsoft Video-1",
+  "encoder_png": "PNG image",
+  "encoder_qtrle": "QuickTime Animation (RLE) video",
+  "encoder_sgi": "SGI image",
+  "encoder_tiff": "TIFF image",
+  "encoder_wmav1": "Windows Media Audio 1",
+  "encoder_wmav2": "Windows Media Audio 2",
+  "encoder_wmv1": "Windows Media Video 7",
+  "encoder_wmv2": "Windows Media Video 8",
+  "encoder_xbm": "XBM (X BitMap) image",
+  "error": "Қате орын алды!",
+  "errorConverter": "Бейнені түрлендіру мүмкін болмады",
+  "errorDragAndDropFile": "Барлық файлдар қосылмаған",
+  "errorFFmpeg": "бұл FFmpeg емес",
+  "errorFFmpegVersion": "FFmpeg нұсқасын анықтау мүмкін болмады",
+  "errorFFplay": "бұл FFplay емес",
+  "errorFFplayVersion": "FFplay нұсқасын анықтау мүмкін болмады",
+  "errorFFprobe": "бұл FFprobe емес",
+  "errorFFprobeVersion": "FFprobe нұсқасын анықтау мүмкін болмады",
+  "errorNoFilesAddedForConversion": "Түрлендіруге арналған файлдар жоқ",
+  "errorQueue": "Қате",
+  "errorSelectedEncoder": "Түрлендіргіш таңдалмаған",
+  "errorSelectedFolderSave": "Сақтау қалтасы таңдалмаған!",
+  "errorSelectedFormat": "Файл кеңейтімі таңдалмаған",
+  "exit": "Шығу",
+  "ffmpegLGPL": "Бұл бағдарламалық құрал **[LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html)** астында **FFmpeg** жобасының кітапханаларын пайдаланады.",
+  "ffmpegTrademark": "FFmpeg — **[FFmpeg](https://ffmpeg.org/about.html)** жобасын жасаушы **[Fabrice Bellard](http://bellard.org/)** сауда белгісі.",
+  "fileForConversionTitle": "Файл:",
+  "fileQueueTitle": "Кезек",
+  "formPreset": "Алдын ала орнатылған",
+  "gratitude": "Алғыс",
+  "gratitudeText": "Сізге баға жетпес және уақтылы көмектескеніңіз\n\r үшін шын жүректен алғыс айтамын:",
+  "help": "Анықтама",
+  "helpFFplay": "FFplay ойнатқышының пернелері",
+  "helpFFplayActivateFrameStepMode": "Уақыт аралығын іске қосыңыз.",
+  "helpFFplayCycleVideoFiltersOrShowModes": "Бейне сүзгілерінің немесе дисплей режимдерінің циклі.",
+  "helpFFplayDecreaseVolume": "Дыбыс деңгейін төмендетіңіз.",
+  "helpFFplayDescription": "Сипаттама",
+  "helpFFplayDoubleClickLeftMouseButton": "тінтуірдің сол жақ\nбатырмасын екі рет басу",
+  "helpFFplayIncreaseVolume": "Дыбыс деңгейін арттыру.",
+  "helpFFplayKeyDown": "төмен",
+  "helpFFplayKeyHoldS": "ұстау S",
+  "helpFFplayKeyLeft": "сол",
+  "helpFFplayKeyRight": "құқық",
+  "helpFFplayKeySpace": "SPACE (пробел)",
+  "helpFFplayKeyUp": "жоғары",
+  "helpFFplayKeys": "Кілттер",
+  "helpFFplayPause": "Кідіртіңіз немесе жоғалтуды жалғастырыңыз.",
+  "helpFFplayQuit": "Ойнатқышты жабыңыз.",
+  "helpFFplaySeekBForward10Minutes": "10 минутқа алға айналдырыңыз.",
+  "helpFFplaySeekBForward1Minute": "1 минутқа алға айналдырыңыз.",
+  "helpFFplaySeekBackward10Minutes": "10 минутқа артқа айналдырыңыз.",
+  "helpFFplaySeekBackward10Seconds": "10 секундқа артқа айналдырыңыз.",
+  "helpFFplaySeekBackward1Minute": "1 минутқа артқа айналдырыңыз.",
+  "helpFFplaySeekForward10Seconds": "10 секунд алға айналдырыңыз.",
+  "helpFFplayToggleFullScreen": "Толық экранға ауысу немесе толық экраннан шығу.",
+  "helpFFplayToggleMute": "Дыбысты өшіріңіз немесе дыбысты қосыңыз.",
+  "inProgressQueue": "Орындалуда",
+  "languageSelectionFormHead": "Тілді ауыстыру",
+  "languageSelectionHead": "Тілді таңдаңыз",
+  "licenseLink": "Лицензия туралы ақпарат",
+  "licenseLinkOther": "Бағдарламада пайдаланылатын басқа өнімдердің лицензиялары",
+  "menuSettingsLanguage": "Тіл",
+  "menuSettingsTheme": "Тақырып",
+  "or": "немесе",
+  "parameterCheckbox": "Опцияны қосу",
+  "pathToFfmpeg": "FFmpeg жол:",
+  "pathToFfplay": "FFplay жол:",
+  "pathToFfprobe": "FFprobe жол:",
+  "preset_fast": "fast («faster» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_faster": "faster («veryfast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_medium": "medium («fast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_placebo": "placebo (ұсынылмайды)",
+  "preset_slow": "slow («medium» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_slower": "slower («slow» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_superfast": "superfast («ultrafast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_ultrafast": "ultrafast (жылдам, бірақ файлдың салмағы көп болады)",
+  "preset_veryfast": "veryfast («superfast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "preset_veryslow": "veryslow («slower» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)",
+  "programmLink": "Жобаның веб-сайты",
+  "programmVersion": "**Бағдарлама нұсқасы:** {{.Version}}",
+  "queue": "Кезек",
+  "save": "Сақтау",
+  "selectEncoder": "Кодировщик:",
+  "selectFFPathTitle": "FFmpeg және FFprobe жолын көрсетіңіз",
+  "selectFormat": "Файл кеңейтімі:",
+  "settings": "Параметрлер",
+  "testFF": "FFmpeg функционалдығы тексерілуде...",
+  "themesNameDark": "Қараңғы тақырып",
+  "themesNameDefault": "Әдепкі бойынша",
+  "themesNameLight": "Жеңіл тақырып",
+  "titleDownloadLink": "Сіз оны осы жерден жүктей аласыз",
+  "total": "Барлығы",
+  "unzipRun": "Орамнан шығарылуда...",
+  "waitingQueue": "Күту"
+}

kernel/translations/app.ru.json

@@ -0,0 +1,143 @@
+{
+  "AlsoUsedProgram": "Также в программе используется:",
+  "about": "О программе",
+  "aboutText": "Простенький интерфейс для консольной утилиты FFmpeg. \nНо я не являюсь автором самой утилиты FFmpeg.",
+  "addedFilesTitle": "Добавленные файлы",
+  "autoClearAfterAddingToQueue": "Очищать после добавления в очередь",
+  "buttonDownloadFFmpeg": "Скачать автоматически FFmpeg",
+  "buttonForSelectedDirTitle": "Сохранить в папку:",
+  "cancel": "Отмена",
+  "changeFFPath": "FFmpeg, FFprobe и FFplay",
+  "changeLanguage": "Поменять язык",
+  "checkboxOverwriteOutputFilesTitle": "Разрешить перезаписать файл",
+  "choose": "выбрать",
+  "clearAll": "Очистить список",
+  "completedQueue": "Готово",
+  "converterVideoFilesSubmitTitle": "Конвертировать",
+  "converterVideoFilesTitle": "Конвертер видео, аудио и картинок",
+  "download": "Скачать",
+  "downloadFFmpegFromSite": "Будет скачано с сайта:",
+  "downloadRun": "Скачивается...",
+  "dragAndDropFiles": "перетащить файлы",
+  "encoderGroupAudio": "Аудио",
+  "encoderGroupImage": "Картинки",
+  "encoderGroupVideo": "Видео",
+  "encoder_apng": "APNG image",
+  "encoder_bmp": "BMP image",
+  "encoder_flv": "FLV",
+  "encoder_gif": "GIF image",
+  "encoder_h264_nvenc": "H.264 с поддержкой NVIDIA",
+  "encoder_libmp3lame": "libmp3lame MP3 (MPEG audio layer 3)",
+  "encoder_libshine": "libshine MP3 (MPEG audio layer 3)",
+  "encoder_libtwolame": "libtwolame MP2 (MPEG audio layer 2)",
+  "encoder_libvpx": "libvpx VP8 (codec vp8)",
+  "encoder_libvpx-vp9": "libvpx VP9 (codec vp9)",
+  "encoder_libwebp": "libwebp WebP image",
+  "encoder_libwebp_anim": "libwebp_anim WebP image",
+  "encoder_libx264": "H.264 libx264",
+  "encoder_libx265": "H.265 libx265",
+  "encoder_libxvid": "libxvidcore MPEG-4 part 2",
+  "encoder_mjpeg": "MJPEG (Motion JPEG)",
+  "encoder_mp2": "MP2 (MPEG audio layer 2)",
+  "encoder_mp2fixed": "MP2 fixed point (MPEG audio layer 2)",
+  "encoder_mpeg1video": "MPEG-1",
+  "encoder_mpeg2video": "MPEG-2",
+  "encoder_mpeg4": "MPEG-4 part 2",
+  "encoder_msmpeg4": "MPEG-4 part 2 Microsoft variant version 3",
+  "encoder_msmpeg4v2": "MPEG-4 part 2 Microsoft variant version 2",
+  "encoder_msvideo1": "Microsoft Video-1",
+  "encoder_png": "PNG image",
+  "encoder_qtrle": "QuickTime Animation (RLE) video",
+  "encoder_sgi": "SGI image",
+  "encoder_tiff": "TIFF image",
+  "encoder_wmav1": "Windows Media Audio 1",
+  "encoder_wmav2": "Windows Media Audio 2",
+  "encoder_wmv1": "Windows Media Video 7",
+  "encoder_wmv2": "Windows Media Video 8",
+  "encoder_xbm": "XBM (X BitMap) image",
+  "error": "Произошла ошибка!",
+  "errorConverter": "не смогли отконвертировать видео",
+  "errorDragAndDropFile": "Не все файлы добавились",
+  "errorFFmpeg": "это не FFmpeg",
+  "errorFFmpegVersion": "Не смогли определить версию FFmpeg",
+  "errorFFplay": "это не FFplay",
+  "errorFFplayVersion": "Не смогли определить версию FFplay",
+  "errorFFprobe": "это не FFprobe",
+  "errorFFprobeVersion": "Не смогли определить версию FFprobe",
+  "errorNoFilesAddedForConversion": "Нет файлов для конвертации",
+  "errorQueue": "Ошибка",
+  "errorSelectedEncoder": "Конвертер не выбран",
+  "errorSelectedFolderSave": "Папка для сохранения не выбрана!",
+  "errorSelectedFormat": "Расширение файла не выбрана",
+  "exit": "Выход",
+  "ffmpegLGPL": "Это программное обеспечение использует библиотеки из проекта **FFmpeg** под **[LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html)**.",
+  "ffmpegTrademark": "**FFmpeg** — торговая марка **[Fabrice Bellard](http://bellard.org/)** , создателя проекта **[FFmpeg](https://ffmpeg.org/about.html)**.",
+  "fileForConversionTitle": "Файл:",
+  "fileQueueTitle": "Очередь",
+  "formPreset": "Предустановка",
+  "gratitude": "Благодарность",
+  "gratitudeText": "Я искренне благодарю вас за неоценимую\n\rи своевременную помощь:",
+  "help": "Справка",
+  "helpFFplay": "Клавиши проигрывателя FFplay",
+  "helpFFplayActivateFrameStepMode": "Активировать покадровый режим.",
+  "helpFFplayCycleVideoFiltersOrShowModes": "Цикл видеофильтров или режимов показа.",
+  "helpFFplayDecreaseVolume": "Уменьшить громкость.",
+  "helpFFplayDescription": "Описание",
+  "helpFFplayDoubleClickLeftMouseButton": "двойной щелчок\nлевой кнопкой мыши",
+  "helpFFplayIncreaseVolume": "Увеличить громкость.",
+  "helpFFplayKeyDown": "вниз",
+  "helpFFplayKeyHoldS": "держать S",
+  "helpFFplayKeyLeft": "лево",
+  "helpFFplayKeyRight": "право",
+  "helpFFplayKeySpace": "SPACE (пробел)",
+  "helpFFplayKeyUp": "вверх",
+  "helpFFplayKeys": "Клавиши",
+  "helpFFplayPause": "Поставить на паузу или продолжить проигрывать.",
+  "helpFFplayQuit": "Закрыть проигрыватель.",
+  "helpFFplaySeekBForward10Minutes": "Перемотать вперёд на 10 минут.",
+  "helpFFplaySeekBForward1Minute": "Перемотать вперёд на 1 минуту.",
+  "helpFFplaySeekBackward10Minutes": "Перемотать назад на 10 минут.",
+  "helpFFplaySeekBackward10Seconds": "Перемотать назад на 10 секунд.",
+  "helpFFplaySeekBackward1Minute": "Перемотать назад на 1 минуту.",
+  "helpFFplaySeekForward10Seconds": "Перемотать вперёд на 10 секунд.",
+  "helpFFplayToggleFullScreen": "Переключиться на полный экран или выйти с полного экрана.",
+  "helpFFplayToggleMute": "Отключить звук или включить звук.",
+  "inProgressQueue": "Выполняется",
+  "languageSelectionFormHead": "Переключить язык",
+  "languageSelectionHead": "Выберите язык",
+  "licenseLink": "Сведения о лицензии",
+  "licenseLinkOther": "Лицензии от других продуктов, которые используются в программе",
+  "menuSettingsLanguage": "Язык",
+  "menuSettingsTheme": "Тема",
+  "or": "или",
+  "parameterCheckbox": "Включить параметр",
+  "pathToFfmpeg": "Путь к FFmpeg:",
+  "pathToFfplay": "Путь к FFplay:",
+  "pathToFfprobe": "Путь к FFprobe:",
+  "preset_fast": "fast (медленней чем faster, но будет файл и меньше весить)",
+  "preset_faster": "faster (медленней чем veryfast, но будет файл и меньше весить)",
+  "preset_medium": "medium (медленней чем fast, но будет файл и меньше весить)",
+  "preset_placebo": "placebo (не рекомендуется)",
+  "preset_slow": "slow (медленней чем medium, но будет файл и меньше весить)",
+  "preset_slower": "slower (медленней чем slow, но будет файл и меньше весить)",
+  "preset_superfast": "superfast (медленней чем ultrafast, но будет файл и меньше весить)",
+  "preset_ultrafast": "ultrafast (быстро, но файл будет много весить)",
+  "preset_veryfast": "veryfast (медленней чем superfast, но будет файл и меньше весить)",
+  "preset_veryslow": "veryslow (медленней чем slower, но будет файл и меньше весить)",
+  "programmLink": "Сайт проекта",
+  "programmVersion": "**Версия программы:** {{.Version}}",
+  "queue": "Очередь",
+  "save": "Сохранить",
+  "selectEncoder": "Кодировщик:",
+  "selectFFPathTitle": "Укажите путь к FFmpeg и к FFprobe",
+  "selectFormat": "Расширение файла:",
+  "settings": "Настройки",
+  "testFF": "Проверка FFmpeg на работоспособность...",
+  "themesNameDark": "Тёмная",
+  "themesNameDefault": "По умолчанию",
+  "themesNameLight": "Светлая",
+  "titleDownloadLink": "Скачать можно от сюда",
+  "total": "Всего",
+  "unzipRun": "Распаковывается...",
+  "waitingQueue": "В очереди"
+}

kernel/translations/base.en.json

@@ -0,0 +1,45 @@
+{
+  "Advanced": "Advanced",
+  "Cancel": "Cancel",
+  "Confirm": "Confirm",
+  "Copy": "Copy",
+  "Create Folder": "Create Folder",
+  "Cut": "Cut",
+  "Enter filename": "Enter filename",
+  "Error": "Error",
+  "Favourites": "Favourites",
+  "File": "File",
+  "Folder": "Folder",
+  "New Folder": "New Folder",
+  "No": "No",
+  "OK": "OK",
+  "Open": "Open",
+  "Paste": "Paste",
+  "Quit": "Quit",
+  "Redo": "Redo",
+  "Save": "Save",
+  "Select all": "Select all",
+  "Show Hidden Files": "Show Hidden Files",
+  "Undo": "Undo",
+  "Yes": "Yes",
+  "file.name": {
+    "other": "Name"
+  },
+  "file.parent": {
+    "other": "Parent"
+  },
+  "friday": "Friday",
+  "friday.short": "Fri",
+  "monday": "Monday",
+  "monday.short": "Mon",
+  "saturday": "Saturday",
+  "saturday.short": "Sat",
+  "sunday": "Sunday",
+  "sunday.short": "Sun",
+  "thursday": "Thursday",
+  "thursday.short": "Thu",
+  "tuesday": "Tuesday",
+  "tuesday.short": "Tue",
+  "wednesday": "Wednesday",
+  "wednesday.short": "Wed"
+}

kernel/translations/base.kk.json

@@ -0,0 +1,45 @@
+{
+  "Advanced": "Кеңейтілген",
+  "Cancel": "Бас тарту",
+  "Confirm": "Растау",
+  "Copy": "Көшіру",
+  "Create Folder": "Қалта жасау",
+  "Cut": "Кесу",
+  "Enter filename": "Файл атауын енгізіңіз",
+  "Error": "Қате",
+  "Favourites": "Таңдаулылар",
+  "File": "Файл",
+  "Folder": "Қалта",
+  "New Folder": "Жаңа қалта",
+  "No": "Жоқ",
+  "OK": "ОК",
+  "Open": "Ашу",
+  "Paste": "Кірістіру",
+  "Quit": "Шығу",
+  "Redo": "Қайталау",
+  "Save": "Сақтау",
+  "Select all": "Барлығын таңдаңыз",
+  "Show Hidden Files": "Жасырын файлдарды көрсету",
+  "Undo": "Бас тарту",
+  "Yes": "Иә",
+  "file.name": {
+    "other": "Аты"
+  },
+  "file.parent": {
+    "other": "Жоғары"
+  },
+  "friday": "Жұма",
+  "friday.short": "Жұ",
+  "monday": "Дүйсенбі",
+  "monday.short": "Дү",
+  "saturday": "Сенбі",
+  "saturday.short": "Сен",
+  "sunday": "Жексенбі",
+  "sunday.short": "Же",
+  "thursday": "Сейсенбі",
+  "thursday.short": "Се",
+  "tuesday": "Бейсенбі",
+  "tuesday.short": "Бе",
+  "wednesday": "Сәрсенбі",
+  "wednesday.short": "Сә"
+}

kernel/translations/base.ru.json

@@ -0,0 +1,45 @@
+{
+  "Advanced": "Расширенные",
+  "Cancel": "Отмена",
+  "Confirm": "Подтвердить",
+  "Copy": "Копировать",
+  "Create Folder": "Создать папку",
+  "Cut": "Вырезать",
+  "Enter filename": "Введите имя файла",
+  "Error": "Ошибка",
+  "Favourites": "Избранное",
+  "File": "Файл",
+  "Folder": "Папка",
+  "New Folder": "Новая папка",
+  "No": "Нет",
+  "OK": "ОК",
+  "Open": "Открыть",
+  "Paste": "Вставить",
+  "Quit": "Выйти",
+  "Redo": "Повторить",
+  "Save": "Сохранить",
+  "Select all": "Выбрать всё",
+  "Show Hidden Files": "Показать скрытые файлы",
+  "Undo": "Отменить",
+  "Yes": "Да",
+  "file.name": {
+    "other": "Имя"
+  },
+  "file.parent": {
+    "other": "Вверх"
+  },
+  "friday": "Пятница",
+  "friday.short": "Пт",
+  "monday": "Понедельник",
+  "monday.short": "Пн",
+  "saturday": "Суббота",
+  "saturday.short": "Сб",
+  "sunday": "Воскресенье",
+  "sunday.short": "Вс",
+  "thursday": "Вторник",
+  "thursday.short": "Вт",
+  "tuesday": "Четверг",
+  "tuesday.short": "Чт",
+  "wednesday": "Среда",
+  "wednesday.short": "Ср"
+}

kernel/window.go

@@ -0,0 +1,89 @@
+package kernel
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/dialog"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/helper"
+	"time"
+)
+
+type WindowContract interface {
+	SetContent(content fyne.CanvasObject)
+	SetMainMenu(menu *fyne.MainMenu)
+	NewFileOpen(callback func(fyne.URIReadCloser, error), location fyne.ListableURI) *dialog.FileDialog
+	NewFolderOpen(callback func(fyne.ListableURI, error), location fyne.ListableURI) *dialog.FileDialog
+	SetOnDropped(callback func(position fyne.Position, uris []fyne.URI))
+	ShowAndRun()
+	GetLayout() LayoutContract
+}
+
+type Window struct {
+	windowFyne fyne.Window
+	layout     LayoutContract
+}
+
+func newWindow(w fyne.Window, layout LayoutContract) Window {
+	windowSize := fyne.Size{Width: 1039, Height: 599}
+	w.Resize(windowSize)
+	w.CenterOnScreen()
+
+	fyne.Do(func() {
+		/**
+		 * Bug fixed.
+		 * When starting the program, sometimes the window was displayed incorrectly.
+		 */
+		windowSize.Width += 1
+		windowSize.Height += 1
+		time.Sleep(time.Millisecond * 500)
+		w.Resize(windowSize)
+	})
+
+	return Window{
+		windowFyne: w,
+		layout:     layout,
+	}
+}
+
+func (w Window) SetContent(content fyne.CanvasObject) {
+	fyne.Do(func() {
+		w.windowFyne.SetContent(w.layout.SetContent(content))
+	})
+}
+
+func (w Window) NewFileOpen(callback func(fyne.URIReadCloser, error), location fyne.ListableURI) *dialog.FileDialog {
+	fileDialog := dialog.NewFileOpen(callback, w.windowFyne)
+	helper.FileDialogResize(fileDialog, w.windowFyne)
+	fileDialog.Show()
+	if location != nil {
+		fileDialog.SetLocation(location)
+	}
+	return fileDialog
+}
+
+func (w Window) NewFolderOpen(callback func(fyne.ListableURI, error), location fyne.ListableURI) *dialog.FileDialog {
+	fileDialog := dialog.NewFolderOpen(callback, w.windowFyne)
+	helper.FileDialogResize(fileDialog, w.windowFyne)
+	fileDialog.Show()
+	if location != nil {
+		fileDialog.SetLocation(location)
+	}
+	return fileDialog
+}
+
+func (w Window) SetMainMenu(menu *fyne.MainMenu) {
+	w.windowFyne.SetMainMenu(menu)
+}
+
+func (w Window) ShowAndRun() {
+	w.windowFyne.ShowAndRun()
+}
+
+func (w Window) GetLayout() LayoutContract {
+	return w.layout
+}
+
+func (w Window) SetOnDropped(callback func(position fyne.Position, uris []fyne.URI)) {
+	fyne.Do(func() {
+		w.windowFyne.SetOnDropped(callback)
+	})
+}

localizer/view.go

@@ -3,27 +3,25 @@ package localizer
 import (
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/widget"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
 )
 
 type ViewContract interface {
-	LanguageSelection(funcSelected func(lang Lang))
+	LanguageSelection(funcSelected func(lang kernel.Lang))
 }
 
 type View struct {
-	w                fyne.Window
+	app kernel.AppContract
-	localizerService ServiceContract
 }
 
-func NewView(w fyne.Window, localizerService ServiceContract) *View {
+func NewView(app kernel.AppContract) *View {
 	return &View{
-		w:                w,
+		app: app,
-		localizerService: localizerService,
 	}
 }
 
-func (v View) LanguageSelection(funcSelected func(lang Lang)) {
+func (v View) LanguageSelection(funcSelected func(lang kernel.Lang)) {
-	languages := v.localizerService.GetLanguages()
+	languages := v.app.GetLocalizerService().GetLanguages()
 	listView := widget.NewList(
 		func() int {
 			return len(languages)
@@ -36,18 +34,15 @@ func (v View) LanguageSelection(funcSelected func(lang Lang)) {
 			block.SetText(languages[i].Title)
 		})
 	listView.OnSelected = func(id widget.ListItemID) {
-		_ = v.localizerService.SetCurrentLanguage(languages[id])
+		_ = v.app.GetLocalizerService().SetCurrentLanguage(languages[id], true)
 		funcSelected(languages[id])
 	}
 
-	messageHead := v.localizerService.GetMessage(&i18n.LocalizeConfig{
+	messageHead := v.app.GetLocalizerService().GetMessage("languageSelectionHead")
-		MessageID: "languageSelectionHead",
+	v.app.GetWindow().SetContent(widget.NewCard(messageHead, "", listView))
-	})
-
-	v.w.SetContent(widget.NewCard(messageHead, "", listView))
 }
 
-func LanguageSelectionForm(localizerService ServiceContract, funcSelected func(lang Lang)) fyne.CanvasObject {
+func LanguageSelectionForm(localizerService kernel.LocalizerContract, funcSelected func(lang kernel.Lang)) fyne.CanvasObject {
 	languages := localizerService.GetLanguages()
 	currentLanguage := localizerService.GetCurrentLanguage()
 	listView := widget.NewList(
@@ -60,17 +55,15 @@ func LanguageSelectionForm(localizerService ServiceContract, funcSelected func(l
 		func(i widget.ListItemID, o fyne.CanvasObject) {
 			block := o.(*widget.Label)
 			block.SetText(languages[i].Title)
-			if languages[i].Code == currentLanguage.Lang.Code {
+			if languages[i].Code == currentLanguage.Code {
 				block.TextStyle = fyne.TextStyle{Bold: true}
 			}
 		})
 	listView.OnSelected = func(id widget.ListItemID) {
-		_ = localizerService.SetCurrentLanguage(languages[id])
+		_ = localizerService.SetCurrentLanguage(languages[id], true)
 		funcSelected(languages[id])
 	}
 
-	messageHead := localizerService.GetMessage(&i18n.LocalizeConfig{
+	messageHead := localizerService.GetMessage("languageSelectionFormHead")
-		MessageID: "languageSelectionFormHead",
-	})
 	return widget.NewCard(messageHead, "", listView)
 }

main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	_ "embed"
+	"fyne.io/fyne/v2"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor"
+	error2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/error"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/handler"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/resources"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/localizer"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/menu"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/setting"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/theme"
+)
+
+var application kernel.AppContract
+var ffPathUtilities *kernel.FFPathUtilities
+
+func init() {
+	appMetadata := &fyne.AppMetadata{
+		ID:      "net.kor-elf.projects.gui-for-ffmpeg",
+		Name:    "GUI for FFmpeg",
+		Version: "0.9.0",
+		Icon:    resources.IconAppLogoResource(),
+	}
+
+	ffPathUtilities = &kernel.FFPathUtilities{FFmpeg: "", FFprobe: "", FFplay: ""}
+	convertorService := kernel.NewService(ffPathUtilities)
+	ffplayService := kernel.NewFFplay(ffPathUtilities)
+
+	queue := kernel.NewQueueList()
+	application = kernel.NewApp(
+		appMetadata,
+		queue,
+		ffplayService,
+		convertorService,
+	)
+}
+
+func main() {
+	errorView := error2.NewView(application)
+
+	settingRepository := setting.NewRepository(application.GetAppFyne())
+	settingDirectoryForSaving := setting.NewSettingDirectoryForSaving(settingRepository)
+
+	convertorRepository := convertor.NewRepository(settingRepository)
+	ffPathUtilities.FFmpeg = convertorRepository.GetPathFfmpeg()
+	ffPathUtilities.FFprobe = convertorRepository.GetPathFfprobe()
+	ffPathUtilities.FFplay = convertorRepository.GetPathFfplay()
+
+	application.RunConvertor()
+	defer application.AfterClosing()
+
+	localizerView := localizer.NewView(application)
+	convertorView := convertor.NewView(application)
+	itemsToConvertService := kernel.NewItemsToConvert(
+		application.GetWindow().GetLayout().GetRightTabs().GetAddedFilesContainer(),
+		application.GetFFplayService(),
+		application.GetLocalizerService(),
+	)
+	convertorHandler := handler.NewConvertorHandler(application, convertorView, errorView, convertorRepository, settingDirectoryForSaving, itemsToConvertService)
+
+	themeRepository := theme.NewRepository(settingRepository)
+	themeService := theme.NewTheme(application, themeRepository)
+
+	menuView := menu.NewView(application)
+	menuSettingView := menu.NewViewSetting(application, themeService)
+	mainMenu := handler.NewMenuHandler(application, convertorHandler, menuView, menuSettingView, localizerView, themeService)
+
+	mainHandler := handler.NewMainHandler(application, convertorHandler, mainMenu)
+	mainHandler.Start()
+
+	application.GetWindow().SetMainMenu(mainMenu.GetMainMenu())
+	application.GetWindow().ShowAndRun()
+}

menu/view.go

@@ -0,0 +1,774 @@
+package menu
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/resources"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"golang.org/x/image/colornames"
+	"net/url"
+)
+
+type ViewContract interface {
+	About(ffmpegVersion string, ffprobeVersion string, ffplayVersion string)
+	Gratitude()
+	HelpFFplay()
+}
+
+type View struct {
+	app kernel.AppContract
+}
+
+func NewView(app kernel.AppContract) *View {
+	return &View{
+		app: app,
+	}
+}
+
+func (v View) Gratitude() {
+	view := v.app.GetAppFyne().NewWindow(v.app.GetLocalizerService().GetMessage("gratitude"))
+	view.Resize(fyne.Size{Width: 500, Height: 400})
+	view.SetFixedSize(true)
+
+	image := canvas.NewImageFromResource(resources.IconAppLogoResource())
+	image.SetMinSize(fyne.Size{Width: 100, Height: 100})
+	image.FillMode = canvas.ImageFillContain
+
+	gratitude := canvas.NewText(v.app.GetLocalizerService().GetMessage("gratitude"), colornames.Darkgreen)
+	gratitude.TextStyle = fyne.TextStyle{Bold: true}
+	gratitude.TextSize = 20
+
+	view.SetContent(
+		container.NewScroll(container.NewVBox(
+			container.NewBorder(nil, nil, container.NewVBox(image), nil, container.NewVBox(
+				gratitude,
+				widget.NewLabel(v.app.GetLocalizerService().GetMessage("gratitudeText")),
+				widget.NewLabel("Екатерина"),
+				widget.NewLabel("Евгений"),
+			)),
+		)),
+	)
+
+	view.CenterOnScreen()
+	view.Show()
+}
+
+func (v View) About(ffmpegVersion string, ffprobeVersion string, ffplayVersion string) {
+	view := v.app.GetAppFyne().NewWindow(v.app.GetLocalizerService().GetMessage("about"))
+	view.Resize(fyne.Size{Width: 793, Height: 550})
+	view.SetFixedSize(true)
+
+	programmName := canvas.NewText(" GUI for FFmpeg", colornames.Darkgreen)
+	programmName.TextStyle = fyne.TextStyle{Bold: true}
+	programmName.TextSize = 20
+
+	programmLink := widget.NewHyperlink(
+		v.app.GetLocalizerService().GetMessage("programmLink"),
+		&url.URL{
+			Scheme: "https",
+			Host:   "gui-for-ffmpeg.projects.kor-elf.net",
+			Path:   "/",
+		},
+	)
+
+	licenseLink := widget.NewHyperlink(
+		v.app.GetLocalizerService().GetMessage("licenseLink"),
+		&url.URL{
+			Scheme: "https",
+			Host:   "git.kor-elf.net",
+			Path:   "kor-elf/gui-for-ffmpeg/src/branch/main/LICENSE",
+		},
+	)
+
+	licenseLinkOther := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage(
+		"licenseLinkOther"),
+		&url.URL{
+			Scheme: "https",
+			Host:   "git.kor-elf.net",
+			Path:   "kor-elf/gui-for-ffmpeg/src/branch/main/LICENSE-3RD-PARTY.txt",
+		},
+	)
+
+	programmVersion := widget.NewRichTextFromMarkdown(
+		v.app.GetLocalizerService().GetMessage(
+			"programmVersion",
+			map[string]any{"Version": v.app.GetAppFyne().Metadata().Version},
+		),
+	)
+
+	aboutText := widget.NewRichText(
+		&widget.TextSegment{
+			Text: v.app.GetLocalizerService().GetMessage("aboutText"),
+		},
+	)
+	image := canvas.NewImageFromResource(resources.IconAppLogoResource())
+	image.SetMinSize(fyne.Size{Width: 100, Height: 100})
+	image.FillMode = canvas.ImageFillContain
+
+	ffmpegTrademark := widget.NewRichTextFromMarkdown(v.app.GetLocalizerService().GetMessage("ffmpegTrademark"))
+	ffmpegLGPL := widget.NewRichTextFromMarkdown(v.app.GetLocalizerService().GetMessage("ffmpegLGPL"))
+
+	view.SetContent(
+		container.NewScroll(container.NewVBox(
+			container.NewBorder(nil, nil, container.NewVBox(image), nil, container.NewVBox(
+				programmName,
+				programmVersion,
+				aboutText,
+				ffmpegTrademark,
+				ffmpegLGPL,
+				v.getCopyright(),
+				container.NewHBox(programmLink, licenseLink),
+				container.NewHBox(licenseLinkOther),
+			)),
+			v.getAboutFfmpeg(ffmpegVersion),
+			v.getAboutFfprobe(ffprobeVersion),
+			v.getAboutFfplay(ffplayVersion),
+			widget.NewCard(v.app.GetLocalizerService().GetMessage("AlsoUsedProgram"), "", v.getOther()),
+		)),
+	)
+	view.CenterOnScreen()
+	view.Show()
+}
+
+func (v View) HelpFFplay() {
+	view := v.app.GetAppFyne().NewWindow(v.app.GetLocalizerService().GetMessage("helpFFplay"))
+	view.Resize(fyne.Size{Width: 800, Height: 550})
+	view.SetFixedSize(true)
+
+	data := [][]string{
+		[]string{
+			v.app.GetLocalizerService().GetMessage("helpFFplayKeys"),
+			v.app.GetLocalizerService().GetMessage("helpFFplayDescription"),
+		},
+		[]string{
+			"Q, ESC",
+			v.app.GetLocalizerService().GetMessage("helpFFplayQuit"),
+		},
+		[]string{
+			"F, " + v.app.GetLocalizerService().GetMessage("helpFFplayDoubleClickLeftMouseButton"),
+			v.app.GetLocalizerService().GetMessage("helpFFplayToggleFullScreen"),
+		},
+		[]string{
+			"P, " +
+				v.app.GetLocalizerService().GetMessage("helpFFplayKeySpace"),
+			v.app.GetLocalizerService().GetMessage("helpFFplayPause"),
+		},
+		[]string{
+			"M",
+			v.app.GetLocalizerService().GetMessage("helpFFplayToggleMute"),
+		},
+		[]string{
+			"9, /",
+			v.app.GetLocalizerService().GetMessage("helpFFplayDecreaseVolume"),
+		},
+		[]string{
+			"0, *",
+			v.app.GetLocalizerService().GetMessage("helpFFplayIncreaseVolume"),
+		},
+		[]string{
+			v.app.GetLocalizerService().GetMessage("helpFFplayKeyLeft"),
+			v.app.GetLocalizerService().GetMessage("helpFFplaySeekBackward10Seconds"),
+		},
+		[]string{
+			v.app.GetLocalizerService().GetMessage("helpFFplayKeyRight"),
+			v.app.GetLocalizerService().GetMessage("helpFFplaySeekForward10Seconds"),
+		},
+		[]string{
+			v.app.GetLocalizerService().GetMessage("helpFFplayKeyDown"),
+			v.app.GetLocalizerService().GetMessage("helpFFplaySeekBackward1Minute"),
+		},
+		[]string{
+			v.app.GetLocalizerService().GetMessage("helpFFplayKeyUp"),
+			v.app.GetLocalizerService().GetMessage("helpFFplaySeekBForward1Minute"),
+		},
+		[]string{
+			"Page Down",
+			v.app.GetLocalizerService().GetMessage("helpFFplaySeekBackward10Minutes"),
+		},
+		[]string{
+			"Page Up",
+			v.app.GetLocalizerService().GetMessage("helpFFplaySeekBForward10Minutes"),
+		},
+		[]string{
+			"S, " + v.app.GetLocalizerService().GetMessage("helpFFplayKeyHoldS"),
+			v.app.GetLocalizerService().GetMessage("helpFFplayActivateFrameStepMode"),
+		},
+		[]string{
+			"W",
+			v.app.GetLocalizerService().GetMessage("helpFFplayCycleVideoFiltersOrShowModes"),
+		},
+	}
+
+	list := widget.NewTable(
+		func() (int, int) {
+			return len(data), len(data[0])
+		},
+		func() fyne.CanvasObject {
+			return widget.NewLabel("")
+		},
+		func(i widget.TableCellID, o fyne.CanvasObject) {
+			if i.Row == 0 {
+				o.(*widget.Label).TextStyle.Bold = true
+				o.(*widget.Label).SizeName = theme.SizeNameSubHeadingText
+			}
+			if i.Col == 0 {
+				o.(*widget.Label).TextStyle.Bold = true
+			}
+			o.(*widget.Label).SetText(data[i.Row][i.Col])
+		})
+	list.SetRowHeight(0, 40)
+	list.SetColumnWidth(0, 200)
+	list.SetColumnWidth(1, 585)
+	list.SetRowHeight(2, 55)
+	view.SetContent(
+		container.NewScroll(list),
+	)
+	view.CenterOnScreen()
+	view.Show()
+}
+
+func (v View) getCopyright() *widget.RichText {
+	return widget.NewRichTextFromMarkdown("Copyright (c) 2024 **[Leonid Nikitin (kor-elf)](https://git.kor-elf.net/kor-elf/)**.")
+}
+
+func (v View) getAboutFfmpeg(version string) *fyne.Container {
+	programmName := canvas.NewText(" FFmpeg", colornames.Darkgreen)
+	programmName.TextStyle = fyne.TextStyle{Bold: true}
+	programmName.TextSize = 20
+
+	programmLink := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage("programmLink"), &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "",
+	})
+
+	licenseLink := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage("licenseLink"), &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "legal.html",
+	})
+
+	return container.NewVBox(
+		programmName,
+		widget.NewLabel(version),
+		widget.NewRichTextFromMarkdown("**FFmpeg** is a trademark of **[Fabrice Bellard](http://bellard.org/)**, originator of the **[FFmpeg](https://ffmpeg.org/about.html)** project."),
+		widget.NewRichTextFromMarkdown("This software uses libraries from the **FFmpeg** project under the **[LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html)**."),
+		container.NewHBox(programmLink, licenseLink),
+	)
+}
+
+func (v View) getAboutFfprobe(version string) *fyne.Container {
+	programmName := canvas.NewText(" FFprobe", colornames.Darkgreen)
+	programmName.TextStyle = fyne.TextStyle{Bold: true}
+	programmName.TextSize = 20
+
+	programmLink := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage("programmLink"), &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "ffprobe.html",
+	})
+
+	licenseLink := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage("licenseLink"), &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "legal.html",
+	})
+
+	return container.NewVBox(
+		programmName,
+		widget.NewLabel(version),
+		widget.NewRichTextFromMarkdown("**FFmpeg** is a trademark of **[Fabrice Bellard](http://bellard.org/)**, originator of the **[FFmpeg](https://ffmpeg.org/about.html)** project."),
+		widget.NewRichTextFromMarkdown("This software uses libraries from the **FFmpeg** project under the **[LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html)**."),
+		container.NewHBox(programmLink, licenseLink),
+	)
+}
+
+func (v View) getAboutFfplay(version string) *fyne.Container {
+	programmName := canvas.NewText(" FFplay", colornames.Darkgreen)
+	programmName.TextStyle = fyne.TextStyle{Bold: true}
+	programmName.TextSize = 20
+
+	programmLink := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage("programmLink"), &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "ffplay.html",
+	})
+
+	licenseLink := widget.NewHyperlink(v.app.GetLocalizerService().GetMessage("licenseLink"), &url.URL{
+		Scheme: "https",
+		Host:   "ffmpeg.org",
+		Path:   "legal.html",
+	})
+
+	return container.NewVBox(
+		programmName,
+		widget.NewLabel(version),
+		widget.NewRichTextFromMarkdown("**FFmpeg** is a trademark of **[Fabrice Bellard](http://bellard.org/)**, originator of the **[FFmpeg](https://ffmpeg.org/about.html)** project."),
+		widget.NewRichTextFromMarkdown("This software uses libraries from the **FFmpeg** project under the **[LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html)**."),
+		container.NewHBox(programmLink, licenseLink),
+	)
+}
+
+func (v View) getOther() *fyne.Container {
+	return container.NewVBox(
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("fyne.io/fyne/v2", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/fyne",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 3-Clause License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/fyne/blob/master/LICENSE",
+		})),
+		widget.NewRichTextFromMarkdown("Copyright (C) 2018 Fyne.io developers (see [AUTHORS](https://github.com/fyne-io/fyne/blob/master/AUTHORS))"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("fyne.io/systray", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/systray",
+		})),
+		container.NewHBox(widget.NewHyperlink("Apache License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/systray/blob/master/LICENSE",
+		})),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/BurntSushi/toml", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "BurntSushi/toml",
+		})),
+		container.NewHBox(widget.NewHyperlink("The MIT License (MIT)", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "BurntSushi/toml/blob/master/COPYING",
+		})),
+		widget.NewLabel("Copyright (c) 2013 TOML authors"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/davecgh/go-spew", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "davecgh/go-spew",
+		})),
+		container.NewHBox(widget.NewHyperlink("ISC License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "davecgh/go-spew/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2012-2016 Dave Collins <dave@davec.name>"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/fredbi/uri", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fredbi/uri",
+		})),
+		container.NewHBox(widget.NewHyperlink("The MIT License (MIT)", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fredbi/uri/blob/master/LICENSE.md",
+		})),
+		widget.NewLabel("Copyright (c) 2018 Frederic Bidon"),
+		widget.NewLabel("Copyright (c) 2015 Trey Tacon"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/fsnotify/fsnotify", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fsnotify/fsnotify",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD-3-Clause license", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fsnotify/fsnotify/blob/main/LICENSE",
+		})),
+		widget.NewLabel("Copyright © 2012 The Go Authors. All rights reserved."),
+		widget.NewLabel("Copyright © fsnotify Authors. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/fyne-io/gl-js", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/gl-js",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD-3-Clause license", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/gl-js/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2009 The Go Authors. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/fyne-io/glfw-js", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/glfw-js",
+		})),
+		container.NewHBox(widget.NewHyperlink("MIT License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/glfw-js/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2014 Dmitri Shuralyov"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/fyne-io/image", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/image",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 3-Clause License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/image/blob/main/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2022, Fyne.io"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/fyne-io/oksvg", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/oksvg",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 3-Clause License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "fyne-io/oksvg/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2018, Steven R Wiley. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/go-gl/gl", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-gl/gl",
+		})),
+		container.NewHBox(widget.NewHyperlink("The MIT License (MIT)", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-gl/gl/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2014 Eric Woroshow"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/go-gl/glfw/v3.3/glfw", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-gl/glfw/",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD-3-Clause license", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-gl/glfw/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2012 The glfw3-go Authors. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/go-text/render", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-text/render",
+		})),
+		container.NewHBox(widget.NewHyperlink("Unlicense OR BSD-3-Clause", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-text/render/blob/main/LICENSE",
+		})),
+		widget.NewLabel("Copyright 2021 The go-text authors"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/go-text/typesetting", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-text/typesetting",
+		})),
+		container.NewHBox(widget.NewHyperlink("Unlicense OR BSD-3-Clause", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-text/typesetting/blob/main/LICENSE",
+		})),
+		widget.NewLabel("Copyright 2021 The go-text authors"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/godbus/dbus/v5", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "godbus/dbus",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 2-Clause \"Simplified\" License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "godbus/dbus/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2013, Georg Reinke (<guelfey at gmail dot com>), Google. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/hack-pad/go-indexeddb", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "hack-pad/go-indexeddb",
+		})),
+		container.NewHBox(widget.NewHyperlink("Apache License 2.0", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "hack-pad/go-indexeddb/blob/main/LICENSE",
+		})),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/hack-pad/safejs", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "hack-pad/safejs",
+		})),
+		container.NewHBox(widget.NewHyperlink("Apache License 2.0", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "hack-pad/safejs/blob/main/LICENSE",
+		})),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/jeandeaual/go-locale", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "jeandeaual/go-locale",
+		})),
+		container.NewHBox(widget.NewHyperlink("MIT License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "jeandeaual/go-locale/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2020 Alexis Jeandeau"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/jsummers/gobmp", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "jsummers/gobmp",
+		})),
+		container.NewHBox(widget.NewHyperlink("The MIT License (MIT)", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "jsummers/gobmp/blob/master/COPYING.txt",
+		})),
+		widget.NewLabel("Copyright (c) 2012-2015 Jason Summers"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/nfnt/resize", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "nfnt/resize",
+		})),
+		container.NewHBox(widget.NewHyperlink("ISC License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "nfnt/resize/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2012, Jan Schlicht <jan.schlicht@gmail.com>"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/nicksnyder/go-i18n/v2", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "nicksnyder/go-i18n",
+		})),
+		container.NewHBox(widget.NewHyperlink("The MIT License (MIT)", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "nicksnyder/go-i18n/blob/main/LICENSE",
+		})),
+		widget.NewRichTextFromMarkdown("Copyright (c) 2014 Nick Snyder [https://github.com/nicksnyder](https://github.com/nicksnyder)"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/pmezard/go-difflib", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "pmezard/go-difflib",
+		})),
+		container.NewHBox(widget.NewHyperlink("License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "pmezard/go-difflib/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2013, Patrick Mezard. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/rymdport/portal", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "rymdport/portal",
+		})),
+		container.NewHBox(widget.NewHyperlink("Apache License 2.0", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "rymdport/portal/blob/main/LICENSE",
+		})),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/srwiley/oksvg", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "srwiley/oksvg",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 3-Clause License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "srwiley/oksvg/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2018, Steven R Wiley. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/srwiley/rasterx", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "srwiley/rasterx",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 3-Clause License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "srwiley/rasterx/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2018, Steven R Wiley. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/stretchr/testify", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "stretchr/testify",
+		})),
+		container.NewHBox(widget.NewHyperlink("MIT License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "stretchr/testify/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2012-2020 Mat Ryer, Tyler Bunnell and contributors."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/ulikunitz/xz", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "ulikunitz/xz",
+		})),
+		container.NewHBox(widget.NewHyperlink("License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "ulikunitz/xz/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2014-2022 Ulrich Kunitz. All rights reserved."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/yuin/goldmark", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "yuin/goldmark",
+		})),
+		container.NewHBox(widget.NewHyperlink("MIT License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "yuin/goldmark/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2019 Yusuke Inuzuka"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("go.etcd.io/bbolt", &url.URL{
+			Scheme: "https",
+			Host:   "pkg.go.dev",
+			Path:   "go.etcd.io/bbolt",
+		})),
+		container.NewHBox(widget.NewHyperlink("MIT License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "etcd-io/bbolt/blob/main/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2013 Ben Johnson"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("golang.org/x/image", &url.URL{
+			Scheme: "https",
+			Host:   "pkg.go.dev",
+			Path:   "golang.org/x/image",
+		})),
+		container.NewHBox(widget.NewHyperlink("License", &url.URL{
+			Scheme: "https",
+			Host:   "cs.opensource.google",
+			Path:   "go/x/image/+/master:LICENSE",
+		})),
+		widget.NewLabel("Copyright 2009 The Go Authors."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("golang.org/x/net", &url.URL{
+			Scheme: "https",
+			Host:   "pkg.go.dev",
+			Path:   "golang.org/x/net",
+		})),
+		container.NewHBox(widget.NewHyperlink("License", &url.URL{
+			Scheme: "https",
+			Host:   "cs.opensource.google",
+			Path:   "go/x/net/+/master:LICENSE",
+		})),
+		widget.NewLabel("Copyright 2009 The Go Authors."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("golang.org/x/sys", &url.URL{
+			Scheme: "https",
+			Host:   "pkg.go.dev",
+			Path:   "golang.org/x/sys",
+		})),
+		container.NewHBox(widget.NewHyperlink("License", &url.URL{
+			Scheme: "https",
+			Host:   "cs.opensource.google",
+			Path:   "go/x/sys/+/master:LICENSE",
+		})),
+		widget.NewLabel("Copyright 2009 The Go Authors."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("golang.org/x/text", &url.URL{
+			Scheme: "https",
+			Host:   "pkg.go.dev",
+			Path:   "golang.org/x/text",
+		})),
+		container.NewHBox(widget.NewHyperlink("License", &url.URL{
+			Scheme: "https",
+			Host:   "cs.opensource.google",
+			Path:   "go/x/text/+/master:LICENSE",
+		})),
+		widget.NewLabel("Copyright 2009 The Go Authors."),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("gopkg.in/yaml.v3", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "go-yaml/yaml/tree/v3.0.1",
+		})),
+		container.NewHBox(widget.NewHyperlink("MIT License and Apache License 2.0", &url.URL{
+			Scheme: "http",
+			Host:   "github.com",
+			Path:   "go-yaml/yaml/blob/v3.0.1/LICENSE",
+		})),
+		widget.NewLabel("Copyright (c) 2006-2010 Kirill Simonov"),
+		widget.NewLabel("Copyright (c) 2006-2011 Kirill Simonov"),
+		widget.NewLabel("Copyright (c) 2011-2019 Canonical Ltd"),
+		canvas.NewLine(colornames.Darkgreen),
+
+		container.NewHBox(widget.NewHyperlink("github.com/golang/go", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "golang/go",
+		})),
+		container.NewHBox(widget.NewHyperlink("BSD 3-Clause \"New\" or \"Revised\" License", &url.URL{
+			Scheme: "https",
+			Host:   "github.com",
+			Path:   "golang/go/blob/master/LICENSE",
+		})),
+		widget.NewLabel("Copyright 2009 The Go Authors."),
+		canvas.NewLine(colornames.Darkgreen),
+	)
+}

menu/view_setting.go

@@ -0,0 +1,101 @@
+package menu
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/widget"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
+	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/theme"
+	"image/color"
+)
+
+type ViewSettingContract interface {
+	Main(
+		save func(*SettingForm) error,
+		cancel func(),
+	)
+}
+
+type SettingForm struct {
+	Language  kernel.Lang
+	ThemeInfo theme.ThemeInfoContract
+}
+
+type ViewSetting struct {
+	app          kernel.AppContract
+	themeService theme.ThemeContract
+}
+
+func NewViewSetting(app kernel.AppContract, themeService theme.ThemeContract) *ViewSetting {
+	return &ViewSetting{
+		app:          app,
+		themeService: themeService,
+	}
+}
+
+func (v ViewSetting) Main(save func(*SettingForm) error, cancel func()) {
+	errorMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	errorMessage.TextSize = 16
+	errorMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	viewSettingForm := &SettingForm{
+		Language:  v.app.GetLocalizerService().GetCurrentLanguage(),
+		ThemeInfo: v.themeService.GetCurrentThemeInfo(),
+	}
+
+	languageItems := []string{}
+	langByTitle := map[string]kernel.Lang{}
+	for _, language := range v.app.GetLocalizerService().GetLanguages() {
+		languageItems = append(languageItems, language.Title)
+		langByTitle[language.Title] = language
+	}
+	selectLanguage := widget.NewSelect(languageItems, func(s string) {
+		if lang, ok := langByTitle[s]; ok {
+			viewSettingForm.Language = lang
+		}
+	})
+	selectLanguage.Selected = v.app.GetLocalizerService().GetCurrentLanguage().Title
+
+	themeItems := []string{}
+	themeByTitle := map[string]theme.ThemeInfoContract{}
+	for _, themeInfo := range v.themeService.List() {
+		themeItems = append(themeItems, themeInfo.GetTitle())
+		themeByTitle[themeInfo.GetTitle()] = themeInfo
+	}
+	selectTheme := widget.NewSelect(themeItems, func(s string) {
+		if themeInfo, ok := themeByTitle[s]; ok {
+			viewSettingForm.ThemeInfo = themeInfo
+		}
+	})
+	selectTheme.Selected = v.themeService.GetCurrentThemeInfo().GetTitle()
+
+	form := &widget.Form{
+		Items: []*widget.FormItem{
+			{
+				Text:   v.app.GetLocalizerService().GetMessage("menuSettingsLanguage"),
+				Widget: selectLanguage,
+			},
+			{
+				Text:   v.app.GetLocalizerService().GetMessage("menuSettingsTheme"),
+				Widget: selectTheme,
+			},
+			{
+				Widget: errorMessage,
+			},
+		},
+		SubmitText: v.app.GetLocalizerService().GetMessage("save"),
+		OnSubmit: func() {
+			err := save(viewSettingForm)
+			if err != nil {
+				errorMessage.Text = err.Error()
+			}
+		},
+	}
+	if cancel != nil {
+		form.OnCancel = cancel
+		form.CancelText = v.app.GetLocalizerService().GetMessage("cancel")
+	}
+
+	messageHead := v.app.GetLocalizerService().GetMessage("settings")
+	v.app.GetWindow().SetContent(widget.NewCard(messageHead, "", form))
+}

setting/directory_for_saving.go

@@ -0,0 +1,22 @@
+package setting
+
+type DirectoryForSavingContract interface {
+	GetDirectoryForSaving() string
+	SaveDirectoryForSaving(path string) Setting
+}
+
+type DirectoryForSaving struct {
+	settingRepository RepositoryContract
+}
+
+func NewSettingDirectoryForSaving(settingRepository RepositoryContract) *DirectoryForSaving {
+	return &DirectoryForSaving{settingRepository: settingRepository}
+}
+
+func (setting DirectoryForSaving) GetDirectoryForSaving() string {
+	return setting.settingRepository.GetValue("directoryForSaving")
+}
+
+func (setting DirectoryForSaving) SaveDirectoryForSaving(path string) Setting {
+	return setting.settingRepository.CreateOrUpdate("directoryForSaving", path)
+}

setting/entity.go

@@ -0,0 +1,6 @@
+package setting
+
+type Setting struct {
+	Code  string
+	Value string
+}

setting/repository.go

@@ -0,0 +1,39 @@
+package setting
+
+import (
+	"fyne.io/fyne/v2"
+)
+
+type RepositoryContract interface {
+	Create(setting Setting) Setting
+	CreateOrUpdate(code string, value string) Setting
+	GetValue(code string) string
+}
+
+type Repository struct {
+	app fyne.App
+}
+
+func NewRepository(app fyne.App) *Repository {
+	return &Repository{
+		app: app,
+	}
+}
+
+func (r Repository) GetValue(code string) string {
+	return r.app.Preferences().String(code)
+}
+
+func (r Repository) Create(setting Setting) Setting {
+	r.app.Preferences().SetString(setting.Code, setting.Value)
+	return setting
+}
+
+func (r Repository) CreateOrUpdate(code string, value string) Setting {
+	var setting Setting
+	setting.Code = code
+	setting.Value = value
+
+	r.app.Preferences().SetString(code, value)
+	return setting
+}

src/convertor/service.go

@@ -1,173 +0,0 @@
-package convertor
-
-import (
-	"errors"
-	"ffmpegGui/helper"
-	"io"
-	"os/exec"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-type ServiceContract interface {
-	RunConvert(setting ConvertSetting, progress ProgressContract) error
-	GetTotalDuration(file *File) (float64, error)
-	GetFFmpegVesrion() (string, error)
-	GetFFprobeVersion() (string, error)
-	ChangeFFmpegPath(path string) (bool, error)
-	ChangeFFprobePath(path string) (bool, error)
-	GetRunningProcesses() map[int]*exec.Cmd
-}
-
-type ProgressContract interface {
-	GetProtocole() string
-	Run(stdOut io.ReadCloser, stdErr io.ReadCloser) error
-}
-
-type FFPathUtilities struct {
-	FFmpeg  string
-	FFprobe string
-}
-
-type runningProcesses struct {
-	items          map[int]*exec.Cmd
-	numberOfStarts int
-}
-
-type Service struct {
-	ffPathUtilities  *FFPathUtilities
-	runningProcesses runningProcesses
-}
-
-type File struct {
-	Path string
-	Name string
-	Ext  string
-}
-
-type ConvertSetting struct {
-	VideoFileInput       *File
-	VideoFileOut         *File
-	OverwriteOutputFiles bool
-}
-
-type ConvertData struct {
-	totalDuration float64
-}
-
-func NewService(ffPathUtilities FFPathUtilities) *Service {
-	return &Service{
-		ffPathUtilities:  &ffPathUtilities,
-		runningProcesses: runningProcesses{items: map[int]*exec.Cmd{}, numberOfStarts: 0},
-	}
-}
-
-func (s Service) RunConvert(setting ConvertSetting, progress ProgressContract) error {
-	overwriteOutputFiles := "-n"
-	if setting.OverwriteOutputFiles == true {
-		overwriteOutputFiles = "-y"
-	}
-	args := []string{overwriteOutputFiles, "-i", setting.VideoFileInput.Path, "-c:v", "libx264", "-progress", progress.GetProtocole(), setting.VideoFileOut.Path}
-	cmd := exec.Command(s.ffPathUtilities.FFmpeg, args...)
-	helper.PrepareBackgroundCommand(cmd)
-
-	stdOut, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	stdErr, err := cmd.StderrPipe()
-	if err != nil {
-		return err
-	}
-
-	err = cmd.Start()
-	if err != nil {
-		return err
-	}
-	index := s.runningProcesses.numberOfStarts
-	s.runningProcesses.numberOfStarts++
-	s.runningProcesses.items[index] = cmd
-
-	errProgress := progress.Run(stdOut, stdErr)
-
-	err = cmd.Wait()
-	delete(s.runningProcesses.items, index)
-	if errProgress != nil {
-		return errProgress
-	}
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (s Service) GetTotalDuration(file *File) (duration float64, err error) {
-	args := []string{"-v", "error", "-select_streams", "v:0", "-count_packets", "-show_entries", "stream=nb_read_packets", "-of", "csv=p=0", file.Path}
-	cmd := exec.Command(s.ffPathUtilities.FFprobe, args...)
-	helper.PrepareBackgroundCommand(cmd)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		errString := strings.TrimSpace(string(out))
-		if len(errString) > 1 {
-			return 0, errors.New(errString)
-		}
-		return 0, err
-	}
-	return strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
-}
-
-func (s Service) GetFFmpegVesrion() (string, error) {
-	cmd := exec.Command(s.ffPathUtilities.FFmpeg, "-version")
-	helper.PrepareBackgroundCommand(cmd)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return "", err
-	}
-	text := regexp.MustCompile("\r?\n").Split(strings.TrimSpace(string(out)), -1)
-	return text[0], nil
-}
-
-func (s Service) GetFFprobeVersion() (string, error) {
-	cmd := exec.Command(s.ffPathUtilities.FFprobe, "-version")
-	helper.PrepareBackgroundCommand(cmd)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return "", err
-	}
-	text := regexp.MustCompile("\r?\n").Split(strings.TrimSpace(string(out)), -1)
-	return text[0], nil
-}
-
-func (s Service) ChangeFFmpegPath(path string) (bool, error) {
-	cmd := exec.Command(path, "-version")
-	helper.PrepareBackgroundCommand(cmd)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return false, err
-	}
-	if strings.Contains(strings.TrimSpace(string(out)), "ffmpeg") == false {
-		return false, nil
-	}
-	s.ffPathUtilities.FFmpeg = path
-	return true, nil
-}
-
-func (s Service) ChangeFFprobePath(path string) (bool, error) {
-	cmd := exec.Command(path, "-version")
-	helper.PrepareBackgroundCommand(cmd)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return false, err
-	}
-	if strings.Contains(strings.TrimSpace(string(out)), "ffprobe") == false {
-		return false, nil
-	}
-	s.ffPathUtilities.FFprobe = path
-	return true, nil
-}
-
-func (s Service) GetRunningProcesses() map[int]*exec.Cmd {
-	return s.runningProcesses.items
-}

src/convertor/view.go

@@ -1,229 +0,0 @@
-package convertor
-
-import (
-	"errors"
-	"ffmpegGui/helper"
-	"ffmpegGui/localizer"
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/canvas"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/dialog"
-	"fyne.io/fyne/v2/widget"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-	"image/color"
-)
-
-type ViewContract interface {
-	Main(
-		runConvert func(setting HandleConvertSetting, progressbar *widget.ProgressBar) error,
-	)
-}
-
-type View struct {
-	w                fyne.Window
-	localizerService localizer.ServiceContract
-}
-
-type HandleConvertSetting struct {
-	VideoFileInput       *File
-	DirectoryForSave     string
-	OverwriteOutputFiles bool
-}
-
-type enableFormConversionStruct struct {
-	fileVideoForConversion *widget.Button
-	buttonForSelectedDir   *widget.Button
-	form                   *widget.Form
-}
-
-func NewView(w fyne.Window, localizerService localizer.ServiceContract) *View {
-	return &View{
-		w:                w,
-		localizerService: localizerService,
-	}
-}
-
-func (v View) Main(
-	runConvert func(setting HandleConvertSetting, progressbar *widget.ProgressBar) error,
-) {
-	form := &widget.Form{}
-
-	conversionMessage := canvas.NewText("", color.RGBA{255, 0, 0, 255})
-	conversionMessage.TextSize = 16
-	conversionMessage.TextStyle = fyne.TextStyle{Bold: true}
-
-	progress := widget.NewProgressBar()
-
-	fileVideoForConversion, fileVideoForConversionMessage, fileInput := v.getButtonFileVideoForConversion(form, progress, conversionMessage)
-	buttonForSelectedDir, buttonForSelectedDirMessage, pathToSaveDirectory := v.getButtonForSelectingDirectoryForSaving()
-
-	isOverwriteOutputFiles := false
-	checkboxOverwriteOutputFilesTitle := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "checkboxOverwriteOutputFilesTitle",
-	})
-	checkboxOverwriteOutputFiles := widget.NewCheck(checkboxOverwriteOutputFilesTitle, func(b bool) {
-		isOverwriteOutputFiles = b
-	})
-
-	form.Items = []*widget.FormItem{
-		{
-			Text:   v.localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: "fileVideoForConversionTitle"}),
-			Widget: fileVideoForConversion,
-		},
-		{
-			Widget: fileVideoForConversionMessage,
-		},
-		{
-			Text:   v.localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: "buttonForSelectedDirTitle"}),
-			Widget: buttonForSelectedDir,
-		},
-		{
-			Widget: buttonForSelectedDirMessage,
-		},
-		{
-			Widget: checkboxOverwriteOutputFiles,
-		},
-	}
-	form.SubmitText = v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "converterVideoFilesSubmitTitle",
-	})
-
-	enableFormConversionStruct := enableFormConversionStruct{
-		fileVideoForConversion: fileVideoForConversion,
-		buttonForSelectedDir:   buttonForSelectedDir,
-		form:                   form,
-	}
-
-	form.OnSubmit = func() {
-		if len(*pathToSaveDirectory) == 0 {
-			showConversionMessage(conversionMessage, errors.New(v.localizerService.GetMessage(&i18n.LocalizeConfig{
-				MessageID: "errorSelectedFolderSave",
-			})))
-			enableFormConversion(enableFormConversionStruct)
-			return
-		}
-		conversionMessage.Text = ""
-
-		fileVideoForConversion.Disable()
-		buttonForSelectedDir.Disable()
-		form.Disable()
-
-		setting := HandleConvertSetting{
-			VideoFileInput:       fileInput,
-			DirectoryForSave:     *pathToSaveDirectory,
-			OverwriteOutputFiles: isOverwriteOutputFiles,
-		}
-		err := runConvert(setting, progress)
-		if err != nil {
-			showConversionMessage(conversionMessage, err)
-			enableFormConversion(enableFormConversionStruct)
-			return
-		}
-		enableFormConversion(enableFormConversionStruct)
-	}
-
-	converterVideoFilesTitle := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "converterVideoFilesTitle",
-	})
-	v.w.SetContent(widget.NewCard(converterVideoFilesTitle, "", container.NewVBox(form, conversionMessage, progress)))
-	form.Disable()
-}
-
-func (v View) getButtonFileVideoForConversion(form *widget.Form, progress *widget.ProgressBar, conversionMessage *canvas.Text) (*widget.Button, *canvas.Text, *File) {
-	fileInput := &File{}
-
-	fileVideoForConversionMessage := canvas.NewText("", color.RGBA{255, 0, 0, 255})
-	fileVideoForConversionMessage.TextSize = 16
-	fileVideoForConversionMessage.TextStyle = fyne.TextStyle{Bold: true}
-
-	buttonTitle := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "choose",
-	})
-
-	button := widget.NewButton(buttonTitle, func() {
-		fileDialog := dialog.NewFileOpen(
-			func(r fyne.URIReadCloser, err error) {
-				if err != nil {
-					fileVideoForConversionMessage.Text = err.Error()
-					setStringErrorStyle(fileVideoForConversionMessage)
-					return
-				}
-				if r == nil {
-					return
-				}
-
-				fileInput.Path = r.URI().Path()
-				fileInput.Name = r.URI().Name()
-				fileInput.Ext = r.URI().Extension()
-
-				fileVideoForConversionMessage.Text = r.URI().Path()
-				setStringSuccessStyle(fileVideoForConversionMessage)
-
-				form.Enable()
-				progress.Value = 0
-				progress.Refresh()
-				conversionMessage.Text = ""
-			}, v.w)
-		helper.FileDialogResize(fileDialog, v.w)
-		fileDialog.Show()
-	})
-
-	return button, fileVideoForConversionMessage, fileInput
-}
-
-func (v View) getButtonForSelectingDirectoryForSaving() (button *widget.Button, buttonMessage *canvas.Text, dirPath *string) {
-	buttonMessage = canvas.NewText("", color.RGBA{255, 0, 0, 255})
-	buttonMessage.TextSize = 16
-	buttonMessage.TextStyle = fyne.TextStyle{Bold: true}
-
-	path := ""
-	dirPath = &path
-
-	buttonTitle := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "choose",
-	})
-
-	button = widget.NewButton(buttonTitle, func() {
-		fileDialog := dialog.NewFolderOpen(
-			func(r fyne.ListableURI, err error) {
-				if err != nil {
-					buttonMessage.Text = err.Error()
-					setStringErrorStyle(buttonMessage)
-					return
-				}
-				if r == nil {
-					return
-				}
-
-				path = r.Path()
-
-				buttonMessage.Text = r.Path()
-				setStringSuccessStyle(buttonMessage)
-			}, v.w)
-		helper.FileDialogResize(fileDialog, v.w)
-		fileDialog.Show()
-	})
-
-	return
-}
-
-func setStringErrorStyle(text *canvas.Text) {
-	text.Color = color.RGBA{255, 0, 0, 255}
-	text.Refresh()
-}
-
-func setStringSuccessStyle(text *canvas.Text) {
-	text.Color = color.RGBA{49, 127, 114, 255}
-	text.Refresh()
-}
-
-func showConversionMessage(conversionMessage *canvas.Text, err error) {
-	conversionMessage.Text = err.Error()
-	setStringErrorStyle(conversionMessage)
-}
-
-func enableFormConversion(enableFormConversionStruct enableFormConversionStruct) {
-	enableFormConversionStruct.fileVideoForConversion.Enable()
-	enableFormConversionStruct.buttonForSelectedDir.Enable()
-	enableFormConversionStruct.form.Enable()
-}

src/data/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore

src/error/view.go

@@ -1,66 +0,0 @@
-package error
-
-import (
-	"ffmpegGui/localizer"
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-)
-
-type ViewContract interface {
-	PanicError(err error)
-}
-
-type View struct {
-	w                fyne.Window
-	localizerService localizer.ServiceContract
-}
-
-func NewView(w fyne.Window, localizerService localizer.ServiceContract) *View {
-	return &View{
-		w:                w,
-		localizerService: localizerService,
-	}
-}
-
-func (v View) PanicError(err error) {
-	messageHead := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "error",
-	})
-
-	v.w.SetContent(container.NewBorder(
-		container.NewVBox(
-			widget.NewLabel(messageHead),
-			widget.NewLabel(err.Error()),
-		),
-		nil,
-		nil,
-		nil,
-		localizer.LanguageSelectionForm(v.localizerService, func(lang localizer.Lang) {
-			v.PanicError(err)
-		}),
-	))
-}
-
-func (v View) PanicErrorWriteDirectoryData() {
-	message := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "errorDatabase",
-	})
-	messageHead := v.localizerService.GetMessage(&i18n.LocalizeConfig{
-		MessageID: "error",
-	})
-
-	v.w.SetContent(container.NewBorder(
-		container.NewVBox(
-			widget.NewLabel(messageHead),
-			widget.NewLabel(message),
-		),
-		nil,
-		nil,
-		nil,
-		localizer.LanguageSelectionForm(v.localizerService, func(lang localizer.Lang) {
-			v.PanicErrorWriteDirectoryData()
-		}),
-	))
-}

src/go.mod

@@ -1,41 +0,0 @@
-module ffmpegGui
-
-go 1.21
-
-require (
-	fyne.io/fyne/v2 v2.4.3 // indirect
-	fyne.io/systray v1.10.1-0.20231115130155-104f5ef7839e // indirect
-	github.com/BurntSushi/toml v1.3.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/fredbi/uri v1.0.0 // indirect
-	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/fyne-io/gl-js v0.0.0-20220119005834-d2da28d9ccfe // indirect
-	github.com/fyne-io/glfw-js v0.0.0-20220120001248-ee7290d23504 // indirect
-	github.com/fyne-io/image v0.0.0-20220602074514-4956b0afb3d2 // indirect
-	github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6 // indirect
-	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20221017161538-93cebf72946b // indirect
-	github.com/go-text/render v0.0.0-20230619120952-35bccb6164b8 // indirect
-	github.com/go-text/typesetting v0.0.0-20230616162802-9c17dd34aa4a // indirect
-	github.com/godbus/dbus/v5 v5.1.0 // indirect
-	github.com/gopherjs/gopherjs v1.17.2 // indirect
-	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/jsummers/gobmp v0.0.0-20151104160322-e2ba15ffa76e // indirect
-	github.com/mattn/go-sqlite3 v1.14.19 // indirect
-	github.com/nicksnyder/go-i18n/v2 v2.3.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/srwiley/oksvg v0.0.0-20221011165216-be6e8873101c // indirect
-	github.com/srwiley/rasterx v0.0.0-20220730225603-2ab79fcdd4ef // indirect
-	github.com/stretchr/testify v1.8.4 // indirect
-	github.com/tevino/abool v1.2.0 // indirect
-	github.com/yuin/goldmark v1.5.5 // indirect
-	golang.org/x/image v0.11.0 // indirect
-	golang.org/x/mobile v0.0.0-20230531173138-3c911d8e3eda // indirect
-	golang.org/x/net v0.17.0 // indirect
-	golang.org/x/sys v0.13.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-	gorm.io/driver/sqlite v1.5.4 // indirect
-	gorm.io/gorm v1.25.5 // indirect
-	honnef.co/go/js/dom v0.0.0-20210725211120-f030747120f2 // indirect
-)