Print Preview: Making margin selection sticky (part 2/2)

chrome/browser/ui/webui/print_preview_handler.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/webui/print_preview_handler.h"
 
 #include <ctype.h>
 
 #include <string>
 #include <vector>
@@ skipping 32 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/print_messages.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "printing/backend/print_backend.h"
 #include "printing/metafile.h"
 #include "printing/metafile_impl.h"
 #include "printing/page_range.h"
+#include "printing/page_size_margins.h"
 #include "printing/print_settings.h"
 #include "unicode/ulocdata.h"
 
 #if !defined(OS_CHROMEOS)
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
 using content::BrowserThread;
 
@@ skipping 136 matching lines @@
 };
 
 // static
 FilePath* PrintPreviewHandler::last_saved_path_ = NULL;
 std::string* PrintPreviewHandler::last_used_printer_cloud_print_data_ = NULL;
 std::string* PrintPreviewHandler::last_used_printer_name_ = NULL;
 printing::ColorModels PrintPreviewHandler::last_used_color_model_ =
     printing::UNKNOWN_COLOR_MODEL;
 printing::MarginType PrintPreviewHandler::last_used_margins_type_ =
     printing::DEFAULT_MARGINS;
+printing::PageSizeMargins*
+    PrintPreviewHandler::last_used_page_size_margins_ = NULL;
 
 PrintPreviewHandler::PrintPreviewHandler()
     : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
       regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
       has_logged_printers_count_(false) {
   ReportUserActionHistogram(PREVIEW_STARTED);
 }
 
