list_item.go

package control

import (
	"fmt"
	"html"
	"strconv"

	"github.com/goradd/goradd/pkg/page"
	"github.com/goradd/html5tag"
)

type ItemLister interface {
	Value() interface{}
	Label() string
}

// ItemIDer is an interface to a listable object that matches most orm objects
type ItemIDer interface {
	ID() string
	String() string
}

// ItemIntIDer matches orm objects that use an int type for the id
type ItemIntIDer interface {
	ID() int
	String() string
}

type Labeler interface {
	Label() string
}

// A ListItem is an object that is a member of a list. HTML has a few different kinds of lists, and this can be a member
// of a select list (<select>), or an ordered or unordered list (<ul> or <ol>). It is up to the manager of the list to
// render the item, but this serves as a place to store options about the item. Not all options are pertinent to
// all lists.
//
// A list item generally has a value, and a label. Often, lists will have ids too, that will appear in the html output,
// but the id values are managed by the list manager and generally should not be set by you. In situations where the
// user selects a list item, you would use the id to retrieve the ListItem selected.
type ListItem struct {
	ItemList
	value             string
	id                string
	label             string
	attributes        html5tag.Attributes
	shouldEscapeLabel bool
	disabled          bool
	isDivider         bool
	anchorAttributes  html5tag.Attributes
}

// NewListItem creates a new item for a list. Specify an empty string for an item that represents no selection.
func NewListItem(label string, value ...string) *ListItem {
	l := &ListItem{label: label}
	if c := len(value); c == 1 {
		l.value = value[0]
	} else if c > 1 {
		panic("Call NewListItem with zero or one value only.")
	} else {
		l.value = label
	}

	l.ItemList = NewItemList(l)
	return l
}

// NewItemFromItemLister creates a new item from any object that has a Value and Label method.
func NewItemFromItemLister(i ItemLister) *ListItem {
	var l *ListItem

	if i.Value() == nil {
		l = &ListItem{value: "", label: i.Label()}
	} else {
		l = &ListItem{value: fmt.Sprint(i.Value()), label: i.Label()}
	}
	l.ItemList = NewItemList(l)
	return l
}

// NewItemFromLabeler creates a new item from any object that has just a Label method.
func NewItemFromLabeler(i Labeler) *ListItem {
	l := &ListItem{label: i.Label(), value: i.Label()}
	l.ItemList = NewItemList(l)
	return l
}

// NewItemFromStringer creates a new item from any object that has just a String method.
// The label and value will be the same.
func NewItemFromStringer(i fmt.Stringer) *ListItem {
	l := &ListItem{label: i.String(), value: i.String()}
	l.ItemList = NewItemList(l)
	return l
}

// NewItemFromItemIDer creates a new item from any object that has an ID and String method.
// Note that the ID() of the ItemIDer will become the value of the select item, and the String()
// will become the label
func NewItemFromItemIDer(i ItemIDer) *ListItem {
	l := &ListItem{value: i.ID(), label: i.String()}
	l.ItemList = NewItemList(l)
	return l
}

func NewItemFromItemIntIDer(i ItemIntIDer) *ListItem {
	l := &ListItem{value: strconv.Itoa(i.ID()), label: i.String()}
	l.ItemList = NewItemList(l)
	return l
}

func (i *ListItem) SetValue(v string) *ListItem {
	i.value = v
	return i
}

func (i *ListItem) Value() string {
	return i.value
}

func (i *ListItem) IntValue() int {
	v, _ := strconv.Atoi(i.value)
	return v
}

func (i *ListItem) ID() string {
	return i.id
}

// SetID should not be called by your code typically. It is exported for implementations of item lists. The IDs of an
// item list are completely managed by the list, you cannot have custom ids.
func (i *ListItem) SetID(id string) {
	i.id = id
	i.Attributes().SetID(id)
	i.ItemList.reindex(0)
}

