Project: cow
Code Examples
/*
 * Copyright (C) 2010 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.actionbarsherlock.internal.widget; 
 
import android.content.Context; 
import android.content.res.TypedArray; 
import android.graphics.drawable.Drawable; 
import android.text.TextUtils; 
import android.util.AttributeSet; 
import android.view.LayoutInflater; 
import android.view.View; 
import android.view.ViewGroup; 
import android.view.accessibility.AccessibilityEvent; 
import android.view.animation.DecelerateInterpolator; 
import android.widget.LinearLayout; 
import android.widget.TextView; 
 
import com.actionbarsherlock.R; 
import com.actionbarsherlock.internal.nineoldandroids.animation.Animator; 
import com.actionbarsherlock.internal.nineoldandroids.animation.Animator.AnimatorListener; 
import com.actionbarsherlock.internal.nineoldandroids.animation.AnimatorSet; 
import com.actionbarsherlock.internal.nineoldandroids.animation.ObjectAnimator; 
import com.actionbarsherlock.internal.nineoldandroids.view.animation.AnimatorProxy; 
import com.actionbarsherlock.internal.view.menu.ActionMenuPresenter; 
import com.actionbarsherlock.internal.view.menu.ActionMenuView; 
import com.actionbarsherlock.internal.view.menu.MenuBuilder; 
import com.actionbarsherlock.view.ActionMode; 
 
/**
 * @hide 
 */ 
public class ActionBarContextView extends AbsActionBarView implements AnimatorListener { 
    //UNUSED private static final String TAG = "ActionBarContextView"; 
 
    private CharSequence mTitle; 
    private CharSequence mSubtitle; 
 
    private View mClose; 
    private AnimatorProxy mCloseWrap; 
    private View mCustomView; 
    private LinearLayout mTitleLayout; 
    private TextView mTitleView; 
    private TextView mSubtitleView; 
    private int mTitleStyleRes; 
    private int mSubtitleStyleRes; 
    private Drawable mSplitBackground; 
 
    private Animator mCurrentAnimation; 
    private boolean mAnimateInOnLayout; 
    private int mAnimationMode; 
 
    private static final int ANIMATE_IDLE = 0; 
    private static final int ANIMATE_IN = 1; 
    private static final int ANIMATE_OUT = 2; 
 
    public ActionBarContextView(Context context) { 
        this(context, null); 
    } 
 
    public ActionBarContextView(Context context, AttributeSet attrs) { 
        this(context, attrs, R.attr.actionModeStyle); 
    } 
 
    public ActionBarContextView(Context context, AttributeSet attrs, int defStyle) { 
        super(context, attrs, defStyle); 
 
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.SherlockActionMode, defStyle, 0); 
        setBackgroundDrawable(a.getDrawable( 
                R.styleable.SherlockActionMode_background)); 
        mTitleStyleRes = a.getResourceId( 
                R.styleable.SherlockActionMode_titleTextStyle, 0); 
        mSubtitleStyleRes = a.getResourceId( 
                R.styleable.SherlockActionMode_subtitleTextStyle, 0); 
 
        mContentHeight = a.getLayoutDimension( 
                R.styleable.SherlockActionMode_height, 0); 
 
        mSplitBackground = a.getDrawable( 
                R.styleable.SherlockActionMode_backgroundSplit); 
 
