| // 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 CHROME_VIEWS_WINDOW_DELEGATE_H_ |
| #define CHROME_VIEWS_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 be resized. |
| virtual bool CanResize() const { |
| return false; |
| } |
| |
| // Returns true if the window can be maximized. |
| virtual bool CanMaximize() const { |
| return false; |
| } |
| |
| // Returns true if the window should be placed on top of all other windows on |
| // the system, even when it is not active. If HasAlwaysOnTopMenu() returns |
| // true, then this method is only used the first time the window is opened, it |
| // is stored in the preferences for next runs. |
| virtual bool IsAlwaysOnTop() const { |
| return false; |
| } |
| |
| // Returns whether an "always on top" menu should be added to the system menu |
| // of the window. |
| virtual bool HasAlwaysOnTopMenu() 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() const { 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, maximized and always-on-top 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, |
| bool always_on_top); |
| |
| // Retreives the window's bounds, maximized and always-on-top 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 bool GetSavedWindowBounds(gfx::Rect* bounds) const; |
| virtual bool GetSavedMaximizedState(bool* maximized) const; |
| virtual bool GetSavedAlwaysOnTopState(bool* always_on_top) const; |
| |
| // Called when the window closes. |
| virtual void WindowClosing() { } |
| |
| // 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 Window; |
| // 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 // CHROME_VIEWS_WINDOW_DELEGATE_H_ |
| |