FileDocCategorySizeDatePackage
CompoundButton.javaAPI DocAndroid 5.1 API16823Thu Mar 12 22:22:10 GMT 2015android.widget

CompoundButton

public abstract class CompoundButton extends Button implements Checkable

A button with two states, checked and unchecked. When the button is pressed or clicked, the state changes automatically.

XML attributes

See {@link android.R.styleable#CompoundButton CompoundButton Attributes}, {@link android.R.styleable#Button Button Attributes}, {@link android.R.styleable#TextView TextView Attributes}, {@link android.R.styleable#View View Attributes}

Fields Summary
private boolean
mChecked
private int
mButtonResource
private boolean
mBroadcasting
private android.graphics.drawable.Drawable
mButtonDrawable
private android.content.res.ColorStateList
mButtonTintList
private PorterDuff.Mode
mButtonTintMode
private boolean
mHasButtonTint
private boolean
mHasButtonTintMode
private OnCheckedChangeListener
mOnCheckedChangeListener
private OnCheckedChangeListener
mOnCheckedChangeWidgetListener
private static final int[]
CHECKED_STATE_SET
Constructors Summary
public CompoundButton(android.content.Context context)


       
        this(context, null);
public CompoundButton(android.content.Context context, android.util.AttributeSet attrs)

        this(context, attrs, 0);
public CompoundButton(android.content.Context context, android.util.AttributeSet attrs, int defStyleAttr)

        this(context, attrs, defStyleAttr, 0);
public CompoundButton(android.content.Context context, android.util.AttributeSet attrs, int defStyleAttr, int defStyleRes)

        super(context, attrs, defStyleAttr, defStyleRes);

        final TypedArray a = context.obtainStyledAttributes(
                attrs, com.android.internal.R.styleable.CompoundButton, defStyleAttr, defStyleRes);

        final Drawable d = a.getDrawable(com.android.internal.R.styleable.CompoundButton_button);
        if (d != null) {
            setButtonDrawable(d);
        }

        if (a.hasValue(R.styleable.CompoundButton_buttonTintMode)) {
            mButtonTintMode = Drawable.parseTintMode(a.getInt(
                    R.styleable.CompoundButton_buttonTintMode, -1), mButtonTintMode);
            mHasButtonTintMode = true;
        }

        if (a.hasValue(R.styleable.CompoundButton_buttonTint)) {
            mButtonTintList = a.getColorStateList(R.styleable.CompoundButton_buttonTint);
            mHasButtonTint = true;
        }

        final boolean checked = a.getBoolean(
                com.android.internal.R.styleable.CompoundButton_checked, false);
        setChecked(checked);

        a.recycle();

        applyButtonTint();
Methods Summary
private voidapplyButtonTint()

        if (mButtonDrawable != null && (mHasButtonTint || mHasButtonTintMode)) {
            mButtonDrawable = mButtonDrawable.mutate();

            if (mHasButtonTint) {
                mButtonDrawable.setTintList(mButtonTintList);
            }

            if (mHasButtonTintMode) {
                mButtonDrawable.setTintMode(mButtonTintMode);
            }

            // The drawable (or one of its children) may not have been
            // stateful before applying the tint, so let's try again.
            if (mButtonDrawable.isStateful()) {
                mButtonDrawable.setState(getDrawableState());
            }
        }
public voiddrawableHotspotChanged(float x, float y)

        super.drawableHotspotChanged(x, y);

        if (mButtonDrawable != null) {
            mButtonDrawable.setHotspot(x, y);
        }
protected voiddrawableStateChanged()

        super.drawableStateChanged();
        
        if (mButtonDrawable != null) {
            int[] myDrawableState = getDrawableState();
            
            // Set the state of the Drawable
            mButtonDrawable.setState(myDrawableState);
            
            invalidate();
        }
public android.content.res.ColorStateListgetButtonTintList()

return
the tint applied to the button drawable
attr
ref android.R.styleable#CompoundButton_buttonTint
see
#setButtonTintList(ColorStateList)

        return mButtonTintList;
public PorterDuff.ModegetButtonTintMode()

return
the blending mode used to apply the tint to the button drawable
attr
ref android.R.styleable#CompoundButton_buttonTintMode
see
#setButtonTintMode(PorterDuff.Mode)

        return mButtonTintMode;
public intgetCompoundPaddingLeft()

        int padding = super.getCompoundPaddingLeft();
        if (!isLayoutRtl()) {
            final Drawable buttonDrawable = mButtonDrawable;
            if (buttonDrawable != null) {
                padding += buttonDrawable.getIntrinsicWidth();
            }
        }
        return padding;
public intgetCompoundPaddingRight()

        int padding = super.getCompoundPaddingRight();
        if (isLayoutRtl()) {
            final Drawable buttonDrawable = mButtonDrawable;
            if (buttonDrawable != null) {
                padding += buttonDrawable.getIntrinsicWidth();
            }
        }
        return padding;
public intgetHorizontalOffsetForDrawables()

hide

        final Drawable buttonDrawable = mButtonDrawable;
        return (buttonDrawable != null) ? buttonDrawable.getIntrinsicWidth() : 0;
public booleanisChecked()

        return mChecked;
public voidjumpDrawablesToCurrentState()

        super.jumpDrawablesToCurrentState();
        if (mButtonDrawable != null) mButtonDrawable.jumpToCurrentState();
protected int[]onCreateDrawableState(int extraSpace)

        final int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
        if (isChecked()) {
            mergeDrawableStates(drawableState, CHECKED_STATE_SET);
        }
        return drawableState;
protected voidonDraw(android.graphics.Canvas canvas)

        final Drawable buttonDrawable = mButtonDrawable;
        if (buttonDrawable != null) {
            final int verticalGravity = getGravity() & Gravity.VERTICAL_GRAVITY_MASK;
            final int drawableHeight = buttonDrawable.getIntrinsicHeight();
            final int drawableWidth = buttonDrawable.getIntrinsicWidth();

            final int top;
            switch (verticalGravity) {
                case Gravity.BOTTOM:
                    top = getHeight() - drawableHeight;
                    break;
                case Gravity.CENTER_VERTICAL:
                    top = (getHeight() - drawableHeight) / 2;
                    break;
                default:
                    top = 0;
            }
            final int bottom = top + drawableHeight;
            final int left = isLayoutRtl() ? getWidth() - drawableWidth : 0;
            final int right = isLayoutRtl() ? getWidth() : drawableWidth;

            buttonDrawable.setBounds(left, top, right, bottom);

            final Drawable background = getBackground();
            if (background != null) {
                background.setHotspotBounds(left, top, right, bottom);
            }
        }

        super.onDraw(canvas);

        if (buttonDrawable != null) {
            final int scrollX = mScrollX;
            final int scrollY = mScrollY;
            if (scrollX == 0 && scrollY == 0) {
                buttonDrawable.draw(canvas);
            } else {
                canvas.translate(scrollX, scrollY);
                buttonDrawable.draw(canvas);
                canvas.translate(-scrollX, -scrollY);
            }
        }
public voidonInitializeAccessibilityEvent(android.view.accessibility.AccessibilityEvent event)

        super.onInitializeAccessibilityEvent(event);
        event.setClassName(CompoundButton.class.getName());
        event.setChecked(mChecked);
public voidonInitializeAccessibilityNodeInfo(android.view.accessibility.AccessibilityNodeInfo info)

        super.onInitializeAccessibilityNodeInfo(info);
        info.setClassName(CompoundButton.class.getName());
        info.setCheckable(true);
        info.setChecked(mChecked);
public voidonRestoreInstanceState(android.os.Parcelable state)

        SavedState ss = (SavedState) state;
  
        super.onRestoreInstanceState(ss.getSuperState());
        setChecked(ss.checked);
        requestLayout();
public android.os.ParcelableonSaveInstanceState()

    

    
       
        Parcelable superState = super.onSaveInstanceState();

        SavedState ss = new SavedState(superState);

        ss.checked = isChecked();
        return ss;
public booleanperformClick()

        toggle();

        final boolean handled = super.performClick();
        if (!handled) {
            // View only makes a sound effect if the onClickListener was
            // called, so we'll need to make one here instead.
            playSoundEffect(SoundEffectConstants.CLICK);
        }

        return handled;
public voidsetButtonDrawable(int resid)
Set the button graphic to a given Drawable, identified by its resource id.

param
resid the resource id of the drawable to use as the button graphic

        if (resid != 0 && resid == mButtonResource) {
            return;
        }

        mButtonResource = resid;

        Drawable d = null;
        if (mButtonResource != 0) {
            d = getContext().getDrawable(mButtonResource);
        }
        setButtonDrawable(d);
public voidsetButtonDrawable(android.graphics.drawable.Drawable d)
Set the button graphic to a given Drawable

param
d The Drawable to use as the button graphic

        if (mButtonDrawable != d) {
            if (mButtonDrawable != null) {
                mButtonDrawable.setCallback(null);
                unscheduleDrawable(mButtonDrawable);
            }

            mButtonDrawable = d;

            if (d != null) {
                d.setCallback(this);
                d.setLayoutDirection(getLayoutDirection());
                if (d.isStateful()) {
                    d.setState(getDrawableState());
                }
                d.setVisible(getVisibility() == VISIBLE, false);
                setMinHeight(d.getIntrinsicHeight());
                applyButtonTint();
            }
        }
public voidsetButtonTintList(android.content.res.ColorStateList tint)
Applies a tint to the button drawable. Does not modify the current tint mode, which is {@link PorterDuff.Mode#SRC_IN} by default.

Subsequent calls to {@link #setButtonDrawable(Drawable)} will automatically mutate the drawable and apply the specified tint and tint mode using {@link Drawable#setTintList(ColorStateList)}.

param
tint the tint to apply, may be {@code null} to clear tint
attr
ref android.R.styleable#CompoundButton_buttonTint
see
#setButtonTintList(ColorStateList)
see
Drawable#setTintList(ColorStateList)

        mButtonTintList = tint;
        mHasButtonTint = true;

        applyButtonTint();
public voidsetButtonTintMode(PorterDuff.Mode tintMode)
Specifies the blending mode used to apply the tint specified by {@link #setButtonTintList(ColorStateList)}} to the button drawable. The default mode is {@link PorterDuff.Mode#SRC_IN}.

param
tintMode the blending mode used to apply the tint, may be {@code null} to clear tint
attr
ref android.R.styleable#CompoundButton_buttonTintMode
see
#getButtonTintMode()
see
Drawable#setTintMode(PorterDuff.Mode)

        mButtonTintMode = tintMode;
        mHasButtonTintMode = true;

        applyButtonTint();
public voidsetChecked(boolean checked)

Changes the checked state of this button.

param
checked true to check the button, false to uncheck it

        if (mChecked != checked) {
            mChecked = checked;
            refreshDrawableState();
            notifyViewAccessibilityStateChangedIfNeeded(
                    AccessibilityEvent.CONTENT_CHANGE_TYPE_UNDEFINED);

            // Avoid infinite recursions if setChecked() is called from a listener
            if (mBroadcasting) {
                return;
            }

            mBroadcasting = true;
            if (mOnCheckedChangeListener != null) {
                mOnCheckedChangeListener.onCheckedChanged(this, mChecked);
            }
            if (mOnCheckedChangeWidgetListener != null) {
                mOnCheckedChangeWidgetListener.onCheckedChanged(this, mChecked);
            }

            mBroadcasting = false;            
        }
public voidsetOnCheckedChangeListener(android.widget.CompoundButton$OnCheckedChangeListener listener)
Register a callback to be invoked when the checked state of this button changes.

param
listener the callback to call on checked state change

        mOnCheckedChangeListener = listener;
voidsetOnCheckedChangeWidgetListener(android.widget.CompoundButton$OnCheckedChangeListener listener)
Register a callback to be invoked when the checked state of this button changes. This callback is used for internal purpose only.

param
listener the callback to call on checked state change
hide

        mOnCheckedChangeWidgetListener = listener;
public voidtoggle()

        setChecked(!mChecked);
protected booleanverifyDrawable(android.graphics.drawable.Drawable who)

        return super.verifyDrawable(who) || who == mButtonDrawable;