#include "ash/metrics/user_metrics_recorder.h"
#include "ash/root_window_controller.h"
#include "ash/scoped_target_root_window.h"
-#include "ash/shelf/alternate_app_list_button.h"
#include "ash/shelf/app_list_button.h"
#include "ash/shelf/overflow_bubble.h"
#include "ash/shelf/overflow_bubble_view.h"
using views::View;
namespace ash {
-namespace internal {
const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM = 0;
const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT = 1;
// Minimum distance before drag starts.
const int kMinimumDragDistance = 8;
-// Size between the buttons.
-const int kButtonSpacing = 4;
-const int kAlternateButtonSpacing = 10;
-
-// Size allocated to for each button.
-const int kButtonSize = 44;
-
// Additional spacing for the left and right side of icons.
const int kHorizontalIconSpacing = 2;
view_model_->Add(child, static_cast<int>(i - items.begin()));
AddChildView(child);
}
- ShelfStatusChanged();
overflow_button_ = new OverflowButton(this);
overflow_button_->set_context_menu_controller(this);
ConfigureChildView(overflow_button_);
AddChildView(overflow_button_);
- UpdateFirstButtonPadding();
// We'll layout when our bounds change.
}
void ShelfView::OnShelfAlignmentChanged() {
- UpdateFirstButtonPadding();
overflow_button_->OnShelfAlignmentChanged();
LayoutToIdealBounds();
for (int i=0; i < view_model_->view_size(); ++i) {
- // TODO: remove when AppIcon is a Shelf Button.
- if (TYPE_APP_LIST == model_->items()[i].type &&
- !ash::switches::UseAlternateShelfLayout()) {
- static_cast<AppListButton*>(view_model_->view_at(i))->SetImageAlignment(
- layout_manager_->SelectValueForShelfAlignment(
- views::ImageButton::ALIGN_CENTER,
- views::ImageButton::ALIGN_LEFT,
- views::ImageButton::ALIGN_RIGHT,
- views::ImageButton::ALIGN_CENTER),
- layout_manager_->SelectValueForShelfAlignment(
- views::ImageButton::ALIGN_TOP,
- views::ImageButton::ALIGN_MIDDLE,
- views::ImageButton::ALIGN_MIDDLE,
- views::ImageButton::ALIGN_BOTTOM));
- }
if (i >= first_visible_index_ && i <= last_visible_index_)
view_model_->view_at(i)->Layout();
}
const gfx::Vector2d& cursor_offset_from_center,
float scale_factor) {
drag_replaced_view_ = replaced_view;
- drag_image_.reset(new ash::internal::DragImageView(
+ drag_image_.reset(new ash::DragImageView(
drag_replaced_view_->GetWidget()->GetNativeWindow()->GetRootWindow(),
ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE));
drag_image_->SetImage(icon);
void ShelfView::UpdateAllButtonsVisibilityInOverflowMode() {
// The overflow button is not shown in overflow mode.
overflow_button_->SetVisible(false);
- int last_button_index = model_->FirstPanelIndex() - 1;
DCHECK_LT(last_visible_index_, view_model_->view_size());
for (int i = 0; i < view_model_->view_size(); ++i) {
bool visible = i >= first_visible_index_ &&
i <= last_visible_index_;
- if (!ash::switches::UseAlternateShelfLayout())
- visible &= i != last_button_index;
-
// To track the dragging of |drag_view_| continuously, its visibility
// should be always true regardless of its position.
if (dragged_off_from_overflow_to_shelf_ &&
int first_panel_index = model_->FirstPanelIndex();
int last_button_index = first_panel_index - 1;
- // Initial x,y values account both leading_inset in primary
- // coordinate and secondary coordinate based on the dynamic edge of the
- // shelf (eg top edge on bottom-aligned shelf).
- int inset = ash::switches::UseAlternateShelfLayout() ? 0 : leading_inset_;
- int x = layout_manager_->SelectValueForShelfAlignment(inset, 0, 0, inset);
- int y = layout_manager_->SelectValueForShelfAlignment(0, inset, inset, 0);
-
- int button_size = GetButtonSize();
- int button_spacing = GetButtonSpacing();
+ int x = 0;
+ int y = 0;
+ int button_size = kShelfButtonSize;
+ int button_spacing = kShelfButtonSpacing;
int w = layout_manager_->PrimaryAxisValue(button_size, width());
int h = layout_manager_->PrimaryAxisValue(height(), button_size);
return;
}
- // To address Fitt's law, we make the first shelf button include the
- // leading inset (if there is one).
- if (!ash::switches::UseAlternateShelfLayout()) {
- if (view_model_->view_size() > 0) {
- view_model_->set_ideal_bounds(0, gfx::Rect(gfx::Size(
- layout_manager_->PrimaryAxisValue(inset + w, w),
- layout_manager_->PrimaryAxisValue(h, inset + h))));
- }
- }
-
// Right aligned icons.
int end_position = available_size - button_spacing;
x = layout_manager_->PrimaryAxisValue(end_position, 0);
// the available space.
int last_icon_position = layout_manager_->PrimaryAxisValue(
view_model_->ideal_bounds(last_button_index).right(),
- view_model_->ideal_bounds(last_button_index).bottom())
- + button_size + inset;
- if (!ash::switches::UseAlternateShelfLayout())
- last_icon_position += button_size;
+ view_model_->ideal_bounds(last_button_index).bottom()) + button_size;
int reserved_icon_space = available_size * kReservedNonPanelIconProportion;
if (last_icon_position < reserved_icon_space)
end_position = last_icon_position;
gfx::Size(layout_manager_->PrimaryAxisValue(w, width()),
layout_manager_->PrimaryAxisValue(height(), h)));
- if (ash::switches::UseAlternateShelfLayout()) {
- last_visible_index_ = DetermineLastVisibleIndex(
- end_position - button_size);
- } else {
- last_visible_index_ = DetermineLastVisibleIndex(
- end_position - inset - 2 * button_size);
- }
+ last_visible_index_ = DetermineLastVisibleIndex(
+ end_position - button_size);
last_hidden_index_ = DetermineFirstVisiblePanelIndex(end_position) - 1;
- bool show_overflow =
- ((ash::switches::UseAlternateShelfLayout() ? 0 : 1) +
- last_visible_index_ < last_button_index ||
- last_hidden_index_ >= first_panel_index);
+ bool show_overflow = last_visible_index_ < last_button_index ||
+ last_hidden_index_ >= first_panel_index;
// Create Space for the overflow button
- if (show_overflow && ash::switches::UseAlternateShelfLayout() &&
+ if (show_overflow &&
last_visible_index_ > 0 && last_visible_index_ < last_button_index)
--last_visible_index_;
for (int i = 0; i < view_model_->view_size(); ++i) {
bool visible = i <= last_visible_index_ || i > last_hidden_index_;
- // Always show the app list.
- if (!ash::switches::UseAlternateShelfLayout())
- visible |= (i == last_button_index);
// To receive drag event continously from |drag_view_| during the dragging
// off from the shelf, don't make |drag_view_| invisible. It will be
// eventually invisible and removed from the |view_model_| by
if (show_overflow) {
DCHECK_NE(0, view_model_->view_size());
if (last_visible_index_ == -1) {
- x = layout_manager_->SelectValueForShelfAlignment(inset, 0, 0, inset);
- y = layout_manager_->SelectValueForShelfAlignment(0, inset, inset, 0);
- } else if (last_visible_index_ == last_button_index
- && !ash::switches::UseAlternateShelfLayout()) {
- x = view_model_->ideal_bounds(last_visible_index_).x();
- y = view_model_->ideal_bounds(last_visible_index_).y();
+ x = 0;
+ y = 0;
} else {
x = layout_manager_->PrimaryAxisValue(
view_model_->ideal_bounds(last_visible_index_).right(),
// Add more space between last visible item and overflow button.
// Without this, two buttons look too close compared with other items.
- if (ash::switches::UseAlternateShelfLayout()) {
- x = layout_manager_->PrimaryAxisValue(x + button_spacing, x);
- y = layout_manager_->PrimaryAxisValue(y, y + button_spacing);
- }
+ x = layout_manager_->PrimaryAxisValue(x + button_spacing, x);
+ y = layout_manager_->PrimaryAxisValue(y, y + button_spacing);
bounds->overflow_bounds.set_x(x);
bounds->overflow_bounds.set_y(y);
- if (!ash::switches::UseAlternateShelfLayout()) {
- // Position app list after overflow button.
- gfx::Rect app_list_bounds = view_model_->ideal_bounds(last_button_index);
-
- x = layout_manager_->PrimaryAxisValue(x + w + button_spacing, x);
- y = layout_manager_->PrimaryAxisValue(y, y + h + button_spacing);
- app_list_bounds.set_x(x);
- app_list_bounds.set_y(y);
- view_model_->set_ideal_bounds(last_button_index, app_list_bounds);
- }
if (overflow_bubble_.get() && overflow_bubble_->IsShowing())
UpdateOverflowRange(overflow_bubble_->shelf_view());
} else {
// padding of the first gets properly transferred to the new first item.
if (i && view->border())
view->SetBorder(views::Border::NullBorder());
- else if (!i && !view->border())
- UpdateFirstButtonPadding();
}
overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
}
}
case TYPE_APP_LIST: {
- if (ash::switches::UseAlternateShelfLayout()) {
- view = new AlternateAppListButton(this,
- this,
- layout_manager_->shelf_widget());
- } else {
- // TODO(dave): turn this into a ShelfButton too.
- AppListButton* button = new AppListButton(this, this);
- button->SetImageAlignment(
- layout_manager_->SelectValueForShelfAlignment(
- views::ImageButton::ALIGN_CENTER,
- views::ImageButton::ALIGN_LEFT,
- views::ImageButton::ALIGN_RIGHT,
- views::ImageButton::ALIGN_CENTER),
- layout_manager_->SelectValueForShelfAlignment(
- views::ImageButton::ALIGN_TOP,
- views::ImageButton::ALIGN_MIDDLE,
- views::ImageButton::ALIGN_MIDDLE,
- views::ImageButton::ALIGN_BOTTOM));
- view = button;
- }
+ view = new AppListButton(this, this, layout_manager_->shelf_widget());
break;
}
Shell::GetInstance()->UpdateShelfVisibility();
}
-void ShelfView::UpdateFirstButtonPadding() {
- if (ash::switches::UseAlternateShelfLayout())
- return;
-
- // Creates an empty border for first shelf button to make included leading
- // inset act as the button's padding. This is only needed on button creation
- // and when shelf alignment changes.
- if (view_model_->view_size() > 0) {
- view_model_->view_at(0)->SetBorder(views::Border::CreateEmptyBorder(
- layout_manager_->PrimaryAxisValue(0, leading_inset_),
- layout_manager_->PrimaryAxisValue(leading_inset_, 0),
- 0,
- 0));
- }
-}
-
void ShelfView::OnFadeOutAnimationEnded() {
AnimateToIdealBounds();
StartFadeInLastVisibleItem();
overflow_view->last_visible_index_ = last_overflow_index;
}
-int ShelfView::GetButtonSize() const {
- return ash::switches::UseAlternateShelfLayout() ?
- kButtonSize : kShelfPreferredSize;
-}
-
-int ShelfView::GetButtonSpacing() const {
- return ash::switches::UseAlternateShelfLayout() ?
- kAlternateButtonSpacing : kButtonSpacing;
-}
-
bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) {
gfx::Rect active_bounds;
owner_overflow_bubble_->bubble_view()->GetBubbleBounds();
preferred_size = bubble_bounds.size();
} else {
- const int preferred_shelf_size = layout_manager_->GetPreferredShelfSize();
-
const int last_button_index = view_model_->view_size() - 1;
gfx::Rect last_button_bounds =
view_model_->view_at(last_button_index)->bounds();
if (layout_manager_->IsHorizontalAlignment()) {
preferred_size = gfx::Size(last_button_bounds.right() + leading_inset_,
- preferred_shelf_size);
+ kShelfSize);
} else {
- preferred_size = gfx::Size(preferred_shelf_size,
+ preferred_size = gfx::Size(kShelfSize,
last_button_bounds.bottom() + leading_inset_);
}
}
IdealBounds ideal_bounds;
CalculateIdealBounds(&ideal_bounds);
- const int preferred_size = layout_manager_->GetPreferredShelfSize();
-
int last_button_index = is_overflow_mode() ?
last_visible_index_ : view_model_->view_size() - 1;
const gfx::Rect last_button_bounds =
last_button_index >= first_visible_index_ ?
view_model_->ideal_bounds(last_button_index) :
- gfx::Rect(gfx::Size(preferred_size, preferred_size));
+ gfx::Rect(gfx::Size(kShelfSize, kShelfSize));
if (layout_manager_->IsHorizontalAlignment()) {
- return gfx::Size(last_button_bounds.right() + leading_inset_,
- preferred_size);
+ return gfx::Size(last_button_bounds.right() + leading_inset_, kShelfSize);
}
- return gfx::Size(preferred_size,
+ return gfx::Size(kShelfSize,
last_button_bounds.bottom() + leading_inset_);
}
}
void ShelfView::ShelfStatusChanged() {
- if (ash::switches::UseAlternateShelfLayout())
- return;
- AppListButton* app_list_button =
- static_cast<AppListButton*>(GetAppListButtonView());
- if (model_->status() == ShelfModel::STATUS_LOADING)
- app_list_button->StartLoadingAnimation();
- else
- app_list_button->StopLoadingAnimation();
+ // Nothing to do here.
}
void ShelfView::PointerPressedOnButton(views::View* view,
source->GetWidget()->GetNativeView()->GetRootWindow());
// Determine the menu alignment dependent on the shelf.
- views::MenuItemView::AnchorPosition menu_alignment =
- views::MenuItemView::TOPLEFT;
+ views::MenuAnchorPosition menu_alignment = views::MENU_ANCHOR_TOPLEFT;
gfx::Rect anchor_point = gfx::Rect(click_point, gfx::Size());
ShelfWidget* shelf = RootWindowController::ForShelf(
switch (align) {
case SHELF_ALIGNMENT_BOTTOM:
- menu_alignment = views::MenuItemView::BUBBLE_ABOVE;
+ menu_alignment = views::MENU_ANCHOR_BUBBLE_ABOVE;
break;
case SHELF_ALIGNMENT_LEFT:
- menu_alignment = views::MenuItemView::BUBBLE_RIGHT;
+ menu_alignment = views::MENU_ANCHOR_BUBBLE_RIGHT;
break;
case SHELF_ALIGNMENT_RIGHT:
- menu_alignment = views::MenuItemView::BUBBLE_LEFT;
+ menu_alignment = views::MENU_ANCHOR_BUBBLE_LEFT;
break;
case SHELF_ALIGNMENT_TOP:
- menu_alignment = views::MenuItemView::BUBBLE_BELOW;
+ menu_alignment = views::MENU_ANCHOR_BUBBLE_BELOW;
break;
}
}
return distance > 0 ? distance : 0;
}
-} // namespace internal
} // namespace ash
projects / platform / framework / web / crosswalk.git / blobdiff