blob: e790ff6fd24cf3deb78fcc28b486731d519a3690 (
plain)
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
|
// Copyright (c) 2006-2008 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 VIEWS_WINDOW_WINDOW_DELEGATE_H_
#define VIEWS_WINDOW_WINDOW_DELEGATE_H_
#include <string>
#include "base/scoped_ptr.h"
class SkBitmap;
namespace gfx {
class Rect;
}
// TODO(maruel): Remove once gfx::Rect is used instead.
namespace WTL {
class CRect;
}
using WTL::CRect;
namespace views {
class ClientView;
class DialogDelegate;
class View;
class Window;
///////////////////////////////////////////////////////////////////////////////
//
// WindowDelegate
//
// WindowDelegate is an interface implemented by objects that wish to show a
// Window. The window that is displayed uses this interface to determine how
// it should be displayed and notify the delegate object of certain events.
//
///////////////////////////////////////////////////////////////////////////////
class WindowDelegate {
public:
WindowDelegate();
virtual ~WindowDelegate();
virtual DialogDelegate* AsDialogDelegate() { return NULL; }
// Returns true if the window can ever be resized.
virtual bool CanResize() const {
return false;
}
// Returns true if the window can ever be maximized.
virtual bool CanMaximize() const {
return false;
}
// Returns true if the dialog should be displayed modally to the window that
// opened it. Only windows with WindowType == DIALOG can be modal.
virtual bool IsModal() const {
return false;
}
// Returns the text to be displayed in the window title.
virtual std::wstring GetWindowTitle() const {
return L"";
}
// Returns the view that should have the focus when the dialog is opened. If
// NULL no view is focused.
virtual View* GetInitiallyFocusedView() { return NULL; }
// Returns true if the window should show a title in the title bar.
virtual bool ShouldShowWindowTitle() const {
return true;
}
// Returns the icon to be displayed in the window.
virtual SkBitmap GetWindowIcon();
// Returns true if a window icon should be shown.
virtual bool ShouldShowWindowIcon() const {
return false;
}
// Execute a command in the window's controller. Returns true if the command
// was handled, false if it was not.
virtual bool ExecuteWindowsCommand(int command_id) { return false; }
// Returns the window's name identifier. Used to identify this window for
// state restoration.
virtual std::wstring GetWindowName() const {
return std::wstring();
}
// Saves the window's bounds and maximized states. By default this uses the
// process' local state keyed by window name (See GetWindowName above). This
// behavior can be overridden to provide additional functionality.
virtual void SaveWindowPlacement(const gfx::Rect& bounds, bool maximized);
// Retrieves the window's bounds and maximized states.
// This behavior can be overridden to provide additional functionality.
virtual bool GetSavedWindowBounds(gfx::Rect* bounds) const;
virtual bool GetSavedMaximizedState(bool* maximized) const;
// Called when the window closes.
virtual void WindowClosing() { }
// Called when the window is destroyed. No events must be sent or received
// after this point. The delegate can use this opportunity to delete itself at
// this time if necessary.
virtual void DeleteDelegate() { }
// Returns the View that is contained within this Window.
virtual View* GetContentsView() {
return NULL;
}
// Called by the Window to create the Client View used to host the contents
// of the window.
virtual ClientView* CreateClientView(Window* window);
// An accessor to the Window this delegate is bound to.
Window* window() const { return window_.get(); }
protected:
// Releases the Window* we maintain. This should be done by a delegate in its
// WindowClosing handler if it intends to be re-cycled to be used on a
// different Window.
void ReleaseWindow();
private:
friend class WindowGtk;
friend class WindowWin;
// This is a little unusual. We use a scoped_ptr here because it's
// initialized to NULL automatically. We do this because we want to allow
// people using this helper to not have to call a ctor on this object.
// Instead we just release the owning ref this pointer has when we are
// destroyed.
scoped_ptr<Window> window_;
};
} // namespace views
#endif // VIEWS_WINDOW_WINDOW_DELEGATE_H_
|