func (i *ListItem) HasChildItems() bool {
	return i.ItemList.Len() > 0
}

func (i *ListItem) Label() string {
	return i.label
}

func (i *ListItem) SetLabel(l string) {
	i.label = l
}

func (i *ListItem) SetDisabled(d bool) {
	i.disabled = d
}

func (i *ListItem) Disabled() bool {
	return i.disabled
}

func (i *ListItem) SetIsDivider(d bool) {
	i.isDivider = d
}

func (i *ListItem) IsDivider() bool {
	return i.isDivider
}

func (i *ListItem) SetAnchor(a string) *ListItem {
	i.AnchorAttributes().Set("href", a)
	return i
}

func (i *ListItem) HasAnchor() bool {
	return i.AnchorAttributes().Has("href")
}

func (i *ListItem) Anchor() string {
	if i.anchorAttributes == nil || !i.anchorAttributes.Has("href") {
		return ""
	}
	return i.anchorAttributes.Get("href")
}

func (i *ListItem) AnchorAttributes() html5tag.Attributes {
	if i.anchorAttributes == nil {
		i.anchorAttributes = html5tag.NewAttributes()
	}
	return i.anchorAttributes
}

func (i *ListItem) SetShouldEscapeLabel(e bool) *ListItem {
	i.shouldEscapeLabel = e
	return i
}

func (i *ListItem) RenderLabel() (h string) {
	if i.shouldEscapeLabel {
		h = html.EscapeString(i.label)
	} else {
		h = i.label
	}
	if i.Anchor() != "" && !i.disabled {
		h = html5tag.RenderTag("a", i.anchorAttributes, h)
	}
	return
}

// Attributes returns a pointer to the attributes of the item for customization. You can directly set the attributes
// on the returned object.
func (i *ListItem) Attributes() html5tag.Attributes {
	if i.attributes == nil {
		i.attributes = html5tag.NewAttributes()
	}
	return i.attributes
}

func (i *ListItem) SetAttribute(key, value string) *ListItem {
	i.Attributes().Set(key, value)
	return i
}

func (i *ListItem) AddClass(class string) *ListItem {
	i.Attributes().AddClass(class)
	return i
}

// IsEmptyValue returns true if the value is empty, meaning it does not satisfy a selection being made
// if the list has IsRequired turned on.
func (i *ListItem) IsEmptyValue() bool {
	return i.value == ""
}

func (i *ListItem) Serialize(e page.Encoder) {
	if err := e.Encode(&i.value); err != nil {
		panic(err)
	}
	if err := e.Encode(i.id); err != nil {
		panic(err)
	}
	if err := e.Encode(i.label); err != nil {
		panic(err)
	}
	if err := e.Encode(i.attributes); err != nil {
		panic(err)
	}
	if err := e.Encode(i.shouldEscapeLabel); err != nil {
		panic(err)
	}
	if err := e.Encode(i.disabled); err != nil {
		panic(err)
	}
	if err := e.Encode(i.isDivider); err != nil {
		panic(err)
	}
	if err := e.Encode(i.anchorAttributes); err != nil {
		panic(err)
	}
	i.ItemList.Serialize(e)
}

func (i *ListItem) Deserialize(dec page.Decoder) {
	if err := dec.Decode(&i.value); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.id); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.label); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.attributes); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.shouldEscapeLabel); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.disabled); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.isDivider); err != nil {
		panic(err)
	}
	if err := dec.Decode(&i.anchorAttributes); err != nil {
		panic(err)
	}

	i.ItemList.Deserialize(dec)
}

// ListValue is a helper for initializing a control based on ItemList.
// It satisfies the ItemLister interface. To use it, create a slice of ListValue's and
// pass the list to AddListItems or SetData.
type ListValue struct {
	L string
	// V is the value
	V interface{}
}

func (l ListValue) Value() interface{} {
	return l.V
}

func (l ListValue) Label() string {
	return l.L
}