.gitignore

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

README.md

@@ -25,9 +25,9 @@
    * 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** копируете:
-   * icon.png
+   * src/icon.png
-   * data
+   * src/data
-   * languages
+   * src/languages
    * LICENSE
    * LICENSE-3RD-PARTY.txt
 <p><strong>Структура должна получиться такая:</strong></p>
@@ -35,11 +35,8 @@
 
 ## Работа с переводами:
 1. go install -v github.com/nicksnyder/go-i18n/v2/goi18n@latest
-3. Создаём файл languages/translate.\*.toml
+2. goi18n merge -sourceLanguage ru -outdir languages languages/active.\*.toml languages/translate.\*.toml
+3. В файлах **languages/translate.\*.toml** переводим текст на нужный язык
 4. goi18n merge -sourceLanguage ru -outdir languages languages/active.\*.toml languages/translate.\*.toml
-5. В файлах **languages/translate.\*.toml** переводим текст на нужный язык
-6. goi18n merge -sourceLanguage ru -outdir languages languages/active.\*.toml languages/translate.\*.toml
-
-___где * подставляем нужный язык___
 
 Более подробно можно почитать тут: https://github.com/nicksnyder/go-i18n

convertor/view.go

@@ -1,18 +1,21 @@
 package convertor
 
 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"
 	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
 	"github.com/nicksnyder/go-i18n/v2/i18n"
 	"image/color"
+	"path/filepath"
 )
 
 type ViewContract interface {
 	Main(
-		formConversion view.ConversionContract,
+		runConvert func(setting HandleConvertSetting),
 	)
 	SelectFFPath(
 		ffmpegPath string,
@@ -27,18 +30,183 @@ type View struct {
 	app kernel.AppContract
 }
 
+type HandleConvertSetting struct {
+	VideoFileInput       kernel.File
+	DirectoryForSave     string
+	OverwriteOutputFiles bool
+}
+
+type enableFormConversionStruct struct {
+	fileVideoForConversion *widget.Button
+	buttonForSelectedDir   *widget.Button
+	form                   *widget.Form
+}
+
 func NewView(app kernel.AppContract) *View {
 	return &View{
 		app: app,
 	}
 }
 
-func (v View) Main(formConversion view.ConversionContract) {
+func (v View) Main(
+	runConvert func(setting HandleConvertSetting),
+) {
+	form := &widget.Form{}
+
+	conversionMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	conversionMessage.TextSize = 16
+	conversionMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	fileVideoForConversion, fileVideoForConversionMessage, fileInput := v.getButtonFileVideoForConversion(form, conversionMessage)
+	buttonForSelectedDir, buttonForSelectedDirMessage, pathToSaveDirectory := v.getButtonForSelectingDirectoryForSaving()
+
+	isOverwriteOutputFiles := false
+	checkboxOverwriteOutputFilesTitle := v.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
+		MessageID: "checkboxOverwriteOutputFilesTitle",
+	})
+	checkboxOverwriteOutputFiles := widget.NewCheck(checkboxOverwriteOutputFilesTitle, func(b bool) {
+		isOverwriteOutputFiles = b
+	})
+
+	form.Items = []*widget.FormItem{
+		{
+			Text:   v.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "fileVideoForConversionTitle"}),
+			Widget: fileVideoForConversion,
+		},
+		{
+			Widget: container.NewHScroll(fileVideoForConversionMessage),
+		},
+		{
+			Text:   v.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "buttonForSelectedDirTitle"}),
+			Widget: buttonForSelectedDir,
+		},
+		{
+			Widget: container.NewHScroll(buttonForSelectedDirMessage),
+		},
+		{
+			Widget: checkboxOverwriteOutputFiles,
+		},
+	}
+	form.SubmitText = v.app.GetLocalizerService().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.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
+				MessageID: "errorSelectedFolderSave",
+			})))
+			enableFormConversion(enableFormConversionStruct)
+			return
+		}
+		conversionMessage.Text = ""
+
+		fileVideoForConversion.Disable()
+		buttonForSelectedDir.Disable()
+		form.Disable()
+
+		setting := HandleConvertSetting{
+			VideoFileInput:       *fileInput,
+			DirectoryForSave:     *pathToSaveDirectory,
+			OverwriteOutputFiles: isOverwriteOutputFiles,
+		}
+		runConvert(setting)
+		enableFormConversion(enableFormConversionStruct)
+
+		fileVideoForConversionMessage.Text = ""
+		form.Disable()
+	}
+
 	converterVideoFilesTitle := v.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
 		MessageID: "converterVideoFilesTitle",
 	})
-	v.app.GetWindow().SetContent(widget.NewCard(converterVideoFilesTitle, "", container.NewVScroll(formConversion.GetContent())))
+	v.app.GetWindow().SetContent(widget.NewCard(converterVideoFilesTitle, "", container.NewVBox(form, conversionMessage)))
-	formConversion.AfterViewContent()
+	form.Disable()
+}
+
+func (v View) getButtonFileVideoForConversion(form *widget.Form, conversionMessage *canvas.Text) (*widget.Button, *canvas.Text, *kernel.File) {
+	fileInput := &kernel.File{}
+
+	fileVideoForConversionMessage := canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	fileVideoForConversionMessage.TextSize = 16
+	fileVideoForConversionMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	buttonTitle := v.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
+		MessageID: "choose",
+	})
+
+	var locationURI fyne.ListableURI
+
+	button := widget.NewButton(buttonTitle, func() {
+		v.app.GetWindow().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()
+			conversionMessage.Text = ""
+
+			listableURI := storage.NewFileURI(filepath.Dir(r.URI().Path()))
+			locationURI, err = storage.ListerForURI(listableURI)
+		}, locationURI)
+	})
+
+	return button, fileVideoForConversionMessage, fileInput
+}
+
+func (v View) getButtonForSelectingDirectoryForSaving() (button *widget.Button, buttonMessage *canvas.Text, dirPath *string) {
+	buttonMessage = canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
+	buttonMessage.TextSize = 16
+	buttonMessage.TextStyle = fyne.TextStyle{Bold: true}
+
+	path := ""
+	dirPath = &path
+
+	buttonTitle := v.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
+		MessageID: "choose",
+	})
+
+	var locationURI fyne.ListableURI
+
+	button = widget.NewButton(buttonTitle, func() {
+		v.app.GetWindow().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)
+			locationURI, _ = storage.ListerForURI(r)
+
+		}, locationURI)
+	})
+
+	return
 }
 
 func setStringErrorStyle(text *canvas.Text) {
@@ -50,3 +218,14 @@ 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)
+}
+
+func enableFormConversion(enableFormConversionStruct enableFormConversionStruct) {
+	enableFormConversionStruct.fileVideoForConversion.Enable()
+	enableFormConversionStruct.buttonForSelectedDir.Enable()
+	enableFormConversionStruct.form.Enable()
+}

convertor/view/conversion.go

