Mac: make save/open dialogs operate as tab-modal sheets....

chrome/browser/cocoa/constrained_window_mac.h

 // 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_COCOA_CONSTRAINED_WINDOW_MAC_H_
 #define CHROME_BROWSER_COCOA_CONSTRAINED_WINDOW_MAC_H_
 
 #import <Cocoa/Cocoa.h>
 
 #include "chrome/browser/tab_contents/constrained_window.h"
@@ skipping 12 matching lines @@
 class ConstrainedWindowMacDelegate {
  public:
   ConstrainedWindowMacDelegate() : is_sheet_open_(false) { }
   virtual ~ConstrainedWindowMacDelegate();
 
   // Tells the delegate to either delete itself or set up a task to delete
   // itself later. Note that you MUST close the sheet belonging to your delegate
   // in this method.
   virtual void DeleteDelegate() = 0;
 
+  // Responds to things done by the parent tab. Called by
+  // |ConstrainedWindowMac::ParentWillDo()|. Returns |true| if it did something
+  // in response, |false| if it did not and if
+  // |ConstrainedWindowMac::ParentWillDo()| should run its default handler. The
+  // default implementation just returns |false|.
+  virtual bool ParentWillDo(ConstrainedWindow::Event event) { return false; }
+
+  // Gives the modality level of the constrained window. The default
+  // implementation just specifies "content-modality".
+  virtual ConstrainedWindow::ModalityLevel GetModalityLevel()
+      { return ConstrainedWindow::kModalForContent; }
+
   // Called by the tab controller, you do not need to do anything yourself
   // with this method.
   virtual void RunSheet(GTMWindowSheetController* sheetController,
-                        NSView* view) = 0;
+                        NSView* view,
+                        SEL frameSelector,
+                        SEL positionSelector) = 0;
  protected:
   // Returns true if this delegate's sheet is currently showing.
   bool is_sheet_open() { return is_sheet_open_; }
 
  private:
   bool is_sheet_open_;
   void set_sheet_open(bool is_open) { is_sheet_open_ = is_open; }
   friend class ConstrainedWindowMac;
 };
 
 // Subclass this for a dialog delegate that displays a system sheet such as
-// an NSAlert, an open or save file panel, etc.
-class ConstrainedWindowMacDelegateSystemSheet
+// an NSSavePanel, NSOpenPanel, etc. This can handle any system sheet that GTM
+// supports (if in a somewhat ugly way).
+class ConstrainedWindowMacDelegateSystemSheetParams
     : public ConstrainedWindowMacDelegate {
  public:
-  ConstrainedWindowMacDelegateSystemSheet(id delegate, SEL didEndSelector)
+  // See third_party/GTM/AppKit/GTMWindowSheetController.h for the format of
+  // |params|.
+  explicit ConstrainedWindowMacDelegateSystemSheetParams(NSArray* params)
     : systemSheet_(nil),
-      delegate_([delegate retain]),
-      didEndSelector_(didEndSelector) { }
+      params_([params retain]) { }
 
  protected:
   void set_sheet(id sheet) { systemSheet_.reset([sheet retain]); }
   id sheet() { return systemSheet_; }
+  void set_params(NSArray* params) { params_.reset([params retain]); }
+  NSArray* params() { return static_cast<NSArray*>(params_); }
+  virtual void RunSheet(GTMWindowSheetController* sheetController,
+                        NSView* view,
+                        SEL frameSelector,
+                        SEL positionSelector);
+
+ private:
+  scoped_nsobject<id> systemSheet_;
+  scoped_nsobject<id> params_;
+};
+
+// Subclass this for a dialog delegate that displays a system sheet such as
+// an NSAlert or other simple panel.
+class ConstrainedWindowMacDelegateSystemSheet
+    : public ConstrainedWindowMacDelegateSystemSheetParams {
+ public:
+  ConstrainedWindowMacDelegateSystemSheet(id delegate, SEL didEndSelector)
+    : ConstrainedWindowMacDelegateSystemSheetParams(nil),
+      delegate_([delegate retain]),
+      didEndSelector_(didEndSelector) { }
 
  private:
   virtual void RunSheet(GTMWindowSheetController* sheetController,
-                        NSView* view);
-  scoped_nsobject<id> systemSheet_;
+                        NSView* view,
+                        SEL frameSelector,
+                        SEL positionSelector);
   scoped_nsobject<id> delegate_;
   SEL didEndSelector_;
 };
 
 // Subclass this for a dialog delegate that displays a custom sheet, e.g. loaded
 // from a nib file.
 class ConstrainedWindowMacDelegateCustomSheet
     : public ConstrainedWindowMacDelegate {
  public:
   ConstrainedWindowMacDelegateCustomSheet()
@@ skipping 15 matching lines @@
     delegate_.reset([delegate retain]);
     didEndSelector_ = didEndSelector;
     DCHECK(delegate_.get());
     DCHECK(didEndSelector_);
   }
   void set_sheet(NSWindow* sheet) { customSheet_.reset([sheet retain]); }
   NSWindow* sheet() { return customSheet_; }
 
  private:
   virtual void RunSheet(GTMWindowSheetController* sheetController,
-                        NSView* view);
+                        NSView* view,
+                        SEL frameSelector,
+                        SEL positionSelector);
   scoped_nsobject<NSWindow> customSheet_;
   scoped_nsobject<id> delegate_;
   SEL didEndSelector_;
 };
 
 // Constrained window implementation for the Mac port. A constrained window
 // is a per-tab sheet on OS X.
 //
 // Constrained windows work slightly differently on OS X than on the other
 // platforms:
 // 1. A constrained window is bound to both a tab and window on OS X.
 // 2. The delegate is responsible for closing the sheet again when it is
 //    deleted.
 class ConstrainedWindowMac : public ConstrainedWindow {
  public:
   virtual ~ConstrainedWindowMac();
 
   // Overridden from ConstrainedWindow:
   virtual void CloseConstrainedWindow();
+  virtual bool ParentWillDo(ConstrainedWindow::Event event);
+
+  // This returns a cached result from the delegate. It can't just get the
+  // delegate to answer because we may outlive the delegate.
+  virtual ConstrainedWindow::ModalityLevel GetModalityLevel()
+      { return modality_level_; }
 
   // Returns the TabContents that constrains this Constrained Window.
   TabContents* owner() const { return owner_; }
 
   // Returns the window's delegate.
   ConstrainedWindowMacDelegate* delegate() { return delegate_; }
 
   // Makes the constrained window visible, if it is not yet visible.
   void Realize(BrowserWindowController* controller);
 
  private:
   friend class ConstrainedWindow;
 
   ConstrainedWindowMac(TabContents* owner,
                        ConstrainedWindowMacDelegate* delegate);
 
   // The TabContents that owns and constrains this ConstrainedWindow.
   TabContents* owner_;
 
   // Delegate that provides the contents of this constrained window.
   ConstrainedWindowMacDelegate* delegate_;
 
   // Controller of the window that contains this sheet.
   BrowserWindowController* controller_;
 
+  // Level of modality (cached result from delegate).
+  ConstrainedWindow::ModalityLevel modality_level_;
+
   DISALLOW_COPY_AND_ASSIGN(ConstrainedWindowMac);
 };
 
 #endif  // CHROME_BROWSER_COCOA_CONSTRAINED_WINDOW_MAC_H_
-