| // Copyright 2024 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/quick_insert/views/quick_insert_section_view.h" |
| |
| #include <algorithm> |
| #include <memory> |
| #include <string> |
| #include <utility> |
| |
| #include "ash/bubble/bubble_utils.h" |
| #include "ash/quick_insert/quick_insert_asset_fetcher.h" |
| #include "ash/quick_insert/quick_insert_category.h" |
| #include "ash/quick_insert/quick_insert_search_result.h" |
| #include "ash/quick_insert/views/quick_insert_async_preview_image_view.h" |
| #include "ash/quick_insert/views/quick_insert_gif_view.h" |
| #include "ash/quick_insert/views/quick_insert_icons.h" |
| #include "ash/quick_insert/views/quick_insert_image_item_grid_view.h" |
| #include "ash/quick_insert/views/quick_insert_image_item_row_view.h" |
| #include "ash/quick_insert/views/quick_insert_image_item_view.h" |
| #include "ash/quick_insert/views/quick_insert_item_view.h" |
| #include "ash/quick_insert/views/quick_insert_item_with_submenu_view.h" |
| #include "ash/quick_insert/views/quick_insert_list_item_container_view.h" |
| #include "ash/quick_insert/views/quick_insert_list_item_view.h" |
| #include "ash/quick_insert/views/quick_insert_shortcut_hint_view.h" |
| #include "ash/quick_insert/views/quick_insert_strings.h" |
| #include "ash/quick_insert/views/quick_insert_traversable_item_container.h" |
| #include "ash/resources/vector_icons/vector_icons.h" |
| #include "ash/strings/grit/ash_strings.h" |
| #include "ash/style/typography.h" |
| #include "base/files/file_util.h" |
| #include "base/notreached.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "build/branding_buildflags.h" |
| #include "chromeos/ash/components/editor_menu/public/cpp/icon.h" |
| #include "chromeos/ui/base/file_icon_util.h" |
| #include "chromeos/ui/vector_icons/vector_icons.h" |
| #include "components/url_formatter/url_formatter.h" |
| #include "components/vector_icons/vector_icons.h" |
| #include "third_party/abseil-cpp/absl/functional/overload.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/base/metadata/metadata_impl_macros.h" |
| #include "ui/chromeos/styles/cros_tokens_color_mappings.h" |
| #include "ui/gfx/geometry/insets.h" |
| #include "ui/gfx/text_constants.h" |
| #include "ui/gfx/vector_icon_types.h" |
| #include "ui/views/accessibility/view_accessibility.h" |
| #include "ui/views/controls/button/image_button.h" |
| #include "ui/views/controls/label.h" |
| #include "ui/views/controls/link.h" |
| #include "ui/views/layout/box_layout.h" |
| #include "ui/views/layout/box_layout_view.h" |
| #include "ui/views/layout/layout_manager.h" |
| #include "ui/views/layout/layout_types.h" |
| #include "ui/views/metadata/view_factory.h" |
| #include "ui/views/view_class_properties.h" |
| #include "ui/views/view_utils.h" |
| |
| namespace ash { |
| namespace { |
| |
| // Some of the icons we use do not have a default size, so we need to manually |
| // set it. |
| constexpr int kIconSize = 20; |
| |
| // Icons for browsing history should be smaller than the normal icon size. |
| constexpr auto kBrowsingHistoryIconSize = gfx::Size(18, 18); |
| |
| constexpr auto kSectionTitleMargins = gfx::Insets::VH(8, 16); |
| constexpr auto kSectionTitleTrailingLinkMargins = |
| gfx::Insets::TLBR(4, 8, 4, 16); |
| |
| QuickInsertCategory GetCategoryForEditorData( |
| const QuickInsertEditorResult& data) { |
| switch (data.mode) { |
| case QuickInsertEditorResult::Mode::kWrite: |
| return QuickInsertCategory::kEditorWrite; |
| case QuickInsertEditorResult::Mode::kRewrite: |
| return QuickInsertCategory::kEditorRewrite; |
| } |
| } |
| |
| QuickInsertCategory GetCategoryForLobsterData( |
| const QuickInsertLobsterResult& data) { |
| switch (data.mode) { |
| case QuickInsertLobsterResult::Mode::kNoSelection: |
| return QuickInsertCategory::kLobsterWithNoSelectedText; |
| case QuickInsertLobsterResult::Mode::kWithSelection: |
| return QuickInsertCategory::kLobsterWithSelectedText; |
| } |
| } |
| |
| std::u16string GetLabelForNewWindowType(QuickInsertNewWindowResult::Type type) { |
| switch (type) { |
| case QuickInsertNewWindowResult::Type::kDoc: |
| return l10n_util::GetStringUTF16(IDS_PICKER_NEW_GOOGLE_DOC_MENU_LABEL); |
| case QuickInsertNewWindowResult::Type::kSheet: |
| return l10n_util::GetStringUTF16(IDS_PICKER_NEW_GOOGLE_SHEET_MENU_LABEL); |
| case QuickInsertNewWindowResult::Type::kSlide: |
| return l10n_util::GetStringUTF16(IDS_PICKER_NEW_GOOGLE_SLIDE_MENU_LABEL); |
| case QuickInsertNewWindowResult::Type::kChrome: |
| return l10n_util::GetStringUTF16(IDS_PICKER_NEW_GOOGLE_CHROME_MENU_LABEL); |
| } |
| } |
| |
| const gfx::VectorIcon& GetIconForNewWindowType( |
| QuickInsertNewWindowResult::Type type) { |
| #if BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| switch (type) { |
| case QuickInsertNewWindowResult::Type::kDoc: |
| return vector_icons::kGoogleDocsIcon; |
| case QuickInsertNewWindowResult::Type::kSheet: |
| return vector_icons::kGoogleSheetsIcon; |
| case QuickInsertNewWindowResult::Type::kSlide: |
| return vector_icons::kGoogleSlidesIcon; |
| case QuickInsertNewWindowResult::Type::kChrome: |
| return vector_icons::kProductRefreshIcon; |
| } |
| #else |
| return kPlaceholderAppIcon; |
| #endif // BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| } |
| |
| std::u16string GetLabelForCaseTransformType( |
| QuickInsertCaseTransformResult::Type type) { |
| switch (type) { |
| case QuickInsertCaseTransformResult::Type::kUpperCase: |
| return l10n_util::GetStringUTF16(IDS_PICKER_UPPER_CASE_MENU_LABEL); |
| case QuickInsertCaseTransformResult::Type::kLowerCase: |
| return l10n_util::GetStringUTF16(IDS_PICKER_LOWER_CASE_MENU_LABEL); |
| case QuickInsertCaseTransformResult::Type::kTitleCase: |
| return l10n_util::GetStringUTF16(IDS_PICKER_TITLE_CASE_MENU_LABEL); |
| } |
| } |
| |
| const gfx::VectorIcon& GetIconForCaseTransformType( |
| QuickInsertCaseTransformResult::Type type) { |
| switch (type) { |
| case QuickInsertCaseTransformResult::Type::kUpperCase: |
| return kQuickInsertUpperCaseIcon; |
| case QuickInsertCaseTransformResult::Type::kLowerCase: |
| return kQuickInsertLowerCaseIcon; |
| case QuickInsertCaseTransformResult::Type::kTitleCase: |
| return kQuickInsertTitleCaseIcon; |
| } |
| } |
| |
| std::u16string FormatBrowsingHistoryUrl(const GURL& url) { |
| return url_formatter::FormatUrl( |
| url, |
| url_formatter::kFormatUrlOmitDefaults | |
| url_formatter::kFormatUrlOmitHTTPS | |
| url_formatter::kFormatUrlOmitTrivialSubdomains, |
| base::UnescapeRule::SPACES, nullptr, nullptr, nullptr); |
| } |
| |
| std::optional<base::File::Info> ResolveFileInfo(const base::FilePath& path) { |
| base::File::Info info; |
| if (!base::GetFileInfo(path, &info)) { |
| return std::nullopt; |
| } |
| return info; |
| } |
| |
| // This should align with `chromeos::clipboard_history::GetIconForDescriptor`. |
| const gfx::VectorIcon& GetIconForClipboardData( |
| const QuickInsertClipboardResult& data) { |
| switch (data.display_format) { |
| case QuickInsertClipboardResult::DisplayFormat::kText: |
| return GURL(data.display_text).is_valid() ? vector_icons::kLinkIcon |
| : chromeos::kTextIcon; |
| case QuickInsertClipboardResult::DisplayFormat::kImage: |
| return chromeos::kFiletypeImageIcon; |
| case QuickInsertClipboardResult::DisplayFormat::kFile: |
| return data.file_count == 1 ? chromeos::GetIconForPath(base::FilePath( |
| base::UTF16ToUTF8(data.display_text))) |
| : vector_icons::kContentCopyIcon; |
| case QuickInsertClipboardResult::DisplayFormat::kHtml: |
| NOTREACHED(); |
| } |
| NOTREACHED(); |
| } |
| |
| template <typename Range> |
| auto FindContainerForItem(Range&& containers, views::View* item) { |
| return std::ranges::find_if( |
| containers, [item](QuickInsertTraversableItemContainer* container) { |
| return container->ContainsItem(item); |
| }); |
| } |
| |
| } // namespace |
| |
| QuickInsertSectionView::QuickInsertSectionView( |
| int section_width, |
| QuickInsertAssetFetcher* asset_fetcher, |
| QuickInsertSubmenuController* submenu_controller) |
| : section_width_(section_width), |
| asset_fetcher_(asset_fetcher), |
| submenu_controller_(submenu_controller) { |
| SetLayoutManager(std::make_unique<views::BoxLayout>()) |
| ->SetOrientation(views::LayoutOrientation::kVertical); |
| |
| title_container_ = |
| AddChildView(views::Builder<views::BoxLayoutView>() |
| .SetOrientation(views::LayoutOrientation::kHorizontal) |
| .Build()); |
| GetViewAccessibility().SetRole(ax::mojom::Role::kList); |
| } |
| |
| QuickInsertSectionView::~QuickInsertSectionView() = default; |
| |
| std::unique_ptr<QuickInsertItemView> |
| QuickInsertSectionView::CreateItemFromResult( |
| const QuickInsertSearchResult& result, |
| QuickInsertPreviewBubbleController* preview_controller, |
| QuickInsertAssetFetcher* asset_fetcher, |
| int available_width, |
| LocalFileResultStyle local_file_result_style, |
| SelectResultCallback select_result_callback) { |
| using ReturnType = std::unique_ptr<QuickInsertItemView>; |
| return std::visit( |
| absl::Overload{ |
| [&](const QuickInsertTextResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(data.primary_text); |
| item_view->SetSecondaryText(data.secondary_text); |
| item_view->SetLeadingIcon(data.icon); |
| return item_view; |
| }, |
| [&](const QuickInsertSearchRequestResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(data.primary_text); |
| item_view->SetSecondaryText(data.secondary_text); |
| item_view->SetLeadingIcon(data.icon); |
| return item_view; |
| }, |
| [&](const QuickInsertEmojiResult& data) -> ReturnType { |
| NOTREACHED(); |
| }, |
| [&](const QuickInsertClipboardResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| switch (data.display_format) { |
| case QuickInsertClipboardResult::DisplayFormat::kFile: |
| case QuickInsertClipboardResult::DisplayFormat::kText: |
| item_view->SetPrimaryText(data.display_text); |
| break; |
| case QuickInsertClipboardResult::DisplayFormat::kImage: |
| if (!data.display_image.has_value()) { |
| return nullptr; |
| } |
| item_view->SetPrimaryImage(*data.display_image, |
| available_width); |
| break; |
| case QuickInsertClipboardResult::DisplayFormat::kHtml: |
| NOTREACHED(); |
| } |
| item_view->SetLeadingIcon(ui::ImageModel::FromVectorIcon( |
| GetIconForClipboardData(data), cros_tokens::kCrosSysOnSurface, |
| kIconSize)); |
| return item_view; |
| }, |
| [&](const QuickInsertGifResult& data) -> ReturnType { |
| // `base::Unretained` is safe because `asset_fetcher` outlives the |
| // return value. |
| auto gif_view = std::make_unique<QuickInsertGifView>( |
| base::BindRepeating(&QuickInsertAssetFetcher::FetchGifFromUrl, |
| base::Unretained(asset_fetcher), |
| data.preview_url, data.rank), |
| base::BindRepeating( |
| &QuickInsertAssetFetcher::FetchGifPreviewImageFromUrl, |
| base::Unretained(asset_fetcher), data.preview_image_url, |
| data.rank), |
| data.preview_dimensions); |
| return std::make_unique<QuickInsertImageItemView>( |
| std::move(gif_view), data.content_description, |
| std::move(select_result_callback)); |
| }, |
| [&](const QuickInsertBrowsingHistoryResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| std::u16string formatted_url = FormatBrowsingHistoryUrl(data.url); |
| item_view->SetPrimaryText(data.title.empty() ? formatted_url |
| : data.title); |
| item_view->SetSecondaryText(formatted_url); |
| item_view->SetLeadingIcon(data.icon, kBrowsingHistoryIconSize); |
| return item_view; |
| }, |
| [&](const QuickInsertLocalFileResult& data) -> ReturnType { |
| switch (local_file_result_style) { |
| case LocalFileResultStyle::kList: { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(data.title); |
| // `base::Unretained` is safe because `asset_fetcher` outlives |
| // the return value. |
| item_view->SetPreview( |
| preview_controller, |
| base::BindOnce(ResolveFileInfo, data.file_path), |
| data.file_path, |
| base::BindRepeating( |
| &QuickInsertAssetFetcher::FetchFileThumbnail, |
| base::Unretained(asset_fetcher)), |
| /*update_icon=*/true); |
| return item_view; |
| } |
| case LocalFileResultStyle::kGrid: |
| case LocalFileResultStyle::kRow: { |
| // `base::Unretained` is safe because `asset_fetcher` outlives |
| // the return value. |
| auto image_view = |
| std::make_unique<QuickInsertAsyncPreviewImageView>( |
| data.file_path, |
| gfx::Size(available_width, available_width), |
| base::BindRepeating( |
| &QuickInsertAssetFetcher::FetchFileThumbnail, |
| base::Unretained(asset_fetcher))); |
| return std::make_unique<QuickInsertImageItemView>( |
| std::move(image_view), data.title, |
| std::move(select_result_callback)); |
| } |
| } |
| }, |
| [&](const QuickInsertDriveFileResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(data.title); |
| // TODO: b/333609460 - Handle dark/light mode. |
| item_view->SetLeadingIcon( |
| ui::ImageModel::FromImageSkia(chromeos::GetIconForPath( |
| data.file_path, /*dark_background=*/false, kIconSize))); |
| // `base::Unretained` is safe because `asset_fetcher` outlives the |
| // return value. |
| item_view->SetPreview( |
| preview_controller, |
| base::BindOnce(ResolveFileInfo, data.file_path), data.file_path, |
| base::BindRepeating( |
| &QuickInsertAssetFetcher::FetchFileThumbnail, |
| base::Unretained(asset_fetcher)), |
| /*update_icon=*/false); |
| return item_view; |
| }, |
| [&](const QuickInsertCategoryResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText( |
| GetLabelForQuickInsertCategory(data.category)); |
| item_view->SetLeadingIcon( |
| GetIconForQuickInsertCategory(data.category)); |
| return item_view; |
| }, |
| [&](const QuickInsertEditorResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| if (data.category.has_value()) { |
| // Preset write or rewrite. |
| item_view->SetPrimaryText(data.display_name); |
| item_view->SetLeadingIcon(ui::ImageModel::FromVectorIcon( |
| chromeos::editor_menu::GetIconForPresetQueryCategory( |
| *data.category), |
| cros_tokens::kCrosSysOnSurface)); |
| } else { |
| // Freeform write or rewrite. |
| const QuickInsertCategory category = |
| GetCategoryForEditorData(data); |
| item_view->SetPrimaryText( |
| GetLabelForQuickInsertCategory(category)); |
| item_view->SetLeadingIcon( |
| GetIconForQuickInsertCategory(category)); |
| } |
| return item_view; |
| }, |
| [&](const QuickInsertLobsterResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| |
| const QuickInsertCategory category = |
| GetCategoryForLobsterData(data); |
| item_view->SetPrimaryText(GetLabelForQuickInsertCategory(category)); |
| item_view->SetLeadingIcon(GetIconForQuickInsertCategory(category)); |
| return item_view; |
| }, |
| [&](const QuickInsertNewWindowResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(GetLabelForNewWindowType(data.type)); |
| item_view->SetLeadingIcon(ui::ImageModel::FromVectorIcon( |
| GetIconForNewWindowType(data.type), |
| cros_tokens::kCrosSysOnSurface)); |
| return item_view; |
| }, |
| [&](const QuickInsertCapsLockResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(l10n_util::GetStringUTF16( |
| data.enabled ? IDS_PICKER_CAPS_LOCK_ON_MENU_LABEL |
| : IDS_PICKER_CAPS_LOCK_OFF_MENU_LABEL)); |
| item_view->SetLeadingIcon(ui::ImageModel::FromVectorIcon( |
| data.enabled ? kQuickInsertCapsLockOnIcon |
| : kQuickInsertCapsLockOffIcon, |
| cros_tokens::kCrosSysOnSurface)); |
| item_view->SetShortcutHintView( |
| std::make_unique<QuickInsertShortcutHintView>(data.shortcut)); |
| return item_view; |
| }, |
| [&](const QuickInsertCaseTransformResult& data) -> ReturnType { |
| auto item_view = std::make_unique<QuickInsertListItemView>( |
| std::move(select_result_callback)); |
| item_view->SetPrimaryText(GetLabelForCaseTransformType(data.type)); |
| item_view->SetLeadingIcon(ui::ImageModel::FromVectorIcon( |
| GetIconForCaseTransformType(data.type), |
| cros_tokens::kCrosSysOnSurface)); |
| return item_view; |
| }, |
| }, |
| result); |
| } |
| |
| void QuickInsertSectionView::AddTitleLabel(const std::u16string& title_text) { |
| if (title_text.empty()) { |
| return; |
| } |
| |
| title_label_ = title_container_->AddChildView( |
| views::Builder<views::Label>( |
| bubble_utils::CreateLabel(TypographyToken::kCrosAnnotation2, |
| title_text, |
| cros_tokens::kCrosSysOnSurfaceVariant)) |
| .SetHorizontalAlignment(gfx::ALIGN_LEFT) |
| .SetProperty(views::kMarginsKey, kSectionTitleMargins) |
| .Build()); |
| title_label_->GetViewAccessibility().SetRole(ax::mojom::Role::kHeading); |
| title_container_->SetFlexForView(title_label_, 1); |
| } |
| |
| void QuickInsertSectionView::AddTitleTrailingLink( |
| const std::u16string& link_text, |
| const std::u16string& accessible_name, |
| views::Link::ClickedCallback link_callback) { |
| title_trailing_link_ = title_container_->AddChildView( |
| views::Builder<views::Link>() |
| .SetText(link_text) |
| .SetCallback(link_callback) |
| .SetFontList(TypographyProvider::Get()->ResolveTypographyToken( |
| TypographyToken::kCrosAnnotation2)) |
| .SetEnabledColor(cros_tokens::kCrosSysPrimary) |
| .SetForceUnderline(false) |
| .SetProperty(views::kMarginsKey, kSectionTitleTrailingLinkMargins) |
| .Build()); |
| title_trailing_link_->GetViewAccessibility().SetRole( |
| ax::mojom::Role::kButton); |
| title_trailing_link_->GetViewAccessibility().SetName(accessible_name); |
| } |
| |
| QuickInsertListItemView* QuickInsertSectionView::AddListItem( |
| std::unique_ptr<QuickInsertListItemView> list_item) { |
| list_item->SetSubmenuController(submenu_controller_); |
| QuickInsertListItemView* list_item_ptr = |
| GetOrCreateListItemContainer()->AddListItem(std::move(list_item)); |
| item_views_.push_back(list_item_ptr); |
| return list_item_ptr; |
| } |
| |
| QuickInsertImageItemView* QuickInsertSectionView::AddImageGridItem( |
| std::unique_ptr<QuickInsertImageItemView> image_item) { |
| image_item->SetSubmenuController(submenu_controller_); |
| QuickInsertImageItemView* image_item_ptr = |
| GetOrCreateImageItemGrid()->AddImageItem(std::move(image_item)); |
| item_views_.push_back(image_item_ptr); |
| return image_item_ptr; |
| } |
| |
| QuickInsertImageItemView* QuickInsertSectionView::AddImageRowItem( |
| std::unique_ptr<QuickInsertImageItemView> image_item) { |
| image_item->SetSubmenuController(submenu_controller_); |
| QuickInsertImageItemView* image_item_ptr = |
| GetOrCreateImageItemRow()->AddImageItem(std::move(image_item)); |
| item_views_.push_back(image_item_ptr); |
| return image_item_ptr; |
| } |
| |
| QuickInsertItemWithSubmenuView* QuickInsertSectionView::AddItemWithSubmenu( |
| std::unique_ptr<QuickInsertItemWithSubmenuView> item_with_submenu) { |
| QuickInsertItemWithSubmenuView* item_ptr = |
| GetOrCreateListItemContainer()->AddItemWithSubmenu( |
| std::move(item_with_submenu)); |
| item_views_.push_back(item_ptr); |
| return item_ptr; |
| } |
| |
| QuickInsertItemView* QuickInsertSectionView::AddResult( |
| const QuickInsertSearchResult& result, |
| QuickInsertPreviewBubbleController* preview_controller, |
| LocalFileResultStyle local_file_result_style, |
| SelectResultCallback select_result_callback) { |
| auto item = CreateItemFromResult(result, preview_controller, asset_fetcher_, |
| section_width_, local_file_result_style, |
| std::move(select_result_callback)); |
| if (views::IsViewClass<QuickInsertListItemView>(item.get())) { |
| return AddListItem(std::unique_ptr<QuickInsertListItemView>( |
| views::AsViewClass<QuickInsertListItemView>(item.release()))); |
| } |
| if (views::IsViewClass<QuickInsertImageItemView>(item.get())) { |
| std::unique_ptr<QuickInsertImageItemView> image_item( |
| views::AsViewClass<QuickInsertImageItemView>(item.release())); |
| if (local_file_result_style == LocalFileResultStyle::kRow) { |
| return AddImageRowItem(std::move(image_item)); |
| } else { |
| return AddImageGridItem(std::move(image_item)); |
| } |
| } |
| if (views::IsViewClass<QuickInsertItemWithSubmenuView>(item.get())) { |
| return AddItemWithSubmenu(std::unique_ptr<QuickInsertItemWithSubmenuView>( |
| views::AsViewClass<QuickInsertItemWithSubmenuView>(item.release()))); |
| } |
| NOTREACHED(); |
| } |
| |
| void QuickInsertSectionView::ClearItems() { |
| item_containers_.clear(); |
| item_views_.clear(); |
| if (image_item_grid_ != nullptr) { |
| RemoveChildViewT(image_item_grid_.ExtractAsDangling()); |
| } |
| if (list_item_container_ != nullptr) { |
| RemoveChildViewT(list_item_container_.ExtractAsDangling()); |
| } |
| } |
| |
| views::View* QuickInsertSectionView::GetTopItem() { |
| return item_containers_.empty() ? nullptr |
| : item_containers_.front()->GetTopItem(); |
| } |
| |
| views::View* QuickInsertSectionView::GetBottomItem() { |
| return item_containers_.empty() ? nullptr |
| : item_containers_.back()->GetBottomItem(); |
| } |
| |
| views::View* QuickInsertSectionView::GetItemAbove(views::View* item) { |
| auto it = FindContainerForItem(item_containers_, item); |
| if (it == item_containers_.end()) { |
| return nullptr; |
| } |
| |
| if (views::View* result = (*it)->GetItemAbove(item)) { |
| return result; |
| } |
| |
| // Get the bottom item of the above container. |
| return it == item_containers_.begin() ? nullptr |
| : (*std::prev(it))->GetBottomItem(); |
| } |
| |
| views::View* QuickInsertSectionView::GetItemBelow(views::View* item) { |
| auto it = FindContainerForItem(item_containers_, item); |
| if (it == item_containers_.end()) { |
| return nullptr; |
| } |
| |
| if (views::View* result = (*it)->GetItemBelow(item)) { |
| return result; |
| } |
| |
| // Get the top item of the below container. |
| return it == item_containers_.end() - 1 ? nullptr |
| : (*std::next(it))->GetTopItem(); |
| } |
| |
| views::View* QuickInsertSectionView::GetItemLeftOf(views::View* item) { |
| auto it = FindContainerForItem(item_containers_, item); |
| return it == item_containers_.end() ? nullptr : (*it)->GetItemLeftOf(item); |
| } |
| |
| views::View* QuickInsertSectionView::GetItemRightOf(views::View* item) { |
| auto it = FindContainerForItem(item_containers_, item); |
| return it == item_containers_.end() ? nullptr : (*it)->GetItemRightOf(item); |
| } |
| |
| void QuickInsertSectionView::SetImageRowProperties( |
| std::u16string accessible_name, |
| base::RepeatingClosure more_items_button_callback, |
| std::u16string more_items_button_accessible_name) { |
| image_row_properties_.accessible_name = std::move(accessible_name); |
| image_row_properties_.more_items_button_callback = |
| std::move(more_items_button_callback); |
| image_row_properties_.more_items_button_accessible_name = |
| std::move(more_items_button_accessible_name); |
| } |
| |
| views::View* QuickInsertSectionView::GetImageRowMoreItemsButtonForTesting() { |
| return image_item_row_ == nullptr |
| ? nullptr |
| : image_item_row_->GetMoreItemsButtonForTesting(); // IN-TEST |
| } |
| |
| QuickInsertSectionView::ImageRowProperties::ImageRowProperties() = default; |
| |
| QuickInsertSectionView::ImageRowProperties::~ImageRowProperties() = default; |
| |
| QuickInsertListItemContainerView* |
| QuickInsertSectionView::GetOrCreateListItemContainer() { |
| if (list_item_container_ == nullptr) { |
| list_item_container_ = |
| AddChildView(std::make_unique<QuickInsertListItemContainerView>()); |
| item_containers_.push_back(list_item_container_); |
| } |
| return list_item_container_; |
| } |
| |
| QuickInsertImageItemGridView* |
| QuickInsertSectionView::GetOrCreateImageItemGrid() { |
| if (image_item_grid_ == nullptr) { |
| image_item_grid_ = |
| AddChildView(std::make_unique<QuickInsertImageItemGridView>( |
| section_width_, |
| /*has_top_margin=*/title_container_->children().empty())); |
| item_containers_.push_back(image_item_grid_); |
| } |
| return image_item_grid_; |
| } |
| |
| QuickInsertImageItemRowView* QuickInsertSectionView::GetOrCreateImageItemRow() { |
| if (image_item_row_ == nullptr) { |
| image_item_row_ = |
| AddChildView(std::make_unique<QuickInsertImageItemRowView>( |
| image_row_properties_.more_items_button_callback, |
| image_row_properties_.more_items_button_accessible_name)); |
| image_item_row_->SetLeadingIcon(ui::ImageModel::FromVectorIcon( |
| kFilesAppIcon, cros_tokens::kCrosSysOnSurface, kIconSize)); |
| image_item_row_->GetViewAccessibility().SetName( |
| image_row_properties_.accessible_name); |
| item_containers_.push_back(image_item_row_); |
| } |
| return image_item_row_; |
| } |
| |
| BEGIN_METADATA(QuickInsertSectionView) |
| END_METADATA |
| |
| } // namespace ash |
