window_util.cc | Explore in Territory

// Copyright 2012 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/wm/core/window_util.h"

#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/window.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_tree_owner.h"
#include "ui/display/screen.h"
#include "ui/display/types/display_constants.h"
#include "ui/wm/core/transient_window_manager.h"
#include "ui/wm/core/window_properties.h"
#include "ui/wm/public/activation_client.h"

namespace {

// Invokes |map_func| on all the children of |to_clone|, adding the newly
// cloned children to |parent|. If |map_func| returns nullptr on
// the layer owner, all its layer's children will not be cloned.
//
// WARNING: It is assumed that |parent| is ultimately owned by a LayerTreeOwner.
void CloneChildren(ui::Layer* to_clone,
                   ui::Layer* parent,
                   const wm::MapLayerFunc& map_func) { … }

// Invokes Mirror() on all the children of |to_mirror|, adding the newly cloned
// children to |parent|.
//
// WARNING: It is assumed that |parent| is ultimately owned by a LayerTreeOwner.
void MirrorChildren(ui::Layer* to_mirror,
                    ui::Layer* parent,
                    bool sync_bounds) { … }

}  // namespace

namespace wm {

void ActivateWindow(aura::Window* window) { … }

void DeactivateWindow(aura::Window* window) { … }

bool IsActiveWindow(const aura::Window* window) { … }

bool CanActivateWindow(const aura::Window* window) { … }

void SetWindowFullscreen(aura::Window* window,
                         bool fullscreen,
                         int64_t target_display_id) { … }

bool WindowStateIs(const aura::Window* window, ui::WindowShowState state) { … }

ui::WindowShowState GetWindowState(const aura::Window* window) { … }

void SetWindowState(aura::Window* window, ui::WindowShowState state) { … }

void Restore(aura::Window* window) { … }

void Unminimize(aura::Window* window) { … }

aura::Window* GetActivatableWindow(aura::Window* window) { … }

aura::Window* GetToplevelWindow(aura::Window* window) { … }

const aura::Window* GetToplevelWindow(const aura::Window* window) { … }

std::unique_ptr<ui::LayerTreeOwner> RecreateLayers(ui::LayerOwner* root) { … }

std::unique_ptr<ui::LayerTreeOwner> RecreateLayersWithClosure(
    ui::LayerOwner* root,
    const MapLayerFunc& map_func) { … }

std::unique_ptr<ui::LayerTreeOwner> MirrorLayers(
    ui::LayerOwner* root, bool sync_bounds) { … }

aura::Window* GetTransientParent(aura::Window* window) { … }

const aura::Window* GetTransientParent(const aura::Window* window) { … }

const std::vector<raw_ptr<aura::Window, VectorExperimental>>&
GetTransientChildren(const aura::Window* window) { … }

aura::Window* GetTransientRoot(aura::Window* window) { … }

void AddTransientChild(aura::Window* parent, aura::Window* child) { … }

void RemoveTransientChild(aura::Window* parent, aura::Window* child) { … }

bool HasTransientAncestor(const aura::Window* window,
                          const aura::Window* ancestor) { … }

}  // namespace wm
chromium/ui/wm/core/window_util.cc
