Use current gtk dialogs in linux_aura.

chrome/browser/ui/libgtk2ui/select_file_dialog_impl_gtk2.cc

 // Copyright (c) 2012 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.
 
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 #include <map>
 #include <set>
 #include <vector>
 
+// Xlib defines RootWindow
+#undef RootWindow
+
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
-//#include "chrome/browser/ui/gtk/select_file_dialog_impl.h"
-#include "chrome/browser/ui/select_file_dialog.h"
-#include "grit/generated_resources.h"
-//#include "ui/base/gtk/gtk_signal.h"
+#include "chrome/browser/ui/libgtk2ui/gtk2_signal.h"
+#include "chrome/browser/ui/libgtk2ui/select_file_dialog_impl.h"
+#include "grit/ui_strings.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/window_observer.h"
+#include "ui/base/dialogs/select_file_dialog.h"
 #include "ui/base/l10n/l10n_util.h"
 
+namespace {
+
+const char kAuraTransientParent[] = "aura-transient-parent";
+
+// Set |dialog| as transient for |parent|, which will keep it on top and center
+// it above |parent|.
+void SetGtkTransientForAura(GtkWidget* dialog, aura::Window* parent) {
+  gtk_widget_realize(dialog);
+  GdkWindow* gdk_window = gtk_widget_get_window(dialog);
+
+  // TODO(erg): Check to make sure we're using X11 if wayland or some other
+  // display server ever happens. Otherwise, this will crash.
+  XSetTransientForHint(GDK_WINDOW_XDISPLAY(gdk_window),
+                       GDK_WINDOW_XID(gdk_window),
+                       parent->GetRootWindow()->GetAcceleratedWidget());
+
+  // We also set the |parent| as a property of |dialog|, so that we can unlink
+  // the two later.
+  g_object_set_data(G_OBJECT(dialog), kAuraTransientParent, parent);
+}
+
+}  // namespace
+
+namespace libgtk2ui {
+
 // Implementation of SelectFileDialog that shows a Gtk common dialog for
 // choosing a file or folder. This acts as a modal dialog.
-class SelectFileDialogImplGTK : public SelectFileDialogImpl {
+class SelectFileDialogImplGTK : public SelectFileDialogImpl,
+                                public aura::WindowObserver {
  public:
   explicit SelectFileDialogImplGTK(Listener* listener,
                                    ui::SelectFilePolicy* policy);
 
  protected:
   virtual ~SelectFileDialogImplGTK();
 
   // SelectFileDialog implementation.
   // |params| is user data we pass back via the Listener interface.
   virtual void SelectFileImpl(Type type,
                               const string16& title,
                               const FilePath& default_path,
                               const FileTypeInfo* file_types,
                               int file_type_index,
                               const FilePath::StringType& default_extension,
                               gfx::NativeWindow owning_window,
                               void* params) OVERRIDE;
 
  private:
   virtual bool HasMultipleFileTypeChoicesImpl() OVERRIDE;
 
+  // Overridden from aura::WindowObserver:
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
+
   // Add the filters from |file_types_| to |chooser|.
   void AddFilters(GtkFileChooser* chooser);
 
   // Notifies the listener that a single file was chosen.
   void FileSelected(GtkWidget* dialog, const FilePath& path);
 
   // Notifies the listener that multiple files were chosen.
   void MultiFilesSelected(GtkWidget* dialog,
                           const std::vector<FilePath>& files);
 
@@ skipping 88 matching lines @@
 SelectFileDialogImplGTK::~SelectFileDialogImplGTK() {
   while (dialogs_.begin() != dialogs_.end()) {
     gtk_widget_destroy(*(dialogs_.begin()));
   }
 }
 
 bool SelectFileDialogImplGTK::HasMultipleFileTypeChoicesImpl() {
   return file_types_.extensions.size() > 1;
 }
 
+void SelectFileDialogImplGTK::OnWindowDestroying(aura::Window* window) {
+  std::set<aura::Window*>::iterator iter = parents_.find(window);
+  if (iter != parents_.end()) {
+    (*iter)->RemoveObserver(this);
+    parents_.erase(iter);
+  }
+}
+
 // We ignore |default_extension|.
 void SelectFileDialogImplGTK::SelectFileImpl(
     Type type,
     const string16& title,
     const FilePath& default_path,
     const FileTypeInfo* file_types,
     int file_type_index,
     const FilePath::StringType& default_extension,
     gfx::NativeWindow owning_window,
     void* params) {
   type_ = type;
   // |owning_window| can be null when user right-clicks on a downloadable item
   // and chooses 'Open Link in New Tab' when 'Ask where to save each file
   // before downloading.' preference is turned on. (http://crbug.com/29213)
-  if (owning_window)
+  if (owning_window) {
+    owning_window->AddObserver(this);
     parents_.insert(owning_window);
+  }
 
   std::string title_string = UTF16ToUTF8(title);
 
   file_type_index_ = file_type_index;
   if (file_types)
     file_types_ = *file_types;
   else
     file_types_.include_all_files = true;
 
   GtkWidget* dialog = NULL;
@@ skipping 22 matching lines @@
 
   preview_ = gtk_image_new();
   g_signal_connect(dialog, "destroy",
                    G_CALLBACK(OnFileChooserDestroyThunk), this);
   g_signal_connect(dialog, "update-preview",
                    G_CALLBACK(OnUpdatePreviewThunk), this);
   gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), preview_);
 
   params_map_[dialog] = params;
 
-  // Set window-to-parent modality by adding the dialog to the same window
-  // group as the parent.
-  gtk_window_group_add_window(gtk_window_get_group(owning_window),
-                              GTK_WINDOW(dialog));
+  // TODO(erg): Figure out how to fake GTK window-to-parent modality without
+  // having the parent be a real GtkWindow.
   gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
 
   gtk_widget_show_all(dialog);
 }
 
 void SelectFileDialogImplGTK::AddFilters(GtkFileChooser* chooser) {
   for (size_t i = 0; i < file_types_.extensions.size(); ++i) {
     GtkFileFilter* filter = NULL;
     std::set<std::string> fallback_labels;
 
@@ skipping 75 matching lines @@
   if (listener_)
     listener_->FileSelectionCanceled(params);
   gtk_widget_destroy(dialog);
 }
 
 GtkWidget* SelectFileDialogImplGTK::CreateFileOpenHelper(
     const std::string& title,
     const FilePath& default_path,
     gfx::NativeWindow parent) {
   GtkWidget* dialog =
-      gtk_file_chooser_dialog_new(title.c_str(), parent,
+      gtk_file_chooser_dialog_new(title.c_str(), NULL,
                                   GTK_FILE_CHOOSER_ACTION_OPEN,
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                   GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                   NULL);
+  SetGtkTransientForAura(dialog, parent);
   AddFilters(GTK_FILE_CHOOSER(dialog));
 
   if (!default_path.empty()) {
     if (CallDirectoryExistsOnUIThread(default_path)) {
       gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                           default_path.value().c_str());
     } else {
       // If the file doesn't exist, this will just switch to the correct
       // directory. That's good enough.
       gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
                                     default_path.value().c_str());
     }
   } else if (!last_opened_path_->empty()) {
     gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                         last_opened_path_->value().c_str());
   }
   return dialog;
 }
 
 GtkWidget* SelectFileDialogImplGTK::CreateSelectFolderDialog(
     const std::string& title,
     const FilePath& default_path,
     gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_SELECT_FOLDER_DIALOG_TITLE);
 
   GtkWidget* dialog =
