ink_drop_host.cc | Explore in Territory

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/views/animation/ink_drop_host.h"

#include <utility>

#include "base/check_is_test.h"
#include "third_party/abseil-cpp/absl/types/variant.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/color/color_provider.h"
#include "ui/events/event.h"
#include "ui/events/scoped_target_handler.h"
#include "ui/gfx/color_palette.h"
#include "ui/gfx/geometry/size_conversions.h"
#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
#include "ui/views/animation/ink_drop.h"
#include "ui/views/animation/ink_drop_highlight.h"
#include "ui/views/animation/ink_drop_impl.h"
#include "ui/views/animation/ink_drop_mask.h"
#include "ui/views/animation/ink_drop_stub.h"
#include "ui/views/animation/pulsing_ink_drop_mask.h"
#include "ui/views/animation/square_ink_drop_ripple.h"
#include "ui/views/controls/focus_ring.h"
#include "ui/views/controls/highlight_path_generator.h"
#include "ui/views/style/platform_style.h"
#include "ui/views/view_class_properties.h"

namespace views {

// static
constexpr gfx::Size InkDropHost::kDefaultSquareInkDropSize;

InkDropHost::InkDropHostEventHandlerDelegate::InkDropHostEventHandlerDelegate(
    InkDropHost* ink_drop_host)
    : … { … }

bool InkDropHost::InkDropHostEventHandlerDelegate::HasInkDrop() const { … }

InkDrop* InkDropHost::InkDropHostEventHandlerDelegate::GetInkDrop() { … }

bool InkDropHost::InkDropHostEventHandlerDelegate::SupportsGestureEvents()
    const { … }

InkDropHost::ViewLayerTransformObserver::ViewLayerTransformObserver(
    InkDropHost* ink_drop_host,
    View* host_view)
    : … { … }

InkDropHost::ViewLayerTransformObserver::~ViewLayerTransformObserver() =
    default;

void InkDropHost::ViewLayerTransformObserver::OnViewLayerTransformed(
    View* observed_view) { … }

InkDropHost::InkDropHost(View* view)
    : … { … }

InkDropHost::~InkDropHost() { … }

std::unique_ptr<InkDrop> InkDropHost::CreateInkDrop() { … }

void InkDropHost::SetCreateInkDropCallback(
    base::RepeatingCallback<std::unique_ptr<InkDrop>()> callback) { … }

std::unique_ptr<InkDropRipple> InkDropHost::CreateInkDropRipple() const { … }

void InkDropHost::SetCreateRippleCallback(
    base::RepeatingCallback<std::unique_ptr<InkDropRipple>()> callback) { … }

gfx::Point InkDropHost::GetInkDropCenterBasedOnLastEvent() const { … }

std::unique_ptr<InkDropHighlight> InkDropHost::CreateInkDropHighlight() const { … }

void InkDropHost::SetCreateHighlightCallback(
    base::RepeatingCallback<std::unique_ptr<InkDropHighlight>()> callback) { … }

std::unique_ptr<views::InkDropMask> InkDropHost::CreateInkDropMask() const { … }

void InkDropHost::SetCreateMaskCallback(
    base::RepeatingCallback<std::unique_ptr<InkDropMask>()> callback) { … }

void InkDropHost::ToggleAttentionState(bool attention_on) { … }

SkColor InkDropHost::GetBaseColor() const { … }

void InkDropHost::SetBaseColor(SkColor color) { … }

void InkDropHost::SetBaseColorId(ui::ColorId color_id) { … }

void InkDropHost::SetBaseColorCallback(
    base::RepeatingCallback<SkColor()> callback) { … }

void InkDropHost::SetMode(InkDropMode ink_drop_mode) { … }

InkDropHost::InkDropMode InkDropHost::GetMode() const { … }

void InkDropHost::SetLayerRegion(LayerRegion region) { … }

LayerRegion InkDropHost::GetLayerRegion() const { … }

void InkDropHost::SetVisibleOpacity(float visible_opacity) { … }

float InkDropHost::GetVisibleOpacity() const { … }

void InkDropHost::SetHighlightOpacity(std::optional<float> opacity) { … }

void InkDropHost::SetSmallCornerRadius(int small_radius) { … }

int InkDropHost::GetSmallCornerRadius() const { … }

void InkDropHost::SetLargeCornerRadius(int large_radius) { … }

int InkDropHost::GetLargeCornerRadius() const { … }

void InkDropHost::AnimateToState(InkDropState state,
                                 const ui::LocatedEvent* event) { … }

bool InkDropHost::HasInkDrop() const { … }

InkDrop* InkDropHost::GetInkDrop() { … }

bool InkDropHost::GetHighlighted() const { … }

base::CallbackListSubscription InkDropHost::AddHighlightedChangedCallback(
    base::RepeatingClosure callback) { … }

void InkDropHost::OnInkDropHighlightedChanged() { … }

void InkDropHost::AddInkDropLayer(ui::Layer* ink_drop_layer) { … }

void InkDropHost::RemoveInkDropLayer(ui::Layer* ink_drop_layer) { … }

// static
gfx::Size InkDropHost::GetLargeSize(gfx::Size small_size) { … }

std::unique_ptr<InkDropRipple> InkDropHost::CreateSquareRipple(
    const gfx::Point& center_point,
    const gfx::Size& size) const { … }

const InkDropEventHandler* InkDropHost::GetEventHandler() const { … }

InkDropEventHandler* InkDropHost::GetEventHandler() { … }

bool InkDropHost::AddInkDropClip(ui::Layer* ink_drop_layer) { … }

void InkDropHost::InstallInkDropMask(ui::Layer* ink_drop_layer) { … }

}  // namespace views
chromium/ui/views/animation/ink_drop_host.cc
