13061183842

Committed 30 Jan 2025 09:03PM UTC coverage: 60.871% (+1.8%) from 59.117%

Build # 13061183842

Build Type

Pull #5431

github

Committed by

dweymouth

Commit Message

update mobile driver too

Pull Request Pull Request #5431: Add new callback-based settings listener API

Run Details

22 of 52 new or added lines in 6 files covered. (42.31%)

524 existing lines in 25 files now uncovered.

25009 of 41085 relevant lines covered (60.87%)

817.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

9.52

/data/binding/bindlists.go

// auto-generated
// **** THIS FILE IS AUTO-GENERATED, PLEASE DO NOT EDIT IT **** //

package binding

import (
        "bytes"

        "fyne.io/fyne/v2"
)

// BoolList supports binding a list of bool values.
//
// Since: 2.0
type BoolList interface {
        DataList

        Append(value bool) error
        Get() ([]bool, error)
        GetValue(index int) (bool, error)
        Prepend(value bool) error
        Remove(value bool) error
        Set(list []bool) error
        SetValue(index int, value bool) error
}

// ExternalBoolList supports binding a list of bool values from an external variable.
//
// Since: 2.0
type ExternalBoolList interface {
        BoolList

        Reload() error
}

// NewBoolList returns a bindable list of bool values.
//
// Since: 2.0
func NewBoolList() BoolList {
        return &boundBoolList{val: &[]bool{}}
}

// BindBoolList returns a bound list of bool values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.0
func BindBoolList(v *[]bool) ExternalBoolList {
        if v == nil {
                return NewBoolList().(ExternalBoolList)
        }

        b := &boundBoolList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindBoolListItem(v, i, b.updateExternal))
        }

        return b
}

type boundBoolList struct {
        listBase

        updateExternal bool
        val            *[]bool
}

