123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825 |
- // Copyright (c) 2012 The Chromium Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
- // found in the LICENSE file.
- #ifndef UI_AURA_WINDOW_H_
- #define UI_AURA_WINDOW_H_
- #include <stdint.h>
- #include <map>
- #include <memory>
- #include <set>
- #include <string>
- #include <vector>
- #include "base/check.h"
- #include "base/containers/flat_set.h"
- #include "base/memory/raw_ptr.h"
- #include "base/memory/weak_ptr.h"
- #include "base/observer_list.h"
- #include "base/time/time.h"
- #include "build/build_config.h"
- #include "components/viz/common/surfaces/frame_sink_id.h"
- #include "components/viz/common/surfaces/local_surface_id.h"
- #include "components/viz/common/surfaces/scoped_surface_id_allocator.h"
- #include "components/viz/common/surfaces/subtree_capture_id.h"
- #include "components/viz/host/host_frame_sink_client.h"
- #include "third_party/abseil-cpp/absl/types/optional.h"
- #include "third_party/skia/include/core/SkRegion.h"
- #include "ui/aura/aura_export.h"
- #include "ui/aura/client/window_types.h"
- #include "ui/aura/scoped_window_capture_request.h"
- #include "ui/aura/window_observer.h"
- #include "ui/base/class_property.h"
- #include "ui/base/metadata/metadata_header_macros.h"
- #include "ui/compositor/layer_delegate.h"
- #include "ui/compositor/layer_owner.h"
- #include "ui/compositor/layer_type.h"
- #include "ui/events/event_constants.h"
- #include "ui/events/event_target.h"
- #include "ui/events/event_targeter.h"
- #include "ui/events/gestures/gesture_types.h"
- #include "ui/gfx/geometry/rect.h"
- #include "ui/gfx/native_widget_types.h"
- #if BUILDFLAG(IS_APPLE)
- #error "This file must not be included on macOS; Chromium Mac doesn't use Aura."
- #endif
- namespace cc {
- class LayerTreeFrameSink;
- }
- namespace display {
- class Display;
- }
- namespace gfx {
- class Transform;
- }
- namespace ui {
- enum class DomCode;
- class Layer;
- } // namespace ui
- namespace viz {
- class ParentLocalSurfaceIdAllocator;
- class SurfaceId;
- }
- namespace aura {
- class LayoutManager;
- class ScopedKeyboardHook;
- class ScopedWindowEventTargetingBlocker;
- class WindowDelegate;
- class WindowTargeter;
- class WindowTreeHost;
- // Defined in class_property.h (which we do not include)
- template <typename T>
- using WindowProperty = ui::ClassProperty<T>;
- namespace test {
- class WindowTestApi;
- }
- enum class EventTargetingPolicy {
- // The target is a valid target for events, but none of its descendants are
- // considered.
- kTargetOnly,
- // The target and its descendants are possible targets. This is the default.
- kTargetAndDescendants,
- // The target is not a valid target, but its descendants are possible targets.
- kDescendantsOnly,
- // Neither the target nor its descendants are valid targets.
- kNone
- };
- // Aura window implementation. Interesting events are sent to the
- // WindowDelegate.
- class AURA_EXPORT Window : public ui::LayerDelegate,
- public ui::LayerOwner,
- public ui::EventTarget,
- public ui::GestureConsumer,
- public ui::PropertyHandler,
- public ui::metadata::MetaDataProvider,
- public viz::HostFrameSinkClient {
- public:
- METADATA_HEADER_BASE(Window);
- // Initial value of id() for newly created windows.
- static constexpr int kInitialId = -1;
- // Used when stacking windows.
- enum StackDirection { STACK_ABOVE, STACK_BELOW };
- // These values are persisted to logs. Entries should not be renumbered and
- // numeric values should never be reused.
- enum class OcclusionState {
- // The window's occlusion state isn't tracked (Window::TrackOcclusionState)
- // or hasn't been computed yet.
- UNKNOWN = 0,
- // The window or one of its descendants IsVisible() [1] and:
- // - Its bounds aren't completely covered by fully opaque windows [2], or,
- // - Its transform, bounds or opacity is animated.
- VISIBLE = 1,
- // The window or one of its descendants IsVisible() [1], but they all:
- // - Have bounds completely covered by fully opaque windows [2], and,
- // - Have no transform, bounds or opacity animation.
- OCCLUDED = 2,
- // The window is not IsVisible() [1].
- HIDDEN = 3,
- // [1] A window can only be IsVisible() if all its parent are IsVisible().
- // [2] A window is "fully opaque" if:
- // - It's visible (IsVisible()).
- // - It's not transparent (transparent()).
- // - It's transform, bounds and opacity aren't animated.
- // - Its combined opacity is 1 (GetCombinedOpacity()).
- // - It has content to draw. Either the type of its layer is not
- // ui::LAYER_NOT_DRAWN, or it is a server window hosting remote client
- // content in Window Service.
- //
- // TODO(fdoray): A window that clips its children shouldn't be VISIBLE just
- // because it has an animated child.
- kMaxValue = HIDDEN,
- };
- using Windows = std::vector<Window*>;
- explicit Window(WindowDelegate* delegate,
- client::WindowType type = client::WINDOW_TYPE_UNKNOWN);
- Window(const Window&) = delete;
- Window& operator=(const Window&) = delete;
- ~Window() override;
- // Initializes the window. This creates the window's layer.
- void Init(ui::LayerType layer_type);
- bool is_destroying() const { return is_destroying_; }
- void set_owned_by_parent(bool owned_by_parent) {
- owned_by_parent_ = owned_by_parent;
- }
- bool owned_by_parent() const { return owned_by_parent_; }
- // A type is used to identify a class of Windows and customize behavior such
- // as event handling and parenting. This field should only be consumed by the
- // shell -- Aura itself shouldn't contain type-specific logic.
- client::WindowType GetType() const;
- void SetType(client::WindowType type);
- int GetId() const;
- void SetId(int id);
- // ui::GestureConsumer:
- const std::string& GetName() const override;
- void SetName(const std::string& name);
- const std::u16string& GetTitle() const;
- void SetTitle(const std::u16string& title);
- bool GetTransparent() const;
- // Note: Setting a window transparent has significant performance impact,
- // especially on low-end Chrome OS devices. Please ensure you are not
- // adding unnecessary overdraw. When in doubt, talk to the graphics team.
- void SetTransparent(bool transparent);
- // See description in Layer::SetFillsBoundsCompletely.
- void SetFillsBoundsCompletely(bool fills_bounds);
- WindowDelegate* delegate() { return delegate_; }
- const WindowDelegate* delegate() const { return delegate_; }
- const gfx::Rect& bounds() const { return bounds_; }
- Window* parent() { return parent_; }
- const Window* parent() const { return parent_; }
- // Returns the root Window that contains this Window. The root Window is
- // defined as the Window that has a dispatcher. These functions return nullptr
- // if the Window is contained in a hierarchy that does not have a dispatcher
- // at its root.
- Window* GetRootWindow();
- const Window* GetRootWindow() const;
- WindowTreeHost* GetHost();
- const WindowTreeHost* GetHost() const;
- void set_host(WindowTreeHost* host) { host_ = host; }
- bool IsRootWindow() const { return !!host_; }
- // Changes the visibility of the window.
- void Show();
- void Hide();
- // Returns true if this window and all its ancestors are visible.
- bool IsVisible() const;
- // Returns the visibility requested by this window. IsVisible() takes into
- // account the visibility of the layer and ancestors, where as this tracks
- // whether Show() without a Hide() has been invoked.
- bool TargetVisibility() const { return visible_; }
- // Returns the occlusion state of this window. Is UNKNOWN if the occlusion
- // state of this window isn't tracked (Window::TrackOcclusionState) or
- // hasn't been computed yet. Is stale if called within the scope of a
- // WindowOcclusionTracker::ScopedPause.
- OcclusionState GetOcclusionState() const;
- // Returns the currently occluded region in the root Window coordinates. This
- // will be empty unless the window is tracked and has a VISIBLE occlusion
- // state. That is, this is only maintained when the window is partially
- // occluded. Further, this region may extend outside the window bounds. For
- // performance reasons, the actual intersection with the window is not
- // computed. The occluded region is the set of window rectangles that may
- // occlude this window. Note that this means that the occluded region may be
- // updated if one of those windows moves, even if the actual intersection of
- // the occluded region with this window does not change. Clients may compute
- // the actual intersection region if necessary.
- const SkRegion& occluded_region_in_root() const {
- return occluded_region_in_root_;
- }
- // Makes this *non-root* window individually capturable by the
- // |FrameSinkVideoCapturer| by tagging its layer with a unique
- // |viz::SubtreeCaptureId| which will force the layer tree root at this
- // window's layer to a render surface that draws into a render pass that is
- // identifiable by the capturer using that ID.
- //
- // Note that this should only be called for non-root windows. Root windows are
- // already capturable by the capturer as they're identifiable by their
- // |viz::FrameSinkId| and thei associated root render pass, so there's no need
- // to call this.
- //
- // This returns a scoped object associated with this request to make the
- // window capturable, since multiple capturers can capture the same window at
- // the same time. Once all requests are destroyed, this window will no longer
- // be individually capturable, and its layer won't be tagged with a valid
- // |viz::SubtreeCaptureId|.
- // See https://crbug.com/1143930 for more details.
- [[nodiscard]] ScopedWindowCaptureRequest MakeWindowCapturable();
- const viz::SubtreeCaptureId& subtree_capture_id() const {
- return subtree_capture_id_;
- }
- // Returns the window's bounds in root window's coordinates. The returned
- // value is calculated using the target transform. The target transform is the
- // end value of a transform animation. If there is no animation ongoing, the
- // target transform is the same as the current transform.
- gfx::Rect GetBoundsInRootWindow() const;
- // Similar to `GetBoundsInRootWindow()` except that the returned value is
- // calculated using the current transform. If there is no animation ongoing,
- // this function returns the same value as `GetBoundsInRootWindow()`.
- gfx::Rect GetActualBoundsInRootWindow() const;
- // Returns the window's bounds in screen coordinates. The returned
- // value is calculated using the target transform. The target transform is the
- // end value of a transform animation. If there is no animation ongoing, the
- // target transform is the same as the current transform.
- // How the root window's coordinates is mapped to screen's coordinates
- // is platform dependent and defined in the implementation of the
- // |aura::client::ScreenPositionClient| interface.
- gfx::Rect GetBoundsInScreen() const;
- // Similar to `GetBoundsInScreen()` except that the returned value is
- // calculated using the current transform. If there is no animation ongoing,
- // this function returns the same value as `GetBoundsInScreen()`.
- gfx::Rect GetActualBoundsInScreen() const;
- void SetTransform(const gfx::Transform& transform);
- const gfx::Transform& transform() const;
- // Assigns a LayoutManager to size and place child windows.
- // The Window takes ownership of the LayoutManager.
- void SetLayoutManager(LayoutManager* layout_manager);
- LayoutManager* layout_manager() { return layout_manager_.get(); }
- // Sets a new event-targeter for the window, and returns the previous
- // event-targeter.
- std::unique_ptr<WindowTargeter> SetEventTargeter(
- std::unique_ptr<WindowTargeter> targeter);
- WindowTargeter* targeter() { return targeter_.get(); }
- const WindowTargeter* targeter() const { return targeter_.get(); }
- // Changes the bounds of the window. If present, the window's parent's
- // LayoutManager may adjust the bounds.
- void SetBounds(const gfx::Rect& new_bounds);
- // Changes the bounds of the window in the screen coordinates.
- // If present, the window's parent's LayoutManager may adjust the bounds.
- void SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen_coords,
- const display::Display& dst_display);
- // Returns the target bounds of the window. If the window's layer is
- // not animating, it simply returns the current bounds.
- gfx::Rect GetTargetBounds() const;
- // Forwards directly to the layer. See Layer::ScheduleDraw() for details.
- void ScheduleDraw();
- // Marks the a portion of window as needing to be painted.
- void SchedulePaintInRect(const gfx::Rect& rect);
- // Stacks the specified child of this Window at the front of the z-order.
- void StackChildAtTop(Window* child);
- // Stacks |child| above |target|. Does nothing if |child| is already above
- // |target|. Does not stack on top of windows with nullptr layer delegates,
- // see WindowTest.StackingMadrigal for details.
- void StackChildAbove(Window* child, Window* target);
- // Stacks the specified child of this window at the bottom of the z-order.
- void StackChildAtBottom(Window* child);
- // Stacks |child| below |target|. Does nothing if |child| is already below
- // |target|.
- void StackChildBelow(Window* child, Window* target);
- // Tree operations.
- void AddChild(Window* child);
- void RemoveChild(Window* child);
- const Windows& children() const { return children_; }
- // Returns true if this Window contains |other| somewhere in its children.
- bool Contains(const Window* other) const;
- // Retrieves the first-level child with the specified id, or nullptr if no
- // first- level child is found matching |id|.
- Window* GetChildById(int id);
- const Window* GetChildById(int id) const;
- // Converts |point| from |source|'s coordinates to |target|'s. If |source| is
- // nullptr, the function returns without modifying |point|. |target| cannot be
- // nullptr. Use layers' target transform in coordinate conversions. The target
- // transform is the end value of a transform animation. If there is no
- // animation ongoing, the target transform is the same as the current
- // transform.
- static void ConvertPointToTarget(const Window* source,
- const Window* target,
- gfx::PointF* point);
- static void ConvertPointToTarget(const Window* source,
- const Window* target,
- gfx::Point* point);
- static void ConvertRectToTarget(const Window* source,
- const Window* target,
- gfx::Rect* rect);
- // Convert the native |point| in pixels to the target's host's coordiantes if
- // source and target have different hosts.
- static void ConvertNativePointToTargetHost(const Window* source,
- const Window* target,
- gfx::PointF* point);
- static void ConvertNativePointToTargetHost(const Window* source,
- const Window* target,
- gfx::Point* point);
- // Moves the cursor to the specified location relative to the window.
- void MoveCursorTo(const gfx::Point& point_in_window);
- // Returns the cursor for the specified point, in window coordinates.
- gfx::NativeCursor GetCursor(const gfx::Point& point) const;
- // Add/remove observer.
- void AddObserver(WindowObserver* observer);
- void RemoveObserver(WindowObserver* observer);
- bool HasObserver(const WindowObserver* observer) const;
- void SetEventTargetingPolicy(EventTargetingPolicy policy);
- EventTargetingPolicy event_targeting_policy() const {
- return event_targeting_policy_;
- }
- // Returns true if the |point_in_root| in root window's coordinate falls
- // within this window's bounds. Returns false if the window is detached
- // from root window.
- bool ContainsPointInRoot(const gfx::Point& point_in_root) const;
- // Returns true if relative-to-this-Window's-origin |local_point| falls
- // within this Window's bounds.
- bool ContainsPoint(const gfx::Point& local_point) const;
- // Returns the Window that most closely encloses |local_point| for the
- // purposes of event targeting.
- Window* GetEventHandlerForPoint(const gfx::Point& local_point);
- // Returns this window's toplevel window (the highest-up-the-tree ancestor
- // that has a delegate set). The toplevel window may be |this|.
- Window* GetToplevelWindow();
- // Claims focus.
- void Focus();
- // Returns true if the Window is currently the focused window.
- bool HasFocus() const;
- // Returns true if the Window can be focused.
- bool CanFocus() const;
- // Does a capture on the window. This does nothing if the window isn't showing
- // (VISIBILITY_SHOWN) or isn't contained in a valid window hierarchy.
- void SetCapture();
- // Releases a capture.
- void ReleaseCapture();
- // Returns true if this window has capture.
- bool HasCapture();
- // Requests that |keys| be intercepted at the platform level and routed
- // directly to the web content. If |codes| has no value, all keys will be
- // intercepted. Returns a ScopedKeyboardHook instance which stops capturing
- // system key events when destroyed.
- std::unique_ptr<ScopedKeyboardHook> CaptureSystemKeyEvents(
- absl::optional<base::flat_set<ui::DomCode>> codes);
- // NativeWidget::[GS]etNativeWindowProperty use strings as keys, and this is
- // difficult to change while retaining compatibility with other platforms.
- // TODO(benrg): Find a better solution.
- void SetNativeWindowProperty(const char* key, void* value);
- void* GetNativeWindowProperty(const char* key) const;
- // Type of a function to delete a property that this window owns.
- // typedef void (*PropertyDeallocator)(int64_t value);
- // Overridden from ui::LayerDelegate:
- void OnDeviceScaleFactorChanged(float old_device_scale_factor,
- float new_device_scale_factor) override;
- void UpdateVisualState() override;
- // ui::LayerOwner:
- std::unique_ptr<ui::Layer> ReleaseLayer() override;
- std::unique_ptr<ui::Layer> RecreateLayer() override;
- void SetLayer(std::unique_ptr<ui::Layer> layer) override;
- #if DCHECK_IS_ON()
- // These methods are useful when debugging.
- std::string GetDebugInfo() const;
- std::string GetWindowHierarchy(int depth) const;
- void PrintWindowHierarchy(int depth) const;
- #endif
- // Returns true if there was state needing to be cleaned up.
- bool CleanupGestureState();
- // Create a LayerTreeFrameSink for the aura::Window.
- std::unique_ptr<cc::LayerTreeFrameSink> CreateLayerTreeFrameSink();
- // Gets the current viz::SurfaceId.
- viz::SurfaceId GetSurfaceId();
- // Forces the window to allocate a new viz::LocalSurfaceId for the next
- // CompositorFrame submission in anticipation of a synchronization operation
- // that does not involve a resize or a device scale factor change.
- void AllocateLocalSurfaceId();
- viz::ScopedSurfaceIdAllocator GetSurfaceIdAllocator(
- base::OnceCallback<void()> allocation_task);
- const viz::LocalSurfaceId& GetLocalSurfaceId();
- // Marks the current viz::LocalSurfaceId as invalid. AllocateLocalSurfaceId
- // must be called before submitting new CompositorFrames.
- void InvalidateLocalSurfaceId();
- // Sets the current viz::LocalSurfaceId, in cases where the embedded client
- // has allocated one. Also sets child sequence number component of the
- // viz::LocalSurfaceId allocator.
- void UpdateLocalSurfaceIdFromEmbeddedClient(
- const absl::optional<viz::LocalSurfaceId>& local_surface_id);
- // Returns the FrameSinkId. In LOCAL mode, this returns a valid FrameSinkId
- // only if a LayerTreeFrameSink has been created. In MUS mode, this always
- // return a valid FrameSinkId.
- const viz::FrameSinkId& GetFrameSinkId() const;
- // Use SetEmbedFrameSinkId() when this window is embedding another client.
- // See comment for |frame_sink_id_| below for more details.
- void SetEmbedFrameSinkId(const viz::FrameSinkId& embed_frame_sink_id);
- // Starts occlusion state tracking.
- void TrackOcclusionState();
- // Notifies observers of the state of a resize loop.
- void NotifyResizeLoopStarted();
- void NotifyResizeLoopEnded();
- // ui::GestureConsumer:
- bool RequiresDoubleTapGestureEvents() const override;
- // Returns |state| as a string. This is generally only useful for debugging.
- static const std::u16string OcclusionStateToString(OcclusionState state);
- // Sets the regions of this window to consider opaque when computing the
- // occlusion of underneath windows. Opaque regions can only be set for a
- // transparent() window, and cannot extend outside of the window bounds.
- // Opaque regions are relative to the window, i.e. the top-left corner of the
- // window is considered to be the point (0, 0). If
- // |opaque_regions_for_occlusion| is empty, the window is considered fully
- // transparent. Opaque regions do not affect what parts of the window are
- // visible; they only affect occlusion tracking of underneath windows. An
- // example use case for this is when a window is made transparent because of
- // rounded corners, and therefore does not contribute to occlusion. But,
- // almost all of that window could be opaque and we would want it to
- // contribute to occlusion. Occlusion tracking can affect rendering, page
- // behaviour, and triggering for Picture-in-picture, for example. Clients
- // should set the opaque regions for occlusion if they have transparent
- // regions, but want to specify that certain areas of them are completely
- // opaque. Clients that use the window shape API should also specify their
- // shape region as a region for occlusion, if it is opaque. The opaque regions
- // for occlusion for a window do not affect occlusion for that window itself,
- // only what parts of other windows that window occludes.
- // TODO: Currently, we only support one Rect in
- // |opaque_regions_for_occlusion|. Supporting multiple Rects will
- // enable window shape based occlusion.
- void SetOpaqueRegionsForOcclusion(
- const std::vector<gfx::Rect>& opaque_regions_for_occlusion);
- const std::vector<gfx::Rect>& opaque_regions_for_occlusion() const {
- return opaque_regions_for_occlusion_;
- }
- protected:
- // Deletes (or removes if not owned by parent) all child windows. Intended for
- // use from the destructor.
- void RemoveOrDestroyChildren();
- // Overrides from ui::PropertyHandler
- void AfterPropertyChange(const void* key, int64_t old_value) override;
- private:
- friend class DefaultWindowOcclusionChangeBuilder;
- friend class HitTestDataProviderAura;
- friend class LayoutManager;
- friend class PropertyConverter;
- friend class ScopedWindowCaptureRequest;
- friend class ScopedWindowEventTargetingBlocker;
- friend class WindowTargeter;
- friend class test::WindowTestApi;
- // Handles registering FrameSinkId hierarchy for SetEmbedFrameSinkId() and
- // CreateLayerTreeFrameSink().
- void SetEmbedFrameSinkIdImpl(const viz::FrameSinkId& frame_sink_id);
- // Returns true if the mouse pointer at relative-to-this-Window's-origin
- // |local_point| can trigger an event for this Window.
- // TODO(beng): A Window can supply a hit-test mask to cause some portions of
- // itself to not trigger events, causing the events to fall through to the
- // Window behind.
- bool HitTest(const gfx::Point& local_point);
- // Changes the bounds of the window without condition.
- void SetBoundsInternal(const gfx::Rect& new_bounds);
- // Updates the visible state of the layer and the Window, but does not make
- // visible-state specific changes. Called from Show()/Hide().
- void SetVisibleInternal(bool visible);
- // Updates the occlusion info of the window.
- void SetOcclusionInfo(OcclusionState occlusion_state,
- const SkRegion& occluded_region);
- // Schedules a paint for the Window's entire bounds.
- void SchedulePaint();
- // Asks the delegate to paint the window.
- void Paint(const ui::PaintContext& context);
- // Implementation of RemoveChild(). If |child| is being removed as the result
- // of an add, |new_parent| is the new parent |child| is going to be parented
- // to.
- void RemoveChildImpl(Window* child, Window* new_parent);
- // Called when this window's parent has changed.
- void OnParentChanged();
- // The various stacking functions call into this to do the actual stacking.
- void StackChildRelativeTo(Window* child,
- Window* target,
- StackDirection direction);
- // Invoked from StackChildRelativeTo() to stack the layers appropriately
- // when stacking |child| relative to |target|.
- void StackChildLayerRelativeTo(Window* child,
- Window* target,
- StackDirection direction);
- // Called when this window's stacking order among its siblings is changed.
- void OnStackingChanged();
- // Notifies observers registered with this Window (and its subtree) when the
- // Window has been added or is about to be removed from a RootWindow.
- void NotifyRemovingFromRootWindow(Window* new_root);
- void NotifyAddedToRootWindow();
- // Methods implementing hierarchy change notifications. See WindowObserver for
- // more details.
- void NotifyWindowHierarchyChange(
- const WindowObserver::HierarchyChangeParams& params);
- // Notifies this window and its child hierarchy.
- void NotifyWindowHierarchyChangeDown(
- const WindowObserver::HierarchyChangeParams& params);
- // Notifies this window and its parent hierarchy.
- void NotifyWindowHierarchyChangeUp(
- const WindowObserver::HierarchyChangeParams& params);
- // Notifies this window's observers.
- void NotifyWindowHierarchyChangeAtReceiver(
- const WindowObserver::HierarchyChangeParams& params);
- // Methods implementing visibility change notifications. See WindowObserver
- // for more details.
- void NotifyWindowVisibilityChanged(aura::Window* target, bool visible);
- // Notifies this window's observers. Returns false if |this| was deleted
- // during the call (by an observer), otherwise true.
- bool NotifyWindowVisibilityChangedAtReceiver(aura::Window* target,
- bool visible);
- // Notifies this window and its child hierarchy. Returns false if
- // |this| was deleted during the call (by an observer), otherwise
- // true.
- bool NotifyWindowVisibilityChangedDown(aura::Window* target, bool visible);
- // Notifies this window and its parent hierarchy.
- void NotifyWindowVisibilityChangedUp(aura::Window* target, bool visible);
- // Overridden from ui::LayerDelegate:
- void OnPaintLayer(const ui::PaintContext& context) override;
- void OnLayerBoundsChanged(const gfx::Rect& old_bounds,
- ui::PropertyChangeReason reason) override;
- void OnLayerTransformed(const gfx::Transform& old_transform,
- ui::PropertyChangeReason reason) override;
- void OnLayerOpacityChanged(ui::PropertyChangeReason reason) override;
- void OnLayerAlphaShapeChanged() override;
- void OnLayerFillsBoundsOpaquelyChanged(
- ui::PropertyChangeReason reason) override;
- // Overridden from ui::EventTarget:
- bool CanAcceptEvent(const ui::Event& event) override;
- EventTarget* GetParentTarget() override;
- std::unique_ptr<ui::EventTargetIterator> GetChildIterator() const override;
- ui::EventTargeter* GetEventTargeter() override;
- void ConvertEventToTarget(const ui::EventTarget* target,
- ui::LocatedEvent* event) const override;
- gfx::PointF GetScreenLocationF(const ui::LocatedEvent& event) const override;
- // viz::HostFrameSinkClient:
- void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;
- void OnFrameTokenChanged(uint32_t frame_token,
- base::TimeTicks activation_time) override;
- // Updates the layer name based on the window's name and id.
- void UpdateLayerName();
- void RegisterFrameSinkId();
- void UnregisterFrameSinkId();
- void UpdateLocalSurfaceId();
- const viz::LocalSurfaceId& GetCurrentLocalSurfaceId() const;
- bool IsEmbeddingExternalContent() const;
- // Called by the constructor of ScopedWindowCaptureRequest to add a request to
- // make this non-root window capturable by the FrameSinkVideoCapturer.
- void OnScopedWindowCaptureRequestAdded();
- // Called by the destructor of ScopedWindowCaptureRequest to remove a request
- // to make this non-root window capturable by the FrameSinkVideoCapturer.
- void OnScopedWindowCaptureRequestRemoved();
- // The following are intended for use by the metadata to access the internals
- // of instances of this class. At some point they should be moved to the
- // public section and code refactored to use them.
- // Break out the separate elements of the Window bounds.
- int GetHeight() const;
- int GetWidth() const;
- int GetX() const;
- int GetY() const;
- void SetHeight(int height);
- void SetWidth(int width);
- void SetX(int x);
- void SetY(int y);
- bool GetCapture() const;
- viz::SurfaceId GetSurfaceId() const;
- bool GetVisible() const;
- void SetVisible(bool visible);
- // Bounds of this window relative to the parent. This is cached as the bounds
- // of the Layer and Window are not necessarily the same. In particular bounds
- // of the Layer are relative to the first ancestor with a Layer, where as this
- // is relative to the parent Window.
- gfx::Rect bounds_;
- raw_ptr<WindowTreeHost> host_ = nullptr;
- client::WindowType type_;
- // True if this window is being destroyed.
- bool is_destroying_ = false;
- // True if the Window is owned by its parent - i.e. it will be deleted by its
- // parent during its parents destruction.
- bool owned_by_parent_ = true;
- raw_ptr<WindowDelegate, DanglingUntriaged> delegate_;
- // The Window's parent.
- raw_ptr<Window> parent_ = nullptr;
- // Child windows. Topmost is last.
- Windows children_;
- // The visibility state of the window as set by Show()/Hide(). This may differ
- // from the visibility of the underlying layer, which may remain visible after
- // the window is hidden (e.g. to animate its disappearance).
- bool visible_ = false;
- // Occlusion state of the window.
- OcclusionState occlusion_state_ = OcclusionState::UNKNOWN;
- // Occluded region of the window in the root window coordiantes.
- SkRegion occluded_region_in_root_;
- int id_ = kInitialId;
- // Whether layer is initialized as non-opaque. Defaults to false.
- bool transparent_ = false;
- // Whether it's in a process of CleanupGestureState() or not.
- bool cleaning_up_gesture_state_ = false;
- std::unique_ptr<LayoutManager> layout_manager_;
- std::unique_ptr<WindowTargeter> targeter_;
- // The opaque regions for occlusion for this window. See comment on
- // |SetOpaqueRegionsForOcclusion| for documentation.
- std::vector<gfx::Rect> opaque_regions_for_occlusion_;
- // Makes the window pass all events through to any windows behind it.
- EventTargetingPolicy event_targeting_policy_;
- // Used to restore to the original event targeting policy after all event
- // targeting blockers on this window are removed.
- EventTargetingPolicy restore_event_targeting_policy_;
- int event_targeting_blocker_count_ = 0;
- base::ReentrantObserverList<WindowObserver, true> observers_;
- // Video capturing support ---------------------------------------------------
- // A non-root window must be marked with a viz::SubtreeCaptureId so that it
- // can be captured by a FrameSinkVideoCapturer. Multiple clients can request
- // to capture the same window at the same time. This is the number of those
- // requests, which once it goes to zero, we well clear the
- // viz::SubtreeCaptureId from the layer associated with this window.
- int number_of_capture_requests_ = 0;
- // The ID allocated for the layer tree rooted at this window's layer, so that
- // it can be uniquely identified by the FrameSinkVideoCapturer. This can only
- // be set for non-root windows. Root windows can be captured normally by the
- // capturer using their frame sink ID, since those root windows are already
- // associated with a root compositor render pass.
- viz::SubtreeCaptureId subtree_capture_id_;
- // Embedding support ---------------------------------------------------------
- // Used to detect changes in device scale factor that require generating a
- // new LocalSurfaceId.
- float last_device_scale_factor_ = 1.0f;
- // The FrameSinkId associated with this window. If this window is embedding
- // another client, then this should be set to the FrameSinkId of that client,
- // and |embeds_external_client_| is turned on. However, a window can still
- // have a valid FrameSinkId without embedding another client, to facilitate
- // hit-testing.
- viz::FrameSinkId frame_sink_id_;
- // Set to true if |frame_sink_id_| has been registered in the Compositor
- // associated this this.
- bool registered_frame_sink_id_ = false;
- // Used by tests to disable registering the FrameSinkId with the Compositor.
- bool disable_frame_sink_id_registration_ = false;
- // Set to true if SetEmbedFrameSinkId() has been called.
- bool embeds_external_client_ = false;
- // Used to allocate LocalSurfaceIds when this is embedding external content.
- std::unique_ptr<viz::ParentLocalSurfaceIdAllocator>
- parent_local_surface_id_allocator_;
- #if DCHECK_IS_ON()
- // Set to true if CreateLayerTreeFrameSink() was called.
- bool created_layer_tree_frame_sink_ = false;
- #endif
- // Used when this is embedding external content.
- base::WeakPtr<cc::LayerTreeFrameSink> frame_sink_;
- };
- } // namespace aura
- #endif // UI_AURA_WINDOW_H_
|