@@ -1,444 +0,0 @@
-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"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-	"image/color"
-	"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)
-}
-
-type HandleConvertSetting struct {
-	FileInput            kernel.File
-	DirectoryForSave     string
-	OverwriteOutputFiles bool
-	Format               string
-	Encoder              encoder2.EncoderContract
-}
-
-func NewConversion(app kernel.AppContract, formats encoder.ConvertorFormatsContract, runConvert func(setting HandleConvertSetting)) *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)
-	directoryForSaving := newDirectoryForSaving(app)
-	overwriteOutputFiles := newOverwriteOutputFiles(app)
-	selectEncoder := newSelectEncoder(app, formats)
-
-	items := []*widget.FormItem{
-		{
-			Text:   app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "fileForConversionTitle"}),
-			Widget: fileForConversion.button,
-		},
-		{
-			Widget: container.NewHScroll(fileForConversion.message),
-		},
-		{
-			Text:   app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "buttonForSelectedDirTitle"}),
-			Widget: directoryForSaving.button,
-		},
-		{
-			Widget: container.NewHScroll(directoryForSaving.message),
-		},
-		{
-			Widget: overwriteOutputFiles.checkbox,
-		},
-		{
-			Widget: selectEncoder.SelectFileType,
-		},
-		{
-			Text:   app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "selectFormat"}),
-			Widget: selectEncoder.SelectFormat,
-		},
-		{
-			Text:   app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "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,
-	}
-}
-
-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() {
-	c.form.form.Disable()
-}
-
-func (c Conversion) selectFileForConversion(err error) {
-	c.conversionMessage.Text = ""
-	if err != nil {
-		c.form.form.Disable()
-		return
-	}
-
-	c.form.form.Enable()
-}
-
-func (c Conversion) submit() {
-	if len(c.directoryForSaving.path) == 0 {
-		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
-			MessageID: "errorSelectedFolderSave",
-		})))
-		c.enableFormConversion()
-		return
-	}
-	if len(c.selectEncoder.SelectFormat.Selected) == 0 {
-		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
-			MessageID: "errorSelectedFormat",
-		})))
-		return
-	}
-	if c.selectEncoder.Encoder == nil {
-		showConversionMessage(c.conversionMessage, errors.New(c.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
-			MessageID: "errorSelectedEncoder",
-		})))
-		return
-	}
-	c.conversionMessage.Text = ""
-
-	c.fileForConversion.button.Disable()
-	c.directoryForSaving.button.Disable()
-	c.form.form.Disable()
-
-	setting := HandleConvertSetting{
-		FileInput:            *c.fileForConversion.file,
-		DirectoryForSave:     c.directoryForSaving.path,
-		OverwriteOutputFiles: c.overwriteOutputFiles.IsChecked(),
-		Format:               c.selectEncoder.SelectFormat.Selected,
-		Encoder:              c.selectEncoder.Encoder,
-	}
-	c.runConvert(setting)
-	c.enableFormConversion()
-
-	c.fileForConversion.message.Text = ""
-	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) *fileForConversion {
-	fileForConversion := &fileForConversion{
-		file:            &kernel.File{},
-		changeCallbacks: map[int]func(err error){},
-	}
-
-	buttonTitle := app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
-		MessageID: "choose",
-	})
-
-	fileForConversion.message = canvas.NewText("", color.RGBA{R: 255, G: 0, B: 0, A: 255})
-	fileForConversion.message.TextSize = 16
-	fileForConversion.message.TextStyle = fyne.TextStyle{Bold: true}
-
-	var locationURI fyne.ListableURI
-
-	fileForConversion.button = widget.NewButton(buttonTitle, func() {
-		app.GetWindow().NewFileOpen(func(r fyne.URIReadCloser, err error) {
-			if err != nil {
-				fileForConversion.message.Text = err.Error()
-				setStringErrorStyle(fileForConversion.message)
-				fileForConversion.eventSelectFile(err)
-				return
-			}
-			if r == nil {
-				return
-			}
-
-			fileForConversion.file.Path = r.URI().Path()
-			fileForConversion.file.Name = r.URI().Name()
-			fileForConversion.file.Ext = r.URI().Extension()
-
-			fileForConversion.message.Text = r.URI().Path()
-			setStringSuccessStyle(fileForConversion.message)
-
-			fileForConversion.eventSelectFile(nil)
-
-			listableURI := storage.NewFileURI(filepath.Dir(r.URI().Path()))
-			locationURI, err = storage.ListerForURI(listableURI)
-		}, locationURI)
-	})
-
-	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) *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(&i18n.LocalizeConfig{
-		MessageID: "choose",
-	})
-
-	var locationURI fyne.ListableURI
-
-	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, _ = storage.ListerForURI(r)
-
-		}, locationURI)
-	})
-
-	return directoryForSaving
-}
-
-type overwriteOutputFiles struct {
-	checkbox  *widget.Check
-	isChecked bool
-}
-
-func newOverwriteOutputFiles(app kernel.AppContract) *overwriteOutputFiles {
-	overwriteOutputFiles := &overwriteOutputFiles{
-		isChecked: false,
-	}
-	checkboxOverwriteOutputFilesTitle := app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
-		MessageID: "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(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{MessageID: "encoderGroupVideo"})
-	encoderGroupAudio := app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "encoderGroupAudio"})
-	encoderGroupImage := app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{
-		MessageID: "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

@@ -1,16 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-)
-
-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(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{MessageID: "formPreset"}),
-			Widget: container.NewVBox(elementCheckbox, elementSelect),
-		},
-	}
-}

convertor/view/form_items/libx264/view.go

@@ -1,65 +0,0 @@
-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"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-)
-
-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(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{MessageID: "formPreset"}),
-			Widget: container.NewVBox(elementCheckbox, elementSelect),
-		},
-	}
-}

convertor/view/form_items/libx265/view.go

@@ -1,65 +0,0 @@
-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"
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-)
-
-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(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{MessageID: "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(&i18n.LocalizeConfig{MessageID: "formPreset"}),
-			Widget: container.NewVBox(elementCheckbox, elementSelect),
-		},
-	}
-}

encoder/apng/encoder.go

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,169 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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)
-}

handler/convertor.go

@@ -3,8 +3,6 @@ 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"
 	"github.com/nicksnyder/go-i18n/v2/i18n"
@@ -20,33 +18,24 @@ type ConvertorHandlerContract interface {
 type ConvertorHandler struct {
 	app                 kernel.AppContract
 	convertorView       convertor.ViewContract
-	errorView           error2.ViewContract
 	convertorRepository convertor.RepositoryContract
 }
 
 func NewConvertorHandler(
 	app kernel.AppContract,
 	convertorView convertor.ViewContract,
-	errorView error2.ViewContract,
 	convertorRepository convertor.RepositoryContract,
 ) *ConvertorHandler {
 	return &ConvertorHandler{
 		app:                 app,
 		convertorView:       convertorView,
-		errorView:           errorView,
 		convertorRepository: convertorRepository,
 	}
 }
 
 func (h ConvertorHandler) MainConvertor() {
 	if h.checkingFFPathUtilities() == true {
-		formats, err := h.app.GetConvertorService().GetSupportFormats()
+		h.convertorView.Main(h.runConvert)
-		if err != nil {
-			h.errorView.PanicError(err)
-			return
-		}
-		conversion := view.NewConversion(h.app, formats, h.runConvert)
-		h.convertorView.Main(conversion)
 		return
 	}
 	h.convertorView.SelectFFPath("", "", h.saveSettingFFPath, nil, h.downloadFFmpeg)
@@ -66,16 +55,15 @@ func (h ConvertorHandler) GetFfprobeVersion() (string, error) {
 	return h.app.GetConvertorService().GetFFprobeVersion()
 }
 
-func (h ConvertorHandler) runConvert(setting view.HandleConvertSetting) {
+func (h ConvertorHandler) runConvert(setting convertor.HandleConvertSetting) {
 	h.app.GetQueue().Add(&kernel.ConvertSetting{
-		VideoFileInput: setting.FileInput,
+		VideoFileInput: setting.VideoFileInput,
 		VideoFileOut: kernel.File{
-			Path: setting.DirectoryForSave + helper.PathSeparator() + setting.FileInput.Name + "." + setting.Format,
+			Path: setting.DirectoryForSave + helper.PathSeparator() + setting.VideoFileInput.Name + ".mp4",
-			Name: setting.FileInput.Name,
+			Name: setting.VideoFileInput.Name,
-			Ext:  "." + setting.Format,
+			Ext:  ".mp4",
 		},
 		OverwriteOutputFiles: setting.OverwriteOutputFiles,
-		Encoder:              setting.Encoder,
 	})
 }
 

handler/menu.go

@@ -19,6 +19,7 @@ type MenuHandler struct {
 	menuView            menu.ViewContract
 	localizerView       localizer.ViewContract
 	localizerRepository localizer.RepositoryContract
+	localizerListener   localizerListenerContract
 }
 
 func NewMenuHandler(
@@ -27,6 +28,7 @@ func NewMenuHandler(
 	menuView menu.ViewContract,
 	localizerView localizer.ViewContract,
 	localizerRepository localizer.RepositoryContract,
+	localizerListener localizerListenerContract,
 ) *MenuHandler {
 	return &MenuHandler{
 		app:                 app,
@@ -34,6 +36,7 @@ func NewMenuHandler(
 		menuView:            menuView,
 		localizerView:       localizerView,
 		localizerRepository: localizerRepository,
+		localizerListener:   localizerListener,
 	}
 }
 
@@ -49,31 +52,22 @@ func (h MenuHandler) getMenuSettings() *fyne.Menu {
 		MessageID: "exit",
 	}), nil)
 	quit.IsQuit = true
-	h.app.GetLocalizerService().AddChangeCallback("exit", func(text string) {
+	h.localizerListener.AddMenuItem("exit", quit)
-		quit.Label = text
-	})
 
 	languageSelection := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
 		MessageID: "changeLanguage",
 	}), h.LanguageSelection)
