-
Notifications
You must be signed in to change notification settings - Fork 3.1k
/
MaterialButtonToggleGroup.java
909 lines (801 loc) · 32.2 KB
/
MaterialButtonToggleGroup.java
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
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
/*
* Copyright (C) 2019 The Android Open Source Project
*
* 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 com.google.android.material.button;
import com.google.android.material.R;
import static com.google.android.material.theme.overlay.MaterialThemeOverlay.wrap;
import static java.lang.Math.min;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.text.TextUtils.TruncateAt;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityNodeInfo;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.ToggleButton;
import androidx.annotation.BoolRes;
import androidx.annotation.IdRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.Px;
import androidx.annotation.VisibleForTesting;
import androidx.core.view.AccessibilityDelegateCompat;
import androidx.core.view.ViewCompat;
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat.CollectionInfoCompat;
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat.CollectionItemInfoCompat;
import com.google.android.material.button.MaterialButton.OnPressedChangeListener;
import com.google.android.material.internal.ThemeEnforcement;
import com.google.android.material.internal.ViewUtils;
import com.google.android.material.shape.AbsoluteCornerSize;
import com.google.android.material.shape.CornerSize;
import com.google.android.material.shape.RelativeCornerSize;
import com.google.android.material.shape.ShapeAppearanceModel;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* A common container for a set of related, toggleable {@link MaterialButton}s. The {@link
* MaterialButton}s in this group will be shown on a single line.
*
* <p>This layout currently only supports child views of type {@link MaterialButton}. Buttons can be
* added to this view group via XML, as follows:
*
* <pre>
* <com.google.android.material.button.MaterialButtonToggleGroup
* xmlns:android="http://schemas.android.com/apk/res/android"
* android:id="@+id/toggle_button_group"
* android:layout_width="wrap_content"
* android:layout_height="wrap_content">
*
* <com.google.android.material.button.MaterialButton
* style="?attr/materialButtonOutlinedStyle"
* android:layout_width="wrap_content"
* android:layout_height="wrap_content"
* android:text="@string/button_label_private"/>
* <com.google.android.material.button.MaterialButton
* style="?attr/materialButtonOutlinedStyle"
* android:layout_width="wrap_content"
* android:layout_height="wrap_content"
* android:text="@string/button_label_team"/>
* <com.google.android.material.button.MaterialButton
* style="?attr/materialButtonOutlinedStyle"
* android:layout_width="wrap_content"
* android:layout_height="wrap_content"
* android:text="@string/button_label_everyone"/>
* <com.google.android.material.button.MaterialButton
* style="?attr/materialButtonOutlinedStyle"
* android:layout_width="wrap_content"
* android:layout_height="wrap_content"
* android:text="@string/button_label_custom"/>
*
* </com.google.android.material.button.MaterialButtonToggleGroup>
* </pre>
*
* <p>Buttons can also be added to this view group programmatically via the {@link #addView(View)}
* methods.
*
* <p>Note: Styling must applied to each child button individually. It is recommended to use the
* {@code materialButtonOutlinedStyle} attribute for all child buttons. {@code
* materialButtonOutlinedStyle} will most closely match the Material Design guidelines for this
* component, and supports the checked state for child buttons.
*
* <p>Any {@link MaterialButton}s added to this view group are automatically marked as {@code
* checkable}, and by default multiple buttons within the same group can be checked. To enforce that
* only one button can be checked at a time, set the {@code app:singleSelection} attribute to {@code
* true} on the MaterialButtonToggleGroup or call {@link #setSingleSelection(boolean)
* setSingleSelection(true)}.
*
* <p>MaterialButtonToggleGroup is a {@link LinearLayout}. Using {@code
* android:layout_width="MATCH_PARENT"} and removing {@code android:insetBottom} {@code
* android:insetTop} on the children is recommended if using {@code VERTICAL}.
*
* <p>In order to cohesively group multiple buttons together, MaterialButtonToggleGroup overrides
* the start and end margins of any children added to this layout such that child buttons are placed
* directly adjacent to one another.
*
* <p>MaterialButtonToggleGroup also overrides any {@code shapeAppearance}, {@code
* shapeAppearanceOverlay}, or {@code cornerRadius} attribute set on MaterialButton children such
* that only the left-most corners of the first child and the right-most corners of the last child
* retain their shape appearance or corner size.
*
* <p>For more information, see the <a
* href="https://github.com/material-components/material-components-android/blob/master/docs/components/Button.md">component
* developer guidance</a> and <a href="https://material.io/components/buttons/overview">design
* guidelines</a>.
*/
public class MaterialButtonToggleGroup extends LinearLayout {
/**
* Interface definition for a callback to be invoked when a {@link MaterialButton} is checked or
* unchecked in this group.
*/
public interface OnButtonCheckedListener {
/**
* Called when a {@link MaterialButton} in this group is checked or unchecked.
*
* @param group The group in which the MaterialButton's checked state was changed
* @param checkedId The unique identifier of the MaterialButton whose check state changed
* @param isChecked Whether the MaterialButton is currently checked
*/
void onButtonChecked(MaterialButtonToggleGroup group, @IdRes int checkedId, boolean isChecked);
}
private static final String LOG_TAG = "MButtonToggleGroup";
private static final int DEF_STYLE_RES =
R.style.Widget_MaterialComponents_MaterialButtonToggleGroup;
private final List<CornerData> originalCornerData = new ArrayList<>();
private final PressedStateTracker pressedStateTracker = new PressedStateTracker();
private final LinkedHashSet<OnButtonCheckedListener> onButtonCheckedListeners =
new LinkedHashSet<>();
private final Comparator<MaterialButton> childOrderComparator =
new Comparator<MaterialButton>() {
@Override
public int compare(MaterialButton v1, MaterialButton v2) {
int checked = Boolean.valueOf(v1.isChecked()).compareTo(v2.isChecked());
if (checked != 0) {
return checked;
}
int stateful = Boolean.valueOf(v1.isPressed()).compareTo(v2.isPressed());
if (stateful != 0) {
return stateful;
}
// don't return 0s
return Integer.valueOf(indexOfChild(v1)).compareTo(indexOfChild(v2));
}
};
private Integer[] childOrder;
private boolean skipCheckedStateTracker = false;
private boolean singleSelection;
private boolean selectionRequired;
@NonNull private CornerSize insideCornerSize;
@Px private int spacing;
@IdRes private final int defaultCheckId;
private Set<Integer> checkedIds = new HashSet<>();
public MaterialButtonToggleGroup(@NonNull Context context) {
this(context, null);
}
public MaterialButtonToggleGroup(@NonNull Context context, @Nullable AttributeSet attrs) {
this(context, attrs, R.attr.materialButtonToggleGroupStyle);
}
public MaterialButtonToggleGroup(
@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(wrap(context, attrs, defStyleAttr, DEF_STYLE_RES), attrs, defStyleAttr);
// Ensure we are using the correctly themed context rather than the context that was passed in.
context = getContext();
TypedArray attributes =
ThemeEnforcement.obtainStyledAttributes(
context, attrs, R.styleable.MaterialButtonToggleGroup, defStyleAttr, DEF_STYLE_RES);
setSingleSelection(
attributes.getBoolean(R.styleable.MaterialButtonToggleGroup_singleSelection, false));
defaultCheckId =
attributes.getResourceId(R.styleable.MaterialButtonToggleGroup_checkedButton, View.NO_ID);
selectionRequired =
attributes.getBoolean(R.styleable.MaterialButtonToggleGroup_selectionRequired, false);
insideCornerSize =
ShapeAppearanceModel.getCornerSize(
attributes,
R.styleable.MaterialButtonToggleGroup_insideCornerSize,
new AbsoluteCornerSize(0));
spacing =
attributes.getDimensionPixelSize(R.styleable.MaterialButtonToggleGroup_android_spacing, 0);
setChildrenDrawingOrderEnabled(true);
setEnabled(attributes.getBoolean(R.styleable.MaterialButtonToggleGroup_android_enabled, true));
attributes.recycle();
setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
if (defaultCheckId != View.NO_ID) {
updateCheckedIds(Collections.singleton(defaultCheckId));
}
}
@Override
protected void dispatchDraw(@NonNull Canvas canvas) {
updateChildOrder();
super.dispatchDraw(canvas);
}
/**
* This override prohibits Views other than {@link MaterialButton} to be added. It also makes
* updates to the add button shape and margins.
*/
@Override
public void addView(View child, int index, ViewGroup.LayoutParams params) {
if (!(child instanceof MaterialButton)) {
Log.e(LOG_TAG, "Child views must be of type MaterialButton.");
return;
}
super.addView(child, index, params);
MaterialButton buttonChild = (MaterialButton) child;
setGeneratedIdIfNeeded(buttonChild);
// Sets sensible default values and an internal checked change listener for this child
setupButtonChild(buttonChild);
// Update button group's checked states
checkInternal(buttonChild.getId(), buttonChild.isChecked());
// Saves original corner data
ShapeAppearanceModel shapeAppearanceModel = buttonChild.getShapeAppearanceModel();
originalCornerData.add(
new CornerData(
shapeAppearanceModel.getTopLeftCornerSize(),
shapeAppearanceModel.getBottomLeftCornerSize(),
shapeAppearanceModel.getTopRightCornerSize(),
shapeAppearanceModel.getBottomRightCornerSize()));
// Enable children based on the MaterialButtonToggleGroup own isEnabled
buttonChild.setEnabled(isEnabled());
ViewCompat.setAccessibilityDelegate(
buttonChild,
new AccessibilityDelegateCompat() {
@Override
public void onInitializeAccessibilityNodeInfo(
View host, @NonNull AccessibilityNodeInfoCompat info) {
super.onInitializeAccessibilityNodeInfo(host, info);
info.setCollectionItemInfo(
CollectionItemInfoCompat.obtain(
/* rowIndex= */ 0,
/* rowSpan= */ 1,
/* columnIndex= */ getIndexWithinVisibleButtons(host),
/* columnSpan= */ 1,
/* heading= */ false,
/* selected= */ ((MaterialButton) host).isChecked()));
}
});
}
@Override
public void onViewRemoved(View child) {
super.onViewRemoved(child);
if (child instanceof MaterialButton) {
((MaterialButton) child).setOnPressedChangeListenerInternal(null);
}
int indexOfChild = indexOfChild(child);
if (indexOfChild >= 0) {
originalCornerData.remove(indexOfChild);
}
updateChildShapes();
adjustChildMarginsAndUpdateLayout();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
updateChildShapes();
adjustChildMarginsAndUpdateLayout();
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
@Override
public void onInitializeAccessibilityNodeInfo(@NonNull AccessibilityNodeInfo info) {
super.onInitializeAccessibilityNodeInfo(info);
AccessibilityNodeInfoCompat infoCompat = AccessibilityNodeInfoCompat.wrap(info);
infoCompat.setCollectionInfo(
CollectionInfoCompat.obtain(
/* rowCount= */ 1,
/* columnCount= */ getVisibleButtonCount(),
/* hierarchical= */ false,
/* selectionMode= */ isSingleSelection()
? CollectionInfoCompat.SELECTION_MODE_SINGLE
: CollectionInfoCompat.SELECTION_MODE_MULTIPLE));
}
/**
* Sets the {@link MaterialButton} whose id is passed in to the checked state. If this
* MaterialButtonToggleGroup is in {@link #isSingleSelection() single selection mode}, then all
* other MaterialButtons in this group will be unchecked. Otherwise, other MaterialButtons will
* retain their checked state.
*
* @param id View ID of {@link MaterialButton} to set checked
* @see #uncheck(int)
* @see #clearChecked()
* @see #getCheckedButtonIds()
* @see #getCheckedButtonId()
*/
public void check(@IdRes int id) {
checkInternal(id, true);
}
/**
* Sets the {@link MaterialButton} whose id is passed in to the unchecked state.
*
* @param id View ID of {@link MaterialButton} to set unchecked
* @see #check(int)
* @see #clearChecked()
* @see #getCheckedButtonIds()
* @see #getCheckedButtonId()
*/
public void uncheck(@IdRes int id) {
checkInternal(id, false);
}
/**
* Clears the selections. When the selections are cleared, no {@link MaterialButton} in this group
* is checked and {@link #getCheckedButtonIds()} returns an empty list.
*
* @see #check(int)
* @see #uncheck(int)
* @see #getCheckedButtonIds()
* @see #getCheckedButtonId()
*/
public void clearChecked() {
updateCheckedIds(new HashSet<Integer>());
}
/**
* When in {@link #isSingleSelection() single selection mode}, returns the identifier of the
* selected button in this group. Upon empty selection, the returned value is {@link View#NO_ID}.
* If not in single selection mode, the return value is {@link View#NO_ID}.
*
* @return The unique id of the selected {@link MaterialButton} in this group in {@link
* #isSingleSelection() single selection mode}. When not in {@link #isSingleSelection() single
* selection mode}, returns {@link View#NO_ID}.
* @see #check(int)
* @see #uncheck(int)
* @see #clearChecked()
* @see #getCheckedButtonIds()
* @attr ref R.styleable#MaterialButtonToggleGroup_checkedButton
*/
@IdRes
public int getCheckedButtonId() {
return singleSelection && !checkedIds.isEmpty() ? checkedIds.iterator().next() : View.NO_ID;
}
/**
* Returns the identifiers of the selected {@link MaterialButton}s in this group. Upon empty
* selection, the returned value is an empty list.
*
* @return The unique IDs of the selected {@link MaterialButton}s in this group. When in {@link
* #isSingleSelection() single selection mode}, returns a list with a single ID. When no
* {@link MaterialButton}s are selected, returns an empty list.
* @see #check(int)
* @see #uncheck(int)
* @see #clearChecked()
* @see #getCheckedButtonId()
*/
@NonNull
public List<Integer> getCheckedButtonIds() {
List<Integer> orderedCheckedIds = new ArrayList<>();
for (int i = 0; i < getChildCount(); i++) {
int childId = getChildButton(i).getId();
if (checkedIds.contains(childId)) {
orderedCheckedIds.add(childId);
}
}
return orderedCheckedIds;
}
/**
* Add a listener that will be invoked when the check state of a {@link MaterialButton} in this
* group changes. See {@link OnButtonCheckedListener}.
*
* <p>Components that add a listener should take care to remove it when finished via {@link
* #removeOnButtonCheckedListener(OnButtonCheckedListener)}.
*
* @param listener listener to add
*/
public void addOnButtonCheckedListener(@NonNull OnButtonCheckedListener listener) {
onButtonCheckedListeners.add(listener);
}
/**
* Remove a listener that was previously added via {@link
* #addOnButtonCheckedListener(OnButtonCheckedListener)}.
*
* @param listener listener to remove
*/
public void removeOnButtonCheckedListener(@NonNull OnButtonCheckedListener listener) {
onButtonCheckedListeners.remove(listener);
}
/** Remove all previously added {@link OnButtonCheckedListener}s. */
public void clearOnButtonCheckedListeners() {
onButtonCheckedListeners.clear();
}
/**
* Returns whether this group only allows a single button to be checked.
*
* @return whether this group only allows a single button to be checked
* @attr ref R.styleable#MaterialButtonToggleGroup_singleSelection
*/
public boolean isSingleSelection() {
return singleSelection;
}
/**
* Sets whether this group only allows a single button to be checked.
*
* <p>Calling this method results in all the buttons in this group to become unchecked.
*
* @param singleSelection whether this group only allows a single button to be checked
* @attr ref R.styleable#MaterialButtonToggleGroup_singleSelection
*/
public void setSingleSelection(boolean singleSelection) {
if (this.singleSelection != singleSelection) {
this.singleSelection = singleSelection;
clearChecked();
}
updateChildrenA11yClassName();
}
private void updateChildrenA11yClassName() {
for (int i = 0; i < getChildCount(); i++) {
String className =
singleSelection ? RadioButton.class.getName() : ToggleButton.class.getName();
getChildButton(i).setA11yClassName(className);
}
}
/**
* Sets whether we prevent all child buttons from being deselected.
*
* @attr ref R.styleable#MaterialButtonToggleGroup_selectionRequired
*/
public void setSelectionRequired(boolean selectionRequired) {
this.selectionRequired = selectionRequired;
}
/**
* Returns whether we prevent all child buttons from being deselected.
*
* @attr ref R.styleable#MaterialButtonToggleGroup_selectionRequired
*/
public boolean isSelectionRequired() {
return selectionRequired;
}
/**
* Sets whether this group only allows a single button to be checked.
*
* <p>Calling this method results in all the buttons in this group to become unchecked.
*
* @param id boolean resource ID of whether this group only allows a single button to be checked
* @attr ref R.styleable#MaterialButtonToggleGroup_singleSelection
*/
public void setSingleSelection(@BoolRes int id) {
setSingleSelection(getResources().getBoolean(id));
}
@Px
public int getSpacing() {
return spacing;
}
public void setSpacing(@Px int spacing) {
this.spacing = spacing;
invalidate();
requestLayout();
}
public void setInsideCornerSizeInPx(@Px int px) {
insideCornerSize = new AbsoluteCornerSize(px);
updateChildShapes();
invalidate();
}
public void setInsideCornerSizeInFraction(float fraction) {
insideCornerSize = new RelativeCornerSize(fraction);
updateChildShapes();
invalidate();
}
private void setCheckedStateForView(@IdRes int viewId, boolean checked) {
View checkedView = findViewById(viewId);
if (checkedView instanceof MaterialButton) {
skipCheckedStateTracker = true;
((MaterialButton) checkedView).setChecked(checked);
skipCheckedStateTracker = false;
}
}
/**
* Sets a negative marginStart on all but the first child, if two adjacent children both have a
* stroke width greater than 0. This prevents a double-width stroke from being drawn for two
* adjacent stroked children, and instead draws the adjacent strokes directly on top of each
* other.
*
* <p>The negative margin adjustment amount will be equal to the smaller of the two adjacent
* stroke widths.
*
* <p>Also rearranges children such that they are shown in the correct visual order.
*/
private void adjustChildMarginsAndUpdateLayout() {
int firstVisibleChildIndex = getFirstVisibleChildIndex();
if (firstVisibleChildIndex == -1) {
return;
}
for (int i = firstVisibleChildIndex + 1; i < getChildCount(); i++) {
// Only adjusts margins if both adjacent children are MaterialButtons
MaterialButton currentButton = getChildButton(i);
MaterialButton previousButton = getChildButton(i - 1);
// Calculates the margin adjustment to be the smaller of the two adjacent stroke widths
int smallestStrokeWidth = 0;
if (spacing <= 0) {
smallestStrokeWidth = min(currentButton.getStrokeWidth(), previousButton.getStrokeWidth());
}
LayoutParams params = buildLayoutParams(currentButton);
if (getOrientation() == HORIZONTAL) {
params.setMarginEnd(0);
params.setMarginStart(spacing - smallestStrokeWidth);
params.topMargin = 0;
} else {
params.bottomMargin = 0;
params.topMargin = spacing - smallestStrokeWidth;
params.setMarginStart(0);
}
currentButton.setLayoutParams(params);
}
resetChildMargins(firstVisibleChildIndex);
}
private MaterialButton getChildButton(int index) {
return (MaterialButton) getChildAt(index);
}
private void resetChildMargins(int childIndex) {
if (getChildCount() == 0 || childIndex == -1) {
return;
}
MaterialButton currentButton = getChildButton(childIndex);
LayoutParams params = (LayoutParams) currentButton.getLayoutParams();
if (getOrientation() == VERTICAL) {
params.topMargin = 0;
params.bottomMargin = 0;
return;
}
params.setMarginEnd(0);
params.setMarginStart(0);
params.leftMargin = 0;
params.rightMargin = 0;
}
/** Sets all corner radii to 0 except for leftmost and rightmost corners. */
@VisibleForTesting
void updateChildShapes() {
int childCount = getChildCount();
int firstVisibleChildIndex = getFirstVisibleChildIndex();
int lastVisibleChildIndex = getLastVisibleChildIndex();
for (int i = 0; i < childCount; i++) {
MaterialButton button = getChildButton(i);
if (button.getVisibility() == GONE) {
continue;
}
ShapeAppearanceModel.Builder builder = button.getShapeAppearanceModel().toBuilder();
CornerData newCornerData = getNewCornerData(i, firstVisibleChildIndex, lastVisibleChildIndex);
updateBuilderWithCornerData(builder, newCornerData);
button.setShapeAppearanceModel(builder.build());
}
}
private int getFirstVisibleChildIndex() {
int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
if (isChildVisible(i)) {
return i;
}
}
return -1;
}
private int getLastVisibleChildIndex() {
int childCount = getChildCount();
for (int i = childCount - 1; i >= 0; i--) {
if (isChildVisible(i)) {
return i;
}
}
return -1;
}
private boolean isChildVisible(int i) {
View child = getChildAt(i);
return child.getVisibility() != View.GONE;
}
private int getVisibleButtonCount() {
int count = 0;
for (int i = 0; i < getChildCount(); i++) {
if (this.getChildAt(i) instanceof MaterialButton && isChildVisible(i)) {
count++;
}
}
return count;
}
private int getIndexWithinVisibleButtons(@Nullable View child) {
if (!(child instanceof MaterialButton)) {
return -1;
}
int index = 0;
for (int i = 0; i < getChildCount(); i++) {
if (this.getChildAt(i) == child) {
return index;
}
if (this.getChildAt(i) instanceof MaterialButton && isChildVisible(i)) {
index++;
}
}
return -1;
}
@Nullable
private CornerData getNewCornerData(
int index, int firstVisibleChildIndex, int lastVisibleChildIndex) {
CornerData cornerData = originalCornerData.get(index);
CornerData insideCornerData = new CornerData(insideCornerSize);
// If only one (visible) child exists, use its original corners
if (firstVisibleChildIndex == lastVisibleChildIndex) {
return cornerData;
}
boolean isHorizontal = getOrientation() == HORIZONTAL;
if (index == firstVisibleChildIndex) {
return isHorizontal
? CornerData.start(cornerData, insideCornerData, this)
: CornerData.top(cornerData, insideCornerData);
}
if (index == lastVisibleChildIndex) {
return isHorizontal
? CornerData.end(cornerData, insideCornerData, this)
: CornerData.bottom(cornerData, insideCornerData);
}
return insideCornerData;
}
private static void updateBuilderWithCornerData(
ShapeAppearanceModel.Builder shapeAppearanceModelBuilder, @Nullable CornerData cornerData) {
if (cornerData == null) {
shapeAppearanceModelBuilder.setAllCornerSizes(0);
return;
}
shapeAppearanceModelBuilder
.setTopLeftCornerSize(cornerData.topLeft)
.setBottomLeftCornerSize(cornerData.bottomLeft)
.setTopRightCornerSize(cornerData.topRight)
.setBottomRightCornerSize(cornerData.bottomRight);
}
private void checkInternal(@IdRes int buttonId, boolean checked) {
if (buttonId == View.NO_ID) {
Log.e(LOG_TAG, "Button ID is not valid: " + buttonId);
return;
}
Set<Integer> checkedIds = new HashSet<>(this.checkedIds);
if (checked && !checkedIds.contains(buttonId)) {
if (singleSelection && !checkedIds.isEmpty()) {
checkedIds.clear();
}
checkedIds.add(buttonId);
} else if (!checked && checkedIds.contains(buttonId)) {
// Do not uncheck button if no selection remains when selection is required.
if (!selectionRequired || checkedIds.size() > 1) {
checkedIds.remove(buttonId);
}
} else {
// No state change, do nothing
return;
}
updateCheckedIds(checkedIds);
}
private void updateCheckedIds(Set<Integer> checkedIds) {
Set<Integer> previousCheckedIds = this.checkedIds;
this.checkedIds = new HashSet<>(checkedIds);
for (int i = 0; i < getChildCount(); i++) {
int buttonId = getChildButton(i).getId();
setCheckedStateForView(buttonId, checkedIds.contains(buttonId));
if (previousCheckedIds.contains(buttonId) != checkedIds.contains(buttonId)) {
dispatchOnButtonChecked(buttonId, checkedIds.contains(buttonId));
}
}
invalidate();
}
private void dispatchOnButtonChecked(@IdRes int buttonId, boolean checked) {
for (OnButtonCheckedListener listener : onButtonCheckedListeners) {
listener.onButtonChecked(this, buttonId, checked);
}
}
private void setGeneratedIdIfNeeded(@NonNull MaterialButton materialButton) {
// Generates an ID if none is set, for relative positioning purposes
if (materialButton.getId() == View.NO_ID) {
materialButton.setId(View.generateViewId());
}
}
/**
* Sets sensible default values for {@link MaterialButton} child of this group, set child to
* {@code checkable}, and set internal checked change listener for this child.
*
* @param buttonChild {@link MaterialButton} child to set up to be added to this {@link
* MaterialButtonToggleGroup}
*/
private void setupButtonChild(@NonNull MaterialButton buttonChild) {
buttonChild.setMaxLines(1);
buttonChild.setEllipsize(TruncateAt.END);
buttonChild.setCheckable(true);
buttonChild.setOnPressedChangeListenerInternal(pressedStateTracker);
// Enables surface layer drawing for semi-opaque strokes
buttonChild.setShouldDrawSurfaceColorStroke(true);
}
@NonNull
private LinearLayout.LayoutParams buildLayoutParams(@NonNull View child) {
ViewGroup.LayoutParams layoutParams = child.getLayoutParams();
if (layoutParams instanceof LinearLayout.LayoutParams) {
return (LayoutParams) layoutParams;
}
return new LayoutParams(layoutParams.width, layoutParams.height);
}
/**
* We keep track of which views are pressed and checked to draw them last. This prevents visual
* issues with overlapping strokes.
*/
@Override
protected int getChildDrawingOrder(int childCount, int i) {
if (childOrder == null || i >= childOrder.length) {
Log.w(LOG_TAG, "Child order wasn't updated");
return i;
}
return childOrder[i];
}
private void updateChildOrder() {
final SortedMap<MaterialButton, Integer> viewToIndexMap = new TreeMap<>(childOrderComparator);
int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
viewToIndexMap.put(getChildButton(i), i);
}
childOrder = viewToIndexMap.values().toArray(new Integer[0]);
}
void onButtonCheckedStateChanged(@NonNull MaterialButton button, boolean isChecked) {
// Checked state change is triggered by the button group, do not update checked ids again.
if (skipCheckedStateTracker) {
return;
}
checkInternal(button.getId(), isChecked);
}
/**
* Enables this {@link MaterialButtonToggleGroup} and all its {@link MaterialButton} children
*
* @param enabled boolean to setEnable {@link MaterialButtonToggleGroup}
*/
@Override
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
// Enable or disable child buttons
for (int i = 0; i < getChildCount(); i++) {
MaterialButton childButton = getChildButton(i);
childButton.setEnabled(enabled);
}
}
private class PressedStateTracker implements OnPressedChangeListener {
@Override
public void onPressedChanged(@NonNull MaterialButton button, boolean isPressed) {
invalidate();
}
}
private static class CornerData {
@NonNull CornerSize topLeft;
@NonNull CornerSize topRight;
@NonNull CornerSize bottomRight;
@NonNull CornerSize bottomLeft;
CornerData(@NonNull CornerSize cornerSize) {
this(cornerSize, cornerSize, cornerSize, cornerSize);
}
CornerData(
@NonNull CornerSize topLeft,
@NonNull CornerSize bottomLeft,
@NonNull CornerSize topRight,
@NonNull CornerSize bottomRight) {
this.topLeft = topLeft;
this.topRight = topRight;
this.bottomRight = bottomRight;
this.bottomLeft = bottomLeft;
}
/** Keep the start side of the corner original data */
public static CornerData start(
@NonNull CornerData orig, @NonNull CornerData other, @NonNull View view) {
return ViewUtils.isLayoutRtl(view) ? right(orig, other) : left(orig, other);
}
/** Keep the end side of the corner original data */
public static CornerData end(
@NonNull CornerData orig, @NonNull CornerData other, @NonNull View view) {
return ViewUtils.isLayoutRtl(view) ? left(orig, other) : right(orig, other);
}
/** Keep the left side of the corner original data */
public static CornerData left(@NonNull CornerData orig, @NonNull CornerData other) {
return new CornerData(orig.topLeft, orig.bottomLeft, other.topRight, other.bottomRight);
}
/** Keep the right side of the corner original data */
public static CornerData right(@NonNull CornerData orig, @NonNull CornerData other) {
return new CornerData(other.topLeft, other.bottomLeft, orig.topRight, orig.bottomRight);
}
/** Keep the top side of the corner original data */
public static CornerData top(@NonNull CornerData orig, @NonNull CornerData other) {
return new CornerData(orig.topLeft, other.bottomLeft, orig.topRight, other.bottomRight);
}
/** Keep the bottom side of the corner original data */
public static CornerData bottom(@NonNull CornerData orig, @NonNull CornerData other) {
return new CornerData(other.topLeft, orig.bottomLeft, other.topRight, orig.bottomRight);
}
}
}