mirror of https://github.com/anoshenko/rui.git
392 lines
11 KiB
Go
392 lines
11 KiB
Go
package rui
|
|
|
|
import (
|
|
"strings"
|
|
)
|
|
|
|
// CheckboxChangedEvent is the constant for "checkbox-event" property tag.
|
|
//
|
|
// Used by `Checkbox`.
|
|
// Event occurs when the checkbox becomes checked/unchecked.
|
|
//
|
|
// General listener format:
|
|
// `func(checkbox rui.Checkbox, checked bool)`.
|
|
//
|
|
// where:
|
|
// checkbox - Interface of a checkbox which generated this event,
|
|
// checked - Checkbox state.
|
|
//
|
|
// Allowed listener formats:
|
|
// `func(checkbox rui.Checkbox)`,
|
|
// `func(checked bool)`,
|
|
// `func()`.
|
|
const CheckboxChangedEvent = "checkbox-event"
|
|
|
|
// Checkbox represent a Checkbox view
|
|
type Checkbox interface {
|
|
ViewsContainer
|
|
}
|
|
|
|
type checkboxData struct {
|
|
viewsContainerData
|
|
checkedListeners []func(Checkbox, bool)
|
|
}
|
|
|
|
// NewCheckbox create new Checkbox object and return it
|
|
func NewCheckbox(session Session, params Params) Checkbox {
|
|
view := new(checkboxData)
|
|
view.init(session)
|
|
setInitParams(view, Params{
|
|
ClickEvent: checkboxClickListener,
|
|
KeyDownEvent: checkboxKeyListener,
|
|
})
|
|
setInitParams(view, params)
|
|
return view
|
|
}
|
|
|
|
func newCheckbox(session Session) View {
|
|
return NewCheckbox(session, nil)
|
|
}
|
|
|
|
func (button *checkboxData) init(session Session) {
|
|
button.viewsContainerData.init(session)
|
|
button.tag = "Checkbox"
|
|
button.systemClass = "ruiGridLayout ruiCheckbox"
|
|
button.checkedListeners = []func(Checkbox, bool){}
|
|
}
|
|
|
|
func (button *checkboxData) String() string {
|
|
return getViewString(button, nil)
|
|
}
|
|
|
|
func (button *checkboxData) Focusable() bool {
|
|
return true
|
|
}
|
|
|
|
func (button *checkboxData) Get(tag string) any {
|
|
switch strings.ToLower(tag) {
|
|
case CheckboxChangedEvent:
|
|
return button.checkedListeners
|
|
}
|
|
|
|
return button.viewsContainerData.Get(tag)
|
|
}
|
|
|
|
func (button *checkboxData) Set(tag string, value any) bool {
|
|
return button.set(tag, value)
|
|
}
|
|
|
|
func (button *checkboxData) set(tag string, value any) bool {
|
|
switch tag {
|
|
case CheckboxChangedEvent:
|
|
if !button.setChangedListener(value) {
|
|
notCompatibleType(tag, value)
|
|
return false
|
|
}
|
|
|
|
case Checked:
|
|
oldChecked := button.checked()
|
|
if !button.setBoolProperty(Checked, value) {
|
|
return false
|
|
}
|
|
if button.created {
|
|
checked := button.checked()
|
|
if checked != oldChecked {
|
|
button.changedCheckboxState(checked)
|
|
}
|
|
}
|
|
|
|
case CheckboxHorizontalAlign, CheckboxVerticalAlign:
|
|
if !button.setEnumProperty(tag, value, enumProperties[tag].values) {
|
|
return false
|
|
}
|
|
if button.created {
|
|
htmlID := button.htmlID()
|
|
updateCSSStyle(htmlID, button.session)
|
|
updateInnerHTML(htmlID, button.session)
|
|
}
|
|
|
|
case VerticalAlign:
|
|
if !button.setEnumProperty(tag, value, enumProperties[tag].values) {
|
|
return false
|
|
}
|
|
if button.created {
|
|
button.session.updateCSSProperty(button.htmlID()+"content", "align-items", button.cssVerticalAlign())
|
|
}
|
|
|
|
case HorizontalAlign:
|
|
if !button.setEnumProperty(tag, value, enumProperties[tag].values) {
|
|
return false
|
|
}
|
|
if button.created {
|
|
button.session.updateCSSProperty(button.htmlID()+"content", "justify-items", button.cssHorizontalAlign())
|
|
}
|
|
|
|
case CellVerticalAlign, CellHorizontalAlign, CellWidth, CellHeight:
|
|
return false
|
|
|
|
case AccentColor:
|
|
if !button.setColorProperty(AccentColor, value) {
|
|
return false
|
|
}
|
|
if button.created {
|
|
updateInnerHTML(button.htmlID(), button.session)
|
|
}
|
|
|
|
default:
|
|
return button.viewsContainerData.set(tag, value)
|
|
}
|
|
|
|
button.propertyChangedEvent(tag)
|
|
return true
|
|
}
|
|
|
|
func (button *checkboxData) Remove(tag string) {
|
|
button.remove(strings.ToLower(tag))
|
|
}
|
|
|
|
func (button *checkboxData) remove(tag string) {
|
|
switch tag {
|
|
case ClickEvent:
|
|
if !button.viewsContainerData.set(ClickEvent, checkboxClickListener) {
|
|
delete(button.properties, tag)
|
|
}
|
|
|
|
case KeyDownEvent:
|
|
if !button.viewsContainerData.set(KeyDownEvent, checkboxKeyListener) {
|
|
delete(button.properties, tag)
|
|
}
|
|
|
|
case CheckboxChangedEvent:
|
|
if len(button.checkedListeners) > 0 {
|
|
button.checkedListeners = []func(Checkbox, bool){}
|
|
}
|
|
|
|
case Checked:
|
|
oldChecked := button.checked()
|
|
delete(button.properties, tag)
|
|
if button.created && oldChecked {
|
|
button.changedCheckboxState(false)
|
|
}
|
|
|
|
case CheckboxHorizontalAlign, CheckboxVerticalAlign:
|
|
delete(button.properties, tag)
|
|
if button.created {
|
|
htmlID := button.htmlID()
|
|
updateCSSStyle(htmlID, button.session)
|
|
updateInnerHTML(htmlID, button.session)
|
|
}
|
|
|
|
case VerticalAlign:
|
|
delete(button.properties, tag)
|
|
if button.created {
|
|
button.session.updateCSSProperty(button.htmlID()+"content", "align-items", button.cssVerticalAlign())
|
|
}
|
|
|
|
case HorizontalAlign:
|
|
delete(button.properties, tag)
|
|
if button.created {
|
|
button.session.updateCSSProperty(button.htmlID()+"content", "justify-items", button.cssHorizontalAlign())
|
|
}
|
|
|
|
default:
|
|
button.viewsContainerData.remove(tag)
|
|
return
|
|
}
|
|
button.propertyChangedEvent(tag)
|
|
}
|
|
|
|
func (button *checkboxData) checked() bool {
|
|
checked, _ := boolProperty(button, Checked, button.Session())
|
|
return checked
|
|
}
|
|
|
|
func (button *checkboxData) changedCheckboxState(state bool) {
|
|
for _, listener := range button.checkedListeners {
|
|
listener(button, state)
|
|
}
|
|
|
|
buffer := allocStringBuilder()
|
|
defer freeStringBuilder(buffer)
|
|
|
|
button.htmlCheckbox(buffer, state)
|
|
button.Session().updateInnerHTML(button.htmlID()+"checkbox", buffer.String())
|
|
}
|
|
|
|
func checkboxClickListener(view View) {
|
|
view.Set(Checked, !IsCheckboxChecked(view))
|
|
BlurView(view)
|
|
}
|
|
|
|
func checkboxKeyListener(view View, event KeyEvent) {
|
|
switch event.Code {
|
|
case "Enter", "Space":
|
|
view.Set(Checked, !IsCheckboxChecked(view))
|
|
}
|
|
}
|
|
|
|
func (button *checkboxData) setChangedListener(value any) bool {
|
|
listeners, ok := valueToEventListeners[Checkbox, bool](value)
|
|
if !ok {
|
|
return false
|
|
} else if listeners == nil {
|
|
listeners = []func(Checkbox, bool){}
|
|
}
|
|
button.checkedListeners = listeners
|
|
return true
|
|
}
|
|
|
|
func (button *checkboxData) cssStyle(self View, builder cssBuilder) {
|
|
session := button.Session()
|
|
vAlign := GetCheckboxVerticalAlign(button)
|
|
hAlign := GetCheckboxHorizontalAlign(button)
|
|
switch hAlign {
|
|
case CenterAlign:
|
|
if vAlign == BottomAlign {
|
|
builder.add("grid-template-rows", "1fr auto")
|
|
} else {
|
|
builder.add("grid-template-rows", "auto 1fr")
|
|
}
|
|
|
|
case RightAlign:
|
|
builder.add("grid-template-columns", "1fr auto")
|
|
|
|
default:
|
|
builder.add("grid-template-columns", "auto 1fr")
|
|
}
|
|
|
|
if gap, ok := sizeConstant(session, "ruiCheckboxGap"); ok && gap.Type != Auto && gap.Value > 0 {
|
|
builder.add("gap", gap.cssString("0", session))
|
|
}
|
|
|
|
builder.add("align-items", "stretch")
|
|
builder.add("justify-items", "stretch")
|
|
|
|
button.viewsContainerData.cssStyle(self, builder)
|
|
}
|
|
|
|
func (button *checkboxData) htmlCheckbox(buffer *strings.Builder, checked bool) (int, int) {
|
|
vAlign := GetCheckboxVerticalAlign(button)
|
|
hAlign := GetCheckboxHorizontalAlign(button)
|
|
|
|
buffer.WriteString(`<div id="`)
|
|
buffer.WriteString(button.htmlID())
|
|
buffer.WriteString(`checkbox" style="display: grid;`)
|
|
if hAlign == CenterAlign {
|
|
buffer.WriteString(" justify-items: center; grid-column-start: 1; grid-column-end: 2;")
|
|
if vAlign == BottomAlign {
|
|
buffer.WriteString(" grid-row-start: 2; grid-row-end: 3;")
|
|
} else {
|
|
buffer.WriteString(" grid-row-start: 1; grid-row-end: 2;")
|
|
}
|
|
} else {
|
|
if hAlign == RightAlign {
|
|
buffer.WriteString(" grid-column-start: 2; grid-column-end: 3;")
|
|
} else {
|
|
buffer.WriteString(" grid-column-start: 1; grid-column-end: 2;")
|
|
}
|
|
buffer.WriteString(" grid-row-start: 1; grid-row-end: 2;")
|
|
switch vAlign {
|
|
case BottomAlign:
|
|
buffer.WriteString(" align-items: end;")
|
|
|
|
case CenterAlign:
|
|
buffer.WriteString(" align-items: center;")
|
|
|
|
default:
|
|
buffer.WriteString(" align-items: start;")
|
|
}
|
|
}
|
|
|
|
buffer.WriteString(`">`)
|
|
|
|
accentColor := Color(0)
|
|
if color := GetAccentColor(button, ""); color != 0 {
|
|
accentColor = color
|
|
}
|
|
|
|
if checked {
|
|
buffer.WriteString(button.Session().checkboxOnImage(accentColor))
|
|
} else {
|
|
buffer.WriteString(button.Session().checkboxOffImage(accentColor))
|
|
}
|
|
buffer.WriteString(`</div>`)
|
|
|
|
return vAlign, hAlign
|
|
}
|
|
|
|
func (button *checkboxData) htmlSubviews(self View, buffer *strings.Builder) {
|
|
|
|
vCheckboxAlign, hCheckboxAlign := button.htmlCheckbox(buffer, IsCheckboxChecked(button))
|
|
|
|
buffer.WriteString(`<div id="`)
|
|
buffer.WriteString(button.htmlID())
|
|
buffer.WriteString(`content" style="display: grid;`)
|
|
if hCheckboxAlign == LeftAlign {
|
|
buffer.WriteString(" grid-column-start: 2; grid-column-end: 3;")
|
|
} else {
|
|
buffer.WriteString(" grid-column-start: 1; grid-column-end: 2;")
|
|
}
|
|
|
|
if hCheckboxAlign == CenterAlign && vCheckboxAlign != BottomAlign {
|
|
buffer.WriteString(" grid-row-start: 2; grid-row-end: 3;")
|
|
} else {
|
|
buffer.WriteString(" grid-row-start: 1; grid-row-end: 2;")
|
|
}
|
|
|
|
buffer.WriteString(" align-items: ")
|
|
buffer.WriteString(button.cssVerticalAlign())
|
|
buffer.WriteRune(';')
|
|
|
|
buffer.WriteString(" justify-items: ")
|
|
buffer.WriteString(button.cssHorizontalAlign())
|
|
buffer.WriteRune(';')
|
|
|
|
buffer.WriteString(`">`)
|
|
button.viewsContainerData.htmlSubviews(self, buffer)
|
|
buffer.WriteString(`</div>`)
|
|
}
|
|
|
|
func (button *checkboxData) cssHorizontalAlign() string {
|
|
align := GetHorizontalAlign(button)
|
|
values := enumProperties[CellHorizontalAlign].cssValues
|
|
if align >= 0 && align < len(values) {
|
|
return values[align]
|
|
}
|
|
return values[0]
|
|
}
|
|
|
|
func (button *checkboxData) cssVerticalAlign() string {
|
|
align := GetVerticalAlign(button)
|
|
values := enumProperties[CellVerticalAlign].cssValues
|
|
if align >= 0 && align < len(values) {
|
|
return values[align]
|
|
}
|
|
return values[0]
|
|
}
|
|
|
|
// IsCheckboxChecked returns true if the Checkbox is checked, false otherwise.
|
|
// If the second argument (subviewID) is not specified or it is "" then a value from the first argument (view) is returned.
|
|
func IsCheckboxChecked(view View, subviewID ...string) bool {
|
|
return boolStyledProperty(view, subviewID, Checked, false)
|
|
}
|
|
|
|
// GetCheckboxVerticalAlign return the vertical align of a Checkbox subview: TopAlign (0), BottomAlign (1), CenterAlign (2)
|
|
// If the second argument (subviewID) is not specified or it is "" then a left position of the first argument (view) is returned
|
|
func GetCheckboxVerticalAlign(view View, subviewID ...string) int {
|
|
return enumStyledProperty(view, subviewID, CheckboxVerticalAlign, LeftAlign, false)
|
|
}
|
|
|
|
// GetCheckboxHorizontalAlign return the vertical align of a Checkbox subview: LeftAlign (0), RightAlign (1), CenterAlign (2)
|
|
// If the second argument (subviewID) is not specified or it is "" then a left position of the first argument (view) is returned
|
|
func GetCheckboxHorizontalAlign(view View, subviewID ...string) int {
|
|
return enumStyledProperty(view, subviewID, CheckboxHorizontalAlign, TopAlign, false)
|
|
}
|
|
|
|
// GetCheckboxChangedListeners returns the CheckboxChangedListener list of an Checkbox subview.
|
|
// 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 GetCheckboxChangedListeners(view View, subviewID ...string) []func(Checkbox, bool) {
|
|
return getEventListeners[Checkbox, bool](view, subviewID, CheckboxChangedEvent)
|
|
}
|