[Win] Should filters in the save as dialog.

diff --git a/browser/file_dialog_win.cc b/browser/file_dialog_win.cc
index f30acc2..4202f55 100644 (file)
--- a/browser/file_dialog_win.cc
+++ b/browser/file_dialog_win.cc
@@ -9,7 +9,11 @@
 #include <shlobj.h>
 
 #include "base/file_util.h"
+#include "base/i18n/case_conversion.h"
 #include "base/string_util.h"
+#include "base/strings/string_split.h"
+#include "base/utf_string_conversions.h"
+#include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #include "browser/native_window.h"
 
@@ -17,6 +21,12 @@ namespace file_dialog {
 
 namespace {
 
+// Given |extension|, if it's not empty, then remove the leading dot.
+std::wstring GetExtensionWithoutLeadingDot(const std::wstring& extension) {
+  DCHECK(extension.empty() || extension[0] == L'.');
+  return extension.empty() ? extension : extension.substr(1);
+}
+
 // Distinguish directories from regular files.
 bool IsDirectory(const base::FilePath& path) {
   base::PlatformFileInfo file_info;
@@ -24,6 +34,148 @@ bool IsDirectory(const base::FilePath& path) {
       file_info.is_directory : path.EndsWithSeparator();
 }
 
+// Get the file type description from the registry. This will be "Text Document"
+// for .txt files, "JPEG Image" for .jpg files, etc. If the registry doesn't
+// have an entry for the file type, we return false, true if the description was
+// found. 'file_ext' must be in form ".txt".
+static bool GetRegistryDescriptionFromExtension(const std::wstring& file_ext,
+                                                std::wstring* reg_description) {
+  DCHECK(reg_description);
+  base::win::RegKey reg_ext(HKEY_CLASSES_ROOT, file_ext.c_str(), KEY_READ);
+  std::wstring reg_app;
+  if (reg_ext.ReadValue(NULL, &reg_app) == ERROR_SUCCESS && !reg_app.empty()) {
+    base::win::RegKey reg_link(HKEY_CLASSES_ROOT, reg_app.c_str(), KEY_READ);
+    if (reg_link.ReadValue(NULL, reg_description) == ERROR_SUCCESS)
+      return true;
+  }
+  return false;
+}
+
+// Set up a filter for a Save/Open dialog, which will consist of |file_ext| file
+// extensions (internally separated by semicolons), |ext_desc| as the text
+// descriptions of the |file_ext| types (optional), and (optionally) the default
+// 'All Files' view. The purpose of the filter is to show only files of a
+// particular type in a Windows Save/Open dialog box. The resulting filter is
+// returned. The filters created here are:
+//   1. only files that have 'file_ext' as their extension
+//   2. all files (only added if 'include_all_files' is true)
+// Example:
+//   file_ext: { "*.txt", "*.htm;*.html" }
+//   ext_desc: { "Text Document" }
+//   returned: "Text Document\0*.txt\0HTML Document\0*.htm;*.html\0"
+//             "All Files\0*.*\0\0" (in one big string)
+// If a description is not provided for a file extension, it will be retrieved
+// from the registry. If the file extension does not exist in the registry, it
+// will be omitted from the filter, as it is likely a bogus extension.
+std::wstring FormatFilterForExtensions(
+    const std::vector<std::wstring>& file_ext,
+    const std::vector<std::wstring>& ext_desc,
+    bool include_all_files) {
+  const std::wstring all_ext = L"*.*";
+  // TODO(zcbenz): Should be localized.
+  const std::wstring all_desc = L"All Files";
+
+  DCHECK(file_ext.size() >= ext_desc.size());
+
+  if (file_ext.empty())
+    include_all_files = true;
+
+  std::wstring result;
+
+  for (size_t i = 0; i < file_ext.size(); ++i) {
+    std::wstring ext = file_ext[i];
+    std::wstring desc;
+    if (i < ext_desc.size())
+      desc = ext_desc[i];
+
+    if (ext.empty()) {
+      // Force something reasonable to appear in the dialog box if there is no
+      // extension provided.
+      include_all_files = true;
+      continue;
+    }
+
+    if (desc.empty()) {
+      DCHECK(ext.find(L'.') != std::wstring::npos);
+      std::wstring first_extension = ext.substr(ext.find(L'.'));
+      size_t first_separator_index = first_extension.find(L';');
+      if (first_separator_index != std::wstring::npos)
+        first_extension = first_extension.substr(0, first_separator_index);
+
+      // Find the extension name without the preceeding '.' character.
+      std::wstring ext_name = first_extension;
+      size_t ext_index = ext_name.find_first_not_of(L'.');
+      if (ext_index != std::wstring::npos)
+        ext_name = ext_name.substr(ext_index);
+
+      if (!GetRegistryDescriptionFromExtension(first_extension, &desc)) {
+        // The extension doesn't exist in the registry. Create a description
+        // based on the unknown extension type (i.e. if the extension is .qqq,
+        // the we create a description "QQQ File (.qqq)").
+        include_all_files = true;
+        // TODO(zcbenz): should be localized.
+        desc = base::i18n::ToUpper(WideToUTF16(ext_name)) + L" File (."
+                                                          + ext_name
+                                                          + L")";
+      }
+      if (desc.empty())
+        desc = L"*." + ext_name;
+    }
+
+    result.append(desc.c_str(), desc.size() + 1);  // Append NULL too.
+    result.append(ext.c_str(), ext.size() + 1);
+  }
+
+  if (include_all_files) {
+    result.append(all_desc.c_str(), all_desc.size() + 1);
+    result.append(all_ext.c_str(), all_ext.size() + 1);
+  }
+
+  result.append(1, '\0');  // Double NULL required.
+  return result;
+}
+
+// This function takes the output of a SaveAs dialog: a filename, a filter and
+// the extension originally suggested to the user (shown in the dialog box) and
+// returns back the filename with the appropriate extension tacked on. If the
+// user requests an unknown extension and is not using the 'All files' filter,
+// the suggested extension will be appended, otherwise we will leave the
+// filename unmodified. |filename| should contain the filename selected in the
+// SaveAs dialog box and may include the path, |filter_selected| should be
+// '*.something', for example '*.*' or it can be blank (which is treated as
+// *.*). |suggested_ext| should contain the extension without the dot (.) in
+// front, for example 'jpg'.
+std::wstring AppendExtensionIfNeeded(
+    const std::wstring& filename,
+    const std::wstring& filter_selected,
+    const std::wstring& suggested_ext) {
+  DCHECK(!filename.empty());
+  std::wstring return_value = filename;
+
+  // If we wanted a specific extension, but the user's filename deleted it or
+  // changed it to something that the system doesn't understand, re-append.
+  // Careful: Checking net::GetMimeTypeFromExtension() will only find
+  // extensions with a known MIME type, which many "known" extensions on Windows
+  // don't have.  So we check directly for the "known extension" registry key.
+  std::wstring file_extension(
+      GetExtensionWithoutLeadingDot(base::FilePath(filename).Extension()));
+  std::wstring key(L"." + file_extension);
+  if (!(filter_selected.empty() || filter_selected == L"*.*") &&
+      !base::win::RegKey(HKEY_CLASSES_ROOT, key.c_str(), KEY_READ).Valid() &&
+      file_extension != suggested_ext) {
+    if (return_value[return_value.length() - 1] != L'.')
+      return_value.append(L".");
+    return_value.append(suggested_ext);
+  }
+
+  // Strip any trailing dots, which Windows doesn't allow.
+  size_t index = return_value.find_last_not_of(L'.');
+  if (index < return_value.size() - 1)
+    return_value.resize(index + 1);
+
+  return return_value;
+}
+
 // Enforce visible dialog box.
 UINT_PTR CALLBACK SaveAsDialogHook(HWND dialog, UINT message,
                                    WPARAM wparam, LPARAM lparam) {
@@ -87,6 +239,12 @@ bool ShowSaveDialog(atom::NativeWindow* window,
                     const std::string& title,
                     const base::FilePath& default_path,
                     base::FilePath* path) {
+  std::wstring file_ext = default_path.Extension().insert(0, L"*");
+  std::wstring filter = FormatFilterForExtensions(
+      std::vector<std::wstring>(1, file_ext),
+      std::vector<std::wstring>(),
+      true);
+
   std::wstring file_part = default_path.BaseName().value();
   // If the default_path is a root directory, file_part will be '\', and the
   // call to GetSaveFileName below will fail.
@@ -111,12 +269,11 @@ bool ShowSaveDialog(atom::NativeWindow* window,
   save_as.hwndOwner = window->GetNativeWindow();
   save_as.hInstance = NULL;
 
-  // TODO(zcbenz): Should support filters.
-  save_as.lpstrFilter = NULL;
-  save_as.nFilterIndex = 0;
+  save_as.lpstrFilter = filter.empty() ? NULL : filter.c_str();
 
   save_as.lpstrCustomFilter = NULL;
   save_as.nMaxCustFilter = 0;
+  save_as.nFilterIndex = 1;
   save_as.lpstrFile = file_name;
   save_as.nMaxFile = arraysize(file_name);
   save_as.lpstrFileTitle = NULL;
@@ -159,7 +316,28 @@ bool ShowSaveDialog(atom::NativeWindow* window,
   }
 
   // Return the user's choice.
-  *path = base::FilePath(save_as.lpstrFile);
+  *path = base::FilePath();
+
+  // Figure out what filter got selected from the vector with embedded nulls.
+  // NOTE: The filter contains a string with embedded nulls, such as:
+  // JPG Image\0*.jpg\0All files\0*.*\0\0
+  // The filter index is 1-based index for which pair got selected. So, using
+  // the example above, if the first index was selected we need to skip 1
+  // instance of null to get to "*.jpg".
+  std::vector<std::wstring> filters;
+  if (!filter.empty() && save_as.nFilterIndex > 0)
+    base::SplitString(filter, '\0', &filters);
+  std::wstring filter_selected;
+  if (!filters.empty())
+    filter_selected = filters[(2 * (save_as.nFilterIndex - 1)) + 1];
+
+  // Get the extension that was suggested to the user (when the Save As dialog
+  // was opened).
+  std::wstring suggested_ext =
+    GetExtensionWithoutLeadingDot(default_path.Extension());
+
+  *path = base::FilePath(AppendExtensionIfNeeded(
+        save_as.lpstrFile, filter_selected, suggested_ext));
   return true;
 }