chromium/ui/views/layout/normalized_geometry.cc

// Copyright 2018 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/layout/normalized_geometry.h"

#include <algorithm>
#include <tuple>
#include <utility>

#include "base/strings/strcat.h"
#include "base/strings/stringprintf.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/views/layout/flex_layout_types.h"

namespace views {

// NormalizedPoint -------------------------------------------------------------

void NormalizedPoint::SetPoint(int main, int cross) {}

void NormalizedPoint::Offset(int delta_main, int delta_cross) {}

bool NormalizedPoint::operator==(const NormalizedPoint& other) const {}

bool NormalizedPoint::operator!=(const NormalizedPoint& other) const {}

bool NormalizedPoint::operator<(const NormalizedPoint& other) const {}

std::string NormalizedPoint::ToString() const {}

// NormalizedSize --------------------------------------------------------------

void NormalizedSize::SetSize(int main, int cross) {}

void NormalizedSize::Enlarge(int delta_main, int delta_cross) {}

void NormalizedSize::SetToMax(int main, int cross) {}

void NormalizedSize::SetToMin(int main, int cross) {}

void NormalizedSize::SetToMax(const NormalizedSize& other) {}

void NormalizedSize::SetToMin(const NormalizedSize& other) {}

bool NormalizedSize::operator==(const NormalizedSize& other) const {}

bool NormalizedSize::operator!=(const NormalizedSize& other) const {}

bool NormalizedSize::operator<(const NormalizedSize& other) const {}

std::string NormalizedSize::ToString() const {}

// NormalizedInsets ------------------------------------------------------------

bool NormalizedInsets::operator==(const NormalizedInsets& other) const {}

bool NormalizedInsets::operator!=(const NormalizedInsets& other) const {}

bool NormalizedInsets::operator<(const NormalizedInsets& other) const {}

std::string NormalizedInsets::ToString() const {}

// NormalizedSizeBounds --------------------------------------------------------

NormalizedSizeBounds::NormalizedSizeBounds() = default;

NormalizedSizeBounds::NormalizedSizeBounds(SizeBound main, SizeBound cross)
    :{}

NormalizedSizeBounds::NormalizedSizeBounds(const NormalizedSizeBounds& other)
    :{}

NormalizedSizeBounds::NormalizedSizeBounds(const NormalizedSize& other)
    :{}

void NormalizedSizeBounds::Expand(int main, int cross) {}

void NormalizedSizeBounds::Inset(const NormalizedInsets& insets) {}

bool NormalizedSizeBounds::operator==(const NormalizedSizeBounds& other) const {}

bool NormalizedSizeBounds::operator!=(const NormalizedSizeBounds& other) const {}

bool NormalizedSizeBounds::operator<(const NormalizedSizeBounds& other) const {}

std::string NormalizedSizeBounds::ToString() const {}

// NormalizedRect --------------------------------------------------------------

Span NormalizedRect::GetMainSpan() const {}

void NormalizedRect::SetMainSpan(const Span& span) {}

void NormalizedRect::AlignMain(const Span& container,
                               LayoutAlignment alignment,
                               const Inset1D& margins) {}

Span NormalizedRect::GetCrossSpan() const {}

void NormalizedRect::SetCrossSpan(const Span& span) {}

void NormalizedRect::AlignCross(const Span& container,
                                LayoutAlignment alignment,
                                const Inset1D& margins) {}

void NormalizedRect::SetRect(int origin_main,
                             int origin_cross,
                             int size_main,
                             int size_cross) {}

void NormalizedRect::SetByBounds(int origin_main,
                                 int origin_cross,
                                 int max_main,
                                 int max_cross) {}

void NormalizedRect::Inset(const NormalizedInsets& insets) {}

void NormalizedRect::Inset(int main, int cross) {}

void NormalizedRect::Inset(int main_leading,
                           int cross_leading,
                           int main_trailing,
                           int cross_trailing) {}

void NormalizedRect::Offset(int main, int cross) {}

bool NormalizedRect::operator==(const NormalizedRect& other) const {}

bool NormalizedRect::operator!=(const NormalizedRect& other) const {}

bool NormalizedRect::operator<(const NormalizedRect& other) const {}

std::string NormalizedRect::ToString() const {}

// Normalization and Denormalization -------------------------------------------

NormalizedPoint Normalize(LayoutOrientation orientation,
                          const gfx::Point& point) {}

gfx::Point Denormalize(LayoutOrientation orientation,
                       const NormalizedPoint& point) {}

NormalizedSize Normalize(LayoutOrientation orientation, const gfx::Size& size) {}

gfx::Size Denormalize(LayoutOrientation orientation,
                      const NormalizedSize& size) {}

NormalizedSizeBounds Normalize(LayoutOrientation orientation,
                               const SizeBounds& bounds) {}

SizeBounds Denormalize(LayoutOrientation orientation,
                       const NormalizedSizeBounds& bounds) {}

NormalizedInsets Normalize(LayoutOrientation orientation,
                           const gfx::Insets& insets) {}

gfx::Insets Denormalize(LayoutOrientation orientation,
                        const NormalizedInsets& insets) {}

NormalizedRect Normalize(LayoutOrientation orientation,
                         const gfx::Rect& bounds) {}

gfx::Rect Denormalize(LayoutOrientation orientation,
                      const NormalizedRect& bounds) {}

int GetMainAxis(LayoutOrientation orientation, const gfx::Size& size) {}

int GetCrossAxis(LayoutOrientation orientation, const gfx::Size& size) {}

SizeBound GetMainAxis(LayoutOrientation orientation, const SizeBounds& size) {}

SizeBound GetCrossAxis(LayoutOrientation orientation, const SizeBounds& size) {}

void SetMainAxis(gfx::Size* size, LayoutOrientation orientation, int main) {}

void SetCrossAxis(gfx::Size* size, LayoutOrientation orientation, int cross) {}

void SetMainAxis(SizeBounds* size,
                 LayoutOrientation orientation,
                 SizeBound main) {}

void SetCrossAxis(SizeBounds* size,
                  LayoutOrientation orientation,
                  SizeBound cross) {}

}  // namespace views