forked from mum4k/termdash
-
Notifications
You must be signed in to change notification settings - Fork 0
/
options.go
769 lines (687 loc) · 25 KB
/
options.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
// 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 container
// options.go defines container options.
import (
"errors"
"fmt"
"image"
"github.com/mum4k/termdash/align"
"github.com/mum4k/termdash/cell"
"github.com/mum4k/termdash/internal/area"
"github.com/mum4k/termdash/linestyle"
"github.com/mum4k/termdash/widgetapi"
)
// applyOptions applies the options to the container and validates them.
func applyOptions(c *Container, opts ...Option) error {
for _, opt := range opts {
if err := opt.set(c); err != nil {
return err
}
}
return nil
}
// validateOptions validates options set in the container tree.
func validateOptions(c *Container) error {
// ensure all the container identifiers are either empty or unique.
var errStr string
seenID := map[string]bool{}
preOrder(c, &errStr, func(c *Container) error {
if c.opts.id == "" {
return nil
}
if seenID[c.opts.id] {
return fmt.Errorf("duplicate container ID %q", c.opts.id)
}
seenID[c.opts.id] = true
return nil
})
if errStr != "" {
return errors.New(errStr)
}
return nil
}
// Option is used to provide options to a container.
type Option interface {
// set sets the provided option.
set(*Container) error
}
// options stores the options provided to the container.
type options struct {
// id is the identifier provided by the user.
id string
// inherited are options that are inherited by child containers.
inherited inherited
// split identifies how is this container split.
split splitType
splitPercent int
// widget is the widget in the container.
// A container can have either two sub containers (left and right) or a
// widget. But not both.
widget widgetapi.Widget
// Alignment of the widget if present.
hAlign align.Horizontal
vAlign align.Vertical
// border is the border around the container.
border linestyle.LineStyle
borderTitle string
borderTitleHAlign align.Horizontal
// padding is a space reserved between the outer edge of the container and
// its content (the widget or other sub-containers).
padding padding
// margin is a space reserved on the outside of the container.
margin margin
}
// margin stores the configured margin for the container.
// For each margin direction, only one of the percentage or cells is set.
type margin struct {
topCells int
topPerc int
rightCells int
rightPerc int
bottomCells int
bottomPerc int
leftCells int
leftPerc int
}
// apply applies the configured margin to the area.
func (p *margin) apply(ar image.Rectangle) (image.Rectangle, error) {
switch {
case p.topCells != 0 || p.rightCells != 0 || p.bottomCells != 0 || p.leftCells != 0:
return area.Shrink(ar, p.topCells, p.rightCells, p.bottomCells, p.leftCells)
case p.topPerc != 0 || p.rightPerc != 0 || p.bottomPerc != 0 || p.leftPerc != 0:
return area.ShrinkPercent(ar, p.topPerc, p.rightPerc, p.bottomPerc, p.leftPerc)
}
return ar, nil
}
// padding stores the configured padding for the container.
// For each padding direction, only one of the percentage or cells is set.
type padding struct {
topCells int
topPerc int
rightCells int
rightPerc int
bottomCells int
bottomPerc int
leftCells int
leftPerc int
}
// apply applies the configured padding to the area.
func (p *padding) apply(ar image.Rectangle) (image.Rectangle, error) {
switch {
case p.topCells != 0 || p.rightCells != 0 || p.bottomCells != 0 || p.leftCells != 0:
return area.Shrink(ar, p.topCells, p.rightCells, p.bottomCells, p.leftCells)
case p.topPerc != 0 || p.rightPerc != 0 || p.bottomPerc != 0 || p.leftPerc != 0:
return area.ShrinkPercent(ar, p.topPerc, p.rightPerc, p.bottomPerc, p.leftPerc)
}
return ar, nil
}
// inherited contains options that are inherited by child containers.
type inherited struct {
// borderColor is the color used for the border.
borderColor cell.Color
// focusedColor is the color used for the border when focused.
focusedColor cell.Color
}
// newOptions returns a new options instance with the default values.
// Parent are the inherited options from the parent container or nil if these
// options are for a container with no parent (the root).
func newOptions(parent *options) *options {
opts := &options{
inherited: inherited{
focusedColor: cell.ColorYellow,
},
hAlign: align.HorizontalCenter,
vAlign: align.VerticalMiddle,
splitPercent: DefaultSplitPercent,
}
if parent != nil {
opts.inherited = parent.inherited
}
return opts
}
// option implements Option.
type option func(*Container) error
// set implements Option.set.
func (o option) set(c *Container) error {
return o(c)
}
// SplitOption is used when splitting containers.
type SplitOption interface {
// setSplit sets the provided split option.
setSplit(*options) error
}
// splitOption implements SplitOption.
type splitOption func(*options) error
// setSplit implements SplitOption.setSplit.
func (so splitOption) setSplit(opts *options) error {
return so(opts)
}
// DefaultSplitPercent is the default value for the SplitPercent option.
const DefaultSplitPercent = 50
// SplitPercent sets the relative size of the split as percentage of the available space.
// When using SplitVertical, the provided size is applied to the new left
// container, the new right container gets the reminder of the size.
// When using SplitHorizontal, the provided size is applied to the new top
// container, the new bottom container gets the reminder of the size.
// The provided value must be a positive number in the range 0 < p < 100.
// If not provided, defaults to DefaultSplitPercent.
func SplitPercent(p int) SplitOption {
return splitOption(func(opts *options) error {
if min, max := 0, 100; p <= min || p >= max {
return fmt.Errorf("invalid split percentage %d, must be in range %d < p < %d", p, min, max)
}
opts.splitPercent = p
return nil
})
}
// SplitVertical splits the container along the vertical axis into two sub
// containers. The use of this option removes any widget placed at this
// container, containers with sub containers cannot contain widgets.
func SplitVertical(l LeftOption, r RightOption, opts ...SplitOption) Option {
return option(func(c *Container) error {
c.opts.split = splitTypeVertical
c.opts.widget = nil
for _, opt := range opts {
if err := opt.setSplit(c.opts); err != nil {
return err
}
}
if err := c.createFirst(l.lOpts()); err != nil {
return err
}
return c.createSecond(r.rOpts())
})
}
// SplitHorizontal splits the container along the horizontal axis into two sub
// containers. The use of this option removes any widget placed at this
// container, containers with sub containers cannot contain widgets.
func SplitHorizontal(t TopOption, b BottomOption, opts ...SplitOption) Option {
return option(func(c *Container) error {
c.opts.split = splitTypeHorizontal
c.opts.widget = nil
for _, opt := range opts {
if err := opt.setSplit(c.opts); err != nil {
return err
}
}
if err := c.createFirst(t.tOpts()); err != nil {
return err
}
return c.createSecond(b.bOpts())
})
}
// ID sets an identifier for this container.
// This ID can be later used to perform dynamic layout changes by passing new
// options to this container. When provided, it must be a non-empty string that
// is unique among all the containers.
func ID(id string) Option {
return option(func(c *Container) error {
if id == "" {
return errors.New("the ID cannot be an empty string")
}
c.opts.id = id
return nil
})
}
// Clear clears this container.
// If the container contains a widget, the widget is removed.
// If the container had any sub containers or splits, they are removed.
func Clear() Option {
return option(func(c *Container) error {
c.opts.widget = nil
c.first = nil
c.second = nil
return nil
})
}
// PlaceWidget places the provided widget into the container.
// The use of this option removes any sub containers. Containers with sub
// containers cannot have widgets.
func PlaceWidget(w widgetapi.Widget) Option {
return option(func(c *Container) error {
c.opts.widget = w
c.first = nil
c.second = nil
return nil
})
}
// MarginTop sets reserved space outside of the container at its top.
// The provided number is the absolute margin in cells and must be zero or a
// positive integer. Only one of MarginTop or MarginTopPercent can be specified.
func MarginTop(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid MarginTop(%d), must be in range %d <= value", cells, min)
}
if c.opts.margin.topPerc > 0 {
return fmt.Errorf("cannot specify both MarginTop(%d) and MarginTopPercent(%d)", cells, c.opts.margin.topPerc)
}
c.opts.margin.topCells = cells
return nil
})
}
// MarginRight sets reserved space outside of the container at its right.
// The provided number is the absolute margin in cells and must be zero or a
// positive integer. Only one of MarginRight or MarginRightPercent can be specified.
func MarginRight(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid MarginRight(%d), must be in range %d <= value", cells, min)
}
if c.opts.margin.rightPerc > 0 {
return fmt.Errorf("cannot specify both MarginRight(%d) and MarginRightPercent(%d)", cells, c.opts.margin.rightPerc)
}
c.opts.margin.rightCells = cells
return nil
})
}
// MarginBottom sets reserved space outside of the container at its bottom.
// The provided number is the absolute margin in cells and must be zero or a
// positive integer. Only one of MarginBottom or MarginBottomPercent can be specified.
func MarginBottom(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid MarginBottom(%d), must be in range %d <= value", cells, min)
}
if c.opts.margin.bottomPerc > 0 {
return fmt.Errorf("cannot specify both MarginBottom(%d) and MarginBottomPercent(%d)", cells, c.opts.margin.bottomPerc)
}
c.opts.margin.bottomCells = cells
return nil
})
}
// MarginLeft sets reserved space outside of the container at its left.
// The provided number is the absolute margin in cells and must be zero or a
// positive integer. Only one of MarginLeft or MarginLeftPercent can be specified.
func MarginLeft(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid MarginLeft(%d), must be in range %d <= value", cells, min)
}
if c.opts.margin.leftPerc > 0 {
return fmt.Errorf("cannot specify both MarginLeft(%d) and MarginLeftPercent(%d)", cells, c.opts.margin.leftPerc)
}
c.opts.margin.leftCells = cells
return nil
})
}
// MarginTopPercent sets reserved space outside of the container at its top.
// The provided number is a relative margin defined as percentage of the container's height.
// Only one of MarginTop or MarginTopPercent can be specified.
// The value must be in range 0 <= value <= 100.
func MarginTopPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid MarginTopPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.margin.topCells > 0 {
return fmt.Errorf("cannot specify both MarginTopPercent(%d) and MarginTop(%d)", perc, c.opts.margin.topCells)
}
c.opts.margin.topPerc = perc
return nil
})
}
// MarginRightPercent sets reserved space outside of the container at its right.
// The provided number is a relative margin defined as percentage of the container's height.
// Only one of MarginRight or MarginRightPercent can be specified.
// The value must be in range 0 <= value <= 100.
func MarginRightPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid MarginRightPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.margin.rightCells > 0 {
return fmt.Errorf("cannot specify both MarginRightPercent(%d) and MarginRight(%d)", perc, c.opts.margin.rightCells)
}
c.opts.margin.rightPerc = perc
return nil
})
}
// MarginBottomPercent sets reserved space outside of the container at its bottom.
// The provided number is a relative margin defined as percentage of the container's height.
// Only one of MarginBottom or MarginBottomPercent can be specified.
// The value must be in range 0 <= value <= 100.
func MarginBottomPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid MarginBottomPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.margin.bottomCells > 0 {
return fmt.Errorf("cannot specify both MarginBottomPercent(%d) and MarginBottom(%d)", perc, c.opts.margin.bottomCells)
}
c.opts.margin.bottomPerc = perc
return nil
})
}
// MarginLeftPercent sets reserved space outside of the container at its left.
// The provided number is a relative margin defined as percentage of the container's height.
// Only one of MarginLeft or MarginLeftPercent can be specified.
// The value must be in range 0 <= value <= 100.
func MarginLeftPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid MarginLeftPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.margin.leftCells > 0 {
return fmt.Errorf("cannot specify both MarginLeftPercent(%d) and MarginLeft(%d)", perc, c.opts.margin.leftCells)
}
c.opts.margin.leftPerc = perc
return nil
})
}
// PaddingTop sets reserved space between container and the top side of its widget.
// The widget's area size is decreased to accommodate the padding.
// The provided number is the absolute padding in cells and must be zero or a
// positive integer. Only one of PaddingTop or PaddingTopPercent can be specified.
func PaddingTop(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid PaddingTop(%d), must be in range %d <= value", cells, min)
}
if c.opts.padding.topPerc > 0 {
return fmt.Errorf("cannot specify both PaddingTop(%d) and PaddingTopPercent(%d)", cells, c.opts.padding.topPerc)
}
c.opts.padding.topCells = cells
return nil
})
}
// PaddingRight sets reserved space between container and the right side of its widget.
// The widget's area size is decreased to accommodate the padding.
// The provided number is the absolute padding in cells and must be zero or a
// positive integer. Only one of PaddingRight or PaddingRightPercent can be specified.
func PaddingRight(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid PaddingRight(%d), must be in range %d <= value", cells, min)
}
if c.opts.padding.rightPerc > 0 {
return fmt.Errorf("cannot specify both PaddingRight(%d) and PaddingRightPercent(%d)", cells, c.opts.padding.rightPerc)
}
c.opts.padding.rightCells = cells
return nil
})
}
// PaddingBottom sets reserved space between container and the bottom side of its widget.
// The widget's area size is decreased to accommodate the padding.
// The provided number is the absolute padding in cells and must be zero or a
// positive integer. Only one of PaddingBottom or PaddingBottomPercent can be specified.
func PaddingBottom(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid PaddingBottom(%d), must be in range %d <= value", cells, min)
}
if c.opts.padding.bottomPerc > 0 {
return fmt.Errorf("cannot specify both PaddingBottom(%d) and PaddingBottomPercent(%d)", cells, c.opts.padding.bottomPerc)
}
c.opts.padding.bottomCells = cells
return nil
})
}
// PaddingLeft sets reserved space between container and the left side of its widget.
// The widget's area size is decreased to accommodate the padding.
// The provided number is the absolute padding in cells and must be zero or a
// positive integer. Only one of PaddingLeft or PaddingLeftPercent can be specified.
func PaddingLeft(cells int) Option {
return option(func(c *Container) error {
if min := 0; cells < min {
return fmt.Errorf("invalid PaddingLeft(%d), must be in range %d <= value", cells, min)
}
if c.opts.padding.leftPerc > 0 {
return fmt.Errorf("cannot specify both PaddingLeft(%d) and PaddingLeftPercent(%d)", cells, c.opts.padding.leftPerc)
}
c.opts.padding.leftCells = cells
return nil
})
}
// PaddingTopPercent sets reserved space between container and the top side of
// its widget. The widget's area size is decreased to accommodate the padding.
// The provided number is a relative padding defined as percentage of the
// container's height. The value must be in range 0 <= value <= 100.
// Only one of PaddingTop or PaddingTopPercent can be specified.
func PaddingTopPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid PaddingTopPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.padding.topCells > 0 {
return fmt.Errorf("cannot specify both PaddingTopPercent(%d) and PaddingTop(%d)", perc, c.opts.padding.topCells)
}
c.opts.padding.topPerc = perc
return nil
})
}
// PaddingRightPercent sets reserved space between container and the right side of
// its widget. The widget's area size is decreased to accommodate the padding.
// The provided number is a relative padding defined as percentage of the
// container's width. The value must be in range 0 <= value <= 100.
// Only one of PaddingRight or PaddingRightPercent can be specified.
func PaddingRightPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid PaddingRightPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.padding.rightCells > 0 {
return fmt.Errorf("cannot specify both PaddingRightPercent(%d) and PaddingRight(%d)", perc, c.opts.padding.rightCells)
}
c.opts.padding.rightPerc = perc
return nil
})
}
// PaddingBottomPercent sets reserved space between container and the bottom side of
// its widget. The widget's area size is decreased to accommodate the padding.
// The provided number is a relative padding defined as percentage of the
// container's height. The value must be in range 0 <= value <= 100.
// Only one of PaddingBottom or PaddingBottomPercent can be specified.
func PaddingBottomPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid PaddingBottomPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.padding.bottomCells > 0 {
return fmt.Errorf("cannot specify both PaddingBottomPercent(%d) and PaddingBottom(%d)", perc, c.opts.padding.bottomCells)
}
c.opts.padding.bottomPerc = perc
return nil
})
}
// PaddingLeftPercent sets reserved space between container and the left side of
// its widget. The widget's area size is decreased to accommodate the padding.
// The provided number is a relative padding defined as percentage of the
// container's width. The value must be in range 0 <= value <= 100.
// Only one of PaddingLeft or PaddingLeftPercent can be specified.
func PaddingLeftPercent(perc int) Option {
return option(func(c *Container) error {
if min, max := 0, 100; perc < min || perc > max {
return fmt.Errorf("invalid PaddingLeftPercent(%d), must be in range %d <= value <= %d", perc, min, max)
}
if c.opts.padding.leftCells > 0 {
return fmt.Errorf("cannot specify both PaddingLeftPercent(%d) and PaddingLeft(%d)", perc, c.opts.padding.leftCells)
}
c.opts.padding.leftPerc = perc
return nil
})
}
// AlignHorizontal sets the horizontal alignment for the widget placed in the
// container. Has no effect if the container contains no widget.
// Defaults to alignment in the center.
func AlignHorizontal(h align.Horizontal) Option {
return option(func(c *Container) error {
c.opts.hAlign = h
return nil
})
}
// AlignVertical sets the vertical alignment for the widget placed in the container.
// Has no effect if the container contains no widget.
// Defaults to alignment in the middle.
func AlignVertical(v align.Vertical) Option {
return option(func(c *Container) error {
c.opts.vAlign = v
return nil
})
}
// Border configures the container to have a border of the specified style.
func Border(ls linestyle.LineStyle) Option {
return option(func(c *Container) error {
c.opts.border = ls
return nil
})
}
// BorderTitle sets a text title within the border.
func BorderTitle(title string) Option {
return option(func(c *Container) error {
c.opts.borderTitle = title
return nil
})
}
// BorderTitleAlignLeft aligns the border title on the left.
func BorderTitleAlignLeft() Option {
return option(func(c *Container) error {
c.opts.borderTitleHAlign = align.HorizontalLeft
return nil
})
}
// BorderTitleAlignCenter aligns the border title in the center.
func BorderTitleAlignCenter() Option {
return option(func(c *Container) error {
c.opts.borderTitleHAlign = align.HorizontalCenter
return nil
})
}
// BorderTitleAlignRight aligns the border title on the right.
func BorderTitleAlignRight() Option {
return option(func(c *Container) error {
c.opts.borderTitleHAlign = align.HorizontalRight
return nil
})
}
// BorderColor sets the color of the border around the container.
// This option is inherited to sub containers created by container splits.
func BorderColor(color cell.Color) Option {
return option(func(c *Container) error {
c.opts.inherited.borderColor = color
return nil
})
}
// FocusedColor sets the color of the border around the container when it has
// keyboard focus.
// This option is inherited to sub containers created by container splits.
func FocusedColor(color cell.Color) Option {
return option(func(c *Container) error {
c.opts.inherited.focusedColor = color
return nil
})
}
// splitType identifies how a container is split.
type splitType int
// String implements fmt.Stringer()
func (st splitType) String() string {
if n, ok := splitTypeNames[st]; ok {
return n
}
return "splitTypeUnknown"
}
// splitTypeNames maps splitType values to human readable names.
var splitTypeNames = map[splitType]string{
splitTypeVertical: "splitTypeVertical",
splitTypeHorizontal: "splitTypeHorizontal",
}
const (
splitTypeVertical splitType = iota
splitTypeHorizontal
)
// LeftOption is used to provide options to the left sub container after a
// vertical split of the parent.
type LeftOption interface {
// lOpts returns the options.
lOpts() []Option
}
// leftOption implements LeftOption.
type leftOption func() []Option
// lOpts implements LeftOption.lOpts.
func (lo leftOption) lOpts() []Option {
if lo == nil {
return nil
}
return lo()
}
// Left applies options to the left sub container after a vertical split of the parent.
func Left(opts ...Option) LeftOption {
return leftOption(func() []Option {
return opts
})
}
// RightOption is used to provide options to the right sub container after a
// vertical split of the parent.
type RightOption interface {
// rOpts returns the options.
rOpts() []Option
}
// rightOption implements RightOption.
type rightOption func() []Option
// rOpts implements RightOption.rOpts.
func (lo rightOption) rOpts() []Option {
if lo == nil {
return nil
}
return lo()
}
// Right applies options to the right sub container after a vertical split of the parent.
func Right(opts ...Option) RightOption {
return rightOption(func() []Option {
return opts
})
}
// TopOption is used to provide options to the top sub container after a
// horizontal split of the parent.
type TopOption interface {
// tOpts returns the options.
tOpts() []Option
}
// topOption implements TopOption.
type topOption func() []Option
// tOpts implements TopOption.tOpts.
func (lo topOption) tOpts() []Option {
if lo == nil {
return nil
}
return lo()
}
// Top applies options to the top sub container after a horizontal split of the parent.
func Top(opts ...Option) TopOption {
return topOption(func() []Option {
return opts
})
}
// BottomOption is used to provide options to the bottom sub container after a
// horizontal split of the parent.
type BottomOption interface {
// bOpts returns the options.
bOpts() []Option
}
// bottomOption implements BottomOption.
type bottomOption func() []Option
// bOpts implements BottomOption.bOpts.
func (lo bottomOption) bOpts() []Option {
if lo == nil {
return nil
}
return lo()
}
// Bottom applies options to the bottom sub container after a horizontal split of the parent.
func Bottom(opts ...Option) BottomOption {
return bottomOption(func() []Option {
return opts
})
}