-	h.app.GetLocalizerService().AddChangeCallback("changeLanguage", func(text string) {
+	h.localizerListener.AddMenuItem("changeLanguage", languageSelection)
-		languageSelection.Label = text
-	})
 
 	ffPathSelection := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
 		MessageID: "changeFFPath",
 	}), h.convertorHandler.FfPathSelection)
-	h.app.GetLocalizerService().AddChangeCallback("changeFFPath", func(text string) {
+	h.localizerListener.AddMenuItem("changeFFPath", ffPathSelection)
-		ffPathSelection.Label = text
-	})
 
 	settings := fyne.NewMenu(h.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
 		MessageID: "settings",
 	}), languageSelection, ffPathSelection, quit)
-	h.app.GetLocalizerService().AddChangeCallback("settings", func(text string) {
+	h.localizerListener.AddMenu("settings", settings)
-		settings.Label = text
-		settings.Refresh()
-	})
 
 	return settings
 }
@@ -82,17 +76,12 @@ func (h MenuHandler) getMenuHelp() *fyne.Menu {
 	about := fyne.NewMenuItem(h.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
 		MessageID: "about",
 	}), h.openAbout)
-	h.app.GetLocalizerService().AddChangeCallback("about", func(text string) {
+	h.localizerListener.AddMenuItem("about", about)
-		about.Label = text
-	})
 
 	help := fyne.NewMenu(h.app.GetLocalizerService().GetMessage(&i18n.LocalizeConfig{
 		MessageID: "help",
 	}), about)
-	h.app.GetLocalizerService().AddChangeCallback("help", func(text string) {
+	h.localizerListener.AddMenu("help", help)
-		help.Label = text
-		help.Refresh()
-	})
 
 	return help
 }
@@ -120,3 +109,41 @@ func (h MenuHandler) LanguageSelection() {
 		h.convertorHandler.MainConvertor()
 	})
 }
+
+type menuItems struct {
+	menuItem map[string]*fyne.MenuItem
+	menu     map[string]*fyne.Menu
+}
+
+type LocalizerListener struct {
+	menuItems *menuItems
+}
+
+type localizerListenerContract interface {
+	AddMenu(messageID string, menu *fyne.Menu)
+	AddMenuItem(messageID string, menuItem *fyne.MenuItem)
+}
+
+func NewLocalizerListener() *LocalizerListener {
+	return &LocalizerListener{
+		&menuItems{menuItem: map[string]*fyne.MenuItem{}, menu: map[string]*fyne.Menu{}},
+	}
+}
+
+func (l LocalizerListener) AddMenu(messageID string, menu *fyne.Menu) {
+	l.menuItems.menu[messageID] = menu
+}
+
+func (l LocalizerListener) AddMenuItem(messageID string, menuItem *fyne.MenuItem) {
+	l.menuItems.menuItem[messageID] = menuItem
+}
+
+func (l LocalizerListener) Change(localizerService kernel.LocalizerContract) {
+	for messageID, menu := range l.menuItems.menuItem {
+		menu.Label = localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: messageID})
+	}
+	for messageID, menu := range l.menuItems.menu {
+		menu.Label = localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: messageID})
+		menu.Refresh()
+	}
+}

kernel/convertor.go

@@ -1,11 +1,8 @@
 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"
@@ -13,19 +10,6 @@ import (
 	"strings"
 )
 
-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)
@@ -34,7 +18,6 @@ type ConvertorContract interface {
 	ChangeFFmpegPath(path string) (bool, error)
 	ChangeFFprobePath(path string) (bool, error)
 	GetRunningProcesses() map[int]*exec.Cmd
-	GetSupportFormats() (encoder.ConvertorFormatsContract, error)
 }
 
 type ProgressContract interface {
@@ -73,9 +56,7 @@ func (s Convertor) RunConvert(setting ConvertSetting, progress ProgressContract)
 	if setting.OverwriteOutputFiles == true {
 		overwriteOutputFiles = "-y"
 	}
-	args := []string{overwriteOutputFiles, "-i", setting.VideoFileInput.Path}
+	args := []string{overwriteOutputFiles, "-i", setting.VideoFileInput.Path, "-c:v", "libx264", "-progress", progress.GetProtocole(), setting.VideoFileOut.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)
 
@@ -122,30 +103,7 @@ func (s Convertor) GetTotalDuration(file *File) (duration float64, err error) {
 		}
 		return 0, err
 	}
-	frames := strings.TrimSpace(string(out))
+	return strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
-	if len(frames) == 0 {
-		return s.getAlternativeTotalDuration(file)
-	}
-	return strconv.ParseFloat(frames, 64)
-}
-
-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) {
@@ -198,46 +156,6 @@ func (s Convertor) ChangeFFprobePath(path string) (bool, error) {
 	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
 }

kernel/encoder/encoder.go

@@ -1,84 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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/layout.go

@@ -65,7 +65,7 @@ type QueueLayoutObject struct {
 	container               *fyne.Container
 	items                   map[int]QueueLayoutItem
 	localizerService        LocalizerContract
-	queueStatisticsFormat *queueStatisticsFormat
+	layoutLocalizerListener LayoutLocalizerListenerContract
 }
 
 type QueueLayoutItem struct {
@@ -73,31 +73,20 @@ type QueueLayoutItem struct {
 	ProgressBar   *widget.ProgressBar
 	StatusMessage *canvas.Text
 	MessageError  *canvas.Text
-
-	status *StatusContract
 }
 
-func NewQueueLayoutObject(queue QueueListContract, localizerService LocalizerContract) *QueueLayoutObject {
+func NewQueueLayoutObject(queue QueueListContract, localizerService LocalizerContract, layoutLocalizerListener LayoutLocalizerListenerContract) *QueueLayoutObject {
-	title := widget.NewLabel(localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: "queue"}))
+	title := widget.NewLabel(localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: "queue"}) + ":")
 	title.TextStyle.Bold = true
 
-	localizerService.AddChangeCallback("queue", func(text string) {
+	layoutLocalizerListener.AddItem("queue", title)
-		title.Text = text
-		title.Refresh()
-	})
-
-	items := map[int]QueueLayoutItem{}
-	queueStatisticsFormat := newQueueStatisticsFormat(localizerService, &items)
 
 	queueLayoutObject := &QueueLayoutObject{
 		queue:                   queue,
-		container: container.NewVBox(
+		container:               container.NewVBox(title),
-			container.NewHBox(title, queueStatisticsFormat.completed.widget, queueStatisticsFormat.error.widget),
+		items:                   map[int]QueueLayoutItem{},
-			container.NewHBox(queueStatisticsFormat.inProgress.widget, queueStatisticsFormat.waiting.widget, queueStatisticsFormat.total.widget),
-		),
-		items:                 items,
 		localizerService:        localizerService,
-		queueStatisticsFormat: queueStatisticsFormat,
+		layoutLocalizerListener: layoutLocalizerListener,
 	}
 
 	queue.AddListener(queueLayoutObject)
@@ -129,18 +118,11 @@ func (o QueueLayoutObject) Add(id int, queue *Queue) {
 		canvas.NewLine(theme.FocusColor()),
 		container.NewPadded(),
 	)
-
-	o.queueStatisticsFormat.addQueue()
-	if o.queueStatisticsFormat.isChecked(queue.Status) == false {
-		content.Hide()
-	}
-
 	o.items[id] = QueueLayoutItem{
 		CanvasObject:  content,
 		ProgressBar:   progressBar,
 		StatusMessage: statusMessage,
 		MessageError:  messageError,
-		status:        &queue.Status,
 	}
 	o.container.Add(content)
 }
@@ -148,7 +130,6 @@ func (o QueueLayoutObject) Add(id int, queue *Queue) {
 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{}
 	}
 }
@@ -164,12 +145,6 @@ func (o QueueLayoutObject) ChangeQueueStatus(queueId int, queue *Queue) {
 			item.MessageError.Color = statusColor
 			item.MessageError.Refresh()
 		}
-		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)
 	}
 }
 
