// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/app_list/model/folder_image.h"
#include <algorithm>
#include <memory>
#include <utility>
#include <vector>
#include "ash/app_list/model/app_list_item.h"
#include "ash/app_list/model/app_list_item_list.h"
#include "ash/public/cpp/app_list/app_list_config.h"
#include "ash/public/cpp/app_list/app_list_config_provider.h"
#include "base/i18n/rtl.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ref.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/image/canvas_image_source.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/image/image_skia_operations.h"
#include "ui/gfx/scoped_canvas.h"
namespace ash {
namespace {
// The shadow blur of icon.
constexpr int kIconShadowBlur = 5;
// The shadow color of icon.
constexpr SkColor kIconShadowColor = SkColorSetA(SK_ColorBLACK, 31);
// Generates the folder icon with the top 4 child item icons laid in 2x2 tile.
class FolderImageSource : public gfx::CanvasImageSource {
public:
typedef std::vector<gfx::ImageSkia> Icons;
FolderImageSource(const AppListConfig& app_list_config,
const Icons& icons,
const gfx::Size& size);
FolderImageSource(const FolderImageSource&) = delete;
FolderImageSource& operator=(const FolderImageSource&) = delete;
~FolderImageSource() override;
private:
void DrawIcon(gfx::Canvas* canvas,
const gfx::ImageSkia& icon,
const gfx::Size& icon_size,
int x,
int y);
// gfx::CanvasImageSource overrides:
void Draw(gfx::Canvas* canvas) override;
const raw_ref<const AppListConfig, DanglingUntriaged> app_list_config_;
Icons icons_;
gfx::Size size_;
};
FolderImageSource::FolderImageSource(const AppListConfig& app_list_config,
const Icons& icons,
const gfx::Size& size)
: gfx::CanvasImageSource(size),
app_list_config_(app_list_config),
icons_(icons),
size_(size) {
DCHECK(icons.size() <= FolderImage::kNumFolderTopItems);
}
FolderImageSource::~FolderImageSource() = default;
void FolderImageSource::DrawIcon(gfx::Canvas* canvas,
const gfx::ImageSkia& icon,
const gfx::Size& icon_size,
int x,
int y) {
if (icon.isNull())
return;
const gfx::ImageSkia resized(gfx::ImageSkiaOperations::CreateResizedImage(
icon, skia::ImageOperations::RESIZE_BEST, icon_size));
// Draw a shadowed icon on the specified location.
const gfx::ShadowValues shadow = {
gfx::ShadowValue(gfx::Vector2d(), kIconShadowBlur, kIconShadowColor)};
const gfx::ImageSkia shadowed(
gfx::ImageSkiaOperations::CreateImageWithDropShadow(resized, shadow));
// Offset the shadowed image so the actual image position matches its original
// bounds. The offset has to be calculated in pixels, as the shadow margin
// might not match the 1x margin scaled to the target scale factor (when the
// drawing the shadow, the shadow margin is first scaled then rounded, which
// might introduce different rounding error depending on the scale factor).
gfx::ScopedCanvas scoped_canvas(canvas);
const float scale = canvas->UndoDeviceScaleFactor();
gfx::Insets shadow_margin =
gfx::ShadowValue::GetMargin({shadow[0].Scale(scale)});
const gfx::ImageSkiaRep& shadowed_rep = shadowed.GetRepresentation(scale);
canvas->DrawImageIntInPixel(
shadowed_rep, x * scale + shadow_margin.left(),
y * scale + shadow_margin.top(), scale * shadowed.width(),
scale * shadowed.height(), true, cc::PaintFlags());
}
void FolderImageSource::Draw(gfx::Canvas* canvas) {
if (icons_.size() == 0)
return;
// Draw top items' icons.
const size_t num_items =
std::min(FolderImage::kNumFolderTopItems, icons_.size());
std::vector<gfx::Rect> top_icon_bounds = FolderImage::GetTopIconsBounds(
*app_list_config_, gfx::Rect(size()), num_items);
for (size_t i = 0; i < num_items; ++i) {
DrawIcon(canvas, icons_[i],
app_list_config_->item_icon_in_folder_icon_size(),
top_icon_bounds[i].x(), top_icon_bounds[i].y());
}
}
} // namespace
// static
const size_t FolderImage::kNumFolderTopItems = 4;
FolderImage::FolderImage(const AppListConfig* app_list_config,
AppListItemList* item_list)
: app_list_config_(app_list_config), item_list_(item_list) {
DCHECK(app_list_config_);
item_list_->AddObserver(this);
}
FolderImage::~FolderImage() {
for (ash::AppListItem* item : top_items_) {
item->RemoveObserver(this);
}
item_list_->RemoveObserver(this);
}
void FolderImage::UpdateIcon() {
for (ash::AppListItem* item : top_items_) {
item->RemoveObserver(this);
}
top_items_.clear();
for (size_t i = 0;
i < item_list_->item_count() && top_items_.size() < kNumFolderTopItems;
++i) {
AppListItem* item = item_list_->item_at(i);
// If this item is currently being dragged, pretend it has already left our
// folder
if (item == dragged_item_)
continue;
item->AddObserver(this);
top_items_.push_back(item);
}
RedrawIconAndNotify();
}
void FolderImage::UpdateDraggedItem(const AppListItem* dragged_item) {
DCHECK(dragged_item_ != dragged_item);
dragged_item_ = dragged_item;
UpdateIcon();
}
// static
std::vector<gfx::Rect> FolderImage::GetTopIconsBounds(
const AppListConfig& app_list_config,
const gfx::Rect& folder_icon_bounds,
size_t num_items) {
DCHECK_LE(num_items, kNumFolderTopItems);
std::vector<gfx::Rect> top_icon_bounds;
const AppListConfig& base_config =
*AppListConfigProvider::Get().GetConfigForType(app_list_config.type(),
true /*can_create*/);
// The folder icons are generated as unclipped icons for default app list
// config, and then scaled down to the required unclipped folder size as
// needed (if clipped icon is needed, the unclipped icon bounds are clipped to
// the target size).
// This method goes through a similar flow:
// 1. Calculate the top icon bounds in the default unclipped folder icon.
// 2. Scale the bounds to the target config unclipped folder icon size.
// 3. Translate the bound to adjust for clipped bounds size (expected to be
// the |folder_icon_bounds| size).
// 4. Translate to bounds to adjust for the clipped bounds origin (expected
// to be the |folder_icon_bounds| origin).
// Steps 2 - 4 are done using |scale_and_translate_bounds|.
const int item_icon_dimension =
base_config.item_icon_in_folder_icon_dimension();
const int folder_icon_dimension = base_config.folder_icon_dimension();
gfx::Point icon_center(folder_icon_dimension / 2, folder_icon_dimension / 2);
const gfx::Rect center_rect(icon_center.x() - item_icon_dimension / 2,
icon_center.y() - item_icon_dimension / 2,
item_icon_dimension, item_icon_dimension);
const int origin_offset =
(item_icon_dimension + base_config.item_icon_in_folder_icon_margin()) / 2;
const int scaled_folder_icon_dimension =
app_list_config.folder_icon_dimension();
auto scale_and_translate_bounds =
[folder_icon_bounds, folder_icon_dimension,
scaled_folder_icon_dimension](const gfx::Rect& original) {
const float scale = static_cast<float>(scaled_folder_icon_dimension) /
folder_icon_dimension;
gfx::Rect bounds = gfx::ScaleToRoundedRect(original, scale, scale);
const int clipped_image_offset =
(scaled_folder_icon_dimension - folder_icon_bounds.width()) / 2;
bounds.Offset(-clipped_image_offset, -clipped_image_offset);
bounds.Offset(folder_icon_bounds.x(), folder_icon_bounds.y());
return bounds;
};
if (num_items == 1) {
// Center icon bounds.
top_icon_bounds.emplace_back(scale_and_translate_bounds(center_rect));
return top_icon_bounds;
}
if (num_items == 2) {
// Left icon bounds.
gfx::Rect left_rect = center_rect;
left_rect.Offset(-origin_offset, 0);
// Right icon bounds.
gfx::Rect right_rect = center_rect;
right_rect.Offset(origin_offset, 0);
if (base::i18n::IsRTL())
std::swap(left_rect, right_rect);
top_icon_bounds.emplace_back(scale_and_translate_bounds(left_rect));
top_icon_bounds.emplace_back(scale_and_translate_bounds(right_rect));
return top_icon_bounds;
}
if (num_items == 3) {
// Top icon bounds.
gfx::Rect top_rect = center_rect;
top_rect.Offset(0, -origin_offset);
top_icon_bounds.emplace_back(scale_and_translate_bounds(top_rect));
}
if (num_items == 4) {
// Top left icon bounds.
gfx::Rect top_left_rect = center_rect;
top_left_rect.Offset(-origin_offset, -origin_offset);
// Top right icon bounds.
gfx::Rect top_right_rect = center_rect;
top_right_rect.Offset(origin_offset, -origin_offset);
if (base::i18n::IsRTL()) {
std::swap(top_left_rect, top_right_rect);
}
top_icon_bounds.emplace_back(scale_and_translate_bounds(top_left_rect));
top_icon_bounds.emplace_back(scale_and_translate_bounds(top_right_rect));
}
// Bottom left icon bounds.
gfx::Rect bottom_left_rect = center_rect;
bottom_left_rect.Offset(-origin_offset, origin_offset);
// Bottom right icon bounds.
gfx::Rect bottom_right_rect = center_rect;
bottom_right_rect.Offset(origin_offset, origin_offset);
if (base::i18n::IsRTL())
std::swap(bottom_left_rect, bottom_right_rect);
top_icon_bounds.emplace_back(scale_and_translate_bounds(bottom_left_rect));
top_icon_bounds.emplace_back(scale_and_translate_bounds(bottom_right_rect));
return top_icon_bounds;
}
gfx::Rect FolderImage::GetTargetIconRectInFolderForItem(
const AppListConfig& app_list_config,
AppListItem* item,
const gfx::Rect& folder_icon_bounds) const {
for (size_t i = 0; i < top_items_.size(); ++i) {
if (item->id() == top_items_[i]->id()) {
std::vector<gfx::Rect> rects = GetTopIconsBounds(
app_list_config, folder_icon_bounds, top_items_.size());
return rects[i];
}
}
gfx::Rect target_rect(folder_icon_bounds);
target_rect.ClampToCenteredSize(
app_list_config.item_icon_in_folder_icon_size());
return target_rect;
}
void FolderImage::AddObserver(FolderImageObserver* observer) {
observers_.AddObserver(observer);
}
void FolderImage::RemoveObserver(FolderImageObserver* observer) {
observers_.RemoveObserver(observer);
}
void FolderImage::ItemIconChanged(AppListConfigType config_type) {
if (config_type != app_list_config_->type())
return;
// Note: Must update the image only (cannot simply call UpdateIcon), because
// UpdateIcon removes and re-adds the FolderImage as an observer of the
// AppListItems, which causes the current iterator to call ItemIconChanged
// again, and goes into an infinite loop.
RedrawIconAndNotify();
}
void FolderImage::OnListItemAdded(size_t index, AppListItem* item) {
if (index < kNumFolderTopItems)
UpdateIcon();
}
void FolderImage::OnListItemRemoved(size_t index, AppListItem* item) {
if (index < kNumFolderTopItems)
UpdateIcon();
}
void FolderImage::OnListItemMoved(size_t from_index,
size_t to_index,
AppListItem* item) {
if (from_index < kNumFolderTopItems || to_index < kNumFolderTopItems)
UpdateIcon();
}
void FolderImage::RedrawIconAndNotify() {
FolderImageSource::Icons top_icons;
for (const ash::AppListItem* item : top_items_) {
top_icons.push_back(item->GetIcon(app_list_config_->type()));
}
const gfx::Size icon_size = app_list_config_->folder_icon_size();
icon_ = gfx::ImageSkia(std::make_unique<FolderImageSource>(
*app_list_config_, top_icons, icon_size),
icon_size);
for (auto& observer : observers_)
observer.OnFolderImageUpdated(app_list_config_->type());
}
} // namespace ash
Codebase Browser
chromium