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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
|
// Copyright (c) 2009 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 CHROME_BROWSER_GTK_BROWSER_WINDOW_GTK_H_
#define CHROME_BROWSER_GTK_BROWSER_WINDOW_GTK_H_
#include <gtk/gtk.h>
#include <map>
#include "app/active_window_watcher_x.h"
#include "base/gfx/rect.h"
#include "base/scoped_ptr.h"
#include "base/timer.h"
#include "build/build_config.h"
#include "chrome/browser/browser_window.h"
#include "chrome/browser/tabs/tab_strip_model.h"
#include "chrome/common/notification_registrar.h"
#include "chrome/common/pref_member.h"
#include "chrome/common/x11_util.h"
#ifdef OS_CHROMEOS
class CompactNavigationBar;
class StatusAreaView;
#endif
class BookmarkBarGtk;
class Browser;
class BrowserTitlebar;
class BrowserToolbarGtk;
class CustomDrawButton;
class DownloadShelfGtk;
class ExtensionShelfGtk;
class FindBarGtk;
class InfoBarContainerGtk;
class LocationBar;
class StatusBubbleGtk;
class TabContentsContainerGtk;
class TabStripGtk;
#ifdef OS_CHROMEOS
class PanelController;
#endif
// An implementation of BrowserWindow for GTK.
// Cross-platform code will interact with this object when
// it needs to manipulate the window.
class BrowserWindowGtk : public BrowserWindow,
public NotificationObserver,
public TabStripModelObserver,
public ActiveWindowWatcherX::Observer {
public:
explicit BrowserWindowGtk(Browser* browser);
virtual ~BrowserWindowGtk();
Browser* browser() const { return browser_.get(); }
// Process a keyboard event which was not handled by webkit.
void HandleKeyboardEvent(GdkEventKey* event);
// Overridden from BrowserWindow
virtual void Show();
virtual void SetBounds(const gfx::Rect& bounds);
virtual void Close();
virtual void Activate();
virtual bool IsActive() const;
virtual void FlashFrame();
virtual gfx::NativeWindow GetNativeHandle();
virtual BrowserWindowTesting* GetBrowserWindowTesting();
virtual StatusBubble* GetStatusBubble();
virtual void SelectedTabToolbarSizeChanged(bool is_animating);
virtual void SelectedTabExtensionShelfSizeChanged();
virtual void UpdateTitleBar();
virtual void ShelfVisibilityChanged();
virtual void UpdateDevTools();
virtual void FocusDevTools();
virtual void UpdateLoadingAnimations(bool should_animate);
virtual void SetStarredState(bool is_starred);
virtual gfx::Rect GetRestoredBounds() const;
virtual bool IsMaximized() const;
virtual void SetFullscreen(bool fullscreen);
virtual bool IsFullscreen() const;
virtual LocationBar* GetLocationBar() const;
virtual void SetFocusToLocationBar();
virtual void UpdateStopGoState(bool is_loading, bool force);
virtual void UpdateToolbar(TabContents* contents,
bool should_restore_state);
virtual void FocusToolbar();
virtual bool IsBookmarkBarVisible() const;
virtual gfx::Rect GetRootWindowResizerRect() const;
virtual void ConfirmAddSearchProvider(const TemplateURL* template_url,
Profile* profile);
virtual void ToggleBookmarkBar();
virtual void ToggleExtensionShelf();
virtual void ShowAboutChromeDialog();
virtual void ShowTaskManager();
virtual void ShowBookmarkManager();
virtual void ShowBookmarkBubble(const GURL& url, bool already_bookmarked);
virtual bool IsDownloadShelfVisible() const;
virtual DownloadShelf* GetDownloadShelf();
virtual void ShowReportBugDialog();
virtual void ShowClearBrowsingDataDialog();
virtual void ShowImportDialog();
virtual void ShowSearchEnginesDialog();
virtual void ShowPasswordManager();
virtual void ShowSelectProfileDialog();
virtual void ShowNewProfileDialog();
virtual void ShowRepostFormWarningDialog(TabContents* tab_contents);
virtual void ShowHistoryTooNewDialog();
virtual void ShowThemeInstallBubble();
virtual void ConfirmBrowserCloseWithPendingDownloads();
virtual void ShowHTMLDialog(HtmlDialogUIDelegate* delegate,
gfx::NativeWindow parent_window);
virtual void UserChangedTheme();
virtual int GetExtraRenderViewHeight() const;
virtual void TabContentsFocused(TabContents* tab_contents);
virtual void ShowPageInfo(Profile* profile,
const GURL& url,
const NavigationEntry::SSLStatus& ssl,
bool show_history);
virtual void ShowPageMenu();
virtual void ShowAppMenu();
virtual int GetCommandId(const NativeWebKeyboardEvent& event);
// Overridden from NotificationObserver:
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
// Overridden from TabStripModelObserver:
virtual void TabDetachedAt(TabContents* contents, int index);
virtual void TabSelectedAt(TabContents* old_contents,
TabContents* new_contents,
int index,
bool user_gesture);
virtual void TabStripEmpty();
// Overriden from ActiveWindowWatcher::Observer.
virtual void ActiveWindowChanged(GdkWindow* active_window);
// Accessor for the tab strip.
TabStripGtk* tabstrip() const { return tabstrip_.get(); }
void UpdateDevToolsForContents(TabContents* contents);
void UpdateUIForContents(TabContents* contents);
void OnBoundsChanged(const gfx::Rect& bounds);
void OnDebouncedBoundsChanged();
void OnStateChanged(GdkWindowState state, GdkWindowState changed_mask);
// Request the underlying window to unmaximize. Also tries to work around
// a window manager "feature" that can prevent this in some edge cases.
void UnMaximize();
// Returns false if we're not ready to close yet. E.g., a tab may have an
// onbeforeunload handler that prevents us from closing.
bool CanClose() const;
bool ShouldShowWindowIcon() const;
// Add the find bar widget to the window hierarchy.
void AddFindBar(FindBarGtk* findbar);
#if defined(OS_CHROMEOS)
// Sets whether a drag is active. If a drag is active the window will not
// close.
void set_drag_active(bool drag_active) { drag_active_ = drag_active; }
// Sets the flag that the next toplevel browser window being created will
// use the compact nav bar. This is used to implement the "new compact nav
// window" menu option. This flag will be cleared after the next window is
// opened, which will revert to the old behavior.
//
// TODO(brettw) remove this when we figure out how this is actually going
// to work long-term. This is a hack so the feature can be tested.
static void set_next_window_should_use_compact_nav() {
next_window_should_use_compact_nav_ = true;
}
#endif
// Reset the mouse cursor to the default cursor if it was set to something
// else for the custom frame.
void ResetCustomFrameCursor();
// Returns the BrowserWindowGtk registered with |window|.
static BrowserWindowGtk* GetBrowserWindowForNativeWindow(
gfx::NativeWindow window);
// Retrieves the GtkWindow associated with |xid|, which is the X Window
// ID of the top-level X window of this object.
static GtkWindow* GetBrowserWindowForXID(XID xid);
Browser* browser() {
return browser_.get();
}
GtkWindow* window() const { return window_; }
gfx::Rect bounds() const { return bounds_; }
// Make changes necessary when the floating state of the bookmark bar changes.
// This should only be called by the bookmark bar itself.
void BookmarkBarIsFloating(bool is_floating);
static void RegisterUserPrefs(PrefService* prefs);
protected:
virtual void DestroyBrowser();
// Top level window.
GtkWindow* window_;
// GtkAlignment that holds the interior components of the chromium window.
// This is used to draw the custom frame border and content shadow.
GtkWidget* window_container_;
// VBox that holds everything (tabs, toolbar, bookmarks bar, tab contents,
// and extension shelf).
GtkWidget* window_vbox_;
// VBox that holds everything below the toolbar.
GtkWidget* render_area_vbox_;
// EventBox that holds render_area_vbox_.
GtkWidget* render_area_event_box_;
scoped_ptr<Browser> browser_;
// The download shelf view (view at the bottom of the page).
scoped_ptr<DownloadShelfGtk> download_shelf_;
private:
// Show or hide the bookmark bar.
void MaybeShowBookmarkBar(TabContents* contents, bool animate);
// Sets the default size for the window and the the way the user is allowed to
// resize it.
void SetGeometryHints();
// Connect to signals on |window_|.
void ConnectHandlersToSignals();
// Create the various UI components.
void InitWidgets();
// Set up background color of the window (depends on if we're incognito or
// not).
void SetBackgroundColor();
// Called when the window size changed.
void OnSizeChanged(int width, int height);
// Applies the window shape to if we're in custom drawing mode.
void UpdateWindowShape(int width, int height);
// Connect accelerators that aren't connected to menu items (like ctrl-o,
// ctrl-l, etc.).
void ConnectAccelerators();
// Change whether we're showing the custom blue frame.
// Must be called once at startup.
// Triggers relayout of the content.
void UpdateCustomFrame();
// Save the window position in the prefs.
void SaveWindowPosition();
// Set the bounds of the current window. If |exterior| is true, set the size
// of the window itself, otherwise set the bounds of the web contents. In
// either case, set the position of the window.
void SetBoundsImpl(const gfx::Rect& bounds, bool exterior);
// Callback for when the custom frame alignment needs to be redrawn.
// The content area includes the toolbar and web page but not the tab strip.
static gboolean OnCustomFrameExpose(GtkWidget* widget, GdkEventExpose* event,
BrowserWindowGtk* window);
// A helper method that draws the shadow above the toolbar and in the frame
// border during an expose.
static void DrawContentShadow(cairo_t* cr, BrowserWindowGtk* window);
static gboolean OnGtkAccelerator(GtkAccelGroup* accel_group,
GObject* acceleratable,
guint keyval,
GdkModifierType modifier,
BrowserWindowGtk* browser_window);
// Mouse move and mouse button press callbacks.
static gboolean OnMouseMoveEvent(GtkWidget* widget,
GdkEventMotion* event,
BrowserWindowGtk* browser);
static gboolean OnButtonPressEvent(GtkWidget* widget,
GdkEventButton* event,
BrowserWindowGtk* browser);
// Maps and Unmaps the xid of |widget| to |window|.
static void MainWindowMapped(GtkWidget* widget, BrowserWindowGtk* window);
static void MainWindowUnMapped(GtkWidget* widget, BrowserWindowGtk* window);
// Tracks focus state of browser.
static gboolean OnFocusIn(GtkWidget* widget,
GdkEventFocus* event,
BrowserWindowGtk* browser);
static gboolean OnFocusOut(GtkWidget* widget,
GdkEventFocus* event,
BrowserWindowGtk* browser);
// A small shim for browser_->ExecuteCommand.
void ExecuteBrowserCommand(int id);
// Callback for the loading animation(s) associated with this window.
void LoadingAnimationCallback();
// Shows UI elements for supported window features.
void ShowSupportedWindowFeatures();
// Hides UI elements for unsupported window features.
void HideUnsupportedWindowFeatures();
// Helper functions that query |browser_| concerning support for UI features
// in this window. (For example, a popup window might not support a tabstrip).
bool IsTabStripSupported() const;
bool IsToolbarSupported() const;
bool IsBookmarkBarSupported() const;
bool IsExtensionShelfSupported() const;
// Checks to see if the mouse pointer at |x|, |y| is over the border of the
// custom frame (a spot that should trigger a window resize). Returns true if
// it should and sets |edge|.
bool GetWindowEdge(int x, int y, GdkWindowEdge* edge);
// Returns |true| if we should use the custom frame.
bool UseCustomFrame();
// Put the bookmark bar where it belongs.
void PlaceBookmarkBar(bool is_floating);
// Determine whether we use should default to native decorations or the custom
// frame based on the currently-running window manager.
static bool GetCustomFramePrefDefault();
NotificationRegistrar registrar_;
// The position and size of the current window.
gfx::Rect bounds_;
// The position and size of the non-maximized, non-fullscreen window.
gfx::Rect restored_bounds_;
GdkWindowState state_;
// The container for the titlebar + tab strip.
scoped_ptr<BrowserTitlebar> titlebar_;
// The object that manages all of the widgets in the toolbar.
scoped_ptr<BrowserToolbarGtk> toolbar_;
// The object that manages the bookmark bar. This will be NULL if the
// bookmark bar is not supported.
scoped_ptr<BookmarkBarGtk> bookmark_bar_;
// The object that manages the extension shelf.
scoped_ptr<ExtensionShelfGtk> extension_shelf_;
// The status bubble manager. Always non-NULL.
scoped_ptr<StatusBubbleGtk> status_bubble_;
// A container that manages the GtkWidget*s that are the webpage display
// (along with associated infobars, shelves, and other things that are part
// of the content area).
scoped_ptr<TabContentsContainerGtk> contents_container_;
// A container that manages the GtkWidget*s of developer tools for the
// selected tab contents.
scoped_ptr<TabContentsContainerGtk> devtools_container_;
// Split pane containing the contents_container_ and the devtools_container_.
GtkWidget* contents_split_;
// The tab strip. Always non-NULL.
scoped_ptr<TabStripGtk> tabstrip_;
// The container for info bars. Always non-NULL.
scoped_ptr<InfoBarContainerGtk> infobar_container_;
// The timer used to update frames for the Loading Animation.
base::RepeatingTimer<BrowserWindowGtk> loading_animation_timer_;
// The timer used to save the window position for session restore.
base::OneShotTimer<BrowserWindowGtk> window_configure_debounce_timer_;
// Whether the custom chrome frame pref is set. Normally you want to use
// UseCustomFrame() above to determine whether to use the custom frame or
// not.
BooleanPrefMember use_custom_frame_pref_;
#if defined(OS_CHROMEOS)
// True if a drag is active. See description above setter for details.
bool drag_active_;
// Controls interactions with the window manager for popup panels.
PanelController* panel_controller_;
CompactNavigationBar* compact_navigation_bar_;
StatusAreaView* status_area_;
static bool next_window_should_use_compact_nav_;
#endif
// A map which translates an X Window ID into its respective GtkWindow.
static std::map<XID, GtkWindow*> xid_map_;
// The current window cursor. We set it to a resize cursor when over the
// custom frame border. We set it to NULL if we want the default cursor.
GdkCursor* frame_cursor_;
// True if the window manager thinks the window is active. Not all window
// managers keep track of this state (_NET_ACTIVE_WINDOW), in which case
// this will always be true.
bool is_active_;
// Keep track of the last click time and the last click position so we can
// filter out extra GDK_BUTTON_PRESS events when a double click happens.
guint32 last_click_time_;
gfx::Point last_click_position_;
// If true, maximize the window after we call BrowserWindow::Show for the
// first time. This is to work around a compiz bug.
bool maximize_after_show_;
// The accelerator group used to handle accelerators, owned by this object.
GtkAccelGroup* accel_group_;
DISALLOW_COPY_AND_ASSIGN(BrowserWindowGtk);
};
#endif // CHROME_BROWSER_GTK_BROWSER_WINDOW_GTK_H_
|