Home | History | Annotate | Download | only in gtk 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <set>
      6 
      7 #include "base/bind.h"
      8 #include "base/bind_helpers.h"
      9 #include "base/command_line.h"
     10 #include "base/logging.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/message_loop/message_loop_proxy.h"
     13 #include "base/nix/mime_util_xdg.h"
     14 #include "base/nix/xdg_util.h"
     15 #include "base/process/launch.h"
     16 #include "base/strings/string_number_conversions.h"
     17 #include "base/strings/string_util.h"
     18 #include "base/strings/utf_string_conversions.h"
     19 #include "base/threading/thread_restrictions.h"
     20 #include "base/threading/worker_pool.h"
     21 #include "grit/ui_strings.h"
     22 #include "ui/base/l10n/l10n_util.h"
     23 #include "ui/shell_dialogs/gtk/select_file_dialog_impl.h"
     24 
     25 // These conflict with base/tracked_objects.h, so need to come last.
     26 #include <gdk/gdkx.h>
     27 #include <gtk/gtk.h>
     28 
     29 namespace {
     30 
     31 std::string GetTitle(const std::string& title, int message_id) {
     32   return title.empty() ? l10n_util::GetStringUTF8(message_id) : title;
     33 }
     34 
     35 const char kKdialogBinary[] = "kdialog";
     36 
     37 // Implementation of SelectFileDialog that shows a KDE common dialog for
     38 // choosing a file or folder. This acts as a modal dialog.
     39 class SelectFileDialogImplKDE : public ui::SelectFileDialogImpl {
     40  public:
     41   SelectFileDialogImplKDE(Listener* listener,
     42                           ui::SelectFilePolicy* policy,
     43                           base::nix::DesktopEnvironment desktop);
     44 
     45  protected:
     46   virtual ~SelectFileDialogImplKDE();
     47 
     48   // SelectFileDialog implementation.
     49   // |params| is user data we pass back via the Listener interface.
     50   virtual void SelectFileImpl(
     51       Type type,
     52       const base::string16& title,
     53       const base::FilePath& default_path,
     54       const FileTypeInfo* file_types,
     55       int file_type_index,
     56       const base::FilePath::StringType& default_extension,
     57       gfx::NativeWindow owning_window,
     58       void* params) OVERRIDE;
     59 
     60  private:
     61   virtual bool HasMultipleFileTypeChoicesImpl() OVERRIDE;
     62 
     63   struct KDialogParams {
     64     // This constructor can only be run from the UI thread.
     65     KDialogParams(const std::string& type,
     66                   const std::string& title,
     67                   const base::FilePath& default_path,
     68                   gfx::NativeWindow parent,
     69                   bool file_operation,
     70                   bool multiple_selection,
     71                   void* kdialog_params,
     72                   void(SelectFileDialogImplKDE::* callback)(const std::string&,
     73                                                             int,
     74                                                             void*))
     75         : type(type),
     76           title(title),
     77           default_path(default_path),
     78           parent(parent),
     79           file_operation(file_operation),
     80           multiple_selection(multiple_selection),
     81           kdialog_params(kdialog_params),
     82           ui_loop_proxy(
     83               base::MessageLoopForUI::current()->message_loop_proxy()),
     84           callback(callback) {}
     85 
     86     std::string type;
     87     std::string title;
     88     base::FilePath default_path;
     89     gfx::NativeWindow parent;
     90     bool file_operation;
     91     bool multiple_selection;
     92     void* kdialog_params;
     93     scoped_refptr<base::MessageLoopProxy> ui_loop_proxy;
     94 
     95     void (SelectFileDialogImplKDE::*callback)(const std::string&, int, void*);
     96   };
     97 
     98   // Get the filters from |file_types_| and concatenate them into
     99   // |filter_string|.
    100   std::string GetMimeTypeFilterString();
    101 
    102   // Get KDialog command line representing the Argv array for KDialog.
    103   void GetKDialogCommandLine(const std::string& type, const std::string& title,
    104       const base::FilePath& default_path, gfx::NativeWindow parent,
    105       bool file_operation, bool multiple_selection, CommandLine* command_line);
    106 
    107   // Call KDialog on a worker thread and post results back to the caller
    108   // thread.
    109   void CallKDialogOutput(const KDialogParams& params);
    110 
    111   // Notifies the listener that a single file was chosen.
    112   void FileSelected(const base::FilePath& path, void* params);
    113 
    114   // Notifies the listener that multiple files were chosen.
    115   void MultiFilesSelected(const std::vector<base::FilePath>& files,
    116                           void* params);
    117 
    118   // Notifies the listener that no file was chosen (the action was canceled).
    119   // Dialog is passed so we can find that |params| pointer that was passed to
    120   // us when we were told to show the dialog.
    121   void FileNotSelected(void *params);
    122 
    123   void CreateSelectFolderDialog(Type type,
    124                                 const std::string& title,
    125                                 const base::FilePath& default_path,
    126                                 gfx::NativeWindow parent, void* params);
    127 
    128   void CreateFileOpenDialog(const std::string& title,
    129                                   const base::FilePath& default_path,
    130                                   gfx::NativeWindow parent, void* params);
    131 
    132   void CreateMultiFileOpenDialog(const std::string& title,
    133                                  const base::FilePath& default_path,
    134                                  gfx::NativeWindow parent, void* params);
    135 
    136   void CreateSaveAsDialog(const std::string& title,
    137                           const base::FilePath& default_path,
    138                           gfx::NativeWindow parent, void* params);
    139 
    140   // Common function for OnSelectSingleFileDialogResponse and
    141   // OnSelectSingleFolderDialogResponse.
    142   void SelectSingleFileHelper(const std::string& output, int exit_code,
    143                               void* params, bool allow_folder);
    144 
    145   void OnSelectSingleFileDialogResponse(const std::string& output,
    146                                         int exit_code, void* params);
    147   void OnSelectMultiFileDialogResponse(const std::string& output,
    148                                        int exit_code, void* params);
    149   void OnSelectSingleFolderDialogResponse(const std::string& output,
    150                                           int exit_code, void* params);
    151 
    152   // Should be either DESKTOP_ENVIRONMENT_KDE3 or DESKTOP_ENVIRONMENT_KDE4.
    153   base::nix::DesktopEnvironment desktop_;
    154 
    155   DISALLOW_COPY_AND_ASSIGN(SelectFileDialogImplKDE);
    156 };
    157 
    158 SelectFileDialogImplKDE::SelectFileDialogImplKDE(
    159     Listener* listener,
    160     ui::SelectFilePolicy* policy,
    161     base::nix::DesktopEnvironment desktop)
    162     : SelectFileDialogImpl(listener, policy),
    163       desktop_(desktop) {
    164   DCHECK(desktop_ == base::nix::DESKTOP_ENVIRONMENT_KDE3 ||
    165          desktop_ == base::nix::DESKTOP_ENVIRONMENT_KDE4);
    166 }
    167 
    168 SelectFileDialogImplKDE::~SelectFileDialogImplKDE() {
    169 }
    170 
    171 // We ignore |default_extension|.
    172 void SelectFileDialogImplKDE::SelectFileImpl(
    173     Type type,
    174     const base::string16& title,
    175     const base::FilePath& default_path,
    176     const FileTypeInfo* file_types,
    177     int file_type_index,
    178     const base::FilePath::StringType& default_extension,
    179     gfx::NativeWindow owning_window,
    180     void* params) {
    181   type_ = type;
    182   // |owning_window| can be null when user right-clicks on a downloadable item
    183   // and chooses 'Open Link in New Tab' when 'Ask where to save each file
    184   // before downloading.' preference is turned on. (http://crbug.com/29213)
    185   if (owning_window)
    186     parents_.insert(owning_window);
    187 
    188   std::string title_string = UTF16ToUTF8(title);
    189 
    190   file_type_index_ = file_type_index;
    191   if (file_types)
    192     file_types_ = *file_types;
    193   else
    194     file_types_.include_all_files = true;
    195 
    196   switch (type) {
    197     case SELECT_FOLDER:
    198     case SELECT_UPLOAD_FOLDER:
    199       CreateSelectFolderDialog(type, title_string, default_path,
    200                                owning_window, params);
    201       return;
    202     case SELECT_OPEN_FILE:
    203       CreateFileOpenDialog(title_string, default_path, owning_window,
    204                            params);
    205       return;
    206     case SELECT_OPEN_MULTI_FILE:
    207       CreateMultiFileOpenDialog(title_string, default_path,
    208                                 owning_window, params);
    209       return;
    210     case SELECT_SAVEAS_FILE:
    211       CreateSaveAsDialog(title_string, default_path, owning_window,
    212                          params);
    213       return;
    214     default:
    215       NOTREACHED();
    216       return;
    217   }
    218 }
    219 
    220 bool SelectFileDialogImplKDE::HasMultipleFileTypeChoicesImpl() {
    221   return file_types_.extensions.size() > 1;
    222 }
    223 
    224 std::string SelectFileDialogImplKDE::GetMimeTypeFilterString() {
    225   std::string filter_string;
    226   // We need a filter set because the same mime type can appear multiple times.
    227   std::set<std::string> filter_set;
    228   for (size_t i = 0; i < file_types_.extensions.size(); ++i) {
    229     for (size_t j = 0; j < file_types_.extensions[i].size(); ++j) {
    230       if (!file_types_.extensions[i][j].empty()) {
    231         std::string mime_type = base::nix::GetFileMimeType(
    232             base::FilePath("name").ReplaceExtension(
    233                 file_types_.extensions[i][j]));
    234         filter_set.insert(mime_type);
    235       }
    236     }
    237   }
    238   // Add the *.* filter, but only if we have added other filters (otherwise it
    239   // is implied).
    240   if (file_types_.include_all_files && !file_types_.extensions.empty())
    241     filter_set.insert("application/octet-stream");
    242   // Create the final output string.
    243   filter_string.clear();
    244   for (std::set<std::string>::iterator it = filter_set.begin();
    245        it != filter_set.end(); ++it) {
    246     filter_string.append(*it + " ");
    247   }
    248   return filter_string;
    249 }
    250 
    251 void SelectFileDialogImplKDE::CallKDialogOutput(const KDialogParams& params) {
    252   CommandLine::StringVector cmd_vector;
    253   cmd_vector.push_back(kKdialogBinary);
    254   CommandLine command_line(cmd_vector);
    255   GetKDialogCommandLine(params.type, params.title, params.default_path,
    256                         params.parent, params.file_operation,
    257                         params.multiple_selection, &command_line);
    258   std::string output;
    259   int exit_code;
    260   // Get output from KDialog
    261   base::GetAppOutputWithExitCode(command_line, &output, &exit_code);
    262   if (!output.empty())
    263     output.erase(output.size() - 1);
    264   // Now the dialog is no longer showing. We can erase its parent from the
    265   // parent set.
    266   std::set<GtkWindow*>::iterator iter = parents_.find(params.parent);
    267   if (iter != parents_.end())
    268     parents_.erase(iter);
    269   params.ui_loop_proxy->PostTask(FROM_HERE,
    270       base::Bind(params.callback, this, output, exit_code,
    271                  params.kdialog_params));
    272 }
    273 
    274 void SelectFileDialogImplKDE::GetKDialogCommandLine(const std::string& type,
    275     const std::string& title, const base::FilePath& path,
    276     gfx::NativeWindow parent, bool file_operation, bool multiple_selection,
    277     CommandLine* command_line) {
    278   CHECK(command_line);
    279 
    280   // Attach to the current Chrome window.
    281   GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET((parent)));
    282   int window_id = GDK_DRAWABLE_XID(gdk_window);
    283   command_line->AppendSwitchNative(
    284       desktop_ == base::nix::DESKTOP_ENVIRONMENT_KDE3 ? "--embed" : "--attach",
    285       base::IntToString(window_id));
    286   // Set the correct title for the dialog.
    287   if (!title.empty())
    288     command_line->AppendSwitchNative("--title", title);
    289   // Enable multiple file selection if we need to.
    290   if (multiple_selection) {
    291     command_line->AppendSwitch("--multiple");
    292     command_line->AppendSwitch("--separate-output");
    293   }
    294   command_line->AppendSwitch(type);
    295   // The path should never be empty. If it is, set it to PWD.
    296   if (path.empty())
    297     command_line->AppendArgPath(base::FilePath("."));
    298   else
    299     command_line->AppendArgPath(path);
    300   // Depending on the type of the operation we need, get the path to the
    301   // file/folder and set up mime type filters.
    302   if (file_operation)
    303     command_line->AppendArg(GetMimeTypeFilterString());
    304   VLOG(1) << "KDialog command line: " << command_line->GetCommandLineString();
    305 }
    306 
    307 void SelectFileDialogImplKDE::FileSelected(const base::FilePath& path,
    308                                            void* params) {
    309   if (type_ == SELECT_SAVEAS_FILE)
    310     *last_saved_path_ = path.DirName();
    311   else if (type_ == SELECT_OPEN_FILE)
    312     *last_opened_path_ = path.DirName();
    313   else if (type_ == SELECT_FOLDER)
    314     *last_opened_path_ = path;
    315   else
    316     NOTREACHED();
    317   if (listener_) {  // What does the filter index actually do?
    318     // TODO(dfilimon): Get a reasonable index value from somewhere.
    319     listener_->FileSelected(path, 1, params);
    320   }
    321 }
    322 
    323 void SelectFileDialogImplKDE::MultiFilesSelected(
    324     const std::vector<base::FilePath>& files, void* params) {
    325   *last_opened_path_ = files[0].DirName();
    326   if (listener_)
    327     listener_->MultiFilesSelected(files, params);
    328 }
    329 
    330 void SelectFileDialogImplKDE::FileNotSelected(void* params) {
    331   if (listener_)
    332     listener_->FileSelectionCanceled(params);
    333 }
    334 
    335 void SelectFileDialogImplKDE::CreateSelectFolderDialog(
    336     Type type, const std::string& title, const base::FilePath& default_path,
    337     gfx::NativeWindow parent, void *params) {
    338   int title_message_id = (type == SELECT_UPLOAD_FOLDER) ?
    339       IDS_SELECT_UPLOAD_FOLDER_DIALOG_TITLE :
    340       IDS_SELECT_FOLDER_DIALOG_TITLE;
    341   base::WorkerPool::PostTask(FROM_HERE,
    342       base::Bind(
    343           &SelectFileDialogImplKDE::CallKDialogOutput,
    344           this,
    345           KDialogParams(
    346               "--getexistingdirectory",
    347               GetTitle(title, title_message_id),
    348               default_path.empty() ? *last_opened_path_ : default_path,
    349               parent, false, false, params,
    350               &SelectFileDialogImplKDE::OnSelectSingleFolderDialogResponse)),
    351       true);
    352 }
    353 
    354 void SelectFileDialogImplKDE::CreateFileOpenDialog(
    355     const std::string& title, const base::FilePath& default_path,
    356     gfx::NativeWindow parent, void* params) {
    357   base::WorkerPool::PostTask(FROM_HERE,
    358       base::Bind(
    359           &SelectFileDialogImplKDE::CallKDialogOutput,
    360           this,
    361           KDialogParams(
    362               "--getopenfilename",
    363               GetTitle(title, IDS_OPEN_FILE_DIALOG_TITLE),
    364               default_path.empty() ? *last_opened_path_ : default_path,
    365               parent, true, false, params,
    366               &SelectFileDialogImplKDE::OnSelectSingleFileDialogResponse)),
    367       true);
    368 }
    369 
    370 void SelectFileDialogImplKDE::CreateMultiFileOpenDialog(
    371     const std::string& title, const base::FilePath& default_path,
    372     gfx::NativeWindow parent, void* params) {
    373   base::WorkerPool::PostTask(FROM_HERE,
    374       base::Bind(
    375           &SelectFileDialogImplKDE::CallKDialogOutput,
    376           this,
    377           KDialogParams(
    378               "--getopenfilename",
    379               GetTitle(title, IDS_OPEN_FILES_DIALOG_TITLE),
    380               default_path.empty() ? *last_opened_path_ : default_path,
    381               parent, true, true, params,
    382               &SelectFileDialogImplKDE::OnSelectMultiFileDialogResponse)),
    383       true);
    384 }
    385 
    386 void SelectFileDialogImplKDE::CreateSaveAsDialog(
    387     const std::string& title, const base::FilePath& default_path,
    388     gfx::NativeWindow parent, void* params) {
    389   base::WorkerPool::PostTask(FROM_HERE,
    390       base::Bind(
    391           &SelectFileDialogImplKDE::CallKDialogOutput,
    392           this,
    393           KDialogParams(
    394               "--getsavefilename",
    395               GetTitle(title, IDS_SAVE_AS_DIALOG_TITLE),
    396               default_path.empty() ? *last_saved_path_ : default_path,
    397               parent, true, false, params,
    398               &SelectFileDialogImplKDE::OnSelectSingleFileDialogResponse)),
    399       true);
    400 }
    401 
    402 void SelectFileDialogImplKDE::SelectSingleFileHelper(const std::string& output,
    403     int exit_code, void* params, bool allow_folder) {
    404   VLOG(1) << "[kdialog] SingleFileResponse: " << output;
    405   if (exit_code != 0 || output.empty()) {
    406     FileNotSelected(params);
    407     return;
    408   }
    409 
    410   base::FilePath path(output);
    411   if (allow_folder) {
    412     FileSelected(path, params);
    413     return;
    414   }
    415 
    416   if (CallDirectoryExistsOnUIThread(path))
    417     FileNotSelected(params);
    418   else
    419     FileSelected(path, params);
    420 }
    421 
    422 void SelectFileDialogImplKDE::OnSelectSingleFileDialogResponse(
    423     const std::string& output, int exit_code, void* params) {
    424   SelectSingleFileHelper(output, exit_code, params, false);
    425 }
    426 
    427 void SelectFileDialogImplKDE::OnSelectSingleFolderDialogResponse(
    428     const std::string& output, int exit_code, void* params) {
    429   SelectSingleFileHelper(output, exit_code, params, true);
    430 }
    431 
    432 void SelectFileDialogImplKDE::OnSelectMultiFileDialogResponse(
    433     const std::string& output, int exit_code, void* params) {
    434   VLOG(1) << "[kdialog] MultiFileResponse: " << output;
    435 
    436   if (exit_code != 0 || output.empty()) {
    437     FileNotSelected(params);
    438     return;
    439   }
    440 
    441   std::vector<std::string> filenames;
    442   Tokenize(output, "\n", &filenames);
    443   std::vector<base::FilePath> filenames_fp;
    444   for (std::vector<std::string>::iterator iter = filenames.begin();
    445        iter != filenames.end(); ++iter) {
    446     base::FilePath path(*iter);
    447     if (CallDirectoryExistsOnUIThread(path))
    448       continue;
    449     filenames_fp.push_back(path);
    450   }
    451 
    452   if (filenames_fp.empty()) {
    453     FileNotSelected(params);
    454     return;
    455   }
    456   MultiFilesSelected(filenames_fp, params);
    457 }
    458 
    459 }  // namespace
    460 
    461 namespace ui {
    462 
    463 // static
    464 bool SelectFileDialogImpl::CheckKDEDialogWorksOnUIThread() {
    465   // No choice. UI thread can't continue without an answer here. Fortunately we
    466   // only do this once, the first time a file dialog is displayed.
    467   base::ThreadRestrictions::ScopedAllowIO allow_io;
    468 
    469   CommandLine::StringVector cmd_vector;
    470   cmd_vector.push_back(kKdialogBinary);
    471   cmd_vector.push_back("--version");
    472   CommandLine command_line(cmd_vector);
    473   std::string dummy;
    474   return base::GetAppOutput(command_line, &dummy);
    475 }
    476 
    477 // static
    478 SelectFileDialogImpl* SelectFileDialogImpl::NewSelectFileDialogImplKDE(
    479     Listener* listener,
    480     ui::SelectFilePolicy* policy,
    481     base::nix::DesktopEnvironment desktop) {
    482   return new SelectFileDialogImplKDE(listener, policy, desktop);
    483 }
    484 
    485 }  // namespace ui
    486