@@ -186,7 +161,7 @@ func (o QueueLayoutObject) getStatusColor(status StatusContract) color.Color {
 }
 
 func (o QueueLayoutObject) getStatusTitle(status StatusContract) string {
-	return o.localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: status.Name() + "Queue"})
+	return o.localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: status.name()})
 }
 
 type Progress struct {
@@ -279,256 +254,35 @@ func (p Progress) Run(stdOut io.ReadCloser, stdErr io.ReadCloser) error {
 	return nil
 }
 
-type queueStatistics struct {
+type LayoutLocalizerItem struct {
-	widget *widget.Check
+	messageID string
-	title  string
+	object    *widget.Label
-	count  *int64
-}
-type queueStatisticsFormat struct {
-	waiting    *queueStatistics
-	inProgress *queueStatistics
-	completed  *queueStatistics
-	error      *queueStatistics
-	total      *queueStatistics
 }
 
-func newQueueStatisticsFormat(localizerService LocalizerContract, queueItems *map[int]QueueLayoutItem) *queueStatisticsFormat {
+type LayoutLocalizerListener struct {
-	checkWaiting := newQueueStatistics("waitingQueue", localizerService)
+	itemCurrentId int
-	checkInProgress := newQueueStatistics("inProgressQueue", localizerService)
+	items         map[int]*LayoutLocalizerItem
-	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) {
+type LayoutLocalizerListenerContract interface {
-	for _, item := range *queueItems {
+	AddItem(messageID string, object *widget.Label)
-		if f.isChecked(*item.status) == true && item.CanvasObject.Visible() == false {
+}
-			item.CanvasObject.Show()
+
-			continue
+func NewLayoutLocalizerListener() *LayoutLocalizerListener {
-		}
+	return &LayoutLocalizerListener{
-		if f.isChecked(*item.status) == false && item.CanvasObject.Visible() == true {
+		itemCurrentId: 0,
-			item.CanvasObject.Hide()
+		items:         map[int]*LayoutLocalizerItem{},
-		}
 	}
 }
 
-func (f queueStatisticsFormat) isChecked(status StatusContract) bool {
+func (l LayoutLocalizerListener) AddItem(messageID string, object *widget.Label) {
-	if status == StatusType(InProgress) {
+	l.itemCurrentId += 1
-		return f.inProgress.widget.Checked
+	l.items[l.itemCurrentId] = &LayoutLocalizerItem{messageID: messageID, object: object}
-	}
-	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() {
+func (l LayoutLocalizerListener) Change(localizerService LocalizerContract) {
-	f.waiting.add()
+	for _, item := range l.items {
-	f.total.add()
+		item.object.Text = localizerService.GetMessage(&i18n.LocalizeConfig{MessageID: item.messageID})
-}
+		item.object.Refresh()
-
-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(&i18n.LocalizeConfig{MessageID: 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 {
-		s.widget.Refresh()
 	}
 }

kernel/localizer.go

@@ -16,7 +16,11 @@ type LocalizerContract interface {
 	SetCurrentLanguage(lang Lang) error
 	SetCurrentLanguageByCode(code string) error
 	GetCurrentLanguage() *CurrentLanguage
-	AddChangeCallback(messageID string, callback func(text string))
+	AddListener(listener LocalizerListenerContract)
+}
+
+type LocalizerListenerContract interface {
+	Change(localizerService LocalizerContract)
 }
 
 type Lang struct {
@@ -30,16 +34,11 @@ type CurrentLanguage struct {
 	localizerDefault *i18n.Localizer
 }
 
-type changeCallback struct {
-	messageID string
-	callback  func(text string)
-}
-
 type Localizer struct {
 	bundle            *i18n.Bundle
 	languages         []Lang
 	currentLanguage   *CurrentLanguage
-	changeCallbacks map[int]*changeCallback
+	localizerListener map[int]LocalizerListenerContract
 }
 
 func NewLocalizer(directory string, languageDefault language.Tag) (*Localizer, error) {
@@ -64,7 +63,7 @@ func NewLocalizer(directory string, languageDefault language.Tag) (*Localizer, e
 			localizer:        localizerDefault,
 			localizerDefault: localizerDefault,
 		},
-		changeCallbacks: map[int]*changeCallback{},
+		localizerListener: map[int]LocalizerListenerContract{},
 	}, nil
 }
 
@@ -124,14 +123,13 @@ func (l Localizer) GetCurrentLanguage() *CurrentLanguage {
 	return l.currentLanguage
 }
 
-func (l Localizer) AddChangeCallback(messageID string, callback func(text string)) {
+func (l Localizer) AddListener(listener LocalizerListenerContract) {
-	l.changeCallbacks[len(l.changeCallbacks)] = &changeCallback{messageID: messageID, callback: callback}
+	l.localizerListener[len(l.localizerListener)] = listener
 }
 
 func (l Localizer) eventSetCurrentLanguage() {
-	for _, changeCallback := range l.changeCallbacks {
+	for _, listener := range l.localizerListener {
-		text := l.GetMessage(&i18n.LocalizeConfig{MessageID: changeCallback.messageID})
+		listener.Change(l)
-		changeCallback.callback(text)
 	}
 }
 

kernel/queue.go

@@ -10,9 +10,21 @@ type Queue struct {
 	Error   error
 }
 
+type File struct {
+	Path string
+	Name string
+	Ext  string
+}
+
+type ConvertSetting struct {
+	VideoFileInput       File
+	VideoFileOut         File
+	OverwriteOutputFiles bool
+}
+
 type StatusContract interface {
-	Name() string
+	name() string
-	Ordinal() int
+	ordinal() int
 }
 
 const (
@@ -31,11 +43,11 @@ var statusTypeStrings = []string{
 	"error",
 }
 
-func (status StatusType) Name() string {
+func (status StatusType) name() string {
 	return statusTypeStrings[status]
 }
 
-func (status StatusType) Ordinal() int {
+func (status StatusType) ordinal() int {
 	return int(status)
 }
 

kernel/window.go

@@ -22,8 +22,7 @@ type Window struct {
 }
 
 func newWindow(w fyne.Window, layout LayoutContract) Window {
-	windowSize := fyne.Size{Width: 1039, Height: 599}
+	w.Resize(fyne.Size{Width: 1039, Height: 599})
-	w.Resize(windowSize)
 	w.CenterOnScreen()
 
 	go func() {
@@ -31,10 +30,11 @@ func newWindow(w fyne.Window, layout LayoutContract) Window {
 		 * 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)
+		size := w.Canvas().Size()
+		size.Width += 1
+		size.Height += 1
+		w.Resize(size)
 	}()
 
 	return Window{

languages/.gitignore

@@ -1 +0,0 @@
-translate.*.toml

languages/active.en.toml

@@ -15,8 +15,8 @@ hash = "sha1-c223c2e15171156192bc3146aee91e6094bb475b"
 other = "Download FFmpeg automatically"
 
 [buttonForSelectedDirTitle]
-hash = "sha1-8cbe5c67bcf89e4624635a79cbea104227faedda"
+hash = "sha1-52b13f1b13e82d22e8c4102332db5d4ec551247b"
-other = "Save to folder:"
+other = "Folder where it will be saved:"
 
 [cancel]
 hash = "sha1-0ec753be8df955a117404fb634b01b45eb386e2a"
@@ -38,7 +38,7 @@ other = "Allow file to be overwritten"
 hash = "sha1-f60bb5f761024d973834b5e9d25ceebce2c85f94"
 other = "choose"
 
-[completedQueue]
+[completed]
 hash = "sha1-398c7d4f7b0d522afb930769c0fbb1a9f4b61fbe"
 other = "Completed"
 
@@ -47,8 +47,8 @@ hash = "sha1-7ac460f3c24c9952082f2db6e4d62f752598709c"
 other = "Convert"
 
 [converterVideoFilesTitle]
-hash = "sha1-1ab29597cc9dfefab08e54ea5442e7ffa15f0394"
+hash = "sha1-4d972809e4c7f9c9ff2c110a126bbc183c9429ce"
-other = "Video, audio and picture converter"
+other = "Converter video files to mp4"
 
 [download]
 hash = "sha1-fe8f79f29da457de2f6bc9531de6e536e0c426ad"
@@ -62,150 +62,6 @@ other = "Will be downloaded from the site:"
 hash = "sha1-55f87f114628fa2d5d8e67d1e1cda22c0e4f9271"
 other = "Downloading..."
 
-[encoderGroupAudio]
-hash = "sha1-24321cb5400df96be8f3e2131918bebdb3a01bba"
-other = "Audio"
-
-[encoderGroupImage]
-hash = "sha1-a7e528bc7ac9538aec87d1593c38b80be95d4745"
-other = "Images"
-
-[encoderGroupVideo]
-hash = "sha1-8e7b9894c7ef0f57ac0bf910f6a8aac1c8a53683"
-other = "Video"
-
-[encoder_apng]
-hash = "sha1-1cbd9abfef96d5614a7e569161b41bd6ad87bbaf"
-other = "APNG image"
-
-[encoder_bmp]
-hash = "sha1-e0b9c16b016961a5abdc2217e8ffd1ba7ddebc40"
-other = "BMP image"
-
-[encoder_flv]
-hash = "sha1-3602bbf1cc90e48254f81975c7879b5fc0c4d602"
-other = "FLV"
-
-[encoder_gif]
-hash = "sha1-d092a779172291b5215aa095390a5b11659128a4"
-other = "GIF image"
-
-[encoder_h264_nvenc]
-hash = "sha1-169389f8c4a2518410159c363378ab5c978c32e5"
-other = "H.264 with NVIDIA support"
-
-[encoder_libmp3lame]
-hash = "sha1-cd2c8d6f246c8bc18554b7105cb50b78d3cb2b98"
-other = "libmp3lame MP3 (MPEG audio layer 3)"
-
-[encoder_libshine]
-hash = "sha1-891d56c85857e5d83ef5a1fe077c1f1540788f49"
-other = "libshine MP3 (MPEG audio layer 3)"
-
-[encoder_libtwolame]
-hash = "sha1-b2f53be810b74edc3c454ac75de7ddecfee322ca"
-other = "libtwolame MP2 (MPEG audio layer 2)"
-
-[encoder_libvpx]
-hash = "sha1-b85c923aecfb48de0e87e71b6a21bfc2c547c70e"
-other = "libvpx VP8 (codec vp8)"
-
-[encoder_libvpx-vp9]
-hash = "sha1-3106417bd89bee87daa691e87614caf78cb934fe"
-other = "libvpx VP9 (codec vp9)"
-
-[encoder_libwebp]
-hash = "sha1-1d590d47d46f7880246061fce0e0de6d743db39e"
-other = "libwebp WebP image"
-
-[encoder_libwebp_anim]
-hash = "sha1-f141a9c8f23d79c13d44c30d8f34e05b363771ad"
-other = "libwebp_anim WebP image"
-
-[encoder_libx264]
-hash = "sha1-6d764ac459c0bf3c819d76618418cdfbb7a749eb"
-other = "H.264 libx264"
-
-[encoder_libx265]
-hash = "sha1-55544c166b1e15fd71a58096518e528109599eea"
-other = "H.265 libx265"
-
-[encoder_libxvid]
-hash = "sha1-d4bed46d6cdd2bfa8fd1689801164a83ab10c3f5"
-other = "libxvidcore MPEG-4 part 2"
-
-[encoder_mjpeg]
-hash = "sha1-94ba63a322b493a04da65e566781fe1cf8bb0d50"
-other = "MJPEG (Motion JPEG)"
-
-[encoder_mp2]
-hash = "sha1-a9154b7203349e5d6fbfd67d1ea97715f54b2065"
-other = "MP2 (MPEG audio layer 2)"
-
-[encoder_mp2fixed]
-hash = "sha1-dd2ee670d8bc8a60a96a717ebd26f16b5748cf3f"
-other = "MP2 fixed point (MPEG audio layer 2)"
-
-[encoder_mpeg1video]
-hash = "sha1-30043660719a3cb19dab5c33450665a8a9cc1c01"
-other = "MPEG-1"
-
-[encoder_mpeg2video]
-hash = "sha1-ccb2dcd8510cfdc9d52e5258af1863e5f2c51e77"
-other = "MPEG-2"
-
-[encoder_mpeg4]
-hash = "sha1-67fe42f18421b2f6c90fcdc579f9199bfca4b182"
-other = "MPEG-4 part 2"
-
-[encoder_msmpeg4]
-hash = "sha1-313ee597e4f0d9bd63a2bc6ac1618f028aef76f4"
-other = "MPEG-4 part 2 Microsoft variant version 3"
-
-[encoder_msmpeg4v2]
-hash = "sha1-adc442ce88f2717693b2da3010a1937d77ee522f"
-other = "MPEG-4 part 2 Microsoft variant version 2"
-
-[encoder_msvideo1]
-hash = "sha1-00f43ac0dc162bca10e0d98d6b70c0c6a902f66f"
-other = "Microsoft Video-1"
-
-[encoder_png]
-hash = "sha1-6715d4b82f5d9dfe3e53e30b402ffa1a6fbf30a5"
-other = "PNG image"
-
-[encoder_qtrle]
-hash = "sha1-31bf155cffaf6842ebc54084e4337ca08fdd9848"
-other = "QuickTime Animation (RLE) video"
-
-[encoder_sgi]
-hash = "sha1-f4510e237f7fc3c02caa728f9e500f4b069f9c11"
-other = "SGI image"
-
-[encoder_tiff]
-hash = "sha1-ed09d78c38e0b17ed695f35740c756dd7340eeac"
-other = "TIFF image"
-
-[encoder_wmav1]
-hash = "sha1-cd4a4c5eeac694b6699d55d0f9b477b3b50f18c7"
-other = "Windows Media Audio 1"
-
-[encoder_wmav2]
-hash = "sha1-eb2e5306cb33a702577ecfbdca0461862c66c053"
-other = "Windows Media Audio 2"
-
-[encoder_wmv1]
-hash = "sha1-f9b748554c590c36a56bcba2cd317196b7bdeddb"
-other = "Windows Media Video 7"
-
-[encoder_wmv2]
-hash = "sha1-5b21c87f5c6104797ead60b488b2948428f6b1b7"
-other = "Windows Media Video 8"
-
-[encoder_xbm]
-hash = "sha1-2dfc35881da62e9a1379d8238cf7839b24f79566"
-other = "XBM (X BitMap) image"
-
 [error]
 hash = "sha1-a7df8f8b5d754f226ac4cb320577fe692b33e483"
 other = "An error has occurred!"
@@ -234,21 +90,9 @@ other = "this is not FFprobe"
 hash = "sha1-da7b37d7df3fafbd153665b13888413d52b24c17"
 other = "Failed to determine FFprobe version"
 
-[errorQueue]
-hash = "sha1-72aecd9ad85642d84d62dbbf3cf70953c5f696c7"
-other = "Error"
-
-[errorSelectedEncoder]
-hash = "sha1-33ed1aaf4cb3c2ee9d8f8c325b9b75d16ddf9979"
-other = "Converter not selected"
-
 [errorSelectedFolderSave]
-hash = "sha1-16f3ef93ee36813fdd79d8fb9bb7fc02acbb94a8"
+hash = "sha1-83da899677cdc90e4344e3b94ee03c46b51bee4c"
-other = "No save folder selected!"
+other = "You haven't selected a folder to save!"
-
-[errorSelectedFormat]
-hash = "sha1-cda92c56a1ef1aabc92bbfc405ede8ab13087e66"
-other = "File extension not selected"
 
 [exit]
 hash = "sha1-c42457057d1ab7950cea00719cbe0b078891775f"
@@ -262,19 +106,15 @@ other = "This software uses libraries from the **FFmpeg** project under the **[L
 hash = "sha1-45f772b2eca5098cd6d31f2d1dc6edec1987a617"
 other = "**FFmpeg** is a trademark of **[Fabrice Bellard](http://bellard.org/)**, originator of the **[FFmpeg](https://ffmpeg.org/about.html)** project."
 
-[fileForConversionTitle]
+[fileVideoForConversionTitle]
-hash = "sha1-96ac799e1086b31fd8f5f8d4c801829d6c853f08"
+hash = "sha1-5e727d4a2ff3f21080e51e81641595b2e668f3be"
-other = "File:"
+other = "File for conversion:"
-
-[formPreset]
-hash = "sha1-7759891ba1ef9f7adc70defc7ac18fbf149c1a68"
-other = "Preset"
 
 [help]
 hash = "sha1-6a45cef900c668effcb2ab10da05855c1fd10f6f"
 other = "Help"
 
-[inProgressQueue]
+[inProgress]
 hash = "sha1-eff79c40e2100ae5fadf3a7d99336025edcca8b5"
 other = "In Progress"
 
@@ -294,10 +134,6 @@ other = "License information"
 hash = "sha1-359fff328717c05104e51a2d29f05bf1875d26b7"
 other = "Licenses from other products used in the program"
 
-[parameterCheckbox]
-hash = "sha1-9e35221d454870996fd51d576249cf47d1784a3c"
-other = "Enable option"
-
 [pathToFfmpeg]
 hash = "sha1-fafc50f1db0f720fe83a96cd70a9e1ad824e96b6"
 other = "Path to FFmpeg:"
@@ -306,46 +142,6 @@ other = "Path to FFmpeg:"
 hash = "sha1-b872edc9633a2e81ef678dc46fe46a7e91732024"
 other = "Path to FFprobe:"
 
-[preset_fast]
-hash = "sha1-935e1ac9d3c8ba4478326c909ba66662acb0540e"
-other = "fast (slower than \"faster\", but the file will weigh less)"
-
-[preset_faster]
-hash = "sha1-98620b73c896440c39ea6ec4b9b19d41301c9a7e"
-other = "faster (slower than \"veryfast\", but the file will weigh less)"
-
-[preset_medium]
-hash = "sha1-f7d1c30135c22c2f07c247075c0df103bb3c3ea5"
-other = "medium (slower than \"fast\", but the file will weigh less)"
-
-[preset_placebo]
-hash = "sha1-7bcff099104bb192881139e6404981bd426b3f91"
-other = "placebo (not recommended)"
-
-[preset_slow]
-hash = "sha1-681bf587275a45b48af49bb2ad8f0947919530e7"
-other = "slow (slower than \"medium\", but the file will weigh less)"
-
-[preset_slower]
-hash = "sha1-d1c692ee2b7643ae2c71a48bea880327a3c6b1e3"
-other = "slower (slower than \"slow\", but the file will weigh less)"
-
-[preset_superfast]
-hash = "sha1-41c39959e8f1547cc9259a5b459c4ccbf368cc23"
-other = "superfast (slower than \"ultrafast\", but the file will weigh less)"
-
-[preset_ultrafast]
-hash = "sha1-dfed981573ac2046832f9a9450bc9388958753fa"
-other = "ultrafast (fast, but the file will weigh a lot)"
-
-[preset_veryfast]
-hash = "sha1-370b82509887d02d7a2ef9b110df4616b16123ce"
-other = "veryfast (slower than \"superfast\", but the file will weigh less)"
-
-[preset_veryslow]
-hash = "sha1-d428bfa6deea9dd5c7c1f80ceba24e123ae96d0d"
-other = "veryslow (slower than \"slower\", but the file will weigh less)"
-
 [programmLink]
 hash = "sha1-18f9a3fad6aacefe1b05eed23122800b391ff5ca"
 other = "Project website"
@@ -362,18 +158,10 @@ other = "Queue"
 hash = "sha1-4864057d626a868fa60f999bed3191d61d045ddc"
 other = "Save"
 
-[selectEncoder]
-hash = "sha1-88f3670b09758a3336057520a215058d61006abd"
-other = "Encoder:"
-
 [selectFFPathTitle]
 hash = "sha1-95581446a28d968ff1a027c623159a7eb08654cf"
 other = "Specify the path to FFmpeg and FFprobe"
 
-[selectFormat]
-hash = "sha1-f3809b0b48886570cd4cf1d7099de6da5b6d4524"
-other = "File extension:"
-
 [settings]
 hash = "sha1-7f17c7c62a7fd8d1a508481f4778688927734c2f"
 other = "Settings"
@@ -386,14 +174,10 @@ other = "Checking FFmpeg for serviceability..."
 hash = "sha1-92df86371f6c3a06ca1e4754f113142776a32d49"
 other = "You can download it from here"
 
-[total]
-hash = "sha1-3b5143902e0c5c84459aedf918e17604d9735b94"
-other = "Total"
-
 [unzipRun]
 hash = "sha1-c554dad13026668a1f6adf3171837c5d51bbac36"
 other = "Unpacked..."
 
-[waitingQueue]
+[waiting]
 hash = "sha1-307429dd84150877080c4bbff2b340d1e7dadff2"
 other = "Waiting"

languages/active.kk.toml

@@ -15,8 +15,8 @@ hash = "sha1-c223c2e15171156192bc3146aee91e6094bb475b"
 other = "FFmpeg автоматты түрде жүктеп алыңыз"
 
 [buttonForSelectedDirTitle]
-hash = "sha1-8cbe5c67bcf89e4624635a79cbea104227faedda"
+hash = "sha1-52b13f1b13e82d22e8c4102332db5d4ec551247b"
-other = "Қалтаға сақтаңыз:"
+other = "Файлды сақтауға арналған каталог:"
 
 [cancel]
 hash = "sha1-0ec753be8df955a117404fb634b01b45eb386e2a"
@@ -38,7 +38,7 @@ other = "Файлды қайта жазуға рұқсат беріңіз"
 hash = "sha1-f60bb5f761024d973834b5e9d25ceebce2c85f94"
 other = "таңдау"
 
-[completedQueue]
+[completed]
 hash = "sha1-398c7d4f7b0d522afb930769c0fbb1a9f4b61fbe"
 other = "Дайын"
 
@@ -47,8 +47,8 @@ hash = "sha1-7ac460f3c24c9952082f2db6e4d62f752598709c"
 other = "Файлды түрлендіру"
 
 [converterVideoFilesTitle]
-hash = "sha1-1ab29597cc9dfefab08e54ea5442e7ffa15f0394"
+hash = "sha1-4d972809e4c7f9c9ff2c110a126bbc183c9429ce"
-other = "Бейне, аудио және суретті түрлендіргіш"
+other = "Бейне файлдарын mp4 форматына түрлендіру"
 
 [download]
 hash = "sha1-fe8f79f29da457de2f6bc9531de6e536e0c426ad"
@@ -62,150 +62,6 @@ other = "Сайттан жүктеледі:"
 hash = "sha1-55f87f114628fa2d5d8e67d1e1cda22c0e4f9271"
 other = "Жүктеп алынуда..."
 
-[encoderGroupAudio]
-hash = "sha1-24321cb5400df96be8f3e2131918bebdb3a01bba"
-other = "Аудио"
-
-[encoderGroupImage]
-hash = "sha1-a7e528bc7ac9538aec87d1593c38b80be95d4745"
-other = "Суреттер"
-
-[encoderGroupVideo]
-hash = "sha1-8e7b9894c7ef0f57ac0bf910f6a8aac1c8a53683"
-other = "Бейне"
-
-[encoder_apng]
-hash = "sha1-1cbd9abfef96d5614a7e569161b41bd6ad87bbaf"
-other = "APNG image"
-
-[encoder_bmp]
-hash = "sha1-e0b9c16b016961a5abdc2217e8ffd1ba7ddebc40"
-other = "BMP image"
-
-[encoder_flv]
-hash = "sha1-3602bbf1cc90e48254f81975c7879b5fc0c4d602"
-other = "FLV"
-
-[encoder_gif]
-hash = "sha1-d092a779172291b5215aa095390a5b11659128a4"
-other = "GIF image"
-
-[encoder_h264_nvenc]
-hash = "sha1-169389f8c4a2518410159c363378ab5c978c32e5"
-other = "NVIDIA қолдауымен H.264"
-
-[encoder_libmp3lame]
-hash = "sha1-cd2c8d6f246c8bc18554b7105cb50b78d3cb2b98"
-other = "libmp3lame MP3 (MPEG audio layer 3)"
-
-[encoder_libshine]
-hash = "sha1-891d56c85857e5d83ef5a1fe077c1f1540788f49"
-other = "libshine MP3 (MPEG audio layer 3)"
-
-[encoder_libtwolame]
-hash = "sha1-b2f53be810b74edc3c454ac75de7ddecfee322ca"
-other = "libtwolame MP2 (MPEG audio layer 2)"
-
-[encoder_libvpx]
-hash = "sha1-b85c923aecfb48de0e87e71b6a21bfc2c547c70e"
-other = "libvpx VP8 (codec vp8)"
-
-[encoder_libvpx-vp9]
-hash = "sha1-3106417bd89bee87daa691e87614caf78cb934fe"
-other = "libvpx VP9 (codec vp9)"
-
-[encoder_libwebp]
-hash = "sha1-1d590d47d46f7880246061fce0e0de6d743db39e"
-other = "libwebp WebP image"
-
-[encoder_libwebp_anim]
-hash = "sha1-f141a9c8f23d79c13d44c30d8f34e05b363771ad"
-other = "libwebp_anim WebP image"
-
-[encoder_libx264]
-hash = "sha1-6d764ac459c0bf3c819d76618418cdfbb7a749eb"
-other = "H.264 libx264"
-
-[encoder_libx265]
-hash = "sha1-55544c166b1e15fd71a58096518e528109599eea"
-other = "H.265 libx265"
-
-[encoder_libxvid]
-hash = "sha1-d4bed46d6cdd2bfa8fd1689801164a83ab10c3f5"
-other = "libxvidcore MPEG-4 part 2"
-
-[encoder_mjpeg]
-hash = "sha1-94ba63a322b493a04da65e566781fe1cf8bb0d50"
-other = "MJPEG (Motion JPEG)"
-
-[encoder_mp2]
-hash = "sha1-a9154b7203349e5d6fbfd67d1ea97715f54b2065"
-other = "MP2 (MPEG audio layer 2)"
-
-[encoder_mp2fixed]
-hash = "sha1-dd2ee670d8bc8a60a96a717ebd26f16b5748cf3f"
-other = "MP2 fixed point (MPEG audio layer 2)"
-
-[encoder_mpeg1video]
-hash = "sha1-30043660719a3cb19dab5c33450665a8a9cc1c01"
-other = "MPEG-1"
-
-[encoder_mpeg2video]
-hash = "sha1-ccb2dcd8510cfdc9d52e5258af1863e5f2c51e77"
-other = "MPEG-2"
-
-[encoder_mpeg4]
-hash = "sha1-67fe42f18421b2f6c90fcdc579f9199bfca4b182"
-other = "MPEG-4 part 2"
-
-[encoder_msmpeg4]
-hash = "sha1-313ee597e4f0d9bd63a2bc6ac1618f028aef76f4"
-other = "MPEG-4 part 2 Microsoft variant version 3"
-
-[encoder_msmpeg4v2]
-hash = "sha1-adc442ce88f2717693b2da3010a1937d77ee522f"
-other = "MPEG-4 part 2 Microsoft variant version 2"
-
-[encoder_msvideo1]
-hash = "sha1-00f43ac0dc162bca10e0d98d6b70c0c6a902f66f"
-other = "Microsoft Video-1"
-
-[encoder_png]
-hash = "sha1-6715d4b82f5d9dfe3e53e30b402ffa1a6fbf30a5"
-other = "PNG image"
-
-[encoder_qtrle]
-hash = "sha1-31bf155cffaf6842ebc54084e4337ca08fdd9848"
-other = "QuickTime Animation (RLE) video"
-
-[encoder_sgi]
-hash = "sha1-f4510e237f7fc3c02caa728f9e500f4b069f9c11"
-other = "SGI image"
-
-[encoder_tiff]
-hash = "sha1-ed09d78c38e0b17ed695f35740c756dd7340eeac"
-other = "TIFF image"
-
-[encoder_wmav1]
-hash = "sha1-cd4a4c5eeac694b6699d55d0f9b477b3b50f18c7"
-other = "Windows Media Audio 1"
-
-[encoder_wmav2]
-hash = "sha1-eb2e5306cb33a702577ecfbdca0461862c66c053"
-other = "Windows Media Audio 2"
-
-[encoder_wmv1]
-hash = "sha1-f9b748554c590c36a56bcba2cd317196b7bdeddb"
-other = "Windows Media Video 7"
-
-[encoder_wmv2]
-hash = "sha1-5b21c87f5c6104797ead60b488b2948428f6b1b7"
-other = "Windows Media Video 8"
-
-[encoder_xbm]
-hash = "sha1-2dfc35881da62e9a1379d8238cf7839b24f79566"
-other = "XBM (X BitMap) image"
-
 [error]
 hash = "sha1-a7df8f8b5d754f226ac4cb320577fe692b33e483"
 other = "Қате орын алды!"
@@ -234,21 +90,9 @@ other = "бұл FFprobe емес"
 hash = "sha1-da7b37d7df3fafbd153665b13888413d52b24c17"
 other = "FFprobe нұсқасын анықтау мүмкін болмады"
 
-[errorQueue]
-hash = "sha1-72aecd9ad85642d84d62dbbf3cf70953c5f696c7"
-other = "Қате"
-
-[errorSelectedEncoder]
-hash = "sha1-33ed1aaf4cb3c2ee9d8f8c325b9b75d16ddf9979"
-other = "Түрлендіргіш таңдалмаған"
-
 [errorSelectedFolderSave]
-hash = "sha1-16f3ef93ee36813fdd79d8fb9bb7fc02acbb94a8"
+hash = "sha1-83da899677cdc90e4344e3b94ee03c46b51bee4c"
-other = "Сақтау қалтасы таңдалмаған!"
+other = "Сіз сақталатын қалтаны таңдамадыңыз!"
-
-[errorSelectedFormat]
-hash = "sha1-cda92c56a1ef1aabc92bbfc405ede8ab13087e66"
-other = "Файл кеңейтімі таңдалмаған"
 
 [exit]
 hash = "sha1-c42457057d1ab7950cea00719cbe0b078891775f"
@@ -262,19 +106,15 @@ other = "Бұл бағдарламалық құрал **[LGPLv2.1](http://www.gn
 hash = "sha1-45f772b2eca5098cd6d31f2d1dc6edec1987a617"
 other = "FFmpeg — **[FFmpeg](https://ffmpeg.org/about.html)** жобасын жасаушы **[Fabrice Bellard](http://bellard.org/)** сауда белгісі."
 
-[fileForConversionTitle]
+[fileVideoForConversionTitle]
-hash = "sha1-96ac799e1086b31fd8f5f8d4c801829d6c853f08"
+hash = "sha1-5e727d4a2ff3f21080e51e81641595b2e668f3be"
-other = "Файл:"
+other = "Түрлендіруге арналған файл:"
-
-[formPreset]
-hash = "sha1-7759891ba1ef9f7adc70defc7ac18fbf149c1a68"
-other = "Алдын ала орнатылған"
 
 [help]
 hash = "sha1-6a45cef900c668effcb2ab10da05855c1fd10f6f"
 other = "Анықтама"
 
-[inProgressQueue]
+[inProgress]
 hash = "sha1-eff79c40e2100ae5fadf3a7d99336025edcca8b5"
 other = "Орындалуда"
 
@@ -294,10 +134,6 @@ other = "Лицензия туралы ақпарат"
 hash = "sha1-359fff328717c05104e51a2d29f05bf1875d26b7"
 other = "Бағдарламада пайдаланылатын басқа өнімдердің лицензиялары"
 
-[parameterCheckbox]
-hash = "sha1-9e35221d454870996fd51d576249cf47d1784a3c"
-other = "Опцияны қосу"
-
 [pathToFfmpeg]
 hash = "sha1-fafc50f1db0f720fe83a96cd70a9e1ad824e96b6"
 other = "FFmpeg жол:"
@@ -306,46 +142,6 @@ other = "FFmpeg жол:"
 hash = "sha1-b872edc9633a2e81ef678dc46fe46a7e91732024"
 other = "FFprobe жол:"
 
-[preset_fast]
-hash = "sha1-935e1ac9d3c8ba4478326c909ba66662acb0540e"
-other = "fast («faster» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_faster]
-hash = "sha1-98620b73c896440c39ea6ec4b9b19d41301c9a7e"
-other = "faster («veryfast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_medium]
-hash = "sha1-f7d1c30135c22c2f07c247075c0df103bb3c3ea5"
-other = "medium («fast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_placebo]
-hash = "sha1-7bcff099104bb192881139e6404981bd426b3f91"
-other = "placebo (ұсынылмайды)"
-
-[preset_slow]
-hash = "sha1-681bf587275a45b48af49bb2ad8f0947919530e7"
-other = "slow («medium» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_slower]
-hash = "sha1-d1c692ee2b7643ae2c71a48bea880327a3c6b1e3"
-other = "slower («slow» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_superfast]
-hash = "sha1-41c39959e8f1547cc9259a5b459c4ccbf368cc23"
-other = "superfast («ultrafast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_ultrafast]
-hash = "sha1-dfed981573ac2046832f9a9450bc9388958753fa"
-other = "ultrafast (жылдам, бірақ файлдың салмағы көп болады)"
-
-[preset_veryfast]
-hash = "sha1-370b82509887d02d7a2ef9b110df4616b16123ce"
-other = "veryfast («superfast» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
-[preset_veryslow]
-hash = "sha1-d428bfa6deea9dd5c7c1f80ceba24e123ae96d0d"
-other = "veryslow («slower» қарағанда баяуырақ, бірақ файлдың салмағы аз болады)"
-
 [programmLink]
 hash = "sha1-18f9a3fad6aacefe1b05eed23122800b391ff5ca"
 other = "Жобаның веб-сайты"
@@ -362,18 +158,10 @@ other = "Кезек"
 hash = "sha1-4864057d626a868fa60f999bed3191d61d045ddc"
 other = "Сақтау"
 
-[selectEncoder]
-hash = "sha1-88f3670b09758a3336057520a215058d61006abd"
-other = "Кодировщик:"
-
 [selectFFPathTitle]
 hash = "sha1-95581446a28d968ff1a027c623159a7eb08654cf"
 other = "FFmpeg және FFprobe жолын көрсетіңіз"
 
-[selectFormat]
-hash = "sha1-f3809b0b48886570cd4cf1d7099de6da5b6d4524"
-other = "Файл кеңейтімі:"
-
 [settings]
 hash = "sha1-7f17c7c62a7fd8d1a508481f4778688927734c2f"
 other = "Параметрлер"
@@ -386,14 +174,10 @@ other = "FFmpeg функционалдығы тексерілуде..."
 hash = "sha1-92df86371f6c3a06ca1e4754f113142776a32d49"
 other = "Сіз оны осы жерден жүктей аласыз"
 
-[total]
-hash = "sha1-3b5143902e0c5c84459aedf918e17604d9735b94"
-other = "Барлығы"
-
 [unzipRun]
 hash = "sha1-c554dad13026668a1f6adf3171837c5d51bbac36"
 other = "Орамнан шығарылуда..."
 
-[waitingQueue]
+[waiting]
 hash = "sha1-307429dd84150877080c4bbff2b340d1e7dadff2"
 other = "Күту"

languages/active.ru.toml

@@ -2,54 +2,18 @@ AlsoUsedProgram = "Также в программе используется:"
 about = "О программе"
 aboutText = "Простенький интерфейс для консольной утилиты FFmpeg. \nНо я не являюсь автором самой утилиты FFmpeg."
 buttonDownloadFFmpeg = "Скачать автоматически FFmpeg"
-buttonForSelectedDirTitle = "Сохранить в папку:"
+buttonForSelectedDirTitle = "Папка куда будет сохраняться:"
 cancel = "Отмена"
 changeFFPath = "FFmpeg и FFprobe"
 changeLanguage = "Поменять язык"
 checkboxOverwriteOutputFilesTitle = "Разрешить перезаписать файл"
 choose = "выбрать"
-completedQueue = "Готово"
+completed = "Готово"
 converterVideoFilesSubmitTitle = "Конвертировать"
-converterVideoFilesTitle = "Конвертер видео, аудио и картинок"
+converterVideoFilesTitle = "Конвертор видео файлов в mp4"
 download = "Скачать"
 downloadFFmpegFromSite = "Будет скачано с сайта:"
 downloadRun = "Скачивается..."
-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 = "не смогли отконвертировать видео"
 errorDatabase = "не смогли создать файл 'database' в папке 'data'"
@@ -57,44 +21,26 @@ errorFFmpeg = "это не FFmpeg"
 errorFFmpegVersion = "Не смогли определить версию FFmpeg"
 errorFFprobe = "это не FFprobe"
 errorFFprobeVersion = "Не смогли определить версию FFprobe"
-errorQueue = "Ошибка"
+errorSelectedFolderSave = "Не выбрали папку для сохранения!"
-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 = "Файл:"
+fileVideoForConversionTitle = "Файл для ковертации:"
-formPreset = "Предустановка"
 help = "Справка"
-inProgressQueue = "Выполняется"
+inProgress = "Выполняется"
 languageSelectionFormHead = "Переключить язык"
 languageSelectionHead = "Выберите язык"
 licenseLink = "Сведения о лицензии"
 licenseLinkOther = "Лицензии от других продуктов, которые используются в программе"
-parameterCheckbox = "Включить параметр"
 pathToFfmpeg = "Путь к FFmpeg:"
 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 на работоспособность..."
 titleDownloadLink = "Скачать можно от сюда"
-total = "Всего"
 unzipRun = "Распаковывается..."
-waitingQueue = "В очереди"
+waiting = "В очереди"

languages/translate.en.toml

@@ -0,0 +1,15 @@
+[completed]
+hash = "sha1-398c7d4f7b0d522afb930769c0fbb1a9f4b61fbe"
+other = "Completed"
+
+[inProgress]
+hash = "sha1-eff79c40e2100ae5fadf3a7d99336025edcca8b5"
+other = "In Progress"
+
+[queue]
+hash = "sha1-aec93b16baeaf55fed871075c9494a460e4a91b8"
+other = "Queue"
+
+[waiting]
+hash = "sha1-307429dd84150877080c4bbff2b340d1e7dadff2"
+other = "Waiting"

languages/translate.kk.toml

@@ -0,0 +1,15 @@
+[completed]
+hash = "sha1-398c7d4f7b0d522afb930769c0fbb1a9f4b61fbe"
+other = "Дайын"
+
+[inProgress]
+hash = "sha1-eff79c40e2100ae5fadf3a7d99336025edcca8b5"
+other = "Орындалуда"
+
+[queue]
+hash = "sha1-aec93b16baeaf55fed871075c9494a460e4a91b8"
+other = "Кезек"
+
+[waiting]
+hash = "sha1-307429dd84150877080c4bbff2b340d1e7dadff2"
+other = "Күту"

main.go

@@ -26,7 +26,7 @@ func init() {
 	appMetadata := &fyne.AppMetadata{
 		ID:      "net.kor-elf.projects.gui-for-ffmpeg",
 		Name:    "GUI for FFmpeg",
-		Version: "0.7.0",
+		Version: "0.4.0",
 		Icon:    iconResource,
 	}
 
@@ -37,13 +37,15 @@ func init() {
 
 	ffPathUtilities = &kernel.FFPathUtilities{FFmpeg: "", FFprobe: ""}
 	convertorService := kernel.NewService(ffPathUtilities)
+	layoutLocalizerListener := kernel.NewLayoutLocalizerListener()
+	localizerService.AddListener(layoutLocalizerListener)
 
 	queue := kernel.NewQueueList()
 	application = kernel.NewApp(
 		appMetadata,
 		localizerService,
 		queue,
-		kernel.NewQueueLayoutObject(queue, localizerService),
+		kernel.NewQueueLayoutObject(queue, localizerService, layoutLocalizerListener),
 		convertorService,
 	)
 }
@@ -95,11 +97,13 @@ func main() {
 
 	localizerView := localizer.NewView(application)
 	convertorView := convertor.NewView(application)
-	convertorHandler := handler.NewConvertorHandler(application, convertorView, errorView, convertorRepository)
+	convertorHandler := handler.NewConvertorHandler(application, convertorView, convertorRepository)
 
 	localizerRepository := localizer.NewRepository(settingRepository)
 	menuView := menu.NewView(application)
-	mainMenu := handler.NewMenuHandler(application, convertorHandler, menuView, localizerView, localizerRepository)
+	localizerListener := handler.NewLocalizerListener()
+	application.GetLocalizerService().AddListener(localizerListener)
+	mainMenu := handler.NewMenuHandler(application, convertorHandler, menuView, localizerView, localizerRepository, localizerListener)
 
 	mainHandler := handler.NewMainHandler(application, convertorHandler, mainMenu, localizerRepository)
 	mainHandler.Start()