1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16package android.widget; 17 18import android.annotation.NonNull; 19import android.annotation.Nullable; 20import android.annotation.StyleRes; 21import android.content.Context; 22import android.content.res.Configuration; 23import android.graphics.drawable.Drawable; 24import android.util.AttributeSet; 25import android.view.ContextThemeWrapper; 26import android.view.Gravity; 27import android.view.Menu; 28import android.view.MenuItem; 29import android.view.View; 30import android.view.ViewDebug; 31import android.view.ViewGroup; 32import android.view.ViewHierarchyEncoder; 33import android.view.accessibility.AccessibilityEvent; 34import com.android.internal.view.menu.ActionMenuItemView; 35import com.android.internal.view.menu.MenuBuilder; 36import com.android.internal.view.menu.MenuItemImpl; 37import com.android.internal.view.menu.MenuPresenter; 38import com.android.internal.view.menu.MenuView; 39 40/** 41 * ActionMenuView is a presentation of a series of menu options as a View. It provides 42 * several top level options as action buttons while spilling remaining options over as 43 * items in an overflow menu. This allows applications to present packs of actions inline with 44 * specific or repeating content. 45 */ 46public class ActionMenuView extends LinearLayout implements MenuBuilder.ItemInvoker, MenuView { 47 private static final String TAG = "ActionMenuView"; 48 49 static final int MIN_CELL_SIZE = 56; // dips 50 static final int GENERATED_ITEM_PADDING = 4; // dips 51 52 private MenuBuilder mMenu; 53 54 /** Context against which to inflate popup menus. */ 55 private Context mPopupContext; 56 57 /** Theme resource against which to inflate popup menus. */ 58 private int mPopupTheme; 59 60 private boolean mReserveOverflow; 61 private ActionMenuPresenter mPresenter; 62 private MenuPresenter.Callback mActionMenuPresenterCallback; 63 private MenuBuilder.Callback mMenuBuilderCallback; 64 private boolean mFormatItems; 65 private int mFormatItemsWidth; 66 private int mMinCellSize; 67 private int mGeneratedItemPadding; 68 69 private OnMenuItemClickListener mOnMenuItemClickListener; 70 71 public ActionMenuView(Context context) { 72 this(context, null); 73 } 74 75 public ActionMenuView(Context context, AttributeSet attrs) { 76 super(context, attrs); 77 setBaselineAligned(false); 78 final float density = context.getResources().getDisplayMetrics().density; 79 mMinCellSize = (int) (MIN_CELL_SIZE * density); 80 mGeneratedItemPadding = (int) (GENERATED_ITEM_PADDING * density); 81 mPopupContext = context; 82 mPopupTheme = 0; 83 } 84 85 /** 86 * Specifies the theme to use when inflating popup menus. By default, uses 87 * the same theme as the action menu view itself. 88 * 89 * @param resId theme used to inflate popup menus 90 * @see #getPopupTheme() 91 */ 92 public void setPopupTheme(@StyleRes int resId) { 93 if (mPopupTheme != resId) { 94 mPopupTheme = resId; 95 if (resId == 0) { 96 mPopupContext = mContext; 97 } else { 98 mPopupContext = new ContextThemeWrapper(mContext, resId); 99 } 100 } 101 } 102 103 /** 104 * @return resource identifier of the theme used to inflate popup menus, or 105 * 0 if menus are inflated against the action menu view theme 106 * @see #setPopupTheme(int) 107 */ 108 public int getPopupTheme() { 109 return mPopupTheme; 110 } 111 112 /** 113 * @param presenter Menu presenter used to display popup menu 114 * @hide 115 */ 116 public void setPresenter(ActionMenuPresenter presenter) { 117 mPresenter = presenter; 118 mPresenter.setMenuView(this); 119 } 120 121 @Override 122 public void onConfigurationChanged(Configuration newConfig) { 123 super.onConfigurationChanged(newConfig); 124 125 if (mPresenter != null) { 126 mPresenter.updateMenuView(false); 127 128 if (mPresenter.isOverflowMenuShowing()) { 129 mPresenter.hideOverflowMenu(); 130 mPresenter.showOverflowMenu(); 131 } 132 } 133 } 134 135 public void setOnMenuItemClickListener(OnMenuItemClickListener listener) { 136 mOnMenuItemClickListener = listener; 137 } 138 139 @Override 140 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 141 // If we've been given an exact size to match, apply special formatting during layout. 142 final boolean wasFormatted = mFormatItems; 143 mFormatItems = MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY; 144 145 if (wasFormatted != mFormatItems) { 146 mFormatItemsWidth = 0; // Reset this when switching modes 147 } 148 149 // Special formatting can change whether items can fit as action buttons. 150 // Kick the menu and update presenters when this changes. 151 final int widthSize = MeasureSpec.getSize(widthMeasureSpec); 152 if (mFormatItems && mMenu != null && widthSize != mFormatItemsWidth) { 153 mFormatItemsWidth = widthSize; 154 mMenu.onItemsChanged(true); 155 } 156 157 final int childCount = getChildCount(); 158 if (mFormatItems && childCount > 0) { 159 onMeasureExactFormat(widthMeasureSpec, heightMeasureSpec); 160 } else { 161 // Previous measurement at exact format may have set margins - reset them. 162 for (int i = 0; i < childCount; i++) { 163 final View child = getChildAt(i); 164 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 165 lp.leftMargin = lp.rightMargin = 0; 166 } 167 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 168 } 169 } 170 171 private void onMeasureExactFormat(int widthMeasureSpec, int heightMeasureSpec) { 172 // We already know the width mode is EXACTLY if we're here. 173 final int heightMode = MeasureSpec.getMode(heightMeasureSpec); 174 int widthSize = MeasureSpec.getSize(widthMeasureSpec); 175 int heightSize = MeasureSpec.getSize(heightMeasureSpec); 176 177 final int widthPadding = getPaddingLeft() + getPaddingRight(); 178 final int heightPadding = getPaddingTop() + getPaddingBottom(); 179 180 final int itemHeightSpec = getChildMeasureSpec(heightMeasureSpec, heightPadding, 181 ViewGroup.LayoutParams.WRAP_CONTENT); 182 183 widthSize -= widthPadding; 184 185 // Divide the view into cells. 186 final int cellCount = widthSize / mMinCellSize; 187 final int cellSizeRemaining = widthSize % mMinCellSize; 188 189 if (cellCount == 0) { 190 // Give up, nothing fits. 191 setMeasuredDimension(widthSize, 0); 192 return; 193 } 194 195 final int cellSize = mMinCellSize + cellSizeRemaining / cellCount; 196 197 int cellsRemaining = cellCount; 198 int maxChildHeight = 0; 199 int maxCellsUsed = 0; 200 int expandableItemCount = 0; 201 int visibleItemCount = 0; 202 boolean hasOverflow = false; 203 204 // This is used as a bitfield to locate the smallest items present. Assumes childCount < 64. 205 long smallestItemsAt = 0; 206 207 final int childCount = getChildCount(); 208 for (int i = 0; i < childCount; i++) { 209 final View child = getChildAt(i); 210 if (child.getVisibility() == GONE) continue; 211 212 final boolean isGeneratedItem = child instanceof ActionMenuItemView; 213 visibleItemCount++; 214 215 if (isGeneratedItem) { 216 // Reset padding for generated menu item views; it may change below 217 // and views are recycled. 218 child.setPadding(mGeneratedItemPadding, 0, mGeneratedItemPadding, 0); 219 } 220 221 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 222 lp.expanded = false; 223 lp.extraPixels = 0; 224 lp.cellsUsed = 0; 225 lp.expandable = false; 226 lp.leftMargin = 0; 227 lp.rightMargin = 0; 228 lp.preventEdgeOffset = isGeneratedItem && ((ActionMenuItemView) child).hasText(); 229 230 // Overflow always gets 1 cell. No more, no less. 231 final int cellsAvailable = lp.isOverflowButton ? 1 : cellsRemaining; 232 233 final int cellsUsed = measureChildForCells(child, cellSize, cellsAvailable, 234 itemHeightSpec, heightPadding); 235 236 maxCellsUsed = Math.max(maxCellsUsed, cellsUsed); 237 if (lp.expandable) expandableItemCount++; 238 if (lp.isOverflowButton) hasOverflow = true; 239 240 cellsRemaining -= cellsUsed; 241 maxChildHeight = Math.max(maxChildHeight, child.getMeasuredHeight()); 242 if (cellsUsed == 1) smallestItemsAt |= (1 << i); 243 } 244 245 // When we have overflow and a single expanded (text) item, we want to try centering it 246 // visually in the available space even though overflow consumes some of it. 247 final boolean centerSingleExpandedItem = hasOverflow && visibleItemCount == 2; 248 249 // Divide space for remaining cells if we have items that can expand. 250 // Try distributing whole leftover cells to smaller items first. 251 252 boolean needsExpansion = false; 253 while (expandableItemCount > 0 && cellsRemaining > 0) { 254 int minCells = Integer.MAX_VALUE; 255 long minCellsAt = 0; // Bit locations are indices of relevant child views 256 int minCellsItemCount = 0; 257 for (int i = 0; i < childCount; i++) { 258 final View child = getChildAt(i); 259 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 260 261 // Don't try to expand items that shouldn't. 262 if (!lp.expandable) continue; 263 264 // Mark indices of children that can receive an extra cell. 265 if (lp.cellsUsed < minCells) { 266 minCells = lp.cellsUsed; 267 minCellsAt = 1 << i; 268 minCellsItemCount = 1; 269 } else if (lp.cellsUsed == minCells) { 270 minCellsAt |= 1 << i; 271 minCellsItemCount++; 272 } 273 } 274 275 // Items that get expanded will always be in the set of smallest items when we're done. 276 smallestItemsAt |= minCellsAt; 277 278 if (minCellsItemCount > cellsRemaining) break; // Couldn't expand anything evenly. Stop. 279 280 // We have enough cells, all minimum size items will be incremented. 281 minCells++; 282 283 for (int i = 0; i < childCount; i++) { 284 final View child = getChildAt(i); 285 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 286 if ((minCellsAt & (1 << i)) == 0) { 287 // If this item is already at our small item count, mark it for later. 288 if (lp.cellsUsed == minCells) smallestItemsAt |= 1 << i; 289 continue; 290 } 291 292 if (centerSingleExpandedItem && lp.preventEdgeOffset && cellsRemaining == 1) { 293 // Add padding to this item such that it centers. 294 child.setPadding(mGeneratedItemPadding + cellSize, 0, mGeneratedItemPadding, 0); 295 } 296 lp.cellsUsed++; 297 lp.expanded = true; 298 cellsRemaining--; 299 } 300 301 needsExpansion = true; 302 } 303 304 // Divide any space left that wouldn't divide along cell boundaries 305 // evenly among the smallest items 306 307 final boolean singleItem = !hasOverflow && visibleItemCount == 1; 308 if (cellsRemaining > 0 && smallestItemsAt != 0 && 309 (cellsRemaining < visibleItemCount - 1 || singleItem || maxCellsUsed > 1)) { 310 float expandCount = Long.bitCount(smallestItemsAt); 311 312 if (!singleItem) { 313 // The items at the far edges may only expand by half in order to pin to either side. 314 if ((smallestItemsAt & 1) != 0) { 315 LayoutParams lp = (LayoutParams) getChildAt(0).getLayoutParams(); 316 if (!lp.preventEdgeOffset) expandCount -= 0.5f; 317 } 318 if ((smallestItemsAt & (1 << (childCount - 1))) != 0) { 319 LayoutParams lp = ((LayoutParams) getChildAt(childCount - 1).getLayoutParams()); 320 if (!lp.preventEdgeOffset) expandCount -= 0.5f; 321 } 322 } 323 324 final int extraPixels = expandCount > 0 ? 325 (int) (cellsRemaining * cellSize / expandCount) : 0; 326 327 for (int i = 0; i < childCount; i++) { 328 if ((smallestItemsAt & (1 << i)) == 0) continue; 329 330 final View child = getChildAt(i); 331 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 332 if (child instanceof ActionMenuItemView) { 333 // If this is one of our views, expand and measure at the larger size. 334 lp.extraPixels = extraPixels; 335 lp.expanded = true; 336 if (i == 0 && !lp.preventEdgeOffset) { 337 // First item gets part of its new padding pushed out of sight. 338 // The last item will get this implicitly from layout. 339 lp.leftMargin = -extraPixels / 2; 340 } 341 needsExpansion = true; 342 } else if (lp.isOverflowButton) { 343 lp.extraPixels = extraPixels; 344 lp.expanded = true; 345 lp.rightMargin = -extraPixels / 2; 346 needsExpansion = true; 347 } else { 348 // If we don't know what it is, give it some margins instead 349 // and let it center within its space. We still want to pin 350 // against the edges. 351 if (i != 0) { 352 lp.leftMargin = extraPixels / 2; 353 } 354 if (i != childCount - 1) { 355 lp.rightMargin = extraPixels / 2; 356 } 357 } 358 } 359 360 cellsRemaining = 0; 361 } 362 363 // Remeasure any items that have had extra space allocated to them. 364 if (needsExpansion) { 365 for (int i = 0; i < childCount; i++) { 366 final View child = getChildAt(i); 367 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 368 369 if (!lp.expanded) continue; 370 371 final int width = lp.cellsUsed * cellSize + lp.extraPixels; 372 child.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), 373 itemHeightSpec); 374 } 375 } 376 377 if (heightMode != MeasureSpec.EXACTLY) { 378 heightSize = maxChildHeight; 379 } 380 381 setMeasuredDimension(widthSize, heightSize); 382 } 383 384 /** 385 * Measure a child view to fit within cell-based formatting. The child's width 386 * will be measured to a whole multiple of cellSize. 387 * 388 * <p>Sets the expandable and cellsUsed fields of LayoutParams. 389 * 390 * @param child Child to measure 391 * @param cellSize Size of one cell 392 * @param cellsRemaining Number of cells remaining that this view can expand to fill 393 * @param parentHeightMeasureSpec MeasureSpec used by the parent view 394 * @param parentHeightPadding Padding present in the parent view 395 * @return Number of cells this child was measured to occupy 396 */ 397 static int measureChildForCells(View child, int cellSize, int cellsRemaining, 398 int parentHeightMeasureSpec, int parentHeightPadding) { 399 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 400 401 final int childHeightSize = MeasureSpec.getSize(parentHeightMeasureSpec) - 402 parentHeightPadding; 403 final int childHeightMode = MeasureSpec.getMode(parentHeightMeasureSpec); 404 final int childHeightSpec = MeasureSpec.makeMeasureSpec(childHeightSize, childHeightMode); 405 406 final ActionMenuItemView itemView = child instanceof ActionMenuItemView ? 407 (ActionMenuItemView) child : null; 408 final boolean hasText = itemView != null && itemView.hasText(); 409 410 int cellsUsed = 0; 411 if (cellsRemaining > 0 && (!hasText || cellsRemaining >= 2)) { 412 final int childWidthSpec = MeasureSpec.makeMeasureSpec( 413 cellSize * cellsRemaining, MeasureSpec.AT_MOST); 414 child.measure(childWidthSpec, childHeightSpec); 415 416 final int measuredWidth = child.getMeasuredWidth(); 417 cellsUsed = measuredWidth / cellSize; 418 if (measuredWidth % cellSize != 0) cellsUsed++; 419 if (hasText && cellsUsed < 2) cellsUsed = 2; 420 } 421 422 final boolean expandable = !lp.isOverflowButton && hasText; 423 lp.expandable = expandable; 424 425 lp.cellsUsed = cellsUsed; 426 final int targetWidth = cellsUsed * cellSize; 427 child.measure(MeasureSpec.makeMeasureSpec(targetWidth, MeasureSpec.EXACTLY), 428 childHeightSpec); 429 return cellsUsed; 430 } 431 432 @Override 433 protected void onLayout(boolean changed, int left, int top, int right, int bottom) { 434 if (!mFormatItems) { 435 super.onLayout(changed, left, top, right, bottom); 436 return; 437 } 438 439 final int childCount = getChildCount(); 440 final int midVertical = (bottom - top) / 2; 441 final int dividerWidth = getDividerWidth(); 442 int overflowWidth = 0; 443 int nonOverflowWidth = 0; 444 int nonOverflowCount = 0; 445 int widthRemaining = right - left - getPaddingRight() - getPaddingLeft(); 446 boolean hasOverflow = false; 447 final boolean isLayoutRtl = isLayoutRtl(); 448 for (int i = 0; i < childCount; i++) { 449 final View v = getChildAt(i); 450 if (v.getVisibility() == GONE) { 451 continue; 452 } 453 454 LayoutParams p = (LayoutParams) v.getLayoutParams(); 455 if (p.isOverflowButton) { 456 overflowWidth = v.getMeasuredWidth(); 457 if (hasDividerBeforeChildAt(i)) { 458 overflowWidth += dividerWidth; 459 } 460 461 int height = v.getMeasuredHeight(); 462 int r; 463 int l; 464 if (isLayoutRtl) { 465 l = getPaddingLeft() + p.leftMargin; 466 r = l + overflowWidth; 467 } else { 468 r = getWidth() - getPaddingRight() - p.rightMargin; 469 l = r - overflowWidth; 470 } 471 int t = midVertical - (height / 2); 472 int b = t + height; 473 v.layout(l, t, r, b); 474 475 widthRemaining -= overflowWidth; 476 hasOverflow = true; 477 } else { 478 final int size = v.getMeasuredWidth() + p.leftMargin + p.rightMargin; 479 nonOverflowWidth += size; 480 widthRemaining -= size; 481 if (hasDividerBeforeChildAt(i)) { 482 nonOverflowWidth += dividerWidth; 483 } 484 nonOverflowCount++; 485 } 486 } 487 488 if (childCount == 1 && !hasOverflow) { 489 // Center a single child 490 final View v = getChildAt(0); 491 final int width = v.getMeasuredWidth(); 492 final int height = v.getMeasuredHeight(); 493 final int midHorizontal = (right - left) / 2; 494 final int l = midHorizontal - width / 2; 495 final int t = midVertical - height / 2; 496 v.layout(l, t, l + width, t + height); 497 return; 498 } 499 500 final int spacerCount = nonOverflowCount - (hasOverflow ? 0 : 1); 501 final int spacerSize = Math.max(0, spacerCount > 0 ? widthRemaining / spacerCount : 0); 502 503 if (isLayoutRtl) { 504 int startRight = getWidth() - getPaddingRight(); 505 for (int i = 0; i < childCount; i++) { 506 final View v = getChildAt(i); 507 final LayoutParams lp = (LayoutParams) v.getLayoutParams(); 508 if (v.getVisibility() == GONE || lp.isOverflowButton) { 509 continue; 510 } 511 512 startRight -= lp.rightMargin; 513 int width = v.getMeasuredWidth(); 514 int height = v.getMeasuredHeight(); 515 int t = midVertical - height / 2; 516 v.layout(startRight - width, t, startRight, t + height); 517 startRight -= width + lp.leftMargin + spacerSize; 518 } 519 } else { 520 int startLeft = getPaddingLeft(); 521 for (int i = 0; i < childCount; i++) { 522 final View v = getChildAt(i); 523 final LayoutParams lp = (LayoutParams) v.getLayoutParams(); 524 if (v.getVisibility() == GONE || lp.isOverflowButton) { 525 continue; 526 } 527 528 startLeft += lp.leftMargin; 529 int width = v.getMeasuredWidth(); 530 int height = v.getMeasuredHeight(); 531 int t = midVertical - height / 2; 532 v.layout(startLeft, t, startLeft + width, t + height); 533 startLeft += width + lp.rightMargin + spacerSize; 534 } 535 } 536 } 537 538 @Override 539 public void onDetachedFromWindow() { 540 super.onDetachedFromWindow(); 541 dismissPopupMenus(); 542 } 543 544 /** 545 * Set the icon to use for the overflow button. 546 * 547 * @param icon Drawable to set, may be null to clear the icon 548 */ 549 public void setOverflowIcon(@Nullable Drawable icon) { 550 getMenu(); 551 mPresenter.setOverflowIcon(icon); 552 } 553 554 /** 555 * Return the current drawable used as the overflow icon. 556 * 557 * @return The overflow icon drawable 558 */ 559 @Nullable 560 public Drawable getOverflowIcon() { 561 getMenu(); 562 return mPresenter.getOverflowIcon(); 563 } 564 565 /** @hide */ 566 public boolean isOverflowReserved() { 567 return mReserveOverflow; 568 } 569 570 /** @hide */ 571 public void setOverflowReserved(boolean reserveOverflow) { 572 mReserveOverflow = reserveOverflow; 573 } 574 575 @Override 576 protected LayoutParams generateDefaultLayoutParams() { 577 LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT, 578 LayoutParams.WRAP_CONTENT); 579 params.gravity = Gravity.CENTER_VERTICAL; 580 return params; 581 } 582 583 @Override 584 public LayoutParams generateLayoutParams(AttributeSet attrs) { 585 return new LayoutParams(getContext(), attrs); 586 } 587 588 @Override 589 protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) { 590 if (p != null) { 591 final LayoutParams result = p instanceof LayoutParams 592 ? new LayoutParams((LayoutParams) p) 593 : new LayoutParams(p); 594 if (result.gravity <= Gravity.NO_GRAVITY) { 595 result.gravity = Gravity.CENTER_VERTICAL; 596 } 597 return result; 598 } 599 return generateDefaultLayoutParams(); 600 } 601 602 @Override 603 protected boolean checkLayoutParams(ViewGroup.LayoutParams p) { 604 return p != null && p instanceof LayoutParams; 605 } 606 607 /** @hide */ 608 public LayoutParams generateOverflowButtonLayoutParams() { 609 LayoutParams result = generateDefaultLayoutParams(); 610 result.isOverflowButton = true; 611 return result; 612 } 613 614 /** @hide */ 615 public boolean invokeItem(MenuItemImpl item) { 616 return mMenu.performItemAction(item, 0); 617 } 618 619 /** @hide */ 620 public int getWindowAnimations() { 621 return 0; 622 } 623 624 /** @hide */ 625 public void initialize(@Nullable MenuBuilder menu) { 626 mMenu = menu; 627 } 628 629 /** 630 * Returns the Menu object that this ActionMenuView is currently presenting. 631 * 632 * <p>Applications should use this method to obtain the ActionMenuView's Menu object 633 * and inflate or add content to it as necessary.</p> 634 * 635 * @return the Menu presented by this view 636 */ 637 public Menu getMenu() { 638 if (mMenu == null) { 639 final Context context = getContext(); 640 mMenu = new MenuBuilder(context); 641 mMenu.setCallback(new MenuBuilderCallback()); 642 mPresenter = new ActionMenuPresenter(context); 643 mPresenter.setReserveOverflow(true); 644 mPresenter.setCallback(mActionMenuPresenterCallback != null 645 ? mActionMenuPresenterCallback : new ActionMenuPresenterCallback()); 646 mMenu.addMenuPresenter(mPresenter, mPopupContext); 647 mPresenter.setMenuView(this); 648 } 649 650 return mMenu; 651 } 652 653 /** 654 * Must be called before the first call to getMenu() 655 * @hide 656 */ 657 public void setMenuCallbacks(MenuPresenter.Callback pcb, MenuBuilder.Callback mcb) { 658 mActionMenuPresenterCallback = pcb; 659 mMenuBuilderCallback = mcb; 660 } 661 662 /** 663 * Returns the current menu or null if one has not yet been configured. 664 * @hide Internal use only for action bar integration 665 */ 666 public MenuBuilder peekMenu() { 667 return mMenu; 668 } 669 670 /** 671 * Show the overflow items from the associated menu. 672 * 673 * @return true if the menu was able to be shown, false otherwise 674 */ 675 public boolean showOverflowMenu() { 676 return mPresenter != null && mPresenter.showOverflowMenu(); 677 } 678 679 /** 680 * Hide the overflow items from the associated menu. 681 * 682 * @return true if the menu was able to be hidden, false otherwise 683 */ 684 public boolean hideOverflowMenu() { 685 return mPresenter != null && mPresenter.hideOverflowMenu(); 686 } 687 688 /** 689 * Check whether the overflow menu is currently showing. This may not reflect 690 * a pending show operation in progress. 691 * 692 * @return true if the overflow menu is currently showing 693 */ 694 public boolean isOverflowMenuShowing() { 695 return mPresenter != null && mPresenter.isOverflowMenuShowing(); 696 } 697 698 /** @hide */ 699 public boolean isOverflowMenuShowPending() { 700 return mPresenter != null && mPresenter.isOverflowMenuShowPending(); 701 } 702 703 /** 704 * Dismiss any popups associated with this menu view. 705 */ 706 public void dismissPopupMenus() { 707 if (mPresenter != null) { 708 mPresenter.dismissPopupMenus(); 709 } 710 } 711 712 /** 713 * @hide Private LinearLayout (superclass) API. Un-hide if LinearLayout API is made public. 714 */ 715 @Override 716 protected boolean hasDividerBeforeChildAt(int childIndex) { 717 if (childIndex == 0) { 718 return false; 719 } 720 final View childBefore = getChildAt(childIndex - 1); 721 final View child = getChildAt(childIndex); 722 boolean result = false; 723 if (childIndex < getChildCount() && childBefore instanceof ActionMenuChildView) { 724 result |= ((ActionMenuChildView) childBefore).needsDividerAfter(); 725 } 726 if (childIndex > 0 && child instanceof ActionMenuChildView) { 727 result |= ((ActionMenuChildView) child).needsDividerBefore(); 728 } 729 return result; 730 } 731 732 /** @hide */ 733 public boolean dispatchPopulateAccessibilityEventInternal(AccessibilityEvent event) { 734 return false; 735 } 736 737 /** @hide */ 738 public void setExpandedActionViewsExclusive(boolean exclusive) { 739 mPresenter.setExpandedActionViewsExclusive(exclusive); 740 } 741 742 /** 743 * Interface responsible for receiving menu item click events if the items themselves 744 * do not have individual item click listeners. 745 */ 746 public interface OnMenuItemClickListener { 747 /** 748 * This method will be invoked when a menu item is clicked if the item itself did 749 * not already handle the event. 750 * 751 * @param item {@link MenuItem} that was clicked 752 * @return <code>true</code> if the event was handled, <code>false</code> otherwise. 753 */ 754 public boolean onMenuItemClick(MenuItem item); 755 } 756 757 private class MenuBuilderCallback implements MenuBuilder.Callback { 758 @Override 759 public boolean onMenuItemSelected(MenuBuilder menu, MenuItem item) { 760 return mOnMenuItemClickListener != null && 761 mOnMenuItemClickListener.onMenuItemClick(item); 762 } 763 764 @Override 765 public void onMenuModeChange(MenuBuilder menu) { 766 if (mMenuBuilderCallback != null) { 767 mMenuBuilderCallback.onMenuModeChange(menu); 768 } 769 } 770 } 771 772 private class ActionMenuPresenterCallback implements ActionMenuPresenter.Callback { 773 @Override 774 public void onCloseMenu(MenuBuilder menu, boolean allMenusAreClosing) { 775 } 776 777 @Override 778 public boolean onOpenSubMenu(MenuBuilder subMenu) { 779 return false; 780 } 781 } 782 783 /** @hide */ 784 public interface ActionMenuChildView { 785 public boolean needsDividerBefore(); 786 public boolean needsDividerAfter(); 787 } 788 789 public static class LayoutParams extends LinearLayout.LayoutParams { 790 /** @hide */ 791 @ViewDebug.ExportedProperty(category = "layout") 792 public boolean isOverflowButton; 793 794 /** @hide */ 795 @ViewDebug.ExportedProperty(category = "layout") 796 public int cellsUsed; 797 798 /** @hide */ 799 @ViewDebug.ExportedProperty(category = "layout") 800 public int extraPixels; 801 802 /** @hide */ 803 @ViewDebug.ExportedProperty(category = "layout") 804 public boolean expandable; 805 806 /** @hide */ 807 @ViewDebug.ExportedProperty(category = "layout") 808 public boolean preventEdgeOffset; 809 810 /** @hide */ 811 public boolean expanded; 812 813 public LayoutParams(Context c, AttributeSet attrs) { 814 super(c, attrs); 815 } 816 817 public LayoutParams(ViewGroup.LayoutParams other) { 818 super(other); 819 } 820 821 public LayoutParams(LayoutParams other) { 822 super((LinearLayout.LayoutParams) other); 823 isOverflowButton = other.isOverflowButton; 824 } 825 826 public LayoutParams(int width, int height) { 827 super(width, height); 828 isOverflowButton = false; 829 } 830 831 /** @hide */ 832 public LayoutParams(int width, int height, boolean isOverflowButton) { 833 super(width, height); 834 this.isOverflowButton = isOverflowButton; 835 } 836 837 /** @hide */ 838 @Override 839 protected void encodeProperties(@NonNull ViewHierarchyEncoder encoder) { 840 super.encodeProperties(encoder); 841 842 encoder.addProperty("layout:overFlowButton", isOverflowButton); 843 encoder.addProperty("layout:cellsUsed", cellsUsed); 844 encoder.addProperty("layout:extraPixels", extraPixels); 845 encoder.addProperty("layout:expandable", expandable); 846 encoder.addProperty("layout:preventEdgeOffset", preventEdgeOffset); 847 } 848 } 849} 850