        a.recycle(); 
    } 
 
    @Override 
    public void onDetachedFromWindow() { 
        super.onDetachedFromWindow(); 
        if (mActionMenuPresenter != null) { 
            mActionMenuPresenter.hideOverflowMenu(); 
            mActionMenuPresenter.hideSubMenus(); 
        } 
    } 
 
    @Override 
    public void setSplitActionBar(boolean split) { 
        if (mSplitActionBar != split) { 
            if (mActionMenuPresenter != null) { 
                // Mode is already active; move everything over and adjust the menu itself. 
                final LayoutParams layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, 
                        LayoutParams.FILL_PARENT); 
                if (!split) { 
                    mMenuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this); 
                    mMenuView.setBackgroundDrawable(null); 
                    final ViewGroup oldParent = (ViewGroup) mMenuView.getParent(); 
                    if (oldParent != null) oldParent.removeView(mMenuView); 
                    addView(mMenuView, layoutParams); 
                } else { 
                    // Allow full screen width in split mode. 
                    mActionMenuPresenter.setWidthLimit( 
                            getContext().getResources().getDisplayMetrics().widthPixels, true); 
                    // No limit to the item count; use whatever will fit. 
                    mActionMenuPresenter.setItemLimit(Integer.MAX_VALUE); 
                    // Span the whole width 
                    layoutParams.width = LayoutParams.FILL_PARENT; 
                    layoutParams.height = mContentHeight; 
                    mMenuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this); 
                    mMenuView.setBackgroundDrawable(mSplitBackground); 
                    final ViewGroup oldParent = (ViewGroup) mMenuView.getParent(); 
                    if (oldParent != null) oldParent.removeView(mMenuView); 
                    mSplitView.addView(mMenuView, layoutParams); 
                } 
            } 
            super.setSplitActionBar(split); 
        } 
    } 
 
    public void setContentHeight(int height) { 
        mContentHeight = height; 
    } 
 
    public void setCustomView(View view) { 
        if (mCustomView != null) { 
            removeView(mCustomView); 
        } 
        mCustomView = view; 
        if (mTitleLayout != null) { 
            removeView(mTitleLayout); 
            mTitleLayout = null; 
        } 
        if (view != null) { 
            addView(view); 
        } 
        requestLayout(); 
    } 
 
    public void setTitle(CharSequence title) { 
        mTitle = title; 
        initTitle(); 
    } 
 
    public void setSubtitle(CharSequence subtitle) { 
        mSubtitle = subtitle; 
        initTitle(); 
    } 
 
    public CharSequence getTitle() { 
        return mTitle; 
    } 
 
    public CharSequence getSubtitle() { 
        return mSubtitle; 
    } 
 
    private void initTitle() { 
        if (mTitleLayout == null) { 
            LayoutInflater inflater = LayoutInflater.from(getContext()); 
            inflater.inflate(R.layout.abs__action_bar_title_item, this); 
            mTitleLayout = (LinearLayout) getChildAt(getChildCount() - 1); 
            mTitleView = (TextView) mTitleLayout.findViewById(R.id.abs__action_bar_title); 
            mSubtitleView = (TextView) mTitleLayout.findViewById(R.id.abs__action_bar_subtitle); 
            if (mTitleStyleRes != 0) { 
                mTitleView.setTextAppearance(mContext, mTitleStyleRes); 
            } 
            if (mSubtitleStyleRes != 0) { 
                mSubtitleView.setTextAppearance(mContext, mSubtitleStyleRes); 
            } 
        } 
 
        mTitleView.setText(mTitle); 
        mSubtitleView.setText(mSubtitle); 
 
        final boolean hasTitle = !TextUtils.isEmpty(mTitle); 
        final boolean hasSubtitle = !TextUtils.isEmpty(mSubtitle); 
        mSubtitleView.setVisibility(hasSubtitle ? VISIBLE : GONE); 
        mTitleLayout.setVisibility(hasTitle || hasSubtitle ? VISIBLE : GONE); 
        if (mTitleLayout.getParent() == null) { 
            addView(mTitleLayout); 
        } 
    } 
 
    public void initForMode(final ActionMode mode) { 
        if (mClose == null) { 
            LayoutInflater inflater = LayoutInflater.from(mContext); 
            mClose = inflater.inflate(R.layout.abs__action_mode_close_item, this, false); 
            mCloseWrap = AnimatorProxy.wrap(mClose); 
            addView(mClose); 
        } else if (mClose.getParent() == null) { 
            addView(mClose); 
        } 
 
        View closeButton = mClose.findViewById(R.id.abs__action_mode_close_button); 
        closeButton.setOnClickListener(new OnClickListener() { 
            public void onClick(View v) { 
                mode.finish(); 
            } 
        }); 
 
        final MenuBuilder menu = (MenuBuilder) mode.getMenu(); 
        mActionMenuPresenter = new ActionMenuPresenter(mContext); 
        mActionMenuPresenter.setReserveOverflow(true); 
 
        final LayoutParams layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, 
                LayoutParams.FILL_PARENT); 
        if (!mSplitActionBar) { 
            menu.addMenuPresenter(mActionMenuPresenter); 
            mMenuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this); 
            mMenuView.setBackgroundDrawable(null); 
            addView(mMenuView, layoutParams); 
        } else { 
            // Allow full screen width in split mode. 
            mActionMenuPresenter.setWidthLimit( 
                    getContext().getResources().getDisplayMetrics().widthPixels, true); 
            // No limit to the item count; use whatever will fit. 
            mActionMenuPresenter.setItemLimit(Integer.MAX_VALUE); 
            // Span the whole width 
            layoutParams.width = LayoutParams.FILL_PARENT; 
            layoutParams.height = mContentHeight; 
            menu.addMenuPresenter(mActionMenuPresenter); 
            mMenuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this); 
            mMenuView.setBackgroundDrawable(mSplitBackground); 
            mSplitView.addView(mMenuView, layoutParams); 
        } 
 
        mAnimateInOnLayout = true; 
    } 
 
    public void closeMode() { 
        if (mAnimationMode == ANIMATE_OUT) { 
            // Called again during close; just finish what we were doing. 
            return; 
        } 
        if (mClose == null) { 
            killMode(); 
            return; 
        } 
 
        finishAnimation(); 
        mAnimationMode = ANIMATE_OUT; 
        mCurrentAnimation = makeOutAnimation(); 
        mCurrentAnimation.start(); 
    } 
 
    private void finishAnimation() { 
        final Animator a = mCurrentAnimation; 
        if (a != null) { 
            mCurrentAnimation = null; 
            a.end(); 
        } 
    } 
 
    public void killMode() { 
        finishAnimation(); 
        removeAllViews(); 
        if (mSplitView != null) { 
            mSplitView.removeView(mMenuView); 
        } 
        mCustomView = null; 
        mMenuView = null; 
        mAnimateInOnLayout = false; 
    } 
 
    @Override 
    public boolean showOverflowMenu() { 
        if (mActionMenuPresenter != null) { 
            return mActionMenuPresenter.showOverflowMenu(); 
        } 
        return false; 
    } 
 
    @Override 
    public boolean hideOverflowMenu() { 
        if (mActionMenuPresenter != null) { 
            return mActionMenuPresenter.hideOverflowMenu(); 
        } 
        return false; 
    } 
 
    @Override 
    public boolean isOverflowMenuShowing() { 
        if (mActionMenuPresenter != null) { 
            return mActionMenuPresenter.isOverflowMenuShowing(); 
        } 
        return false; 
    } 
 
    @Override 
    protected ViewGroup.LayoutParams generateDefaultLayoutParams() { 
        // Used by custom views if they don't supply layout params. Everything else 
        // added to an ActionBarContextView should have them already. 
        return new MarginLayoutParams(LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT); 
    } 
 
    @Override 
    public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) { 
        return new MarginLayoutParams(getContext(), attrs); 
    } 
 
    @Override 
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
        final int widthMode = MeasureSpec.getMode(widthMeasureSpec); 
        if (widthMode != MeasureSpec.EXACTLY) { 
            throw new IllegalStateException(getClass().getSimpleName() + " can only be used " + 
                    "with android:layout_width=\"match_parent\" (or fill_parent)"); 
        } 
 
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec); 
        if (heightMode == MeasureSpec.UNSPECIFIED) { 
            throw new IllegalStateException(getClass().getSimpleName() + " can only be used " + 
                    "with android:layout_height=\"wrap_content\""); 
        } 
 
        final int contentWidth = MeasureSpec.getSize(widthMeasureSpec); 
 
        int maxHeight = mContentHeight > 0 ? 
                mContentHeight : MeasureSpec.getSize(heightMeasureSpec); 
 
        final int verticalPadding = getPaddingTop() + getPaddingBottom(); 
        int availableWidth = contentWidth - getPaddingLeft() - getPaddingRight(); 
        final int height = maxHeight - verticalPadding; 
        final int childSpecHeight = MeasureSpec.makeMeasureSpec(height, MeasureSpec.AT_MOST); 
 
        if (mClose != null) { 
            availableWidth = measureChildView(mClose, availableWidth, childSpecHeight, 0); 
            MarginLayoutParams lp = (MarginLayoutParams) mClose.getLayoutParams(); 
            availableWidth -= lp.leftMargin + lp.rightMargin; 
        } 
 
        if (mMenuView != null && mMenuView.getParent() == this) { 
            availableWidth = measureChildView(mMenuView, availableWidth, 
                    childSpecHeight, 0); 
        } 
 
        if (mTitleLayout != null && mCustomView == null) { 
            availableWidth = measureChildView(mTitleLayout, availableWidth, childSpecHeight, 0); 
        } 
 
        if (mCustomView != null) { 
            ViewGroup.LayoutParams lp = mCustomView.getLayoutParams(); 
            final int customWidthMode = lp.width != LayoutParams.WRAP_CONTENT ? 
                    MeasureSpec.EXACTLY : MeasureSpec.AT_MOST; 
            final int customWidth = lp.width >= 0 ? 
                    Math.min(lp.width, availableWidth) : availableWidth; 
            final int customHeightMode = lp.height != LayoutParams.WRAP_CONTENT ? 
                    MeasureSpec.EXACTLY : MeasureSpec.AT_MOST; 
            final int customHeight = lp.height >= 0 ? 
                    Math.min(lp.height, height) : height; 
            mCustomView.measure(MeasureSpec.makeMeasureSpec(customWidth, customWidthMode), 
                    MeasureSpec.makeMeasureSpec(customHeight, customHeightMode)); 
        } 
 
        if (mContentHeight <= 0) { 
            int measuredHeight = 0; 
            final int count = getChildCount(); 
            for (int i = 0; i < count; i++) { 
                View v = getChildAt(i); 
                int paddedViewHeight = v.getMeasuredHeight() + verticalPadding; 
                if (paddedViewHeight > measuredHeight) { 
                    measuredHeight = paddedViewHeight; 
                } 
            } 
            setMeasuredDimension(contentWidth, measuredHeight); 
        } else { 
            setMeasuredDimension(contentWidth, maxHeight); 
        } 
    } 
 
    private Animator makeInAnimation() { 
        mCloseWrap.setTranslationX(-mClose.getWidth() - 
                ((MarginLayoutParams) mClose.getLayoutParams()).leftMargin); 
        ObjectAnimator buttonAnimator = ObjectAnimator.ofFloat(mCloseWrap, "translationX", 0); 
        buttonAnimator.setDuration(200); 
        buttonAnimator.addListener(this); 
        buttonAnimator.setInterpolator(new DecelerateInterpolator()); 
 
        AnimatorSet set = new AnimatorSet(); 
        AnimatorSet.Builder b = set.play(buttonAnimator); 
 
        if (mMenuView != null) { 
            final int count = mMenuView.getChildCount(); 
            if (count > 0) { 
                for (int i = count - 1, j = 0; i >= 0; i--, j++) { 
                    AnimatorProxy child = AnimatorProxy.wrap(mMenuView.getChildAt(i)); 
                    child.setScaleY(0); 
                    ObjectAnimator a = ObjectAnimator.ofFloat(child, "scaleY", 0, 1); 
                    a.setDuration(100); 
                    a.setStartDelay(j * 70); 
                    b.with(a); 
                } 
            } 
        } 
 
        return set; 
    } 
 
    private Animator makeOutAnimation() { 
        ObjectAnimator buttonAnimator = ObjectAnimator.ofFloat(mCloseWrap, "translationX", 
                -mClose.getWidth() - ((MarginLayoutParams) mClose.getLayoutParams()).leftMargin); 
        buttonAnimator.setDuration(200); 
        buttonAnimator.addListener(this); 
        buttonAnimator.setInterpolator(new DecelerateInterpolator()); 
 
        AnimatorSet set = new AnimatorSet(); 
        AnimatorSet.Builder b = set.play(buttonAnimator); 
 
        if (mMenuView != null) { 
            final int count = mMenuView.getChildCount(); 
            if (count > 0) { 
                for (int i = 0; i < 0; i++) { 
                    AnimatorProxy child = AnimatorProxy.wrap(mMenuView.getChildAt(i)); 
                    child.setScaleY(0); 
                    ObjectAnimator a = ObjectAnimator.ofFloat(child, "scaleY", 0); 
                    a.setDuration(100); 
                    a.setStartDelay(i * 70); 
                    b.with(a); 
                } 
            } 
        } 
 
        return set; 
    } 
 
    @Override 
    protected void onLayout(boolean changed, int l, int t, int r, int b) { 
        int x = getPaddingLeft(); 
        final int y = getPaddingTop(); 
        final int contentHeight = b - t - getPaddingTop() - getPaddingBottom(); 
 
        if (mClose != null && mClose.getVisibility() != GONE) { 
            MarginLayoutParams lp = (MarginLayoutParams) mClose.getLayoutParams(); 
            x += lp.leftMargin; 
            x += positionChild(mClose, x, y, contentHeight); 
            x += lp.rightMargin; 
 
            if (mAnimateInOnLayout) { 
                mAnimationMode = ANIMATE_IN; 
                mCurrentAnimation = makeInAnimation(); 
                mCurrentAnimation.start(); 
                mAnimateInOnLayout = false; 
            } 
        } 
 
        if (mTitleLayout != null && mCustomView == null) { 
            x += positionChild(mTitleLayout, x, y, contentHeight); 
        } 
 
        if (mCustomView != null) { 
            x += positionChild(mCustomView, x, y, contentHeight); 
        } 
 
        x = r - l - getPaddingRight(); 
 
        if (mMenuView != null) { 
            x -= positionChildInverse(mMenuView, x, y, contentHeight); 
        } 
    } 
 
    @Override 
    public void onAnimationStart(Animator animation) { 
    } 
 
    @Override 
    public void onAnimationEnd(Animator animation) { 
        if (mAnimationMode == ANIMATE_OUT) { 
            killMode(); 
        } 
        mAnimationMode = ANIMATE_IDLE; 
    } 
 
    @Override 
    public void onAnimationCancel(Animator animation) { 
    } 
 
    @Override 
    public void onAnimationRepeat(Animator animation) { 
    } 
 
    //@Override 
    public boolean shouldDelayChildPressedState() { 
        return false; 
    } 
 
    //@Override 
    public void onInitializeAccessibilityEvent(AccessibilityEvent event) { 
        if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) { 
            // Action mode started 
            //TODO event.setSource(this); 
            event.setClassName(getClass().getName()); 
            event.setPackageName(getContext().getPackageName()); 
            event.setContentDescription(mTitle); 
        } else { 
            //TODO super.onInitializeAccessibilityEvent(event); 
        } 
    } 
}