@@ skipping 45 matching lines @@
   web_ui_->RegisterMessageCallback("saveLastPrinter",
       base::Bind(&PrintPreviewHandler::HandleSaveLastPrinter,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("getInitiatorTabTitle",
       base::Bind(&PrintPreviewHandler::HandleGetInitiatorTabTitle,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("getNumberFormatAndMeasurementSystem",
       base::Bind(
           &PrintPreviewHandler::HandleGetNumberFormatAndMeasurementSystem,
           base::Unretained(this)));
+  web_ui_->RegisterMessageCallback("getLastUsedMarginSettings",
+      base::Bind(&PrintPreviewHandler::HandleGetLastUsedMarginSettings,
+                 base::Unretained(this)));
 }
 
 TabContentsWrapper* PrintPreviewHandler::preview_tab_wrapper() const {
   return TabContentsWrapper::GetCurrentWrapperForContents(preview_tab());
 }
 TabContents* PrintPreviewHandler::preview_tab() const {
   return web_ui_->tab_contents();
 }
 
 void PrintPreviewHandler::HandleGetDefaultPrinter(const ListValue* /*args*/) {
@@ skipping 110 matching lines @@
   int color_model;
   if (!settings->GetInteger(printing::kSettingColor, &color_model))
     color_model = printing::GRAY;
   last_used_color_model_ = static_cast<printing::ColorModels>(color_model);
 
   // Storing last used margin settings.
   int margin_type;
   if (!settings->GetInteger(printing::kSettingMarginsType, &margin_type))
     margin_type = printing::DEFAULT_MARGINS;
   last_used_margins_type_ = static_cast<printing::MarginType>(margin_type);
+  if (last_used_margins_type_ == printing::CUSTOM_MARGINS) {
+    if (!last_used_page_size_margins_)
+      last_used_page_size_margins_ = new printing::PageSizeMargins();
+    getCustomMarginsFromJobSettings(*settings, last_used_page_size_margins_);
+  }
 
   bool print_to_pdf = false;
   settings->GetBoolean(printing::kSettingPrintToPDF, &print_to_pdf);
 
   settings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
 
   bool is_cloud_printer = settings->HasKey(printing::kSettingCloudPrintId);
   bool is_cloud_dialog = false;
   settings->GetBoolean(printing::kSettingCloudPrintDialog, &is_cloud_dialog);
   if (is_cloud_printer) {
@@ skipping 220 matching lines @@
   // Getting the number formatting based on the locale.
   StringValue number_format(base::FormatDouble(123456.78, 2));
   base::FundamentalValue system(measurement_system);
 
   web_ui_->CallJavascriptFunction(
       "print_preview.setNumberFormatAndMeasurementSystem",
       number_format,
       system);
 }
 
+void PrintPreviewHandler::HandleGetLastUsedMarginSettings(
+    const ListValue* /*args*/) {
+  base::FundamentalValue margins_type(
+      PrintPreviewHandler::last_used_margins_type_);
+  if (last_used_margins_type_ == printing::CUSTOM_MARGINS) {
+    DCHECK(last_used_page_size_margins_);

[dpapad, 2011/11/03 18:48:27]

Let me clarify a bit how the 4 margin values are used. 

- If the last print job was done with custom margins they are sent to the UI and
displayed. 
- If the last print job was NOT done with custom margins these values are not
sent to the UI. 

In any case changing the selection manually to custom in the UI picks up from
whatever is currently displayed (not from previously used settings).

+    base::DictionaryValue page_size_margins;
+    page_size_margins.SetDouble(printing::kSettingMarginTop,
+                                last_used_page_size_margins_->margin_top);
+    page_size_margins.SetDouble(printing::kSettingMarginBottom,
+                                last_used_page_size_margins_->margin_bottom);
+    page_size_margins.SetDouble(printing::kSettingMarginLeft,
+                                last_used_page_size_margins_->margin_left);
+    page_size_margins.SetDouble(printing::kSettingMarginRight,
+                                last_used_page_size_margins_->margin_right);
+    web_ui_->CallJavascriptFunction("print_preview.setLastUsedMargins",
+                                    margins_type,
+                                    page_size_margins);
+  } else {
+    web_ui_->CallJavascriptFunction("print_preview.setLastUsedMargins",
+                                    margins_type);
+  }
+}
+
 void PrintPreviewHandler::ActivateInitiatorTabAndClosePreviewTab() {
   TabContentsWrapper* initiator_tab = GetInitiatorTab();
   if (initiator_tab) {
     static_cast<RenderViewHostDelegate*>(
         initiator_tab->tab_contents())->Activate();
   }
   ClosePrintPreviewTab();
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
     const DictionaryValue& settings_info) {
   VLOG(1) << "Get printer capabilities finished";
   web_ui_->CallJavascriptFunction("updateWithPrinterCapabilities",
                                   settings_info);
 }
 
 void PrintPreviewHandler::SendDefaultPrinter(
     const StringValue& default_printer,
     const StringValue& cloud_print_data) {
-  base::FundamentalValue margins_type(
-      PrintPreviewHandler::last_used_margins_type_);
-  web_ui_->CallJavascriptFunction("setDefaultPrinter",
-                                  default_printer,
-                                  cloud_print_data,
-                                  margins_type);
+    web_ui_->CallJavascriptFunction(
+        "setDefaultPrinter", default_printer, cloud_print_data);
 }
 
 void PrintPreviewHandler::SetupPrinterList(const ListValue& printers) {
   SendCloudPrintEnabled();
   web_ui_->CallJavascriptFunction("setPrinters", printers);
 }
 
 void PrintPreviewHandler::SendCloudPrintEnabled() {
   Profile* profile = BrowserList::GetLastActive()->profile();
   PrefService* prefs = profile->GetPrefs();
@@ skipping 189 matching lines @@
     return;
 
   // We no longer require the initiator tab details. Remove those details
   // associated with the preview tab to allow the initiator tab to create
   // another preview tab.
   printing::PrintPreviewTabController* tab_controller =
       printing::PrintPreviewTabController::GetInstance();
   if (tab_controller)
     tab_controller->EraseInitiatorTabInfo(preview_tab_wrapper());
 }