xref: /frameworks/support/v7/appcompat/src/android/support/v7/widget/ActionBarContextView.java

/*
 * 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 android.support.appcompat.widget;

import android.animation.Animator;
import android.animation.Animator.AnimatorListener;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.drawable.Drawable;
import android.support.appcompat.R;
import android.support.appcompat.view.menu.ActionMenuPresenter;
import android.support.appcompat.view.menu.ActionMenuView;
import android.support.appcompat.view.menu.MenuBuilder;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.ActionMode;
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;

/**
 * @hide
 */
public class ActionBarContextView extends AbsActionBarView implements AnimatorListener {
  private static final String TAG = "ActionBarContextView";

  private CharSequence mTitle;
  private CharSequence mSubtitle;

  private View mClose;
  private View mCustomView;
  private LinearLayout mTitleLayout;
  private TextView mTitleView;
  private TextView mSubtitleView;
  private int mTitleStyleRes;
  private int mSubtitleStyleRes;
  private Drawable mSplitBackground;
  private boolean mTitleOptional;

  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.ActionMode, defStyle, 0);
    setBackgroundDrawable(a.getDrawable(
        R.styleable.ActionMode_background));
    mTitleStyleRes = a.getResourceId(
        R.styleable.ActionMode_titleTextStyle, 0);
    mSubtitleStyleRes = a.getResourceId(
        R.styleable.ActionMode_subtitleTextStyle, 0);

    mContentHeight = a.getLayoutDimension(
        R.styleable.ActionMode_height, 0);

    mSplitBackground = a.getDrawable(
        R.styleable.ActionMode_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 ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(
            ViewGroup.LayoutParams.WRAP_CONTENT,
            ViewGroup.LayoutParams.MATCH_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 = ViewGroup.LayoutParams.MATCH_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.action_bar_title_item, this);
      mTitleLayout = (LinearLayout) getChildAt(getChildCount() - 1);
      mTitleView = (TextView) mTitleLayout.findViewById(R.id.action_bar_title);
      mSubtitleView = (TextView) mTitleLayout.findViewById(R.id.action_bar_subtitle);
      if (mTitleStyleRes != 0) {
        mTitleView.setTextAppearance(getContext(), mTitleStyleRes);
      }
      if (mSubtitleStyleRes != 0) {
        mSubtitleView.setTextAppearance(getContext(), 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(getContext());
      mClose = inflater.inflate(R.layout.action_mode_close_item, this, false);
      addView(mClose);
    } else if (mClose.getParent() == null) {
      addView(mClose);
    }

    View closeButton = mClose.findViewById(R.id.action_mode_close_button);
    closeButton.setOnClickListener(new View.OnClickListener() {
      public void onClick(View v) {
        mode.finish();
      }
    });

    final MenuBuilder menu = (MenuBuilder) mode.getMenu();
    if (mActionMenuPresenter != null) {
      mActionMenuPresenter.dismissPopupMenus();
    }
    mActionMenuPresenter = new ActionMenuPresenter(getContext());
    mActionMenuPresenter.setReserveOverflow(true);

    final ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(
        ViewGroup.LayoutParams.WRAP_CONTENT,
        ViewGroup.LayoutParams.MATCH_PARENT);
    if (!mSplitActionBar) {
      // TODO(trevorjohns): Re-enable menu option
      // 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 = ViewGroup.LayoutParams.MATCH_PARENT;
      layoutParams.height = mContentHeight;
      // TODO(trevorjohns): Re-enable menu option
      // 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 ViewGroup.MarginLayoutParams(
        ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);
  }

  @Override
  public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
    return new ViewGroup.MarginLayoutParams(getContext(), attrs);
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int widthMode = View.MeasureSpec.getMode(widthMeasureSpec);
    if (widthMode != View.MeasureSpec.EXACTLY) {
      throw new IllegalStateException(getClass().getSimpleName() + " can only be used " +
          "with android:layout_width=\"match_parent\" (or fill_parent)");
    }

    final int heightMode = View.MeasureSpec.getMode(heightMeasureSpec);
    if (heightMode == View.MeasureSpec.UNSPECIFIED) {
      throw new IllegalStateException(getClass().getSimpleName() + " can only be used " +
          "with android:layout_height=\"wrap_content\"");
    }

    final int contentWidth = View.MeasureSpec.getSize(widthMeasureSpec);

    int maxHeight = mContentHeight > 0 ?
        mContentHeight : View.MeasureSpec.getSize(heightMeasureSpec);

    final int verticalPadding = getPaddingTop() + getPaddingBottom();
    int availableWidth = contentWidth - getPaddingLeft() - getPaddingRight();
    final int height = maxHeight - verticalPadding;
    final int childSpecHeight = View.MeasureSpec
        .makeMeasureSpec(height, View.MeasureSpec.AT_MOST);

    if (mClose != null) {
      availableWidth = measureChildView(mClose, availableWidth, childSpecHeight, 0);
      ViewGroup.MarginLayoutParams lp = (ViewGroup.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) {
      if (mTitleOptional) {
        final int titleWidthSpec = View.MeasureSpec
            .makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
        mTitleLayout.measure(titleWidthSpec, childSpecHeight);
        final int titleWidth = mTitleLayout.getMeasuredWidth();
        final boolean titleFits = titleWidth <= availableWidth;
        if (titleFits) {
          availableWidth -= titleWidth;
        }
        mTitleLayout.setVisibility(titleFits ? VISIBLE : GONE);
      } else {
        availableWidth = measureChildView(mTitleLayout, availableWidth, childSpecHeight, 0);
      }
    }

    if (mCustomView != null) {
      ViewGroup.LayoutParams lp = mCustomView.getLayoutParams();
      final int customWidthMode = lp.width != ViewGroup.LayoutParams.WRAP_CONTENT ?
          View.MeasureSpec.EXACTLY : View.MeasureSpec.AT_MOST;
      final int customWidth = lp.width >= 0 ?
          Math.min(lp.width, availableWidth) : availableWidth;
      final int customHeightMode = lp.height != ViewGroup.LayoutParams.WRAP_CONTENT ?
          View.MeasureSpec.EXACTLY : View.MeasureSpec.AT_MOST;
      final int customHeight = lp.height >= 0 ?
          Math.min(lp.height, height) : height;
      mCustomView.measure(View.MeasureSpec.makeMeasureSpec(customWidth, customWidthMode),
          View.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() {
    mClose.setTranslationX(-mClose.getWidth() -
        ((ViewGroup.MarginLayoutParams) mClose.getLayoutParams()).leftMargin);
    ObjectAnimator buttonAnimator = ObjectAnimator.ofFloat(mClose, "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++) {
          View child = mMenuView.getChildAt(i);
          child.setScaleY(0);
          ObjectAnimator a = ObjectAnimator.ofFloat(child, "scaleY", 0, 1);
          a.setDuration(300);
          b.with(a);
        }
      }
    }

    return set;
  }

  private Animator makeOutAnimation() {
    ObjectAnimator buttonAnimator = ObjectAnimator.ofFloat(mClose, "translationX",
        -mClose.getWidth() - ((ViewGroup.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++) {
          View child = mMenuView.getChildAt(i);
          child.setScaleY(0);
          ObjectAnimator a = ObjectAnimator.ofFloat(child, "scaleY", 0);
          a.setDuration(300);
          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) {
      ViewGroup.MarginLayoutParams lp = (ViewGroup.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 && mTitleLayout.getVisibility() != GONE) {
      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
      event.setSource(this);
      event.setClassName(getClass().getName());
      event.setPackageName(getContext().getPackageName());
      event.setContentDescription(mTitle);
    } else {
      super.onInitializeAccessibilityEvent(event);
    }
  }

  public void setTitleOptional(boolean titleOptional) {
    if (titleOptional != mTitleOptional) {
      requestLayout();
    }
    mTitleOptional = titleOptional;
  }

  public boolean isTitleOptional() {
    return mTitleOptional;
  }
}