forked from mbk-lab/rui_orig
109 lines
2.6 KiB
Go
109 lines
2.6 KiB
Go
package rui
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"net"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
var stringBuilders []*strings.Builder = make([]*strings.Builder, 4096)
|
|
var stringBuilderCount = 0
|
|
|
|
func allocStringBuilder() *strings.Builder {
|
|
for stringBuilderCount > 0 {
|
|
stringBuilderCount--
|
|
result := stringBuilders[stringBuilderCount]
|
|
if result != nil {
|
|
stringBuilders[stringBuilderCount] = nil
|
|
result.Reset()
|
|
return result
|
|
}
|
|
}
|
|
|
|
result := new(strings.Builder)
|
|
result.Grow(4096)
|
|
return result
|
|
}
|
|
|
|
func freeStringBuilder(builder *strings.Builder) {
|
|
if builder != nil {
|
|
if stringBuilderCount == len(stringBuilders) {
|
|
stringBuilders = append(stringBuilders, builder)
|
|
} else {
|
|
stringBuilders[stringBuilderCount] = builder
|
|
}
|
|
stringBuilderCount++
|
|
}
|
|
}
|
|
|
|
func GetLocalIP() string {
|
|
addrs, err := net.InterfaceAddrs()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
for _, address := range addrs {
|
|
// check the address type and if it is not a loopback the display it
|
|
if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
|
|
if ipnet.IP.To4() != nil {
|
|
return ipnet.IP.String()
|
|
}
|
|
}
|
|
}
|
|
return "localhost"
|
|
}
|
|
|
|
func dataIntProperty(data DataObject, tag string) (int, bool) {
|
|
if value, ok := data.PropertyValue(tag); ok {
|
|
if n, err := strconv.Atoi(value); err == nil {
|
|
return n, true
|
|
}
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
func dataBoolProperty(data DataObject, tag string) bool {
|
|
if value, ok := data.PropertyValue(tag); ok && value == "1" {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func dataFloatProperty(data DataObject, tag string) float64 {
|
|
if value, ok := data.PropertyValue(tag); ok {
|
|
if n, err := strconv.ParseFloat(value, 64); err == nil {
|
|
return n
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// InlineImageFromResource reads image from resources and converts it to an inline image.
|
|
// Supported png, jpeg, gif, and svg files
|
|
func InlineImageFromResource(filename string) (string, bool) {
|
|
if image, ok := resources.images[filename]; ok && image.fs != nil {
|
|
dataType := map[string]string{
|
|
".svg": "data:image/svg+xml",
|
|
".png": "data:image/png",
|
|
".jpg": "data:image/jpg",
|
|
".jpeg": "data:image/jpg",
|
|
".gif": "data:image/gif",
|
|
}
|
|
ext := strings.ToLower(filepath.Ext(filename))
|
|
if prefix, ok := dataType[ext]; ok {
|
|
if data, err := image.fs.ReadFile(image.path); err == nil {
|
|
return prefix + ";base64," + base64.StdEncoding.EncodeToString(data), true
|
|
} else {
|
|
DebugLog(err.Error())
|
|
}
|
|
} else {
|
|
DebugLogF(`InlineImageFromResource("%s") error: Unsupported file`, filename)
|
|
}
|
|
} else {
|
|
DebugLogF(`The resource image "%s" not found`, filename)
|
|
}
|
|
|
|
return "", false
|
|
}
|