-      gtk_file_chooser_dialog_new(title_string.c_str(), parent,
+      gtk_file_chooser_dialog_new(title_string.c_str(), NULL,
                                   GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                   GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                   NULL);
+  SetGtkTransientForAura(dialog, parent);
 
   if (!default_path.empty()) {
     gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
                                   default_path.value().c_str());
   } else if (!last_opened_path_->empty()) {
     gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                         last_opened_path_->value().c_str());
   }
   gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
   g_signal_connect(dialog, "response",
@@ skipping 28 matching lines @@
                    G_CALLBACK(OnSelectMultiFileDialogResponseThunk), this);
   return dialog;
 }
 
 GtkWidget* SelectFileDialogImplGTK::CreateSaveAsDialog(const std::string& title,
     const FilePath& default_path, gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_SAVE_AS_DIALOG_TITLE);
 
   GtkWidget* dialog =
-      gtk_file_chooser_dialog_new(title_string.c_str(), parent,
+      gtk_file_chooser_dialog_new(title_string.c_str(), NULL,
                                   GTK_FILE_CHOOSER_ACTION_SAVE,
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                   GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                   NULL);
+  SetGtkTransientForAura(dialog, parent);
 
   AddFilters(GTK_FILE_CHOOSER(dialog));
   if (!default_path.empty()) {
     // Since the file may not already exist, we use
     // set_current_folder() followed by set_current_name(), as per the
     // recommendation of the GTK docs.
     gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
         default_path.DirName().value().c_str());
     gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
         default_path.BaseName().value().c_str());
@@ skipping 18 matching lines @@
 }
 
 void SelectFileDialogImplGTK::FileDialogDestroyed(GtkWidget* dialog) {
   dialogs_.erase(dialog);
 
   // Parent may be NULL in a few cases: 1) on shutdown when
   // AllBrowsersClosed() trigger this handler after all the browser
   // windows got destroyed, or 2) when the parent tab has been opened by
   // 'Open Link in New Tab' context menu on a downloadable item and
   // the tab has no content (see the comment in SelectFile as well).
-  GtkWindow* parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
+  aura::Window* parent = reinterpret_cast<aura::Window*>(
+      g_object_get_data(G_OBJECT(dialog), kAuraTransientParent));
   if (!parent)
     return;
-  std::set<GtkWindow*>::iterator iter = parents_.find(parent);
-  if (iter != parents_.end())
+  std::set<aura::Window*>::iterator iter = parents_.find(parent);
+  if (iter != parents_.end()) {
+    (*iter)->RemoveObserver(this);
     parents_.erase(iter);
-  else
+  } else {
     NOTREACHED();
+  }
 }
 
 bool SelectFileDialogImplGTK::IsCancelResponse(gint response_id) {
   bool is_cancel = response_id == GTK_RESPONSE_CANCEL ||
                    response_id == GTK_RESPONSE_DELETE_EVENT;
   if (is_cancel)
     return true;
 
   DCHECK(response_id == GTK_RESPONSE_ACCEPT);
   return false;
@@ skipping 80 matching lines @@
   GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file_at_size(filename, kPreviewWidth,
                                                        kPreviewHeight, NULL);
   g_free(filename);
   if (pixbuf) {
     gtk_image_set_from_pixbuf(GTK_IMAGE(preview_), pixbuf);
     g_object_unref(pixbuf);
   }
   gtk_file_chooser_set_preview_widget_active(GTK_FILE_CHOOSER(chooser),
                                              pixbuf ? TRUE : FALSE);
 }
+
+}  // namespace libgtk2ui