func (l *boundBoolList) Append(val bool) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBoolList) Get() ([]bool, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundBoolList) GetValue(i int) (bool, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return false, errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundBoolList) Prepend(val bool) error {
        l.lock.Lock()
        *l.val = append([]bool{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBoolList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified bool out of the list.
//
// Since: 2.5
func (l *boundBoolList) Remove(val bool) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if v[0] == val {
                *l.val = v[1:]
        } else if v[len(v)-1] == val {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if v == val {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBoolList) Set(v []bool) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBoolList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindBoolListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalBoolListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundBoolListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundBoolList) SetValue(i int, v bool) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(Bool).Set(v)
}

func bindBoolListItem(v *[]bool, i int, external bool) Bool {
        if external {
                ret := &boundExternalBoolListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundBoolListItem{val: v, index: i}
}

type boundBoolListItem struct {
        base

        val   *[]bool
        index int
}

func (b *boundBoolListItem) Get() (bool, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return false, errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundBoolListItem) Set(val bool) error {
        return b.doSet(val)
}

func (b *boundBoolListItem) doSet(val bool) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalBoolListItem struct {
        boundBoolListItem

        old bool
}

func (b *boundExternalBoolListItem) setIfChanged(val bool) error {
        b.lock.Lock()
        if val == b.old {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// BytesList supports binding a list of []byte values.
//
// Since: 2.2
type BytesList interface {
        DataList

        Append(value []byte) error
        Get() ([][]byte, error)
        GetValue(index int) ([]byte, error)
        Prepend(value []byte) error
        Remove(value []byte) error
        Set(list [][]byte) error
        SetValue(index int, value []byte) error
}

// ExternalBytesList supports binding a list of []byte values from an external variable.
//
// Since: 2.2
type ExternalBytesList interface {
        BytesList

        Reload() error
}

// NewBytesList returns a bindable list of []byte values.
//
// Since: 2.2
func NewBytesList() BytesList {
        return &boundBytesList{val: &[][]byte{}}
}

// BindBytesList returns a bound list of []byte values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.2
func BindBytesList(v *[][]byte) ExternalBytesList {
        if v == nil {
                return NewBytesList().(ExternalBytesList)
        }

        b := &boundBytesList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindBytesListItem(v, i, b.updateExternal))
        }

        return b
}

type boundBytesList struct {
        listBase

        updateExternal bool
        val            *[][]byte
}

func (l *boundBytesList) Append(val []byte) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBytesList) Get() ([][]byte, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundBytesList) GetValue(i int) ([]byte, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return nil, errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundBytesList) Prepend(val []byte) error {
        l.lock.Lock()
        *l.val = append([][]byte{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBytesList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified []byte out of the list.
//
// Since: 2.5
func (l *boundBytesList) Remove(val []byte) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if bytes.Equal(v[0], val) {
                *l.val = v[1:]
        } else if bytes.Equal(v[len(v)-1], val) {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if bytes.Equal(v, val) {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBytesList) Set(v [][]byte) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundBytesList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindBytesListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalBytesListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundBytesListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundBytesList) SetValue(i int, v []byte) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(Bytes).Set(v)
}

func bindBytesListItem(v *[][]byte, i int, external bool) Bytes {
        if external {
                ret := &boundExternalBytesListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundBytesListItem{val: v, index: i}
}

type boundBytesListItem struct {
        base

        val   *[][]byte
        index int
}

func (b *boundBytesListItem) Get() ([]byte, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return nil, errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundBytesListItem) Set(val []byte) error {
        return b.doSet(val)
}

func (b *boundBytesListItem) doSet(val []byte) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalBytesListItem struct {
        boundBytesListItem

        old []byte
}

func (b *boundExternalBytesListItem) setIfChanged(val []byte) error {
        b.lock.Lock()
        if bytes.Equal(val, b.old) {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// FloatList supports binding a list of float64 values.
//
// Since: 2.0
type FloatList interface {
        DataList

        Append(value float64) error
        Get() ([]float64, error)
        GetValue(index int) (float64, error)
        Prepend(value float64) error
        Remove(value float64) error
        Set(list []float64) error
        SetValue(index int, value float64) error
}

// ExternalFloatList supports binding a list of float64 values from an external variable.
//
// Since: 2.0
type ExternalFloatList interface {
        FloatList

        Reload() error
}

// NewFloatList returns a bindable list of float64 values.
//
// Since: 2.0
func NewFloatList() FloatList {
        return &boundFloatList{val: &[]float64{}}
}

// BindFloatList returns a bound list of float64 values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.0
func BindFloatList(v *[]float64) ExternalFloatList {
        if v == nil {
                return NewFloatList().(ExternalFloatList)
        }

        b := &boundFloatList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindFloatListItem(v, i, b.updateExternal))
        }

        return b
}

type boundFloatList struct {
        listBase

        updateExternal bool
        val            *[]float64
}

func (l *boundFloatList) Append(val float64) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundFloatList) Get() ([]float64, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundFloatList) GetValue(i int) (float64, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return 0.0, errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundFloatList) Prepend(val float64) error {
        l.lock.Lock()
        *l.val = append([]float64{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundFloatList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified float64 out of the list.
//
// Since: 2.5
func (l *boundFloatList) Remove(val float64) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if v[0] == val {
                *l.val = v[1:]
        } else if v[len(v)-1] == val {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if v == val {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundFloatList) Set(v []float64) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundFloatList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindFloatListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalFloatListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundFloatListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundFloatList) SetValue(i int, v float64) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(Float).Set(v)
}

func bindFloatListItem(v *[]float64, i int, external bool) Float {
        if external {
                ret := &boundExternalFloatListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundFloatListItem{val: v, index: i}
}

type boundFloatListItem struct {
        base

        val   *[]float64
        index int
}

func (b *boundFloatListItem) Get() (float64, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return 0.0, errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundFloatListItem) Set(val float64) error {
        return b.doSet(val)
}

func (b *boundFloatListItem) doSet(val float64) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalFloatListItem struct {
        boundFloatListItem

        old float64
}

func (b *boundExternalFloatListItem) setIfChanged(val float64) error {
        b.lock.Lock()
        if val == b.old {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// IntList supports binding a list of int values.
//
// Since: 2.0
type IntList interface {
        DataList

        Append(value int) error
        Get() ([]int, error)
        GetValue(index int) (int, error)
        Prepend(value int) error
        Remove(value int) error
        Set(list []int) error
        SetValue(index int, value int) error
}

// ExternalIntList supports binding a list of int values from an external variable.
//
// Since: 2.0
type ExternalIntList interface {
        IntList

        Reload() error
}

// NewIntList returns a bindable list of int values.
//
// Since: 2.0
func NewIntList() IntList {
        return &boundIntList{val: &[]int{}}
}

// BindIntList returns a bound list of int values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.0
func BindIntList(v *[]int) ExternalIntList {
        if v == nil {
                return NewIntList().(ExternalIntList)
        }

        b := &boundIntList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindIntListItem(v, i, b.updateExternal))
        }

        return b
}

type boundIntList struct {
        listBase

        updateExternal bool
        val            *[]int
}

func (l *boundIntList) Append(val int) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundIntList) Get() ([]int, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundIntList) GetValue(i int) (int, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return 0, errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundIntList) Prepend(val int) error {
        l.lock.Lock()
        *l.val = append([]int{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundIntList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified int out of the list.
//
// Since: 2.5
func (l *boundIntList) Remove(val int) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if v[0] == val {
                *l.val = v[1:]
        } else if v[len(v)-1] == val {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if v == val {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundIntList) Set(v []int) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundIntList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindIntListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalIntListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundIntListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundIntList) SetValue(i int, v int) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(Int).Set(v)
}

func bindIntListItem(v *[]int, i int, external bool) Int {
        if external {
                ret := &boundExternalIntListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundIntListItem{val: v, index: i}
}

type boundIntListItem struct {
        base

        val   *[]int
        index int
}

func (b *boundIntListItem) Get() (int, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return 0, errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundIntListItem) Set(val int) error {
        return b.doSet(val)
}

func (b *boundIntListItem) doSet(val int) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalIntListItem struct {
        boundIntListItem

        old int
}

func (b *boundExternalIntListItem) setIfChanged(val int) error {
        b.lock.Lock()
        if val == b.old {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// RuneList supports binding a list of rune values.
//
// Since: 2.0
type RuneList interface {
        DataList

        Append(value rune) error
        Get() ([]rune, error)
        GetValue(index int) (rune, error)
        Prepend(value rune) error
        Remove(value rune) error
        Set(list []rune) error
        SetValue(index int, value rune) error
}

// ExternalRuneList supports binding a list of rune values from an external variable.
//
// Since: 2.0
type ExternalRuneList interface {
        RuneList

        Reload() error
}

// NewRuneList returns a bindable list of rune values.
//
// Since: 2.0
func NewRuneList() RuneList {
        return &boundRuneList{val: &[]rune{}}
}

// BindRuneList returns a bound list of rune values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.0
func BindRuneList(v *[]rune) ExternalRuneList {
        if v == nil {
                return NewRuneList().(ExternalRuneList)
        }

        b := &boundRuneList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindRuneListItem(v, i, b.updateExternal))
        }

        return b
}

type boundRuneList struct {
        listBase

        updateExternal bool
        val            *[]rune
}

func (l *boundRuneList) Append(val rune) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundRuneList) Get() ([]rune, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundRuneList) GetValue(i int) (rune, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return rune(0), errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundRuneList) Prepend(val rune) error {
        l.lock.Lock()
        *l.val = append([]rune{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundRuneList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified rune out of the list.
//
// Since: 2.5
func (l *boundRuneList) Remove(val rune) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if v[0] == val {
                *l.val = v[1:]
        } else if v[len(v)-1] == val {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if v == val {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundRuneList) Set(v []rune) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundRuneList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindRuneListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalRuneListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundRuneListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundRuneList) SetValue(i int, v rune) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(Rune).Set(v)
}

func bindRuneListItem(v *[]rune, i int, external bool) Rune {
        if external {
                ret := &boundExternalRuneListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundRuneListItem{val: v, index: i}
}

type boundRuneListItem struct {
        base

        val   *[]rune
        index int
}

func (b *boundRuneListItem) Get() (rune, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return rune(0), errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundRuneListItem) Set(val rune) error {
        return b.doSet(val)
}

func (b *boundRuneListItem) doSet(val rune) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalRuneListItem struct {
        boundRuneListItem

        old rune
}

func (b *boundExternalRuneListItem) setIfChanged(val rune) error {
        b.lock.Lock()
        if val == b.old {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// StringList supports binding a list of string values.
//
// Since: 2.0
type StringList interface {
        DataList

        Append(value string) error
        Get() ([]string, error)
        GetValue(index int) (string, error)
        Prepend(value string) error
        Remove(value string) error
        Set(list []string) error
        SetValue(index int, value string) error
}

// ExternalStringList supports binding a list of string values from an external variable.
//
// Since: 2.0
type ExternalStringList interface {
        StringList

        Reload() error
}

// NewStringList returns a bindable list of string values.
//
// Since: 2.0
func NewStringList() StringList {
        return &boundStringList{val: &[]string{}}
}

// BindStringList returns a bound list of string values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.0
func BindStringList(v *[]string) ExternalStringList {
        if v == nil {
                return NewStringList().(ExternalStringList)
        }

        b := &boundStringList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindStringListItem(v, i, b.updateExternal))
        }

        return b
}

type boundStringList struct {
        listBase

        updateExternal bool
        val            *[]string
}

func (l *boundStringList) Append(val string) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundStringList) Get() ([]string, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundStringList) GetValue(i int) (string, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return "", errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundStringList) Prepend(val string) error {
        l.lock.Lock()
        *l.val = append([]string{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundStringList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified string out of the list.
//
// Since: 2.5
func (l *boundStringList) Remove(val string) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if v[0] == val {
                *l.val = v[1:]
        } else if v[len(v)-1] == val {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if v == val {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundStringList) Set(v []string) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundStringList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindStringListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalStringListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundStringListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundStringList) SetValue(i int, v string) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(String).Set(v)
}

func bindStringListItem(v *[]string, i int, external bool) String {
        if external {
                ret := &boundExternalStringListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundStringListItem{val: v, index: i}
}

type boundStringListItem struct {
        base

        val   *[]string
        index int
}

func (b *boundStringListItem) Get() (string, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return "", errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundStringListItem) Set(val string) error {
        return b.doSet(val)
}

func (b *boundStringListItem) doSet(val string) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalStringListItem struct {
        boundStringListItem

        old string
}

func (b *boundExternalStringListItem) setIfChanged(val string) error {
        b.lock.Lock()
        if val == b.old {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// UntypedList supports binding a list of any values.
//
// Since: 2.1
type UntypedList interface {
        DataList

        Append(value any) error
        Get() ([]any, error)
        GetValue(index int) (any, error)
        Prepend(value any) error
        Remove(value any) error
        Set(list []any) error
        SetValue(index int, value any) error
}

// ExternalUntypedList supports binding a list of any values from an external variable.
//
// Since: 2.1
type ExternalUntypedList interface {
        UntypedList

        Reload() error
}

// NewUntypedList returns a bindable list of any values.
//
// Since: 2.1
func NewUntypedList() UntypedList {
        return &boundUntypedList{val: &[]any{}}
}

// BindUntypedList returns a bound list of any values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.1
func BindUntypedList(v *[]any) ExternalUntypedList {
        if v == nil {
                return NewUntypedList().(ExternalUntypedList)
        }

        b := &boundUntypedList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindUntypedListItem(v, i, b.updateExternal))
        }

        return b
}

type boundUntypedList struct {
        listBase

        updateExternal bool
        val            *[]any
}

func (l *boundUntypedList) Append(val any) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundUntypedList) Get() ([]any, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundUntypedList) GetValue(i int) (any, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return nil, errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundUntypedList) Prepend(val any) error {
        l.lock.Lock()
        *l.val = append([]any{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundUntypedList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified any out of the list.
//
// Since: 2.5
func (l *boundUntypedList) Remove(val any) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if v[0] == val {
                *l.val = v[1:]
        } else if v[len(v)-1] == val {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if v == val {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundUntypedList) Set(v []any) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundUntypedList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindUntypedListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalUntypedListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundUntypedListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundUntypedList) SetValue(i int, v any) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(Untyped).Set(v)
}

func bindUntypedListItem(v *[]any, i int, external bool) Untyped {
        if external {
                ret := &boundExternalUntypedListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundUntypedListItem{val: v, index: i}
}

type boundUntypedListItem struct {
        base

        val   *[]any
        index int
}

func (b *boundUntypedListItem) Get() (any, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return nil, errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundUntypedListItem) Set(val any) error {
        return b.doSet(val)
}

func (b *boundUntypedListItem) doSet(val any) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalUntypedListItem struct {
        boundUntypedListItem

        old any
}

func (b *boundExternalUntypedListItem) setIfChanged(val any) error {
        b.lock.Lock()
        if val == b.old {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

// URIList supports binding a list of fyne.URI values.
//
// Since: 2.1
type URIList interface {
        DataList

        Append(value fyne.URI) error
        Get() ([]fyne.URI, error)
        GetValue(index int) (fyne.URI, error)
        Prepend(value fyne.URI) error
        Remove(value fyne.URI) error
        Set(list []fyne.URI) error
        SetValue(index int, value fyne.URI) error
}

// ExternalURIList supports binding a list of fyne.URI values from an external variable.
//
// Since: 2.1
type ExternalURIList interface {
        URIList

        Reload() error
}

// NewURIList returns a bindable list of fyne.URI values.
//
// Since: 2.1
func NewURIList() URIList {
        return &boundURIList{val: &[]fyne.URI{}}
}

// BindURIList returns a bound list of fyne.URI values, based on the contents of the passed slice.
// If your code changes the content of the slice this refers to you should call Reload() to inform the bindings.
//
// Since: 2.1
func BindURIList(v *[]fyne.URI) ExternalURIList {
        if v == nil {
                return NewURIList().(ExternalURIList)
        }

        b := &boundURIList{val: v, updateExternal: true}

        for i := range *v {
                b.appendItem(bindURIListItem(v, i, b.updateExternal))
        }

        return b
}

type boundURIList struct {
        listBase

        updateExternal bool
        val            *[]fyne.URI
}

func (l *boundURIList) Append(val fyne.URI) error {
        l.lock.Lock()
        *l.val = append(*l.val, val)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundURIList) Get() ([]fyne.URI, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        return *l.val, nil
}

func (l *boundURIList) GetValue(i int) (fyne.URI, error) {
        l.lock.RLock()
        defer l.lock.RUnlock()

        if i < 0 || i >= l.Length() {
                return fyne.URI(nil), errOutOfBounds
        }

        return (*l.val)[i], nil
}

func (l *boundURIList) Prepend(val fyne.URI) error {
        l.lock.Lock()
        *l.val = append([]fyne.URI{val}, *l.val...)

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundURIList) Reload() error {
        l.lock.Lock()
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

// Remove takes the specified fyne.URI out of the list.
//
// Since: 2.5
func (l *boundURIList) Remove(val fyne.URI) error {
        l.lock.Lock()

        v := *l.val
        if len(v) == 0 {
                l.lock.Unlock()
                return nil
        }
        if compareURI(v[0], val) {
                *l.val = v[1:]
        } else if compareURI(v[len(v)-1], val) {
                *l.val = v[:len(v)-1]
        } else {
                id := -1
                for i, v := range v {
                        if compareURI(v, val) {
                                id = i
                                break
                        }
                }

                if id == -1 {
                        l.lock.Unlock()
                        return nil
                }
                *l.val = append(v[:id], v[id+1:]...)
        }

        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundURIList) Set(v []fyne.URI) error {
        l.lock.Lock()
        *l.val = v
        trigger, err := l.doReload()
        l.lock.Unlock()

        if trigger {
                l.trigger()
        }

        return err
}

func (l *boundURIList) doReload() (trigger bool, retErr error) {
        oldLen := len(l.items)
        newLen := len(*l.val)
        if oldLen > newLen {
                for i := oldLen - 1; i >= newLen; i-- {
                        l.deleteItem(i)
                }
                trigger = true
        } else if oldLen < newLen {
                for i := oldLen; i < newLen; i++ {
                        l.appendItem(bindURIListItem(l.val, i, l.updateExternal))
                }
                trigger = true
        }

        for i, item := range l.items {
                if i > oldLen || i > newLen {
                        break
                }

                var err error
                if l.updateExternal {
                        err = item.(*boundExternalURIListItem).setIfChanged((*l.val)[i])
                } else {
                        err = item.(*boundURIListItem).doSet((*l.val)[i])
                }
                if err != nil {
                        retErr = err
                }
        }
        return
}

func (l *boundURIList) SetValue(i int, v fyne.URI) error {
        l.lock.RLock()
        len := l.Length()
        l.lock.RUnlock()

        if i < 0 || i >= len {
                return errOutOfBounds
        }

        l.lock.Lock()
        (*l.val)[i] = v
        l.lock.Unlock()

        item, err := l.GetItem(i)
        if err != nil {
                return err
        }
        return item.(URI).Set(v)
}

func bindURIListItem(v *[]fyne.URI, i int, external bool) URI {
        if external {
                ret := &boundExternalURIListItem{old: (*v)[i]}
                ret.val = v
                ret.index = i
                return ret
        }

        return &boundURIListItem{val: v, index: i}
}

type boundURIListItem struct {
        base

        val   *[]fyne.URI
        index int
}

func (b *boundURIListItem) Get() (fyne.URI, error) {
        b.lock.Lock()
        defer b.lock.Unlock()

        if b.index < 0 || b.index >= len(*b.val) {
                return fyne.URI(nil), errOutOfBounds
        }

        return (*b.val)[b.index], nil
}

func (b *boundURIListItem) Set(val fyne.URI) error {
        return b.doSet(val)
}

func (b *boundURIListItem) doSet(val fyne.URI) error {
        b.lock.Lock()
        (*b.val)[b.index] = val
        b.lock.Unlock()

        b.trigger()
        return nil
}

type boundExternalURIListItem struct {
        boundURIListItem

        old fyne.URI
}

func (b *boundExternalURIListItem) setIfChanged(val fyne.URI) error {
        b.lock.Lock()
        if compareURI(val, b.old) {
                b.lock.Unlock()
                return nil
        }
        (*b.val)[b.index] = val
        b.old = val

        b.lock.Unlock()
        b.trigger()
        return nil
}

fyne-io / fyne / 13061183842

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous