content: /*
   * 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.nineoldandroids.widget.NineLinearLayout;
  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 NineLinearLayout mClose;
      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.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 = 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.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 = (NineLinearLayout)inflater.inflate(R.layout.abs__action_mode_close_item, this, false);
              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();
          if (mActionMenuPresenter != null) {
              mActionMenuPresenter.dismissPopupMenus();
          }
          mActionMenuPresenter = new ActionMenuPresenter(mContext);
          mActionMenuPresenter.setReserveOverflow(true);
  
          final LayoutParams layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT,
                  LayoutParams.MATCH_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.MATCH_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.MATCH_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() {
          mClose.setTranslationX(-mClose.getWidth() -
                  ((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++) {
                      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(mClose, "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);
          }
      }
  }
  