1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
// Copyright 2015 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 COMPONENTS_EXO_SHELL_SURFACE_H_
#define COMPONENTS_EXO_SHELL_SURFACE_H_
#include <string>
#include "ash/wm/window_state_observer.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string16.h"
#include "components/exo/surface_delegate.h"
#include "components/exo/surface_observer.h"
#include "ui/views/widget/widget_delegate.h"
#include "ui/wm/public/activation_change_observer.h"
namespace base {
namespace trace_event {
class TracedValue;
}
}
namespace exo {
class Surface;
// This class provides functions for treating a surfaces like toplevel,
// fullscreen or popup widgets, move, resize or maximize them, associate
// metadata like title and class, etc.
class ShellSurface : public SurfaceDelegate,
public SurfaceObserver,
public views::WidgetDelegate,
public views::View,
public ash::wm::WindowStateObserver,
public aura::client::ActivationChangeObserver {
public:
explicit ShellSurface(Surface* surface);
~ShellSurface() override;
// Set the callback to run when the user wants the shell surface to be closed.
// The receiver can chose to not close the window on this signal.
void set_close_callback(const base::Closure& close_callback) {
close_callback_ = close_callback;
}
// Set the callback to run when the surface is destroyed.
void set_surface_destroyed_callback(
const base::Closure& surface_destroyed_callback) {
surface_destroyed_callback_ = surface_destroyed_callback;
}
// Set the callback to run when the client is asked to configure the surface.
// The size is a hint, in the sense that the client is free to ignore it if
// it doesn't resize, pick a smaller size (to satisfy aspect ratio or resize
// in steps of NxM pixels).
using ConfigureCallback =
base::Callback<void(const gfx::Size& size,
ash::wm::WindowStateType state_type,
bool activated)>;
void set_configure_callback(const ConfigureCallback& configure_callback) {
configure_callback_ = configure_callback;
}
// Maximizes the shell surface.
void Maximize();
// Restore the shell surface.
void Restore();
// Set fullscreen state for shell surface.
void SetFullscreen(bool fullscreen);
// Set title for surface.
void SetTitle(const base::string16& title);
// Sets the application ID for the window. The application ID identifies the
// general class of applications to which the window belongs.
static void SetApplicationId(aura::Window* window,
std::string* application_id);
static const std::string GetApplicationId(aura::Window* window);
// Set application id for surface.
void SetApplicationId(const std::string& application_id);
// Start an interactive move of surface.
void Move();
// Signal a request to close the window. It is up to the implementation to
// actually decide to do so though.
void Close();
// Set geometry for surface. The geometry represents the "visible bounds"
// for the surface from the user's perspective.
void SetGeometry(const gfx::Rect& geometry);
// Sets the main surface for the window.
static void SetMainSurface(aura::Window* window, Surface* surface);
static Surface* GetMainSurface(const aura::Window* window);
// Returns a trace value representing the state of the surface.
scoped_refptr<base::trace_event::TracedValue> AsTracedValue() const;
// Overridden from SurfaceDelegate:
void OnSurfaceCommit() override;
bool IsSurfaceSynchronized() const override;
// Overridden from SurfaceObserver:
void OnSurfaceDestroying(Surface* surface) override;
// Overridden from views::WidgetDelegate:
base::string16 GetWindowTitle() const override;
views::Widget* GetWidget() override;
const views::Widget* GetWidget() const override;
views::View* GetContentsView() override;
views::NonClientFrameView* CreateNonClientFrameView(
views::Widget* widget) override;
bool WidgetHasHitTestMask() const override;
void GetWidgetHitTestMask(gfx::Path* mask) const override;
// Overridden from views::View:
gfx::Size GetPreferredSize() const override;
// Overridden from ash::wm::WindowStateObserver:
void OnPostWindowStateTypeChange(ash::wm::WindowState* window_state,
ash::wm::WindowStateType old_type) override;
// Overridden from aura::client::ActivationChangeObserver:
void OnWindowActivated(
aura::client::ActivationChangeObserver::ActivationReason reason,
aura::Window* gained_active,
aura::Window* lost_active) override;
private:
// Creates the |widget_| for |surface_|.
void CreateShellSurfaceWidget();
// Asks the client to configure its surface.
void Configure();
scoped_ptr<views::Widget> widget_;
Surface* surface_;
base::string16 title_;
std::string application_id_;
gfx::Rect geometry_;
base::Closure close_callback_;
base::Closure surface_destroyed_callback_;
ConfigureCallback configure_callback_;
DISALLOW_COPY_AND_ASSIGN(ShellSurface);
};
} // namespace exo
#endif // COMPONENTS_EXO_SHELL_SURFACE_H_
|
