forked from mbk-lab/rui_orig
394 lines
11 KiB
Go
394 lines
11 KiB
Go
package rui
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
// FileSelectedEvent is the constant for "file-selected-event" property tag.
|
|
// The "file-selected-event" is fired when user selects file(s) in the FilePicker.
|
|
FileSelectedEvent = "file-selected-event"
|
|
// Accept is the constant for "accept" property tag.
|
|
// The "accept" property of the FilePicker sets the list of allowed file extensions or MIME types.
|
|
Accept = "accept"
|
|
// Multiple is the constant for "multiple" property tag.
|
|
// The "multiple" bool property of the FilePicker sets whether multiple files can be selected
|
|
Multiple = "multiple"
|
|
)
|
|
|
|
// FileInfo describes a file which selected in the FilePicker view
|
|
type FileInfo struct {
|
|
// Name - the file's name.
|
|
Name string
|
|
// LastModified specifying the date and time at which the file was last modified
|
|
LastModified time.Time
|
|
// Size - the size of the file in bytes.
|
|
Size int64
|
|
// MimeType - the file's MIME type.
|
|
MimeType string
|
|
}
|
|
|
|
// FilePicker - the control view for the files selecting
|
|
type FilePicker interface {
|
|
View
|
|
// Files returns the list of selected files.
|
|
// If there are no files selected then an empty slice is returned (the result is always not nil)
|
|
Files() []FileInfo
|
|
// LoadFile loads the content of the selected file. This function is asynchronous.
|
|
// The "result" function will be called after loading the data.
|
|
LoadFile(file FileInfo, result func(FileInfo, []byte))
|
|
}
|
|
|
|
type filePickerData struct {
|
|
viewData
|
|
files []FileInfo
|
|
fileSelectedListeners []func(FilePicker, []FileInfo)
|
|
loader map[int]func(FileInfo, []byte)
|
|
}
|
|
|
|
func (file *FileInfo) initBy(node DataValue) {
|
|
if obj := node.Object(); obj != nil {
|
|
file.Name, _ = obj.PropertyValue("name")
|
|
file.MimeType, _ = obj.PropertyValue("mime-type")
|
|
|
|
if size, ok := obj.PropertyValue("size"); ok {
|
|
if n, err := strconv.ParseInt(size, 10, 64); err == nil {
|
|
file.Size = n
|
|
}
|
|
}
|
|
|
|
if value, ok := obj.PropertyValue("last-modified"); ok {
|
|
if n, err := strconv.ParseInt(value, 10, 64); err == nil {
|
|
file.LastModified = time.UnixMilli(n)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// NewFilePicker create new FilePicker object and return it
|
|
func NewFilePicker(session Session, params Params) FilePicker {
|
|
view := new(filePickerData)
|
|
view.init(session)
|
|
setInitParams(view, params)
|
|
return view
|
|
}
|
|
|
|
func newFilePicker(session Session) View {
|
|
return NewFilePicker(session, nil)
|
|
}
|
|
|
|
func (picker *filePickerData) init(session Session) {
|
|
picker.viewData.init(session)
|
|
picker.tag = "FilePicker"
|
|
picker.files = []FileInfo{}
|
|
picker.loader = map[int]func(FileInfo, []byte){}
|
|
picker.fileSelectedListeners = []func(FilePicker, []FileInfo){}
|
|
}
|
|
|
|
func (picker *filePickerData) String() string {
|
|
return getViewString(picker)
|
|
}
|
|
|
|
func (picker *filePickerData) Focusable() bool {
|
|
return true
|
|
}
|
|
|
|
func (picker *filePickerData) Files() []FileInfo {
|
|
return picker.files
|
|
}
|
|
|
|
func (picker *filePickerData) LoadFile(file FileInfo, result func(FileInfo, []byte)) {
|
|
if result == nil {
|
|
return
|
|
}
|
|
|
|
for i, info := range picker.files {
|
|
if info.Name == file.Name && info.Size == file.Size && info.LastModified == file.LastModified {
|
|
picker.loader[i] = result
|
|
picker.Session().callFunc("loadSelectedFile", picker.htmlID(), i)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (picker *filePickerData) Remove(tag string) {
|
|
picker.remove(strings.ToLower(tag))
|
|
}
|
|
|
|
func (picker *filePickerData) remove(tag string) {
|
|
switch tag {
|
|
case FileSelectedEvent:
|
|
if len(picker.fileSelectedListeners) > 0 {
|
|
picker.fileSelectedListeners = []func(FilePicker, []FileInfo){}
|
|
picker.propertyChangedEvent(tag)
|
|
}
|
|
|
|
case Accept:
|
|
delete(picker.properties, tag)
|
|
if picker.created {
|
|
picker.session.removeProperty(picker.htmlID(), "accept")
|
|
}
|
|
picker.propertyChangedEvent(tag)
|
|
|
|
default:
|
|
picker.viewData.remove(tag)
|
|
}
|
|
}
|
|
|
|
func (picker *filePickerData) Set(tag string, value any) bool {
|
|
return picker.set(strings.ToLower(tag), value)
|
|
}
|
|
|
|
func (picker *filePickerData) set(tag string, value any) bool {
|
|
if value == nil {
|
|
picker.remove(tag)
|
|
return true
|
|
}
|
|
|
|
switch tag {
|
|
case FileSelectedEvent:
|
|
listeners, ok := valueToEventListeners[FilePicker, []FileInfo](value)
|
|
if !ok {
|
|
notCompatibleType(tag, value)
|
|
return false
|
|
} else if listeners == nil {
|
|
listeners = []func(FilePicker, []FileInfo){}
|
|
}
|
|
picker.fileSelectedListeners = listeners
|
|
picker.propertyChangedEvent(tag)
|
|
return true
|
|
|
|
case Accept:
|
|
switch value := value.(type) {
|
|
case string:
|
|
value = strings.Trim(value, " \t\n")
|
|
if value == "" {
|
|
picker.remove(Accept)
|
|
} else {
|
|
picker.properties[Accept] = value
|
|
}
|
|
|
|
case []string:
|
|
buffer := allocStringBuilder()
|
|
defer freeStringBuilder(buffer)
|
|
for _, val := range value {
|
|
val = strings.Trim(val, " \t\n")
|
|
if val != "" {
|
|
if buffer.Len() > 0 {
|
|
buffer.WriteRune(',')
|
|
}
|
|
buffer.WriteString(val)
|
|
}
|
|
}
|
|
if buffer.Len() == 0 {
|
|
picker.remove(Accept)
|
|
} else {
|
|
picker.properties[Accept] = buffer.String()
|
|
}
|
|
|
|
default:
|
|
notCompatibleType(tag, value)
|
|
return false
|
|
}
|
|
|
|
if picker.created {
|
|
if css := picker.acceptCSS(); css != "" {
|
|
picker.session.updateProperty(picker.htmlID(), "accept", css)
|
|
} else {
|
|
picker.session.removeProperty(picker.htmlID(), "accept")
|
|
}
|
|
}
|
|
picker.propertyChangedEvent(tag)
|
|
return true
|
|
|
|
default:
|
|
return picker.viewData.set(tag, value)
|
|
}
|
|
}
|
|
|
|
func (picker *filePickerData) htmlTag() string {
|
|
return "input"
|
|
}
|
|
|
|
func (picker *filePickerData) acceptCSS() string {
|
|
accept, ok := stringProperty(picker, Accept, picker.Session())
|
|
if !ok {
|
|
if value := valueFromStyle(picker, Accept); value != nil {
|
|
accept, ok = value.(string)
|
|
}
|
|
}
|
|
|
|
if ok {
|
|
buffer := allocStringBuilder()
|
|
defer freeStringBuilder(buffer)
|
|
for _, value := range strings.Split(accept, ",") {
|
|
if value = strings.Trim(value, " \t\n"); value != "" {
|
|
if buffer.Len() > 0 {
|
|
buffer.WriteString(", ")
|
|
}
|
|
if value[0] != '.' && !strings.Contains(value, "/") {
|
|
buffer.WriteRune('.')
|
|
}
|
|
buffer.WriteString(value)
|
|
}
|
|
}
|
|
return buffer.String()
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (picker *filePickerData) htmlProperties(self View, buffer *strings.Builder) {
|
|
picker.viewData.htmlProperties(self, buffer)
|
|
|
|
if accept := picker.acceptCSS(); accept != "" {
|
|
buffer.WriteString(` accept="`)
|
|
buffer.WriteString(accept)
|
|
buffer.WriteRune('"')
|
|
}
|
|
|
|
buffer.WriteString(` type="file"`)
|
|
if IsMultipleFilePicker(picker) {
|
|
buffer.WriteString(` multiple`)
|
|
}
|
|
|
|
buffer.WriteString(` oninput="fileSelectedEvent(this)"`)
|
|
if picker.getRaw(ClickEvent) == nil {
|
|
buffer.WriteString(` onclick="stopEventPropagation(this, event)"`)
|
|
}
|
|
}
|
|
|
|
func (picker *filePickerData) htmlDisabledProperties(self View, buffer *strings.Builder) {
|
|
if IsDisabled(self) {
|
|
buffer.WriteString(` disabled`)
|
|
}
|
|
picker.viewData.htmlDisabledProperties(self, buffer)
|
|
}
|
|
|
|
func (picker *filePickerData) handleCommand(self View, command string, data DataObject) bool {
|
|
switch command {
|
|
case "fileSelected":
|
|
if node := data.PropertyWithTag("files"); node != nil && node.Type() == ArrayNode {
|
|
count := node.ArraySize()
|
|
files := make([]FileInfo, count)
|
|
for i := 0; i < count; i++ {
|
|
if value := node.ArrayElement(i); value != nil {
|
|
files[i].initBy(value)
|
|
}
|
|
}
|
|
picker.files = files
|
|
|
|
for _, listener := range picker.fileSelectedListeners {
|
|
listener(picker, files)
|
|
}
|
|
}
|
|
return true
|
|
|
|
case "fileLoaded":
|
|
if index, ok := dataIntProperty(data, "index"); ok {
|
|
if result, ok := picker.loader[index]; ok {
|
|
var file FileInfo
|
|
file.initBy(data)
|
|
|
|
var fileData []byte = nil
|
|
if base64Data, ok := data.PropertyValue("data"); ok {
|
|
if index := strings.LastIndex(base64Data, ","); index >= 0 {
|
|
base64Data = base64Data[index+1:]
|
|
}
|
|
decode, err := base64.StdEncoding.DecodeString(base64Data)
|
|
if err == nil {
|
|
fileData = decode
|
|
} else {
|
|
ErrorLog(err.Error())
|
|
}
|
|
}
|
|
|
|
result(file, fileData)
|
|
delete(picker.loader, index)
|
|
}
|
|
}
|
|
return true
|
|
|
|
case "fileLoadingError":
|
|
if error, ok := data.PropertyValue("error"); ok {
|
|
ErrorLog(error)
|
|
}
|
|
if index, ok := dataIntProperty(data, "index"); ok {
|
|
if result, ok := picker.loader[index]; ok {
|
|
if index >= 0 && index < len(picker.files) {
|
|
result(picker.files[index], nil)
|
|
} else {
|
|
result(FileInfo{}, nil)
|
|
}
|
|
delete(picker.loader, index)
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
return picker.viewData.handleCommand(self, command, data)
|
|
}
|
|
|
|
// GetFilePickerFiles returns the list of FilePicker selected files
|
|
// If there are no files selected then an empty slice is returned (the result is always not nil)
|
|
// If the second argument (subviewID) is not specified or it is "" then selected files of the first argument (view) is returned
|
|
func GetFilePickerFiles(view View, subviewID ...string) []FileInfo {
|
|
subview := ""
|
|
if len(subviewID) > 0 {
|
|
subview = subviewID[0]
|
|
}
|
|
|
|
if picker := FilePickerByID(view, subview); picker != nil {
|
|
return picker.Files()
|
|
}
|
|
return []FileInfo{}
|
|
}
|
|
|
|
// LoadFilePickerFile loads the content of the selected file. This function is asynchronous.
|
|
// The "result" function will be called after loading the data.
|
|
// If the second argument (subviewID) is "" then the file from the first argument (view) is loaded
|
|
func LoadFilePickerFile(view View, subviewID string, file FileInfo, result func(FileInfo, []byte)) {
|
|
if picker := FilePickerByID(view, subviewID); picker != nil {
|
|
picker.LoadFile(file, result)
|
|
}
|
|
}
|
|
|
|
// IsMultipleFilePicker returns "true" if multiple files can be selected in the FilePicker, "false" otherwise.
|
|
// If the second argument (subviewID) is not specified or it is "" then a value from the first argument (view) is returned.
|
|
func IsMultipleFilePicker(view View, subviewID ...string) bool {
|
|
return boolStyledProperty(view, subviewID, Multiple, false)
|
|
}
|
|
|
|
// GetFilePickerAccept returns sets the list of allowed file extensions or MIME types.
|
|
// If the second argument (subviewID) is not specified or it is "" then a value from the first argument (view) is returned.
|
|
func GetFilePickerAccept(view View, subviewID ...string) []string {
|
|
if len(subviewID) > 0 && subviewID[0] != "" {
|
|
view = ViewByID(view, subviewID[0])
|
|
}
|
|
if view != nil {
|
|
accept, ok := stringProperty(view, Accept, view.Session())
|
|
if !ok {
|
|
if value := valueFromStyle(view, Accept); value != nil {
|
|
accept, ok = value.(string)
|
|
}
|
|
}
|
|
if ok {
|
|
result := strings.Split(accept, ",")
|
|
for i := 0; i < len(result); i++ {
|
|
result[i] = strings.Trim(result[i], " \t\n")
|
|
}
|
|
return result
|
|
}
|
|
}
|
|
return []string{}
|
|
}
|
|
|
|
// GetFileSelectedListeners returns the "file-selected-event" listener list.
|
|
// If there are no listeners then the empty list is returned.
|
|
// If the second argument (subviewID) is not specified or it is "" then a value from the first argument (view) is returned.
|
|
func GetFileSelectedListeners(view View, subviewID ...string) []func(FilePicker, []FileInfo) {
|
|
return getEventListeners[FilePicker, []FileInfo](view, subviewID, FileSelectedEvent)
|
|
}
|