ui_element.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 "chrome/browser/vr/elements/ui_element.h"

#include <algorithm>
#include <limits>

#include "base/check_op.h"
#include "base/containers/adapters.h"
#include "base/notreached.h"
#include "base/numerics/angle_conversions.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "chrome/browser/vr/model/camera_model.h"
#include "device/vr/vr_gl_util.h"
#include "third_party/skia/include/core/SkRRect.h"
#include "third_party/skia/include/core/SkRect.h"
#include "ui/gfx/geometry/rect_f.h"

namespace vr {

namespace {

int AllocateId() { … }

#ifndef NDEBUG
constexpr char kRed[] = …;
constexpr char kGreen[] = …;
constexpr char kBlue[] = …;
constexpr char kCyan[] = …;
constexpr char kYellow[] = …;
constexpr char kReset[] = …;

void DumpTransformOperations(const gfx::TransformOperations& ops,
                             std::ostringstream* os) { … }
#endif

}  // namespace

UiElement::UiElement() : … { … }

UiElement::~UiElement() = default;

void UiElement::SetName(UiElementName name) { … }

void UiElement::SetType(UiElementType type) { … }

void UiElement::SetDrawPhase(DrawPhase draw_phase) { … }

void UiElement::Render(UiElementRenderer* renderer,
                       const CameraModel& model) const { … }

void UiElement::Initialize(SkiaSurfaceProvider* provider) { … }

bool UiElement::DoBeginFrame(const gfx::Transform& head_pose,
                             bool force_animations_to_completion) { … }

bool UiElement::OnBeginFrame(const gfx::Transform& head_pose) { … }

bool UiElement::PrepareToDraw() { … }

bool UiElement::HasDirtyTexture() const { … }

void UiElement::UpdateTexture() { … }

void UiElement::SetSize(float width, float height) { … }

void UiElement::SetVisible(bool visible) { … }

void UiElement::SetVisibleImmediately(bool visible) { … }

bool UiElement::IsVisible() const { … }

bool UiElement::IsOrWillBeLocallyVisible() const { … }

gfx::SizeF UiElement::size() const { … }

void UiElement::SetLayoutOffset(float x, float y) { … }

void UiElement::SetTranslate(float x, float y, float z) { … }

void UiElement::SetRotate(float x, float y, float z, float radians) { … }

void UiElement::SetScale(float x, float y, float z) { … }

void UiElement::SetOpacity(float opacity) { … }

void UiElement::SetCornerRadii(const CornerRadii& radii) { … }

gfx::SizeF UiElement::GetTargetSize() const { … }

gfx::TransformOperations UiElement::GetTargetTransform() const { … }

gfx::Transform UiElement::ComputeTargetWorldSpaceTransform() const { … }

float UiElement::GetTargetOpacity() const { … }

float UiElement::ComputeTargetOpacity() const { … }

float UiElement::computed_opacity() const { … }

const gfx::Transform& UiElement::world_space_transform() const { … }

bool UiElement::IsWorldPositioned() const { … }

std::string UiElement::DebugName() const { … }

#ifndef NDEBUG
void DumpLines(const std::vector<size_t>& counts,
               const std::vector<const UiElement*>& ancestors,
               std::ostringstream* os) { … }

void UiElement::DumpHierarchy(std::vector<size_t> counts,
                              std::ostringstream* os,
                              bool include_bindings) const { … }

void UiElement::DumpGeometry(std::ostringstream* os) const { … }
#endif

void UiElement::AddChild(std::unique_ptr<UiElement> child) { … }

std::unique_ptr<UiElement> UiElement::RemoveChild(UiElement* to_remove) { … }

std::unique_ptr<UiElement> UiElement::ReplaceChild(
    UiElement* to_remove,
    std::unique_ptr<UiElement> to_add) { … }

void UiElement::AddBinding(std::unique_ptr<BindingBase> binding) { … }

void UiElement::UpdateBindings() { … }

gfx::Point3F UiElement::GetCenter() const { … }

void UiElement::OnFloatAnimated(const float& value,
                                int target_property_id,
                                gfx::KeyframeModel* keyframe_model) { … }

void UiElement::OnTransformAnimated(const gfx::TransformOperations& operations,
                                    int target_property_id,
                                    gfx::KeyframeModel* keyframe_model) { … }

void UiElement::OnSizeAnimated(const gfx::SizeF& size,
                               int target_property_id,
                               gfx::KeyframeModel* keyframe_model) { … }

void UiElement::OnColorAnimated(const SkColor& size,
                                int target_property_id,
                                gfx::KeyframeModel* keyframe_model) { … }

void UiElement::SetTransitionedProperties(
    const std::set<TargetProperty>& properties) { … }

void UiElement::AddKeyframeModel(
    std::unique_ptr<gfx::KeyframeModel> keyframe_model) { … }

void UiElement::RemoveKeyframeModels(int target_property) { … }

bool UiElement::IsAnimatingProperty(TargetProperty property) const { … }

bool UiElement::SizeAndLayOut() { … }

bool UiElement::SizeAndLayOutChildren() { … }

gfx::RectF UiElement::ComputeContributingChildrenBounds() { … }

void UiElement::LayOutContributingChildren() { … }

void UiElement::LayOutNonContributingChildren() { … }

gfx::RectF UiElement::GetClipRect() const { … }

void UiElement::SetClipRect(const gfx::RectF& rect) { … }

void UiElement::UpdateComputedOpacity() { … }

bool UiElement::UpdateWorldSpaceTransform(bool parent_changed) { … }

gfx::Transform UiElement::LocalTransform() const { … }

gfx::Transform UiElement::GetTargetLocalTransform() const { … }

bool UiElement::ShouldUpdateWorldSpaceTransform(
    bool parent_transform_changed) const { … }

}  // namespace vr
chromium/chrome/browser/vr/elements/ui_element.cc
