| /* |
| * 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.android.internal.widget; |
| |
| import com.android.internal.R; |
| |
| import android.widget.ActionMenuPresenter; |
| import android.widget.ActionMenuView; |
| import com.android.internal.view.menu.MenuBuilder; |
| |
| 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.ActionMode; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.widget.LinearLayout; |
| import android.widget.TextView; |
| |
| /** |
| * @hide |
| */ |
| public class ActionBarContextView extends AbsActionBarView { |
| 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 int mCloseItemLayout; |
| |
| public ActionBarContextView(Context context) { |
| this(context, null); |
| } |
| |
| public ActionBarContextView(Context context, AttributeSet attrs) { |
| this(context, attrs, com.android.internal.R.attr.actionModeStyle); |
| } |
| |
| public ActionBarContextView(Context context, AttributeSet attrs, int defStyleAttr) { |
| this(context, attrs, defStyleAttr, 0); |
| } |
| |
| public ActionBarContextView( |
| Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) { |
| super(context, attrs, defStyleAttr, defStyleRes); |
| |
| final TypedArray a = context.obtainStyledAttributes( |
| attrs, R.styleable.ActionMode, defStyleAttr, defStyleRes); |
| setBackground(a.getDrawable( |
| com.android.internal.R.styleable.ActionMode_background)); |
| mTitleStyleRes = a.getResourceId( |
| com.android.internal.R.styleable.ActionMode_titleTextStyle, 0); |
| mSubtitleStyleRes = a.getResourceId( |
| com.android.internal.R.styleable.ActionMode_subtitleTextStyle, 0); |
| |
| mContentHeight = a.getLayoutDimension( |
| com.android.internal.R.styleable.ActionMode_height, 0); |
| |
| mSplitBackground = a.getDrawable( |
| com.android.internal.R.styleable.ActionMode_backgroundSplit); |
| |
| mCloseItemLayout = a.getResourceId( |
| com.android.internal.R.styleable.ActionMode_closeItemLayout, |
| R.layout.action_mode_close_item); |
| |
| a.recycle(); |
| } |
| |
| @Override |
| public void onDetachedFromWindow() { |
| super.onDetachedFromWindow(); |
| if (mActionMenuPresenter != null) { |
| mActionMenuPresenter.hideOverflowMenu(); |
| mActionMenuPresenter.hideSubMenus(); |
| } |
| } |
| |
| @Override |
| public void setSplitToolbar(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.setBackground(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.setBackground(mSplitBackground); |
| final ViewGroup oldParent = (ViewGroup) mMenuView.getParent(); |
| if (oldParent != null) oldParent.removeView(mMenuView); |
| mSplitView.addView(mMenuView, layoutParams); |
| } |
| } |
| super.setSplitToolbar(split); |
| } |
| } |
| |
| public void setContentHeight(int height) { |
| mContentHeight = height; |
| } |
| |
| public void setCustomView(View view) { |
| if (mCustomView != null) { |
| removeView(mCustomView); |
| } |
| mCustomView = view; |
| if (view != null && 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(mTitleStyleRes); |
| } |
| if (mSubtitleStyleRes != 0) { |
| mSubtitleView.setTextAppearance(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(mCloseItemLayout, this, false); |
| addView(mClose); |
| } else if (mClose.getParent() == null) { |
| addView(mClose); |
| } |
| |
| View closeButton = mClose.findViewById(R.id.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, mPopupContext); |
| mMenuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this); |
| mMenuView.setBackground(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, mPopupContext); |
| mMenuView = (ActionMenuView) mActionMenuPresenter.getMenuView(this); |
| mMenuView.setBackgroundDrawable(mSplitBackground); |
| mSplitView.addView(mMenuView, layoutParams); |
| } |
| } |
| |
| public void closeMode() { |
| if (mClose == null) { |
| killMode(); |
| return; |
| } |
| |
| } |
| |
| public void killMode() { |
| removeAllViews(); |
| if (mSplitView != null) { |
| mSplitView.removeView(mMenuView); |
| } |
| mCustomView = null; |
| mMenuView = null; |
| } |
| |
| @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) { |
| if (mTitleOptional) { |
| final int titleWidthSpec = MeasureSpec.makeSafeMeasureSpec(contentWidth, |
| 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 != 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); |
| } |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int l, int t, int r, int b) { |
| final boolean isLayoutRtl = isLayoutRtl(); |
| int x = isLayoutRtl ? r - l - getPaddingRight() : getPaddingLeft(); |
| final int y = getPaddingTop(); |
| final int contentHeight = b - t - getPaddingTop() - getPaddingBottom(); |
| |
| if (mClose != null && mClose.getVisibility() != GONE) { |
| MarginLayoutParams lp = (MarginLayoutParams) mClose.getLayoutParams(); |
| final int startMargin = (isLayoutRtl ? lp.rightMargin : lp.leftMargin); |
| final int endMargin = (isLayoutRtl ? lp.leftMargin : lp.rightMargin); |
| x = next(x, startMargin, isLayoutRtl); |
| x += positionChild(mClose, x, y, contentHeight, isLayoutRtl); |
| x = next(x, endMargin, isLayoutRtl); |
| |
| } |
| |
| if (mTitleLayout != null && mCustomView == null && mTitleLayout.getVisibility() != GONE) { |
| x += positionChild(mTitleLayout, x, y, contentHeight, isLayoutRtl); |
| } |
| |
| if (mCustomView != null) { |
| x += positionChild(mCustomView, x, y, contentHeight, isLayoutRtl); |
| } |
| |
| x = isLayoutRtl ? getPaddingLeft() : r - l - getPaddingRight(); |
| |
| if (mMenuView != null) { |
| x += positionChild(mMenuView, x, y, contentHeight, !isLayoutRtl); |
| } |
| } |
| |
| @Override |
| public boolean shouldDelayChildPressedState() { |
| return false; |
| } |
| |
| @Override |
| public void onInitializeAccessibilityEventInternal(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.onInitializeAccessibilityEventInternal(event); |
| } |
| } |
| |
| public void setTitleOptional(boolean titleOptional) { |
| if (titleOptional != mTitleOptional) { |
| requestLayout(); |
| } |
| mTitleOptional = titleOptional; |
| } |
| |
| public boolean isTitleOptional() { |
| return mTitleOptional; |
| } |
| } |
