Stu Leak
68df790d27
Major improvements to UnifiedPlayer: 1. GetFrameImage() now works when paused for responsive UI updates 2. Play() method properly starts FFmpeg process 3. Frame display loop runs continuously for smooth video display 4. Disabled audio temporarily to fix video playback fundamentals 5. Simplified FFmpeg command to focus on video stream only Player now: - Generates video frames correctly - Shows video when paused - Has responsive progress tracking - Starts playback properly Next steps: Re-enable audio playback once video is stable
498 lines
13 KiB
Go
498 lines
13 KiB
Go
package widget
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
|
|
"fyne.io/fyne/v2"
|
|
"fyne.io/fyne/v2/canvas"
|
|
"fyne.io/fyne/v2/internal/cache"
|
|
"fyne.io/fyne/v2/layout"
|
|
"fyne.io/fyne/v2/theme"
|
|
)
|
|
|
|
// errFormItemInitialState defines the error if the initial validation for a FormItem result
|
|
// in an error
|
|
var errFormItemInitialState = errors.New("widget.FormItem initial state error")
|
|
|
|
// FormItem provides the details for a row in a form
|
|
type FormItem struct {
|
|
Text string
|
|
Widget fyne.CanvasObject
|
|
|
|
// Since: 2.0
|
|
HintText string
|
|
|
|
validationError error
|
|
invalid bool
|
|
helperOutput *canvas.Text
|
|
wasFocused bool
|
|
}
|
|
|
|
// NewFormItem creates a new form item with the specified label text and input widget
|
|
func NewFormItem(text string, widget fyne.CanvasObject) *FormItem {
|
|
return &FormItem{Text: text, Widget: widget}
|
|
}
|
|
|
|
var _ fyne.Validatable = (*Form)(nil)
|
|
|
|
// Form widget is two column grid where each row has a label and a widget (usually an input).
|
|
// The last row of the grid will contain the appropriate form control buttons if any should be shown.
|
|
// Setting OnSubmit will set the submit button to be visible and call back the function when tapped.
|
|
// Setting OnCancel will do the same for a cancel button.
|
|
// If you change OnSubmit/OnCancel after the form is created and rendered, you need to call
|
|
// Refresh() to update the form with the correct buttons.
|
|
// Setting OnSubmit/OnCancel to nil will remove the buttons.
|
|
type Form struct {
|
|
BaseWidget
|
|
|
|
Items []*FormItem
|
|
OnSubmit func() `json:"-"`
|
|
OnCancel func() `json:"-"`
|
|
SubmitText string
|
|
CancelText string
|
|
|
|
// Orientation allows a form to be vertical (a single column), horizontal (default, label then input)
|
|
// or to adapt according to the orientation of the mobile device (adaptive).
|
|
//
|
|
// Since: 2.5
|
|
Orientation Orientation
|
|
|
|
itemGrid *fyne.Container
|
|
buttonBox *fyne.Container
|
|
cancelButton *Button
|
|
submitButton *Button
|
|
|
|
disabled bool
|
|
|
|
onValidationChanged func(error)
|
|
validationError error
|
|
}
|
|
|
|
// Append adds a new row to the form, using the text as a label next to the specified Widget
|
|
func (f *Form) Append(text string, widget fyne.CanvasObject) {
|
|
item := &FormItem{Text: text, Widget: widget}
|
|
f.AppendItem(item)
|
|
}
|
|
|
|
// AppendItem adds the specified row to the end of the Form
|
|
func (f *Form) AppendItem(item *FormItem) {
|
|
f.ExtendBaseWidget(f) // could be called before render
|
|
|
|
f.Items = append(f.Items, item)
|
|
if f.itemGrid != nil {
|
|
f.itemGrid.Add(f.createLabel(item.Text))
|
|
f.itemGrid.Add(f.createInput(item))
|
|
f.setUpValidation(item.Widget, len(f.Items)-1)
|
|
}
|
|
|
|
f.Refresh()
|
|
}
|
|
|
|
// MinSize returns the size that this widget should not shrink below
|
|
func (f *Form) MinSize() fyne.Size {
|
|
f.ExtendBaseWidget(f)
|
|
return f.BaseWidget.MinSize()
|
|
}
|
|
|
|
// Refresh updates the widget state when requested.
|
|
func (f *Form) Refresh() {
|
|
f.ExtendBaseWidget(f)
|
|
cache.Renderer(f.super()) // we are about to make changes to renderer created content... not great!
|
|
f.ensureRenderItems()
|
|
f.updateButtons()
|
|
f.updateLabels()
|
|
|
|
if f.isVertical() {
|
|
f.itemGrid.Layout = layout.NewVBoxLayout()
|
|
} else {
|
|
f.itemGrid.Layout = layout.NewFormLayout()
|
|
}
|
|
|
|
f.BaseWidget.Refresh()
|
|
canvas.Refresh(f.super()) // refresh ourselves for BG color - the above updates the content
|
|
}
|
|
|
|
// Enable enables submitting this form.
|
|
//
|
|
// Since: 2.1
|
|
func (f *Form) Enable() {
|
|
f.disabled = false
|
|
f.cancelButton.Enable()
|
|
f.checkValidation(nil) // as the form may be invalid
|
|
}
|
|
|
|
// Disable disables submitting this form.
|
|
//
|
|
// Since: 2.1
|
|
func (f *Form) Disable() {
|
|
f.disabled = true
|
|
f.submitButton.Disable()
|
|
f.cancelButton.Disable()
|
|
}
|
|
|
|
// Disabled returns whether submitting the form is disabled.
|
|
// Note that, if the form fails validation, the submit button may be
|
|
// disabled even if this method returns true.
|
|
//
|
|
// Since: 2.1
|
|
func (f *Form) Disabled() bool {
|
|
return f.disabled
|
|
}
|
|
|
|
// SetOnValidationChanged is intended for parent widgets or containers to hook into the validation.
|
|
// The function might be overwritten by a parent that cares about child validation (e.g. widget.Form)
|
|
func (f *Form) SetOnValidationChanged(callback func(error)) {
|
|
f.onValidationChanged = callback
|
|
}
|
|
|
|
// Validate validates the entire form and returns the first error that is encountered.
|
|
func (f *Form) Validate() error {
|
|
for _, item := range f.Items {
|
|
if w, ok := item.Widget.(fyne.Validatable); ok {
|
|
if err := w.Validate(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *Form) createInput(item *FormItem) fyne.CanvasObject {
|
|
_, ok := item.Widget.(fyne.Validatable)
|
|
if item.HintText == "" {
|
|
if !ok {
|
|
return item.Widget
|
|
}
|
|
if !f.itemWidgetHasValidator(item.Widget) { // we don't have validation
|
|
return item.Widget
|
|
}
|
|
}
|
|
|
|
th := f.Theme()
|
|
v := fyne.CurrentApp().Settings().ThemeVariant()
|
|
|
|
text := canvas.NewText(item.HintText, th.Color(theme.ColorNamePlaceHolder, v))
|
|
text.TextSize = th.Size(theme.SizeNameCaptionText)
|
|
item.helperOutput = text
|
|
f.updateHelperText(item)
|
|
textContainer := &fyne.Container{Objects: []fyne.CanvasObject{text}}
|
|
return &fyne.Container{Layout: formItemLayout{form: f}, Objects: []fyne.CanvasObject{item.Widget, textContainer}}
|
|
}
|
|
|
|
func (f *Form) itemWidgetHasValidator(w fyne.CanvasObject) bool {
|
|
value := reflect.ValueOf(w).Elem()
|
|
validatorField := value.FieldByName("Validator")
|
|
if validatorField == (reflect.Value{}) {
|
|
return false
|
|
}
|
|
validator, ok := validatorField.Interface().(fyne.StringValidator)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return validator != nil
|
|
}
|
|
|
|
func (f *Form) createLabel(text string) fyne.CanvasObject {
|
|
th := f.Theme()
|
|
v := fyne.CurrentApp().Settings().ThemeVariant()
|
|
label := &canvas.Text{
|
|
Text: text,
|
|
Alignment: fyne.TextAlignTrailing,
|
|
Color: th.Color(theme.ColorNameForeground, v),
|
|
TextSize: th.Size(theme.SizeNameText),
|
|
TextStyle: fyne.TextStyle{Bold: true},
|
|
}
|
|
if f.isVertical() {
|
|
label.Alignment = fyne.TextAlignLeading
|
|
}
|
|
|
|
return &fyne.Container{Layout: &formLabelLayout{form: f}, Objects: []fyne.CanvasObject{label}}
|
|
}
|
|
|
|
func (f *Form) updateButtons() {
|
|
if f.CancelText == "" {
|
|
f.CancelText = "Cancel"
|
|
}
|
|
if f.SubmitText == "" {
|
|
f.SubmitText = "Submit"
|
|
}
|
|
|
|
// set visibility on the buttons
|
|
if f.OnCancel == nil {
|
|
f.cancelButton.Hide()
|
|
} else {
|
|
f.cancelButton.SetText(f.CancelText)
|
|
f.cancelButton.OnTapped = f.OnCancel
|
|
f.cancelButton.Show()
|
|
}
|
|
if f.OnSubmit == nil {
|
|
f.submitButton.Hide()
|
|
} else {
|
|
f.submitButton.SetText(f.SubmitText)
|
|
f.submitButton.OnTapped = f.OnSubmit
|
|
f.submitButton.Show()
|
|
}
|
|
if f.OnCancel == nil && f.OnSubmit == nil {
|
|
f.buttonBox.Hide()
|
|
} else {
|
|
f.buttonBox.Show()
|
|
}
|
|
}
|
|
|
|
func (f *Form) checkValidation(err error) {
|
|
if err != nil {
|
|
f.submitButton.Disable()
|
|
return
|
|
}
|
|
|
|
for _, item := range f.Items {
|
|
if item.invalid {
|
|
f.submitButton.Disable()
|
|
return
|
|
}
|
|
}
|
|
|
|
if !f.disabled {
|
|
f.submitButton.Enable()
|
|
}
|
|
}
|
|
|
|
func (f *Form) ensureRenderItems() {
|
|
done := len(f.itemGrid.Objects) / 2
|
|
if done >= len(f.Items) {
|
|
f.itemGrid.Objects = f.itemGrid.Objects[0 : len(f.Items)*2]
|
|
return
|
|
}
|
|
|
|
adding := len(f.Items) - done
|
|
objects := make([]fyne.CanvasObject, adding*2)
|
|
off := 0
|
|
for i, item := range f.Items {
|
|
if i < done {
|
|
continue
|
|
}
|
|
|
|
objects[off] = f.createLabel(item.Text)
|
|
off++
|
|
f.setUpValidation(item.Widget, i)
|
|
objects[off] = f.createInput(item)
|
|
off++
|
|
}
|
|
f.itemGrid.Objects = append(f.itemGrid.Objects, objects...)
|
|
}
|
|
|
|
func (f *Form) isVertical() bool {
|
|
if f.Orientation == Vertical {
|
|
return true
|
|
} else if f.Orientation == Horizontal {
|
|
return false
|
|
}
|
|
|
|
dev := fyne.CurrentDevice()
|
|
if dev.IsMobile() {
|
|
orient := dev.Orientation()
|
|
return orient == fyne.OrientationVertical || orient == fyne.OrientationVerticalUpsideDown
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (f *Form) setUpValidation(widget fyne.CanvasObject, i int) {
|
|
updateValidation := func(err error) {
|
|
if err == errFormItemInitialState {
|
|
return
|
|
}
|
|
f.Items[i].validationError = err
|
|
f.Items[i].invalid = err != nil
|
|
f.setValidationError(err)
|
|
f.checkValidation(err)
|
|
f.updateHelperText(f.Items[i])
|
|
}
|
|
if w, ok := widget.(fyne.Validatable); ok {
|
|
f.Items[i].invalid = w.Validate() != nil
|
|
if e, ok := w.(*Entry); ok {
|
|
e.onFocusChanged = func(bool) {
|
|
updateValidation(e.validationError)
|
|
}
|
|
if e.Validator != nil && f.Items[i].invalid {
|
|
// set initial state error to guarantee next error (if triggers) is always different
|
|
e.SetValidationError(errFormItemInitialState)
|
|
}
|
|
}
|
|
w.SetOnValidationChanged(updateValidation)
|
|
}
|
|
}
|
|
|
|
func (f *Form) setValidationError(err error) {
|
|
if err == nil && f.validationError == nil {
|
|
return
|
|
}
|
|
|
|
if !errors.Is(err, f.validationError) {
|
|
if err == nil {
|
|
for _, item := range f.Items {
|
|
if item.invalid {
|
|
err = item.validationError
|
|
break
|
|
}
|
|
}
|
|
}
|
|
f.validationError = err
|
|
|
|
if f.onValidationChanged != nil {
|
|
f.onValidationChanged(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (f *Form) updateHelperText(item *FormItem) {
|
|
th := f.Theme()
|
|
v := fyne.CurrentApp().Settings().ThemeVariant()
|
|
|
|
if item.helperOutput == nil {
|
|
return // testing probably, either way not rendered yet
|
|
}
|
|
showHintIfError := false
|
|
if e, ok := item.Widget.(*Entry); ok {
|
|
if !e.dirty || (e.focused && !item.wasFocused) {
|
|
showHintIfError = true
|
|
}
|
|
if e.dirty && !e.focused {
|
|
item.wasFocused = true
|
|
}
|
|
}
|
|
|
|
if item.validationError == nil || showHintIfError {
|
|
item.helperOutput.Text = item.HintText
|
|
item.helperOutput.Color = th.Color(theme.ColorNamePlaceHolder, v)
|
|
} else {
|
|
item.helperOutput.Text = item.validationError.Error()
|
|
item.helperOutput.Color = th.Color(theme.ColorNameError, v)
|
|
}
|
|
|
|
if item.helperOutput.Text == "" {
|
|
item.helperOutput.Hide()
|
|
} else {
|
|
item.helperOutput.Show()
|
|
}
|
|
item.helperOutput.Refresh()
|
|
}
|
|
|
|
func (f *Form) updateLabels() {
|
|
th := f.Theme()
|
|
v := fyne.CurrentApp().Settings().ThemeVariant()
|
|
|
|
for i, item := range f.Items {
|
|
l := f.itemGrid.Objects[i*2].(*fyne.Container).Objects[0].(*canvas.Text)
|
|
l.TextSize = th.Size(theme.SizeNameText)
|
|
if dis, ok := item.Widget.(fyne.Disableable); ok {
|
|
if dis.Disabled() {
|
|
l.Color = th.Color(theme.ColorNameDisabled, v)
|
|
} else {
|
|
l.Color = th.Color(theme.ColorNameForeground, v)
|
|
}
|
|
} else {
|
|
l.Color = th.Color(theme.ColorNameForeground, v)
|
|
}
|
|
|
|
l.Text = item.Text
|
|
if f.isVertical() {
|
|
l.Alignment = fyne.TextAlignLeading
|
|
} else {
|
|
l.Alignment = fyne.TextAlignTrailing
|
|
}
|
|
l.Refresh()
|
|
f.updateHelperText(item)
|
|
}
|
|
}
|
|
|
|
// CreateRenderer is a private method to Fyne which links this widget to its renderer
|
|
func (f *Form) CreateRenderer() fyne.WidgetRenderer {
|
|
f.ExtendBaseWidget(f)
|
|
th := f.Theme()
|
|
f.cancelButton = &Button{Icon: th.Icon(theme.IconNameCancel), OnTapped: f.OnCancel}
|
|
f.submitButton = &Button{Icon: th.Icon(theme.IconNameConfirm), OnTapped: f.OnSubmit, Importance: HighImportance}
|
|
buttons := &fyne.Container{Layout: layout.NewGridLayoutWithRows(1), Objects: []fyne.CanvasObject{f.cancelButton, f.submitButton}}
|
|
f.buttonBox = &fyne.Container{Layout: layout.NewBorderLayout(nil, nil, nil, buttons), Objects: []fyne.CanvasObject{buttons}}
|
|
f.validationError = errFormItemInitialState // set initial state error to guarantee next error (if triggers) is always different
|
|
|
|
f.itemGrid = &fyne.Container{Layout: layout.NewFormLayout()}
|
|
if f.isVertical() {
|
|
f.itemGrid.Layout = layout.NewVBoxLayout()
|
|
} else {
|
|
f.itemGrid.Layout = layout.NewFormLayout()
|
|
}
|
|
content := &fyne.Container{Layout: layout.NewVBoxLayout(), Objects: []fyne.CanvasObject{f.itemGrid, f.buttonBox}}
|
|
renderer := NewSimpleRenderer(content)
|
|
f.ensureRenderItems()
|
|
f.updateButtons()
|
|
f.updateLabels()
|
|
f.checkValidation(nil) // will trigger a validation check for correct initial validation status
|
|
return renderer
|
|
}
|
|
|
|
// NewForm creates a new form widget with the specified rows of form items
|
|
// and (if any of them should be shown) a form controls row at the bottom
|
|
func NewForm(items ...*FormItem) *Form {
|
|
form := &Form{Items: items}
|
|
form.ExtendBaseWidget(form)
|
|
|
|
return form
|
|
}
|
|
|
|
type formLabelLayout struct {
|
|
form *Form
|
|
}
|
|
|
|
func (f formLabelLayout) Layout(objs []fyne.CanvasObject, size fyne.Size) {
|
|
innerPad := f.form.Theme().Size(theme.SizeNameInnerPadding)
|
|
xPad := innerPad
|
|
yPos := float32(0)
|
|
if !f.form.isVertical() {
|
|
xPad += innerPad
|
|
yPos = innerPad
|
|
}
|
|
objs[0].Move(fyne.NewPos(innerPad, yPos))
|
|
objs[0].Resize(fyne.NewSize(size.Width-xPad, objs[0].MinSize().Height))
|
|
}
|
|
|
|
func (f formLabelLayout) MinSize(objs []fyne.CanvasObject) fyne.Size {
|
|
innerPad := f.form.Theme().Size(theme.SizeNameInnerPadding)
|
|
min0 := objs[0].MinSize()
|
|
|
|
if !f.form.isVertical() {
|
|
min0 = min0.AddWidthHeight(innerPad, 0)
|
|
}
|
|
|
|
return min0.AddWidthHeight(innerPad, 0)
|
|
}
|
|
|
|
type formItemLayout struct {
|
|
form *Form
|
|
}
|
|
|
|
func (f formItemLayout) Layout(objs []fyne.CanvasObject, size fyne.Size) {
|
|
innerPad := f.form.Theme().Size(theme.SizeNameInnerPadding)
|
|
itemHeight := objs[0].MinSize().Height
|
|
objs[0].Resize(fyne.NewSize(size.Width, itemHeight))
|
|
|
|
objs[1].Move(fyne.NewPos(innerPad, itemHeight+innerPad/2))
|
|
objs[1].Resize(fyne.NewSize(size.Width, objs[1].MinSize().Width))
|
|
}
|
|
|
|
func (f formItemLayout) MinSize(objs []fyne.CanvasObject) fyne.Size {
|
|
innerPad := f.form.Theme().Size(theme.SizeNameInnerPadding)
|
|
min0 := objs[0].MinSize()
|
|
min1 := objs[1].MinSize()
|
|
|
|
minWidth := fyne.Max(min0.Width, min1.Width)
|
|
height := min0.Height
|
|
|
|
items := objs[1].(*fyne.Container).Objects
|
|
if len(items) > 0 && items[0].(*canvas.Text).Text != "" {
|
|
height += min1.Height + innerPad
|
|
}
|
|
return fyne.NewSize(minWidth, height)
|
|
}
|