refactored GUI styles to use PanelStyle and BasicStyle

gui/align.go

@@ -8,7 +8,7 @@ package gui
 type Align int
 
 const (
-	AlignNone   = Align(iota) // No aligh
+	AlignNone   = Align(iota) // No alignment
 	AlignLeft                 // Align horizontally at left
 	AlignRight                // Align horizontally at right
 	AlignWidth                // Align horizontally using all width

gui/button.go

@@ -5,7 +5,6 @@
 package gui
 
 import (
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 )
 
@@ -33,13 +32,7 @@ type Button struct {
 }
 
 // Button style
-type ButtonStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type ButtonStyle BasicStyle
 
 // All Button styles
 type ButtonStyles struct {
@@ -199,14 +192,11 @@ func (b *Button) update() {
 // applyStyle applies the specified button style
 func (b *Button) applyStyle(bs *ButtonStyle) {
 
-	b.SetBordersColor4(&bs.BorderColor)
-	b.SetBordersFrom(&bs.Border)
-	b.SetPaddingsFrom(&bs.Paddings)
-	b.SetColor(&bs.BgColor)
+	b.Panel.ApplyStyle(&bs.PanelStyle)
 	if b.icon != nil {
-		b.icon.SetColor(&bs.FgColor)
+		b.icon.SetColor4(&bs.FgColor)
 	}
-	//b.Label.SetColor(&bs.FgColor)
+	b.Label.SetColor4(&bs.FgColor)
 }
 
 // recalc recalculates all dimensions and position from inside out

gui/checkradio.go

@@ -6,7 +6,6 @@ package gui
 
 import (
 	"github.com/g3n/engine/gui/assets/icon"
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 )
 
@@ -31,13 +30,7 @@ type CheckRadio struct {
 	subroot    bool // indicates root subcription
 }
 
-type CheckRadioStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color4
-	FgColor     math32.Color
-}
+type CheckRadioStyle BasicStyle
 
 type CheckRadioStyles struct {
 	Normal   CheckRadioStyle
@@ -250,13 +243,9 @@ func (cb *CheckRadio) update() {
 // setStyle sets the specified checkradio style
 func (cb *CheckRadio) applyStyle(s *CheckRadioStyle) {
 
-	cb.Panel.SetBordersColor4(&s.BorderColor)
-	cb.Panel.SetBordersFrom(&s.Border)
-	cb.Panel.SetPaddingsFrom(&s.Paddings)
-	cb.Panel.SetColor4(&s.BgColor)
-
-	cb.icon.SetColor(&s.FgColor)
-	cb.Label.SetColor(&s.FgColor)
+	cb.Panel.ApplyStyle(&s.PanelStyle)
+	cb.icon.SetColor4(&s.FgColor)
+	cb.Label.SetColor4(&s.FgColor)
 }
 
 // recalc recalculates dimensions and position from inside out

gui/dropdown.go

@@ -6,7 +6,6 @@ package gui
 
 import (
 	"github.com/g3n/engine/gui/assets/icon"
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 )
 
@@ -24,13 +23,7 @@ type DropDown struct {
 }
 
 // DropDown list style
-type DropDownStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type DropDownStyle BasicStyle
 
 // DropDown list styles
 type DropDownStyles struct {
@@ -280,8 +273,5 @@ func (dd *DropDown) update() {
 // applyStyle applies the specified style
 func (dd *DropDown) applyStyle(s *DropDownStyle) {
 
-	dd.SetBordersFrom(&s.Border)
-	dd.SetBordersColor4(&s.BorderColor)
-	dd.SetPaddingsFrom(&s.Paddings)
-	dd.SetColor(&s.BgColor)
+	dd.Panel.ApplyStyle(&s.PanelStyle)
 }

gui/edit.go

@@ -30,10 +30,10 @@ type EditStyle struct {
 	Border      RectBounds
 	Paddings    RectBounds
 	BorderColor math32.Color4
-	BgColor     math32.Color
+	BgColor     math32.Color4
 	BgAlpha     float32
-	FgColor     math32.Color
-	HolderColor math32.Color
+	FgColor     math32.Color4
+	HolderColor math32.Color4
 }
 
 type EditStyles struct {
@@ -327,15 +327,15 @@ func (ed *Edit) applyStyle(s *EditStyle) {
 	ed.SetBordersFrom(&s.Border)
 	ed.SetBordersColor4(&s.BorderColor)
 	ed.SetPaddingsFrom(&s.Paddings)
-	ed.Label.SetColor(&s.FgColor)
-	ed.Label.SetBgColor(&s.BgColor)
+	ed.Label.SetColor4(&s.FgColor)
+	ed.Label.SetBgColor4(&s.BgColor)
 	//ed.Label.SetBgAlpha(s.BgAlpha)
 
 	if !ed.focus && len(ed.text) == 0 && len(ed.placeHolder) > 0 {
-		ed.Label.SetColor(&s.HolderColor)
+		ed.Label.SetColor4(&s.HolderColor)
 		ed.Label.setTextCaret(ed.placeHolder, editMarginX, ed.width, -1, ed.col)
 	} else {
-		ed.Label.SetColor(&s.FgColor)
+		ed.Label.SetColor4(&s.FgColor)
 		ed.redraw(ed.focus)
 	}
 }

gui/folder.go

@@ -19,12 +19,8 @@ type Folder struct {
 }
 
 type FolderStyle struct {
-	Margins     RectBounds
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
+	PanelStyle
+	FgColor     math32.Color4
 	Icons       [2]string
 }
 
@@ -148,20 +144,16 @@ func (f *Folder) update() {
 // applyStyle applies the specified style
 func (f *Folder) applyStyle(s *FolderStyle) {
 
-	f.SetMarginsFrom(&s.Margins)
-	f.SetBordersColor4(&s.BorderColor)
-	f.SetBordersFrom(&s.Border)
-	f.SetPaddingsFrom(&s.Paddings)
-	f.SetColor(&s.BgColor)
+	f.Panel.ApplyStyle(&s.PanelStyle)
 
 	icode := 0
 	if f.contentPanel.GetPanel().Visible() {
 		icode = 1
 	}
 	f.icon.SetText(string(s.Icons[icode]))
-	f.icon.SetColor(&s.FgColor)
-	f.label.SetBgColor(&s.BgColor)
-	f.label.SetColor(&s.FgColor)
+	f.icon.SetColor4(&s.FgColor)
+	f.label.SetBgColor4(&s.BgColor)
+	f.label.SetColor4(&s.FgColor)
 }
 
 func (f *Folder) recalc() {

gui/image_button.go

@@ -5,7 +5,6 @@
 package gui
 
 import (
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/texture"
 	"github.com/g3n/engine/window"
 )
@@ -32,13 +31,7 @@ const (
 )
 
 // ImageButton style
-type ImageButtonStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color4
-	FgColor     math32.Color
-}
+type ImageButtonStyle BasicStyle
 
 // All ImageButton styles
 type ImageButtonStyles struct {
@@ -253,12 +246,9 @@ func (b *ImageButton) update() {
 // applyStyle applies the specified button style
 func (b *ImageButton) applyStyle(bs *ImageButtonStyle) {
 
-	b.SetBordersColor4(&bs.BorderColor)
-	b.SetBordersFrom(&bs.Border)
-	b.SetPaddingsFrom(&bs.Paddings)
-	b.SetColor4(&bs.BgColor)
+	b.Panel.ApplyStyle(&bs.PanelStyle)
 	if b.label != nil {
-		b.label.SetColor(&bs.FgColor)
+		b.label.SetColor4(&bs.FgColor)
 	}
 }
 

gui/imagelabel.go

@@ -30,13 +30,7 @@ type ImageLabel struct {
 }
 
 // ImageLabel style
-type ImageLabelStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color4
-	FgColor     math32.Color4
-}
+type ImageLabelStyle BasicStyle
 
 // NewImageLabel creates and returns a pointer to a new image label widget
 // with the specified text for the label and no image/icon
@@ -194,10 +188,7 @@ func (il *ImageLabel) CopyFields(other *ImageLabel) {
 // applyStyle applies the specified image label style
 func (il *ImageLabel) applyStyle(s *ImageLabelStyle) {
 
-	il.SetBordersColor4(&s.BorderColor)
-	il.SetBordersFrom(&s.Border)
-	il.SetPaddingsFrom(&s.Paddings)
-	il.SetColor4(&s.BgColor)
+	il.Panel.ApplyStyle(&s.PanelStyle)
 	if il.icon != nil {
 		il.icon.SetColor4(&s.FgColor)
 	}

gui/list.go

@@ -5,7 +5,6 @@
 package gui
 
 import (
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 )
 
@@ -43,13 +42,7 @@ type ListItemStyles struct {
 	SelHigh     ListItemStyle
 }
 
-type ListItemStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color4
-	FgColor     math32.Color
-}
+type ListItemStyle BasicStyle
 
 // Event sent to list item child panel on resize
 const OnListItemResize = "gui.OnListItemResize"
@@ -538,10 +531,7 @@ func (litem *ListItem) update() {
 // applyStyle applies the specified style to this ListItem
 func (litem *ListItem) applyStyle(s *ListItemStyle) {
 
-	litem.SetBordersFrom(&s.Border)
-	litem.SetBordersColor4(&s.BorderColor)
-	pads := s.Paddings
-	pads.Left += litem.padLeft
-	litem.SetPaddingsFrom(&pads)
-	litem.SetColor4(&s.BgColor)
+	styleCopy := s.PanelStyle
+	styleCopy.Padding.Left += litem.padLeft
+	litem.Panel.ApplyStyle(&styleCopy)
 }

gui/menu.go

@@ -8,6 +8,7 @@ import (
 	"github.com/g3n/engine/gui/assets/icon"
 	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
+
 	"time"
 )
 
@@ -21,13 +22,7 @@ type Menu struct {
 }
 
 // MenuBodyStyle describes the style of the menu body
-type MenuBodyStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type MenuBodyStyle BasicStyle
 
 // MenuBodyStyles describes all styles of the menu body
 type MenuBodyStyles struct {
@@ -63,11 +58,8 @@ type MenuItem struct {
 
 // MenuItemStyle describes the style of a menu item
 type MenuItemStyle struct {
-	Border           RectBounds
-	Paddings         RectBounds
-	BorderColor      math32.Color4
-	BgColor          math32.Color
-	FgColor          math32.Color
+	PanelStyle
+	FgColor          math32.Color4
 	IconPaddings     RectBounds
 	ShortcutPaddings RectBounds
 	RiconPaddings    RectBounds
@@ -478,10 +470,7 @@ func (m *Menu) update() {
 // applyStyle applies the specified menu body style
 func (m *Menu) applyStyle(mbs *MenuBodyStyle) {
 
-	m.SetBordersFrom(&mbs.Border)
-	m.SetBordersColor4(&mbs.BorderColor)
-	m.SetPaddingsFrom(&mbs.Paddings)
-	m.SetColor(&mbs.BgColor)
+	m.Panel.ApplyStyle(&mbs.PanelStyle)
 }
 
 // recalc recalculates the positions of this menu internal items
@@ -827,15 +816,12 @@ func (mi *MenuItem) update() {
 // applyStyle applies the specified menu item style
 func (mi *MenuItem) applyStyle(mis *MenuItemStyle) {
 
-	mi.SetBordersFrom(&mis.Border)
-	mi.SetBordersColor4(&mis.BorderColor)
-	mi.SetPaddingsFrom(&mis.Paddings)
-	mi.SetColor(&mis.BgColor)
+	mi.Panel.ApplyStyle(&mis.PanelStyle)
 	if mi.licon != nil {
 		mi.licon.SetPaddingsFrom(&mis.IconPaddings)
 	}
 	if mi.label != nil {
-		mi.label.SetColor(&mis.FgColor)
+		mi.label.SetColor4(&mis.FgColor)
 	}
 	if mi.shortcut != nil {
 		mi.shortcut.SetPaddingsFrom(&mis.ShortcutPaddings)

gui/panel.go

@@ -91,6 +91,19 @@ type Panel struct {
 	}
 }
 
+type PanelStyle struct {
+	Margin      RectBounds
+	Border      RectBounds
+	Padding     RectBounds
+	BorderColor math32.Color4
+	BgColor     math32.Color4
+}
+
+type BasicStyle struct {
+	PanelStyle
+	FgColor     math32.Color4
+}
+
 const (
 	deltaZ    = -0.000001      // delta Z for bounded panels
 	deltaZunb = deltaZ * 10000 // delta Z for unbounded panels
@@ -180,9 +193,9 @@ func (p *Panel) InitializeGraphic(width, height float32, gr *graphic.Graphic) {
 
 // GetPanel satisfies the IPanel interface and
 // returns pointer to this panel
-func (pan *Panel) GetPanel() *Panel {
+func (p *Panel) GetPanel() *Panel {
 
-	return pan
+	return p
 }
 
 // SetRoot satisfies the IPanel interface
@@ -436,6 +449,18 @@ func (p *Panel) Color4() math32.Color4 {
 	return p.udata.contentColor
 }
 
+// ApplyStyle applies the provided PanelStyle to the panel
+func (p *Panel) ApplyStyle(ps *PanelStyle) {
+
+	p.udata.bordersColor = ps.BorderColor
+	p.udata.paddingsColor = ps.BgColor
+	p.udata.contentColor = ps.BgColor
+	p.marginSizes = ps.Margin
+	p.borderSizes = ps.Border
+	p.paddingSizes = ps.Padding
+	p.resize(p.calcWidth(), p.calcHeight(), true)
+}
+
 // SetContentSize sets this panel content size to the specified dimensions.
 // The external size of the panel may increase or decrease to acomodate
 // the new content size.

gui/scrollbar.go

@@ -47,17 +47,14 @@ type ScrollBarStyles struct {
 }
 
 type ScrollBarStyle struct {
-	Paddings     RectBounds
-	Borders      RectBounds
-	BordersColor math32.Color4
-	Color        math32.Color
+	PanelStyle
 	Button       ScrollBarButtonStyle
 }
 
 type ScrollBarButtonStyle struct {
 	Borders      RectBounds
 	BordersColor math32.Color4
-	Color        math32.Color
+	Color        math32.Color4
 	Size         float32 	   // This is the default/minimum button size
 }
 
@@ -192,14 +189,11 @@ func (sb *ScrollBar) update() {
 // update updates border sizes and colors
 func (sb *ScrollBar) applyStyle(sbs *ScrollBarStyle) {
 
-	sb.SetBordersFrom(&sbs.Borders)
-	sb.SetPaddingsFrom(&sbs.Paddings)
-	sb.SetBordersColor4(&sbs.BordersColor)
-	sb.SetColor(&sbs.Color)
+	sb.Panel.ApplyStyle(&sbs.PanelStyle)
 
 	sb.button.SetBordersFrom(&sbs.Button.Borders)
 	sb.button.SetBordersColor4(&sbs.Button.BordersColor)
-	sb.button.SetColor(&sbs.Button.Color)
+	sb.button.SetColor4(&sbs.Button.Color)
 
 	sb.button.MinSize = sbs.Button.Size
 }

gui/scroller.go

@@ -5,7 +5,6 @@
 package gui
 
 import (
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 	"math"
 )
@@ -27,13 +26,7 @@ type Scroller struct {
 	scrollBarEvent bool
 }
 
-type ScrollerStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type ScrollerStyle BasicStyle
 
 type ScrollerStyles struct {
 	Normal   ScrollerStyle
@@ -639,8 +632,5 @@ func (s *Scroller) update() {
 // applyStyle sets the specified style
 func (s *Scroller) applyStyle(st *ScrollerStyle) {
 
-	s.SetBordersFrom(&st.Border)
-	s.SetBordersColor4(&st.BorderColor)
-	s.SetPaddingsFrom(&st.Paddings)
-	s.SetColor(&st.BgColor)
+	s.Panel.ApplyStyle(&st.PanelStyle)
 }

gui/slider.go

@@ -5,7 +5,6 @@
 package gui
 
 import (
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 )
 
@@ -37,13 +36,7 @@ type Slider struct {
 }
 
 // SliderStyle
-type SliderStyle struct {
-	Border      RectBounds    // outer panel border sizes
-	BorderColor math32.Color4 // outer panel border colors
-	Paddings    RectBounds    // outer panel padding sizes
-	BgColor     math32.Color4 // outer panel color
-	FgColor     math32.Color4 // slider panel color
-}
+type SliderStyle BasicStyle
 
 // All Slider styles
 type SliderStyles struct {
@@ -289,10 +282,7 @@ func (s *Slider) update() {
 // applyStyle applies the specified slider style
 func (s *Slider) applyStyle(ss *SliderStyle) {
 
-	s.SetBordersColor4(&ss.BorderColor)
-	s.SetBordersFrom(&ss.Border)
-	s.SetPaddingsFrom(&ss.Paddings)
-	s.Panel.SetColor4(&ss.BgColor)
+	s.Panel.ApplyStyle(&ss.PanelStyle)
 	s.slider.SetColor4(&ss.FgColor)
 }
 

gui/splitter.go

@@ -24,7 +24,7 @@ type Splitter struct {
 
 type SplitterStyle struct {
 	SpacerBorderColor math32.Color4
-	SpacerColor       math32.Color
+	SpacerColor       math32.Color4
 	SpacerSize        float32
 }
 
@@ -198,7 +198,7 @@ func (s *Splitter) update() {
 func (s *Splitter) applyStyle(ss *SplitterStyle) {
 
 	s.spacer.SetBordersColor4(&ss.SpacerBorderColor)
-	s.spacer.SetColor(&ss.SpacerColor)
+	s.spacer.SetColor4(&ss.SpacerColor)
 	if s.horiz {
 		s.spacer.SetWidth(ss.SpacerSize)
 	} else {

gui/style_light.go

@@ -51,25 +51,24 @@ func NewLightStyle() *Style {
 	borderColor := math32.Color4Name("DimGray")
 	borderColorDis := math32.Color4Name("LightGray")
 
-	bgColor := math32.Color{0.85, 0.85, 0.85}
+	bgColor := math32.Color4{0.85, 0.85, 0.85, 1}
 	bgColor4 := math32.Color4{0, 0, 0, 0}
-	bgColorOver := math32.Color{0.9, 0.9, 0.9}
+	bgColorOver := math32.Color4{0.9, 0.9, 0.9, 1}
 	bgColor4Over := math32.Color4{1, 1, 1, 0.5}
 	bgColor4Sel := math32.Color4{0.6, 0.6, 0.6, 1}
 
-	fgColor := math32.Color{0, 0, 0}
-	fgColorSel := math32.Color{0, 0, 0}
-	fgColorDis := math32.Color{0.4, 0.4, 0.4}
+	fgColor := math32.Color4{0, 0, 0, 1}
+	fgColorSel := math32.Color4{0, 0, 0, 1}
+	fgColorDis := math32.Color4{0.4, 0.4, 0.4, 1}
 
 	// Button styles
 	s.Button = ButtonStyles{}
-	s.Button.Normal = ButtonStyle{
-		Border:      oneBounds,
-		Paddings:    RectBounds{2, 4, 2, 4},
-		BorderColor: borderColor,
-		BgColor:     bgColor,
-		FgColor:     fgColor,
-	}
+	s.Button.Normal = ButtonStyle{}
+	s.Button.Normal.Border = oneBounds
+	s.Button.Normal.Padding = RectBounds{2, 4, 2, 4}
+	s.Button.Normal.BorderColor = borderColor
+	s.Button.Normal.BgColor = bgColor
+	s.Button.Normal.FgColor = fgColor
 	s.Button.Over = s.Button.Normal
 	s.Button.Over.BgColor = bgColorOver
 	s.Button.Focus = s.Button.Over
@@ -81,13 +80,10 @@ func NewLightStyle() *Style {
 
 	// CheckRadio styles
 	s.CheckRadio = CheckRadioStyles{}
-	s.CheckRadio.Normal = CheckRadioStyle{
-		Border:      zeroBounds,
-		Paddings:    zeroBounds,
-		BorderColor: borderColor,
-		BgColor:     bgColor4,
-		FgColor:     fgColor,
-	}
+	s.CheckRadio.Normal = CheckRadioStyle{}
+	s.CheckRadio.Normal.BorderColor = borderColor
+	s.CheckRadio.Normal.BgColor = bgColor4
+	s.CheckRadio.Normal.FgColor = fgColor
 	s.CheckRadio.Over = s.CheckRadio.Normal
 	s.CheckRadio.Over.BgColor = bgColor4Over
 	s.CheckRadio.Focus = s.CheckRadio.Over
@@ -103,7 +99,7 @@ func NewLightStyle() *Style {
 		BgColor:     bgColor,
 		BgAlpha:     1.0,
 		FgColor:     fgColor,
-		HolderColor: math32.Color{0.4, 0.4, 0.4},
+		HolderColor: math32.Color4{0.4, 0.4, 0.4, 1},
 	}
 	s.Edit.Over = s.Edit.Normal
 	s.Edit.Over.BgColor = bgColorOver
@@ -113,30 +109,27 @@ func NewLightStyle() *Style {
 
 	// ScrollBar styles
 	s.ScrollBar = ScrollBarStyles{}
-	s.ScrollBar.Normal = ScrollBarStyle{
-		Paddings:     oneBounds,
+	s.ScrollBar.Normal = ScrollBarStyle{}
+	s.ScrollBar.Normal.Padding = oneBounds
+	s.ScrollBar.Normal.Border = oneBounds
+	s.ScrollBar.Normal.BorderColor = borderColor
+	s.ScrollBar.Normal.BgColor = math32.Color4{0.8, 0.8, 0.8, 1}
+	s.ScrollBar.Normal.Button = ScrollBarButtonStyle{
 		Borders:      oneBounds,
 		BordersColor: borderColor,
-		Color:        math32.Color{0.8, 0.8, 0.8},
-		Button: ScrollBarButtonStyle{
-			Borders:      oneBounds,
-			BordersColor: borderColor,
-			Color:        math32.Color{0.5, 0.5, 0.5},
-			Size:         30,
-		},
+		Color:        math32.Color4{0.5, 0.5, 0.5, 1},
+		Size:         30,
 	}
 	s.ScrollBar.Over = s.ScrollBar.Normal
 	s.ScrollBar.Disabled = s.ScrollBar.Normal
 
 	// Slider styles
 	s.Slider = SliderStyles{}
-	s.Slider.Normal = SliderStyle{
-		Border:      oneBounds,
-		BorderColor: borderColor,
-		Paddings:    zeroBounds,
-		BgColor:     math32.Color4{0.8, 0.8, 0.8, 1},
-		FgColor:     math32.Color4{0, 0.8, 0, 1},
-	}
+	s.Slider.Normal = SliderStyle{}
+	s.Slider.Normal.Border = oneBounds
+	s.Slider.Normal.BorderColor = borderColor
+	s.Slider.Normal.BgColor = math32.Color4{0.8, 0.8, 0.8, 1}
+	s.Slider.Normal.FgColor = math32.Color4{0, 0.8, 0, 1}
 	s.Slider.Over = s.Slider.Normal
 	s.Slider.Over.BgColor = math32.Color4{1, 1, 1, 1}
 	s.Slider.Over.FgColor = math32.Color4{0, 1, 0, 1}
@@ -171,13 +164,11 @@ func NewLightStyle() *Style {
 
 	// Scroller styles
 	s.Scroller = ScrollerStyles{}
-	s.Scroller.Normal = ScrollerStyle{
-		Border:      oneBounds,
-		Paddings:    zeroBounds,
-		BorderColor: borderColor,
-		BgColor:     bgColor,
-		FgColor:     fgColor,
-	}
+	s.Scroller.Normal = ScrollerStyle{}
+	s.Scroller.Normal.Border = oneBounds
+	s.Scroller.Normal.BorderColor = borderColor
+	s.Scroller.Normal.BgColor = bgColor
+	s.Scroller.Normal.FgColor = fgColor
 	s.Scroller.Over = s.Scroller.Normal
 	s.Scroller.Over.BgColor = bgColorOver
 	s.Scroller.Focus = s.Scroller.Over
@@ -187,13 +178,12 @@ func NewLightStyle() *Style {
 	s.List = ListStyles{}
 	s.List.Scroller = &s.Scroller
 	s.List.Item = &ListItemStyles{}
-	s.List.Item.Normal = ListItemStyle{
-		Border:      RectBounds{1, 0, 1, 0},
-		Paddings:    RectBounds{0, 0, 0, 2},
-		BorderColor: math32.Color4{0, 0, 0, 0},
-		BgColor:     bgColor4,
-		FgColor:     fgColor,
-	}
+	s.List.Item.Normal = ListItemStyle{}
+	s.List.Item.Normal.Border = RectBounds{0, 0, 1, 0}
+	s.List.Item.Normal.Padding = RectBounds{0, 0, 0, 2}
+	s.List.Item.Normal.BorderColor = math32.Color4{0, 0, 0, 0}
+	s.List.Item.Normal.BgColor = bgColor4
+	s.List.Item.Normal.FgColor = fgColor
 	s.List.Item.Selected = s.List.Item.Normal
 	s.List.Item.Selected.BgColor = bgColor4Sel
 	s.List.Item.Selected.FgColor = fgColorSel
@@ -207,13 +197,12 @@ func NewLightStyle() *Style {
 
 	// DropDown styles
 	s.DropDown = DropDownStyles{}
-	s.DropDown.Normal = DropDownStyle{
-		Border:      oneBounds,
-		Paddings:    RectBounds{0, 0, 0, 2},
-		BorderColor: borderColor,
-		BgColor:     bgColor,
-		FgColor:     fgColor,
-	}
+	s.DropDown.Normal = DropDownStyle{}
+	s.DropDown.Normal.Border = oneBounds
+	s.DropDown.Normal.Padding = RectBounds{0, 0, 0, 2}
+	s.DropDown.Normal.BorderColor = borderColor
+	s.DropDown.Normal.BgColor = bgColor
+	s.DropDown.Normal.FgColor = fgColor
 	s.DropDown.Over = s.DropDown.Normal
 	s.DropDown.Over.BgColor = bgColorOver
 	s.DropDown.Focus = s.DropDown.Over
@@ -221,19 +210,17 @@ func NewLightStyle() *Style {
 
 	// Folder styles
 	s.Folder = FolderStyles{}
-	s.Folder.Normal = FolderStyle{
-		Margins:     zeroBounds,
-		Border:      oneBounds,
-		Paddings:    RectBounds{2, 0, 2, 2},
-		BorderColor: borderColor,
-		BgColor:     bgColor,
-		FgColor:     fgColor,
-		Icons:       [2]string{icon.ExpandMore, icon.ExpandLess},
-	}
+	s.Folder.Normal = FolderStyle{}
+	s.Folder.Normal.Border = oneBounds
+	s.Folder.Normal.Padding = RectBounds{2, 0, 2, 2}
+	s.Folder.Normal.BorderColor = borderColor
+	s.Folder.Normal.BgColor = bgColor
+	s.Folder.Normal.FgColor = fgColor
+	s.Folder.Normal.Icons = [2]string{icon.ExpandMore, icon.ExpandLess}
 	s.Folder.Over = s.Folder.Normal
 	s.Folder.Over.BgColor = bgColorOver
 	s.Folder.Focus = s.Folder.Over
-	s.Folder.Focus.Paddings = twoBounds
+	s.Folder.Focus.Padding = twoBounds
 	s.Folder.Disabled = s.Folder.Focus
 
 	// Tree styles
@@ -241,34 +228,31 @@ func NewLightStyle() *Style {
 	s.Tree.Padlevel = 16.0
 	s.Tree.List = &s.List
 	s.Tree.Node = &TreeNodeStyles{}
-	s.Tree.Node.Normal = TreeNodeStyle{
-		Border:      zeroBounds,
-		Paddings:    zeroBounds,
-		BorderColor: borderColor,
-		BgColor:     bgColor4,
-		FgColor:     fgColor,
-		Icons:       [2]string{icon.ExpandMore, icon.ExpandLess},
-	}
+	s.Tree.Node.Normal = TreeNodeStyle{}
+	s.Tree.Node.Normal.BorderColor = borderColor
+	s.Tree.Node.Normal.BgColor = bgColor4
+	s.Tree.Node.Normal.FgColor = fgColor
+	s.Tree.Node.Normal.Icons = [2]string{icon.ExpandMore, icon.ExpandLess}
 
 	// ControlFolder styles
 	s.ControlFolder = ControlFolderStyles{}
 	s.ControlFolder.Folder = &FolderStyles{}
 	s.ControlFolder.Folder.Normal = s.Folder.Normal
 	s.ControlFolder.Folder.Normal.BorderColor = math32.Color4{0, 0, 0, 0}
-	s.ControlFolder.Folder.Normal.BgColor = math32.Color{0, 0.5, 1}
+	s.ControlFolder.Folder.Normal.BgColor = math32.Color4{0, 0.5, 1, 1}
 	s.ControlFolder.Folder.Over = s.ControlFolder.Folder.Normal
 	s.ControlFolder.Folder.Focus = s.ControlFolder.Folder.Normal
-	s.ControlFolder.Folder.Focus.Paddings = twoBounds
+	s.ControlFolder.Folder.Focus.Padding = twoBounds
 	s.ControlFolder.Folder.Disabled = s.ControlFolder.Folder.Focus
 	s.ControlFolder.Tree = &TreeStyles{}
 	s.ControlFolder.Tree.Padlevel = 2.0
 	s.ControlFolder.Tree.List = &ListStyles{}
 	scrollerStylesCopy := *s.List.Scroller
 	s.ControlFolder.Tree.List.Scroller = &scrollerStylesCopy
-	s.ControlFolder.Tree.List.Scroller.Normal.Paddings = RectBounds{0, 2, 0, 0}
-	s.ControlFolder.Tree.List.Scroller.Over.Paddings = RectBounds{0, 2, 0, 0}
-	s.ControlFolder.Tree.List.Scroller.Focus.Paddings = RectBounds{0, 2, 0, 0}
-	s.ControlFolder.Tree.List.Scroller.Disabled.Paddings = RectBounds{0, 2, 0, 0}
+	s.ControlFolder.Tree.List.Scroller.Normal.Padding = RectBounds{0, 2, 0, 0}
+	s.ControlFolder.Tree.List.Scroller.Over.Padding = RectBounds{0, 2, 0, 0}
+	s.ControlFolder.Tree.List.Scroller.Focus.Padding = RectBounds{0, 2, 0, 0}
+	s.ControlFolder.Tree.List.Scroller.Disabled.Padding = RectBounds{0, 2, 0, 0}
 	s.ControlFolder.Tree.List.Item = s.List.Item
 	s.ControlFolder.Tree.Node = &TreeNodeStyles{}
 	s.ControlFolder.Tree.Node.Normal = s.Tree.Node.Normal
@@ -276,69 +260,62 @@ func NewLightStyle() *Style {
 	// Menu styles
 	s.Menu = MenuStyles{}
 	s.Menu.Body = &MenuBodyStyles{}
-	s.Menu.Body.Normal = MenuBodyStyle{
-		Border:      oneBounds,
-		Paddings:    twoBounds,
-		BorderColor: borderColor,
-		BgColor:     bgColor,
-		FgColor:     fgColor,
-	}
+	s.Menu.Body.Normal = MenuBodyStyle{}
+	s.Menu.Body.Normal.Border = oneBounds
+	s.Menu.Body.Normal.Padding = twoBounds
+	s.Menu.Body.Normal.BorderColor = borderColor
+	s.Menu.Body.Normal.BgColor = bgColor
+	s.Menu.Body.Normal.FgColor = fgColor
 	s.Menu.Body.Over = s.Menu.Body.Normal
 	s.Menu.Body.Over.BgColor = bgColorOver
 	s.Menu.Body.Focus = s.Menu.Body.Over
 	s.Menu.Body.Disabled = s.Menu.Body.Normal
 	s.Menu.Item = &MenuItemStyles{}
-	s.Menu.Item.Normal = MenuItemStyle{
-		Border:           zeroBounds,
-		Paddings:         RectBounds{2, 4, 2, 2},
-		BorderColor:      borderColor,
-		BgColor:          bgColor,
-		FgColor:          fgColor,
-		IconPaddings:     RectBounds{0, 6, 0, 4},
-		ShortcutPaddings: RectBounds{0, 0, 0, 10},
-		RiconPaddings:    RectBounds{2, 0, 0, 4},
-	}
+	s.Menu.Item.Normal = MenuItemStyle{}
+	s.Menu.Item.Normal.Padding = RectBounds{2, 4, 2, 2}
+	s.Menu.Item.Normal.BorderColor = borderColor
+	s.Menu.Item.Normal.BgColor = bgColor
+	s.Menu.Item.Normal.FgColor = fgColor
+	s.Menu.Item.Normal.IconPaddings = RectBounds{0, 6, 0, 4}
+	s.Menu.Item.Normal.ShortcutPaddings = RectBounds{0, 0, 0, 10}
+	s.Menu.Item.Normal.RiconPaddings = RectBounds{2, 0, 0, 4}
 	s.Menu.Item.Over = s.Menu.Item.Normal
-	s.Menu.Item.Over.BgColor = math32.Color{0.6, 0.6, 0.6}
+	s.Menu.Item.Over.BgColor = math32.Color4{0.6, 0.6, 0.6, 1}
 	s.Menu.Item.Disabled = s.Menu.Item.Normal
 	s.Menu.Item.Disabled.FgColor = fgColorDis
-	s.Menu.Item.Separator = MenuItemStyle{
-		Border:      twoBounds,
-		Paddings:    zeroBounds,
-		BorderColor: math32.Color4{0, 0, 0, 0},
-		BgColor:     math32.Color{0.6, 0.6, 0.6},
-		FgColor:     fgColor,
-	}
+	s.Menu.Item.Separator = MenuItemStyle{}
+	s.Menu.Item.Separator.Border = twoBounds
+	s.Menu.Item.Separator.Padding = zeroBounds
+	s.Menu.Item.Separator.BorderColor = math32.Color4{0, 0, 0, 0}
+	s.Menu.Item.Separator.BgColor = math32.Color4{0.6, 0.6, 0.6, 1}
+	s.Menu.Item.Separator.FgColor = fgColor
 
 	// Table styles
 	s.Table = TableStyles{}
-	s.Table.Header = TableHeaderStyle{
-		Border:      RectBounds{0, 1, 1, 0},
-		Paddings:    twoBounds,
-		BorderColor: borderColor,
-		BgColor:     math32.Color{0.7, 0.7, 0.7},
-		FgColor:     fgColor,
-	}
-	s.Table.RowEven = TableRowStyle{
-		Border:      RectBounds{0, 1, 1, 0},
-		Paddings:    twoBounds,
-		BorderColor: math32.Color4{0.6, 0.6, 0.6, 1},
-		BgColor:     math32.Color{0.90, 0.90, 0.90},
-		FgColor:     fgColor,
-	}
+	s.Table.Header = TableHeaderStyle{}
+	s.Table.Header.Border = RectBounds{0, 1, 1, 0}
+	s.Table.Header.Padding = twoBounds
+	s.Table.Header.BorderColor = borderColor
+	s.Table.Header.BgColor = math32.Color4{0.7, 0.7, 0.7, 1}
+	s.Table.Header.FgColor = fgColor
+	s.Table.RowEven = TableRowStyle{}
+	s.Table.RowEven.Border = RectBounds{0, 1, 1, 0}
+	s.Table.RowEven.Padding = twoBounds
+	s.Table.RowEven.BorderColor = math32.Color4{0.6, 0.6, 0.6, 1}
+	s.Table.RowEven.BgColor = math32.Color4{0.90, 0.90, 0.90, 1}
+	s.Table.RowEven.FgColor = fgColor
 	s.Table.RowOdd = s.Table.RowEven
-	s.Table.RowOdd.BgColor = math32.Color{0.88, 0.88, 0.88}
+	s.Table.RowOdd.BgColor = math32.Color4{0.88, 0.88, 0.88, 1}
 	s.Table.RowCursor = s.Table.RowEven
-	s.Table.RowCursor.BgColor = math32.Color{0.75, 0.75, 0.75}
+	s.Table.RowCursor.BgColor = math32.Color4{0.75, 0.75, 0.75, 1}
 	s.Table.RowSel = s.Table.RowEven
-	s.Table.RowSel.BgColor = math32.Color{0.70, 0.70, 0.70}
-	s.Table.Status = TableStatusStyle{
-		Border:      RectBounds{1, 0, 0, 0},
-		Paddings:    twoBounds,
-		BorderColor: borderColor,
-		BgColor:     math32.Color{0.9, 0.9, 0.9},
-		FgColor:     fgColor,
-	}
+	s.Table.RowSel.BgColor = math32.Color4{0.70, 0.70, 0.70, 1}
+	s.Table.Status = TableStatusStyle{}
+	s.Table.Status.Border = RectBounds{1, 0, 0, 0}
+	s.Table.Status.Padding = twoBounds
+	s.Table.Status.BorderColor = borderColor
+	s.Table.Status.BgColor = math32.Color4{0.9, 0.9, 0.9, 1}
+	s.Table.Status.FgColor = fgColor
 	s.Table.Resizer = TableResizerStyle{
 		Width:       4,
 		Border:      zeroBounds,
@@ -348,13 +325,11 @@ func NewLightStyle() *Style {
 
 	// ImageButton styles
 	s.ImageButton = ImageButtonStyles{}
-	s.ImageButton.Normal = ImageButtonStyle{
-		Border:      oneBounds,
-		Paddings:    zeroBounds,
-		BorderColor: borderColor,
-		BgColor:     bgColor4,
-		FgColor:     fgColor,
-	}
+	s.ImageButton.Normal = ImageButtonStyle{}
+	s.ImageButton.Normal.Border = oneBounds
+	s.ImageButton.Normal.BorderColor = borderColor
+	s.ImageButton.Normal.BgColor = bgColor4
+	s.ImageButton.Normal.FgColor = fgColor
 	s.ImageButton.Over = s.ImageButton.Normal
 	s.ImageButton.Over.BgColor = bgColor4Over
 	s.ImageButton.Focus = s.ImageButton.Over
@@ -368,12 +343,11 @@ func NewLightStyle() *Style {
 		ListButtonIcon:     icon.MoreVert,
 		ListButtonPaddings: RectBounds{2, 4, 0, 0},
 	}
-	s.TabBar.Normal = TabBarStyle{
-		Border:      oneBounds,
-		Paddings:    RectBounds{2, 0, 0, 0},
-		BorderColor: borderColor,
-		BgColor:     math32.Color4{0.7, 0.7, 0.7, 1},
-	}
+	s.TabBar.Normal = TabBarStyle{}
+	s.TabBar.Normal.Border = oneBounds
+	s.TabBar.Normal.Padding = RectBounds{2, 0, 0, 0}
+	s.TabBar.Normal.BorderColor = borderColor
+	s.TabBar.Normal.BgColor = math32.Color4{0.7, 0.7, 0.7, 1}
 	s.TabBar.Over = s.TabBar.Normal
 	s.TabBar.Over.BgColor = bgColor4Over
 	s.TabBar.Focus = s.TabBar.Normal
@@ -384,14 +358,13 @@ func NewLightStyle() *Style {
 		ImagePaddings: RectBounds{0, 2, 0, 0},
 		IconClose:     icon.Clear,
 	}
-	s.TabBar.Tab.Normal = TabStyle{
-		Margins:     RectBounds{0, 2, 0, 2},
-		Border:      RectBounds{1, 1, 0, 1},
-		Paddings:    twoBounds,
-		BorderColor: borderColor,
-		BgColor:     bgColor4,
-		FgColor:     fgColor,
-	}
+	s.TabBar.Tab.Normal = TabStyle{}
+	s.TabBar.Tab.Normal.Margin = RectBounds{0, 2, 0, 2}
+	s.TabBar.Tab.Normal.Border = RectBounds{1, 1, 0, 1}
+	s.TabBar.Tab.Normal.Padding = twoBounds
+	s.TabBar.Tab.Normal.BorderColor = borderColor
+	s.TabBar.Tab.Normal.BgColor = bgColor4
+	s.TabBar.Tab.Normal.FgColor = fgColor
 	s.TabBar.Tab.Over = s.TabBar.Tab.Normal
 	s.TabBar.Tab.Over.BgColor = bgColor4Over
 	s.TabBar.Tab.Focus = s.TabBar.Tab.Normal

gui/tabbar.go

@@ -7,7 +7,6 @@ package gui
 import (
 	"fmt"
 
-	"github.com/g3n/engine/math32"
 	"github.com/g3n/engine/window"
 )
 
@@ -26,12 +25,7 @@ type TabBar struct {
 }
 
 // TabBarStyle describes the style of the TabBar
-type TabBarStyle struct {
-	Border      RectBounds    // Border sizes
-	Paddings    RectBounds    // Padding sizes
-	BorderColor math32.Color4 // Border color
-	BgColor     math32.Color4 // Background color
-}
+type TabBarStyle BasicStyle
 
 // TabBarStyles describes all the TabBarStyles
 type TabBarStyles struct {
@@ -46,14 +40,7 @@ type TabBarStyles struct {
 }
 
 // TabStyle describes the style of the individual Tabs header
-type TabStyle struct {
-	Margins     RectBounds    // Tab header margins
-	Border      RectBounds    // Tab header borders
-	Paddings    RectBounds    // Tab header paddings
-	BorderColor math32.Color4 // Tab header border color
-	BgColor     math32.Color4 // Tab header background color
-	FgColor     math32.Color  // Tab header color for icon and text
-}
+type TabStyle BasicStyle
 
 // TabStyles describes all Tab styles
 type TabStyles struct {
@@ -293,10 +280,7 @@ func (tb *TabBar) onListChange(evname string, ev interface{}) {
 // applyStyle applies the specified TabBar style
 func (tb *TabBar) applyStyle(s *TabBarStyle) {
 
-	tb.SetBordersFrom(&s.Border)
-	tb.SetBordersColor4(&s.BorderColor)
-	tb.SetPaddingsFrom(&s.Paddings)
-	tb.SetColor4(&s.BgColor)
+	tb.Panel.ApplyStyle(&s.PanelStyle)
 	tb.separator.SetColor4(&s.BorderColor)
 }
 
@@ -626,11 +610,7 @@ func (tab *Tab) minWidth() float32 {
 // applyStyle applies the specified Tab style to the Tab header
 func (tab *Tab) applyStyle(s *TabStyle) {
 
-	tab.header.SetMarginsFrom(&s.Margins)
-	tab.header.SetBordersFrom(&s.Border)
-	tab.header.SetBordersColor4(&s.BorderColor)
-	tab.header.SetPaddingsFrom(&s.Paddings)
-	tab.header.SetColor4(&s.BgColor)
+	tab.header.GetPanel().ApplyStyle(&s.PanelStyle)
 }
 
 // update updates the Tab header visual style
@@ -657,7 +637,7 @@ func (tab *Tab) setBottomPanel() {
 
 	if tab.selected {
 		bwidth := tab.header.ContentWidth() + tab.header.Paddings().Left + tab.header.Paddings().Right
-		bx := tab.styles.Selected.Margins.Left + tab.styles.Selected.Border.Left
+		bx := tab.styles.Selected.Margin.Left + tab.styles.Selected.Border.Left
 		tab.bottom.SetSize(bwidth, tab.tb.styles.SepHeight)
 		tab.bottom.SetPosition(bx, tab.header.Height())
 	}

gui/table.go

@@ -106,31 +106,13 @@ type TableCell struct {
 type TableFormatFunc func(cell TableCell) string
 
 // TableHeaderStyle describes the style of the table header
-type TableHeaderStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type TableHeaderStyle BasicStyle
 
 // TableRowStyle describes the style of the table row
-type TableRowStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type TableRowStyle BasicStyle
 
 // TableStatusStyle describes the style of the table status line panel
-type TableStatusStyle struct {
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color
-	FgColor     math32.Color
-}
+type TableStatusStyle BasicStyle
 
 // TableResizerStyle describes the style of the table resizer panel
 type TableResizerStyle struct {
@@ -1582,17 +1564,11 @@ func (t *Table) updateRowStyle(ri int) {
 // the last header panel does not the right border.
 func (t *Table) applyHeaderStyle(h *Panel, last bool) {
 
-	s := t.styles.Header
-	borders := s.Border
-	if !last {
-		h.SetBordersFrom(&borders)
-	} else {
-		borders.Right = 0
-		h.SetBordersFrom(&borders)
+	styleCopy := t.styles.Header.PanelStyle
+	if last {
+		styleCopy.Border.Right = 0
 	}
-	h.SetBordersColor4(&s.BorderColor)
-	h.SetPaddingsFrom(&s.Paddings)
-	h.SetColor(&s.BgColor)
+	h.ApplyStyle(&styleCopy)
 }
 
 // applyRowStyle applies the specified style to all cells for the specified table row
@@ -1600,10 +1576,7 @@ func (t *Table) applyRowStyle(trow *tableRow, trs *TableRowStyle) {
 
 	for i := 0; i < len(trow.cells); i++ {
 		cell := trow.cells[i]
-		cell.SetBordersFrom(&trs.Border)
-		cell.SetBordersColor4(&trs.BorderColor)
-		cell.SetPaddingsFrom(&trs.Paddings)
-		cell.SetColor(&trs.BgColor)
+		cell.ApplyStyle(&trs.PanelStyle)
 	}
 }
 
@@ -1611,10 +1584,7 @@ func (t *Table) applyRowStyle(trow *tableRow, trs *TableRowStyle) {
 func (t *Table) applyStatusStyle() {
 
 	s := t.styles.Status
-	t.statusPanel.SetBordersFrom(&s.Border)
-	t.statusPanel.SetBordersColor4(&s.BorderColor)
-	t.statusPanel.SetPaddingsFrom(&s.Paddings)
-	t.statusPanel.SetColor(&s.BgColor)
+	t.statusPanel.ApplyStyle(&s.PanelStyle)
 }
 
 // applyResizerStyle applies the status style

gui/tree.go

@@ -25,12 +25,8 @@ type TreeNodeStyles struct {
 }
 
 type TreeNodeStyle struct {
-	Margins     RectBounds
-	Border      RectBounds
-	Paddings    RectBounds
-	BorderColor math32.Color4
-	BgColor     math32.Color4
-	FgColor     math32.Color
+	PanelStyle
+	FgColor     math32.Color4
 	Icons       [2]string
 }
 
@@ -362,17 +358,14 @@ func (n *TreeNode) level() int {
 // applyStyles applies the specified style to this tree node
 func (n *TreeNode) applyStyle(s *TreeNodeStyle) {
 
-	n.SetMarginsFrom(&s.Margins)
-	n.SetBordersColor4(&s.BorderColor)
-	n.SetBordersFrom(&s.Border)
-	n.SetColor4(&s.BgColor)
+	n.Panel.ApplyStyle(&s.PanelStyle)
 	icode := 0
 	if n.expanded {
 		icode = 1
 	}
 	n.icon.SetText(string(s.Icons[icode]))
-	n.icon.SetColor(&s.FgColor)
-	n.label.SetColor(&s.FgColor)
+	n.icon.SetColor4(&s.FgColor)
+	n.label.SetColor4(&s.FgColor)
 }
 
 // update updates this tree node style