outputs/group.go
// Copyright 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package outputs
import (
"image/color"
"math"
"time"
"barista.run/bar"
"barista.run/timing"
)
// SegmentGroup represents a group of Segments to be
// displayed together on the bar.
type SegmentGroup struct {
outputs []bar.Output
timedOutputs []bar.TimedOutput
startTime time.Time
// To support addition of segments after construction, store
// attributes on the group, and apply them in Segments().
attrSet int
clickHandler func(bar.Event)
color color.Color
background color.Color
border color.Color
minWidth int
align bar.TextAlignment
urgent bool
innerSeparator bool
innerPadding int
outerSeparator bool
outerPadding int
}
const (
sgaUrgent int = 1 << iota
sgaMinWidth
sgaInnerSeparators
sgaInnerPadding
sgaOuterSeparator
sgaOuterPadding
)
// OnClick sets the default click handler for the group. Any segments
// that don't already have a click handler will delegate to this one.
func (g *SegmentGroup) OnClick(f func(bar.Event)) *SegmentGroup {
g.clickHandler = f
return g
}
// Color sets the color for all segments in the group.
func (g *SegmentGroup) Color(color color.Color) *SegmentGroup {
g.color = color
return g
}
// Background sets the background color for all segments in the group.
func (g *SegmentGroup) Background(background color.Color) *SegmentGroup {
g.background = background
return g
}
// Border sets the border color for all segments in the group.
func (g *SegmentGroup) Border(border color.Color) *SegmentGroup {
g.border = border
return g
}
// Align sets the text alignment for all segments in the group.
func (g *SegmentGroup) Align(align bar.TextAlignment) *SegmentGroup {
g.align = align
return g
}
// Urgent sets the urgency flag for all segments in the group.
func (g *SegmentGroup) Urgent(urgent bool) *SegmentGroup {
g.attrSet |= sgaUrgent
g.urgent = urgent
return g
}
/*
Width and separator(width) are treated specially such that the methods
make sense when called on a single-segment output (such as the result
of outputs.Textf(...)) as well as when called on a multi-segment group.
To that end, min-width distributes the minimum width equally amongst
all segments, and separator(width) only operate on the last segment.
Additional methods for "inner" separator(width) operate on all but the
last segment.
*/
// MinWidth sets the minimum width for the output, by (mostly) equally
// distributing the given minWidth amongst all segments in the group.
func (g *SegmentGroup) MinWidth(minWidth int) *SegmentGroup {
g.attrSet |= sgaMinWidth
g.minWidth = minWidth
return g
}
// Separator sets the separator visibility of the last segment in the group.
func (g *SegmentGroup) Separator(separator bool) *SegmentGroup {
g.attrSet |= sgaOuterSeparator
g.outerSeparator = separator
return g
}
// Padding sets the padding of the last segment in the group.
func (g *SegmentGroup) Padding(separatorWidth int) *SegmentGroup {
g.attrSet |= sgaOuterPadding
g.outerPadding = separatorWidth
return g
}
// InnerSeparators sets the separator visibility between segments of this group.
func (g *SegmentGroup) InnerSeparators(separator bool) *SegmentGroup {
g.attrSet |= sgaInnerSeparators
g.innerSeparator = separator
return g
}
// InnerPadding sets the padding between segments of this group.
func (g *SegmentGroup) InnerPadding(separatorWidth int) *SegmentGroup {
g.attrSet |= sgaInnerPadding
g.innerPadding = separatorWidth
return g
}
// Glue is a shortcut to remove the inner separators and padding.
func (g *SegmentGroup) Glue() *SegmentGroup {
return g.InnerSeparators(false).InnerPadding(0)
}
// Append adds an additional output to this group.
func (g *SegmentGroup) Append(output bar.Output) *SegmentGroup {
if g.startTime.IsZero() {
g.startTime = timing.Now()
}
if output == nil {
return g
}
output = resetStartTime(output, g.startTime)
g.outputs = append(g.outputs, output)
if to, ok := output.(bar.TimedOutput); ok {
g.timedOutputs = append(g.timedOutputs, to)
}
return g
}
// isSet returns true if an attribute was set, discarding its value.
func isSet(_ interface{}, isSet bool) bool {
return isSet
}
// Segments implements bar.Output for SegmentGroup.
// This method is responsible for computing all attributes so that
// all segments, even those added after attributes were set on the group
// correctly reflect those attributes in the final output.
func (g *SegmentGroup) Segments() []*bar.Segment {
var segments []*bar.Segment
for _, o := range g.outputs {
for _, s := range o.Segments() {
segments = append(segments, s.Clone())
}
}
remainingWidth := float64(g.minWidth)
if g.attrSet&sgaMinWidth != 0 {
remainingWidth -= existingMinWidth(segments)
}
for idx, s := range segments {
remainingSegments := len(segments) - idx
if remainingSegments == 1 {
if !isSet(s.HasSeparator()) && g.attrSet&sgaOuterSeparator != 0 {
s.Separator(g.outerSeparator)
}
if !isSet(s.GetPadding()) && g.attrSet&sgaOuterPadding != 0 {
s.Padding(g.outerPadding)
}
} else {
if !isSet(s.HasSeparator()) && g.attrSet&sgaInnerSeparators != 0 {
s.Separator(g.innerSeparator)
}
if !isSet(s.GetPadding()) && g.attrSet&sgaInnerPadding != 0 {
s.Padding(g.innerPadding)
}
}
if !isSet(s.GetMinWidth()) && g.attrSet&sgaMinWidth != 0 {
myWidth := math.Floor(remainingWidth/float64(remainingSegments) + 0.5)
if myWidth >= 0 {
s.MinWidth(int(myWidth))
remainingWidth = remainingWidth - myWidth
}
}
if !isSet(s.GetColor()) && g.color != nil {
s.Color(g.color)
}
if !isSet(s.GetBackground()) && g.background != nil {
s.Background(g.background)
}
if !isSet(s.GetBorder()) && g.border != nil {
s.Border(g.border)
}
if !isSet(s.GetAlignment()) && g.align != "" {
s.Align(g.align)
}
if !isSet(s.IsUrgent()) && g.attrSet&sgaUrgent != 0 {
s.Urgent(g.urgent)
}
if !s.HasClick() && g.clickHandler != nil {
s.OnClick(g.clickHandler)
}
}
return segments
}
// NextRefresh handles the case of one or more TimedOutputs being added to the
// group. If any timed outputs exist, NextRefresh will return the earliest next
// refresh time of any of them.
func (g *SegmentGroup) NextRefresh() time.Time {
var refresh time.Time
for _, o := range g.timedOutputs {
next := o.NextRefresh()
if next.IsZero() {
continue
}
if refresh.IsZero() || next.Before(refresh) {
refresh = next
}
}
return refresh
}
// existingMinWidth sums all integral minimum widths from the segments.
// This allows us to distribute the minWidth amongst the other segments
// while keeping the total min width the same as what was given.
func existingMinWidth(segments []*bar.Segment) (result float64) {
for _, s := range segments {
minWidth, isSet := s.GetMinWidth()
if !isSet {
continue
}
if minWidthPx, ok := minWidth.(int); ok {
result += float64(minWidthPx)
}
}
return result
}