Make File-Picker modal on Linux

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/gdkx.h>
 #include <gtk/gtk.h>
 #include <map>
 #include <set>
 #include <vector>
 
 // Xlib defines RootWindow
 #undef RootWindow
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/ui/libgtk2ui/gtk2_signal.h"
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #include "chrome/browser/ui/libgtk2ui/select_file_dialog_impl.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/shell_dialogs/select_file_dialog.h"
 #include "ui/strings/grit/ui_strings.h"
+#include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_handler.h"
 
 namespace {
 
 // Makes sure that .jpg also shows .JPG.
 gboolean FileFilterCaseInsensitive(const GtkFileFilterInfo* file_info,
                                    std::string* file_extension) {
   return base::EndsWith(file_info->filename, *file_extension,
                         base::CompareCase::INSENSITIVE_ASCII);
 }
@@ skipping 24 matching lines @@
   // SelectFileDialog implementation.
   // |params| is user data we pass back via the Listener interface.
   void SelectFileImpl(Type type,
                       const base::string16& title,
                       const base::FilePath& default_path,
                       const FileTypeInfo* file_types,
                       int file_type_index,
                       const base::FilePath::StringType& default_extension,
                       gfx::NativeWindow owning_window,
                       void* params) override;
+  // Close the file dialog.
+  void CloseImpl() override;
 
  private:
   bool HasMultipleFileTypeChoicesImpl() override;
 
   // Overridden from aura::WindowObserver:
   void OnWindowDestroying(aura::Window* window) override;
 
   // Add the filters from |file_types_| to |chooser|.
   void AddFilters(GtkFileChooser* chooser);
 
@@ skipping 184 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;
 
-  // 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);
+  // Disable input events handling in the host window to make this dialog modal.
+  views::DesktopWindowTreeHostX11* host =
+      views::DesktopWindowTreeHostX11::GetHostForXID(
+      owning_window->GetHost()->GetAcceleratedWidget());
+  host->DisableEventListening(GDK_WINDOW_XID(gtk_widget_get_window(dialog)));
 
   gtk_widget_show_all(dialog);
 
   // We need to call gtk_window_present after making the widgets visible to make
   // sure window gets correctly raised and gets focus.
   int time = views::X11DesktopHandler::get()->wm_user_time_ms();
   gtk_window_present_with_time(GTK_WINDOW(dialog), time);
 }
 
+// Close the file-picker by sending an ESC key event to it.
+void SelectFileDialogImplGTK::CloseImpl() {
+  // Get the focused window.
+  XID focused_window;
+  int revert;
+  XGetInputFocus(gfx::GetXDisplay(), &focused_window, &revert);
+
+  // Send an ESC key event to the focused_window.
+  XKeyEvent event;
+  memset(&event, 0, sizeof(event));
+  event.display = gfx::GetXDisplay();
+  event.window = focused_window;
+  event.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Escape);
+  event.type = KeyPress;
+
+  XSendEvent(gfx::GetXDisplay(), focused_window, True, KeyPressMask,
+      reinterpret_cast<XEvent*>(&event));
+}
+
 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;
 
     for (size_t j = 0; j < file_types_.extensions[i].size(); ++j) {
       const std::string& current_extension = file_types_.extensions[i][j];
       if (!current_extension.empty()) {
         if (!filter)
           filter = gtk_file_filter_new();
@@ skipping 222 matching lines @@
   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).
   aura::Window* parent = GetAuraTransientParent(dialog);
   if (!parent)
     return;
+
+  views::DesktopWindowTreeHostX11* host =
+      views::DesktopWindowTreeHostX11::GetHostForXID(
+      parent->GetHost()->GetAcceleratedWidget());
+  host->EnableEventListening();
+
   std::set<aura::Window*>::iterator iter = parents_.find(parent);
   if (iter != parents_.end()) {
     (*iter)->RemoveObserver(this);
     parents_.erase(iter);
   } else {
     NOTREACHED();
   }
 }
 
 bool SelectFileDialogImplGTK::IsCancelResponse(gint response_id) {
@@ skipping 89 matching lines @@
   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