MacViews: views_examples_with_content_exe working!

ui/app_list/views/apps_grid_view.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/app_list/views/apps_grid_view.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
 #include "base/guid.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/pagination_model.h"
 #include "ui/app_list/views/app_list_drag_and_drop_host.h"
 #include "ui/app_list/views/app_list_folder_view.h"
 #include "ui/app_list/views/app_list_item_view.h"
 #include "ui/app_list/views/apps_grid_view_delegate.h"
+#include "ui/app_list/views/apps_grid_view_folder_delegate.h"
 #include "ui/app_list/views/page_switcher.h"
 #include "ui/app_list/views/pulsing_block_view.h"
 #include "ui/app_list/views/top_icon_animation_view.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/widget.h"
@@ skipping 353 matching lines @@
   cols_ = cols;
   rows_per_page_ = rows_per_page;
 
   SetBorder(views::Border::CreateEmptyBorder(
       kTopPadding, kLeftRightPadding, 0, kLeftRightPadding));
 }
 
 void AppsGridView::ResetForShowApps() {
   activated_folder_item_view_ = NULL;
   ClearDragState();
-  layer()->SetOpacity(1.0f);
+  if (layer())
+    layer()->SetOpacity(1.0f);
   SetVisible(true);
   // Set all views to visible in case they weren't made visible again by an
   // incomplete animation.
   for (int i = 0; i < view_model_.view_size(); ++i) {
     view_model_.view_at(i)->SetVisible(true);
   }
 }
 
 void AppsGridView::SetModel(AppListModel* model) {
   if (model_)
@@ skipping 428 matching lines @@
   for (int i = start; i < end; i++) {
     AppListItemView* v = static_cast<AppListItemView*>(view_model_.view_at(i));
     v->Prerender();
   }
 }
 
 bool AppsGridView::IsAnimatingView(views::View* view) {
   return bounds_animator_.IsAnimating(view);
 }
 
+const char* AppsGridView::GetClassName() const {
+  return "GridView";
+}
+
 gfx::Size AppsGridView::GetPreferredSize() const {
   const gfx::Insets insets(GetInsets());
   const gfx::Size tile_size = gfx::Size(kPreferredTileWidth,
                                         kPreferredTileHeight);
   const int page_switcher_height =
       page_switcher_view_->GetPreferredSize().height();
   return gfx::Size(
       tile_size.width() * cols_ + insets.width(),
       tile_size.height() * rows_per_page_ +
           page_switcher_height + insets.height());
@@ skipping 142 matching lines @@
   }
 }
 
 views::View* AppsGridView::CreateViewForItemAtIndex(size_t index) {
   // The drag_view_ might be pending for deletion, therefore view_model_
   // may have one more item than item_list_.
   DCHECK_LE(index, item_list_->item_count());
   AppListItemView* view = new AppListItemView(this,
                                               item_list_->item_at(index));
   view->SetIconSize(icon_size_);
-#if defined(USE_AURA)
   view->SetPaintToLayer(true);
   view->SetFillsBoundsOpaquely(false);
-#endif
   return view;
 }
 
 AppsGridView::Index AppsGridView::GetIndexFromModelIndex(
     int model_index) const {
   return Index(model_index / tiles_per_page(), model_index % tiles_per_page());
 }
 
 int AppsGridView::GetModelIndexFromIndex(const Index& index) const {
   return index.page * tiles_per_page() + index.slot;
@@ skipping 205 matching lines @@
   // Determine page of |current| and |target|. -1 means in the left invisible
   // page, 0 is the center visible page and 1 means in the right invisible page.
   const int current_page = current.x() < 0 ? -1 :
       current.x() >= width() ? 1 : 0;
   const int target_page = target.x() < 0 ? -1 :
       target.x() >= width() ? 1 : 0;
 
   const int dir = current_page < target_page ||
       (current_page == target_page && current.y() < target.y()) ? 1 : -1;
 
-#if defined(USE_AURA)
   scoped_ptr<ui::Layer> layer;
   if (animate_current) {
     layer = view->RecreateLayer();
     layer->SuppressPaint();
 
     view->SetFillsBoundsOpaquely(false);
     view->layer()->SetOpacity(0.f);
   }
 
   gfx::Rect current_out(current);
   current_out.Offset(dir * kPreferredTileWidth, 0);
-#endif
 
   gfx::Rect target_in(target);
   if (animate_target)
     target_in.Offset(-dir * kPreferredTileWidth, 0);
   view->SetBoundsRect(target_in);
   bounds_animator_.AnimateViewTo(view, target);
 
-#if defined(USE_AURA)
   bounds_animator_.SetAnimationDelegate(
       view,
       new RowMoveAnimationDelegate(view, layer.release(), current_out),
       true);
-#endif
 }
 
 void AppsGridView::ExtractDragLocation(const ui::LocatedEvent& event,
                                        gfx::Point* drag_point) {
 #if defined(USE_AURA) && !defined(OS_WIN)
   // Use root location of |event| instead of location in |drag_view_|'s
   // coordinates because |drag_view_| has a scale transform and location
   // could have integer round error and causes jitter.
   *drag_point = event.root_location();
 
   // GetWidget() could be NULL for tests.
   if (GetWidget()) {
     aura::Window::ConvertPointToTarget(
         GetWidget()->GetNativeWindow()->GetRootWindow(),
         GetWidget()->GetNativeWindow(),
         drag_point);
   }
 
   views::View::ConvertPointFromWidget(this, drag_point);
 #else
   // For non-aura, root location is not clearly defined but |drag_view_| does
   // not have the scale transform. So no round error would be introduced and
   // it's okay to use View::ConvertPointToTarget.
+  // TODO(tapted): Investigate round error.
   *drag_point = event.location();
   views::View::ConvertPointToTarget(drag_view_, this, drag_point);
 #endif
 }
 
 void AppsGridView::CalculateDropTarget(const gfx::Point& drag_point,
                                        bool use_page_button_hovering) {
   if (EnableFolderDragDropUI()) {
     CalculateDropTargetWithFolderEnabled(drag_point, use_page_button_hovering);
     return;
@@ skipping 647 matching lines @@
     Layout();
 }
 
 void AppsGridView::OnAppListModelStatusChanged() {
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 void AppsGridView::SetViewHidden(views::View* view, bool hide, bool immediate) {
-#if defined(USE_AURA)
   ui::ScopedLayerAnimationSettings animator(view->layer()->GetAnimator());
   animator.SetPreemptionStrategy(
       immediate ? ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET :
                   ui::LayerAnimator::BLEND_WITH_CURRENT_ANIMATION);
   view->layer()->SetOpacity(hide ? 0 : 1);
-#endif
 }
 
 void AppsGridView::OnImplicitAnimationsCompleted() {
   if (layer()->opacity() == 0.0f)
     SetVisible(false);
 }
 
 bool AppsGridView::EnableFolderDragDropUI() {
   // Enable drag and drop folder UI only if it is at the app list root level
   // and the switch is on and the target folder can still accept new items.
@@ skipping 180 matching lines @@
 void AppsGridView::SetAsFolderDroppingTarget(const Index& target_index,
                                              bool is_target_folder) {
   AppListItemView* target_view =
       static_cast<AppListItemView*>(
           GetViewAtSlotOnCurrentPage(target_index.slot));
   if (target_view)
     target_view->SetAsAttemptedFolderTarget(is_target_folder);
 }
 
 }  // namespace app_list