Home | History | Annotate | Download | only in printing 
      1 // Copyright 2014 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 "printing/print_settings_conversion.h"
      6 
      7 #include <algorithm>
      8 #include <cmath>
      9 #include <string>
     10 
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "base/time/time.h"
     14 #include "base/values.h"
     15 #include "printing/page_size_margins.h"
     16 #include "printing/print_job_constants.h"
     17 #include "printing/print_settings.h"
     18 #include "printing/units.h"
     19 
     20 namespace printing {
     21 
     22 namespace {
     23 
     24 void GetCustomMarginsFromJobSettings(const base::DictionaryValue& settings,
     25                                      PageSizeMargins* page_size_margins) {
     26   const base::DictionaryValue* custom_margins;
     27   if (!settings.GetDictionary(kSettingMarginsCustom, &custom_margins) ||
     28       !custom_margins->GetDouble(kSettingMarginTop,
     29                                  &page_size_margins->margin_top) ||
     30       !custom_margins->GetDouble(kSettingMarginBottom,
     31                                  &page_size_margins->margin_bottom) ||
     32       !custom_margins->GetDouble(kSettingMarginLeft,
     33                                  &page_size_margins->margin_left) ||
     34       !custom_margins->GetDouble(kSettingMarginRight,
     35                                  &page_size_margins->margin_right)) {
     36     NOTREACHED();
     37   }
     38 }
     39 
     40 void SetMarginsToJobSettings(const std::string& json_path,
     41                              const PageMargins& margins,
     42                              base::DictionaryValue* job_settings) {
     43   base::DictionaryValue* dict = new base::DictionaryValue;
     44   job_settings->Set(json_path, dict);
     45   dict->SetInteger(kSettingMarginTop, margins.top);
     46   dict->SetInteger(kSettingMarginBottom, margins.bottom);
     47   dict->SetInteger(kSettingMarginLeft, margins.left);
     48   dict->SetInteger(kSettingMarginRight, margins.right);
     49 }
     50 
     51 void SetSizeToJobSettings(const std::string& json_path,
     52                           const gfx::Size& size,
     53                           base::DictionaryValue* job_settings) {
     54   base::DictionaryValue* dict = new base::DictionaryValue;
     55   job_settings->Set(json_path, dict);
     56   dict->SetInteger("width", size.width());
     57   dict->SetInteger("height", size.height());
     58 }
     59 
     60 void SetRectToJobSettings(const std::string& json_path,
     61                           const gfx::Rect& rect,
     62                           base::DictionaryValue* job_settings) {
     63   base::DictionaryValue* dict = new base::DictionaryValue;
     64   job_settings->Set(json_path, dict);
     65   dict->SetInteger("x", rect.x());
     66   dict->SetInteger("y", rect.y());
     67   dict->SetInteger("width", rect.width());
     68   dict->SetInteger("height", rect.height());
     69 }
     70 
     71 }  // namespace
     72 
     73 bool PrintSettingsFromJobSettings(const base::DictionaryValue& job_settings,
     74                                   PrintSettings* settings) {
     75   bool display_header_footer = false;
     76   if (!job_settings.GetBoolean(kSettingHeaderFooterEnabled,
     77                                &display_header_footer)) {
     78     return false;
     79   }
     80   settings->set_display_header_footer(display_header_footer);
     81 
     82   if (settings->display_header_footer()) {
     83     base::string16 title;
     84     base::string16 url;
     85     if (!job_settings.GetString(kSettingHeaderFooterTitle, &title) ||
     86         !job_settings.GetString(kSettingHeaderFooterURL, &url)) {
     87       return false;
     88     }
     89     settings->set_title(title);
     90     settings->set_url(url);
     91   }
     92 
     93   bool backgrounds = false;
     94   bool selection_only = false;
     95   if (!job_settings.GetBoolean(kSettingShouldPrintBackgrounds, &backgrounds) ||
     96       !job_settings.GetBoolean(kSettingShouldPrintSelectionOnly,
     97                                &selection_only)) {
     98     return false;
     99   }
    100   settings->set_should_print_backgrounds(backgrounds);
    101   settings->set_selection_only(selection_only);
    102 
    103   PrintSettings::RequestedMedia requested_media;
    104   const base::DictionaryValue* media_size_value = NULL;
    105   if (job_settings.GetDictionary(kSettingMediaSize, &media_size_value)) {
    106     int width_microns = 0;
    107     int height_microns = 0;
    108     if (media_size_value->GetInteger(kSettingMediaSizeWidthMicrons,
    109                                      &width_microns) &&
    110         media_size_value->GetInteger(kSettingMediaSizeHeightMicrons,
    111                                      &height_microns)) {
    112       requested_media.size_microns = gfx::Size(width_microns, height_microns);
    113     }
    114     std::string vendor_id;
    115     if (media_size_value->GetString(kSettingMediaSizeVendorId, &vendor_id) &&
    116         !vendor_id.empty()) {
    117       requested_media.vendor_id = vendor_id;
    118     }
    119   }
    120   settings->set_requested_media(requested_media);
    121 
    122   int margin_type = DEFAULT_MARGINS;
    123   if (!job_settings.GetInteger(kSettingMarginsType, &margin_type) ||
    124       (margin_type != DEFAULT_MARGINS &&
    125        margin_type != NO_MARGINS &&
    126        margin_type != CUSTOM_MARGINS &&
    127        margin_type != PRINTABLE_AREA_MARGINS)) {
    128     margin_type = DEFAULT_MARGINS;
    129   }
    130   settings->set_margin_type(static_cast<MarginType>(margin_type));
    131 
    132   if (margin_type == CUSTOM_MARGINS) {
    133     PageSizeMargins page_size_margins;
    134     GetCustomMarginsFromJobSettings(job_settings, &page_size_margins);
    135 
    136     PageMargins margins_in_points;
    137     margins_in_points.Clear();
    138     margins_in_points.top = page_size_margins.margin_top;
    139     margins_in_points.bottom = page_size_margins.margin_bottom;
    140     margins_in_points.left = page_size_margins.margin_left;
    141     margins_in_points.right = page_size_margins.margin_right;
    142 
    143     settings->SetCustomMargins(margins_in_points);
    144   }
    145 
    146   PageRanges new_ranges;
    147   const base::ListValue* page_range_array = NULL;
    148   if (job_settings.GetList(kSettingPageRange, &page_range_array)) {
    149     for (size_t index = 0; index < page_range_array->GetSize(); ++index) {
    150       const base::DictionaryValue* dict;
    151       if (!page_range_array->GetDictionary(index, &dict))
    152         continue;
    153 
    154       PageRange range;
    155       if (!dict->GetInteger(kSettingPageRangeFrom, &range.from) ||
    156           !dict->GetInteger(kSettingPageRangeTo, &range.to)) {
    157         continue;
    158       }
    159 
    160       // Page numbers are 1-based in the dictionary.
    161       // Page numbers are 0-based for the printing context.
    162       range.from--;
    163       range.to--;
    164       new_ranges.push_back(range);
    165     }
    166   }
    167   settings->set_ranges(new_ranges);
    168 
    169   int color = 0;
    170   bool landscape = false;
    171   int duplex_mode = 0;
    172   base::string16 device_name;
    173   bool collate = false;
    174   int copies = 1;
    175 
    176   if (!job_settings.GetBoolean(kSettingCollate, &collate) ||
    177       !job_settings.GetInteger(kSettingCopies, &copies) ||
    178       !job_settings.GetInteger(kSettingColor, &color) ||
    179       !job_settings.GetInteger(kSettingDuplexMode, &duplex_mode) ||
    180       !job_settings.GetBoolean(kSettingLandscape, &landscape) ||
    181       !job_settings.GetString(kSettingDeviceName, &device_name)) {
    182     return false;
    183   }
    184 
    185   settings->set_collate(collate);
    186   settings->set_copies(copies);
    187   settings->SetOrientation(landscape);
    188   settings->set_device_name(device_name);
    189   settings->set_duplex_mode(static_cast<DuplexMode>(duplex_mode));
    190   settings->set_color(static_cast<ColorModel>(color));
    191 
    192   return true;
    193 }
    194 
    195 void PrintSettingsToJobSettingsDebug(const PrintSettings& settings,
    196                                      base::DictionaryValue* job_settings) {
    197   job_settings->SetBoolean(kSettingHeaderFooterEnabled,
    198                            settings.display_header_footer());
    199   job_settings->SetString(kSettingHeaderFooterTitle, settings.title());
    200   job_settings->SetString(kSettingHeaderFooterURL, settings.url());
    201   job_settings->SetBoolean(kSettingShouldPrintBackgrounds,
    202                            settings.should_print_backgrounds());
    203   job_settings->SetBoolean(kSettingShouldPrintSelectionOnly,
    204                            settings.selection_only());
    205   job_settings->SetInteger(kSettingMarginsType, settings.margin_type());
    206   if (!settings.ranges().empty()) {
    207     base::ListValue* page_range_array = new base::ListValue;
    208     job_settings->Set(kSettingPageRange, page_range_array);
    209     for (size_t i = 0; i < settings.ranges().size(); ++i) {
    210       base::DictionaryValue* dict = new base::DictionaryValue;
    211       page_range_array->Append(dict);
    212       dict->SetInteger(kSettingPageRangeFrom, settings.ranges()[i].from + 1);
    213       dict->SetInteger(kSettingPageRangeTo, settings.ranges()[i].to + 1);
    214     }
    215   }
    216 
    217   job_settings->SetBoolean(kSettingCollate, settings.collate());
    218   job_settings->SetInteger(kSettingCopies, settings.copies());
    219   job_settings->SetInteger(kSettingColor, settings.color());
    220   job_settings->SetInteger(kSettingDuplexMode, settings.duplex_mode());
    221   job_settings->SetBoolean(kSettingLandscape, settings.landscape());
    222   job_settings->SetString(kSettingDeviceName, settings.device_name());
    223 
    224   // Following values are not read form JSON by InitSettings, so do not have
    225   // common public constants. So just serialize in "debug" section.
    226   base::DictionaryValue* debug = new base::DictionaryValue;
    227   job_settings->Set("debug", debug);
    228   debug->SetDouble("minShrink", settings.min_shrink());
    229   debug->SetDouble("maxShrink", settings.max_shrink());
    230   debug->SetInteger("desiredDpi", settings.desired_dpi());
    231   debug->SetInteger("dpi", settings.dpi());
    232   debug->SetInteger("deviceUnitsPerInch", settings.device_units_per_inch());
    233   debug->SetBoolean("support_alpha_blend", settings.should_print_backgrounds());
    234   debug->SetString("media_vendor_od", settings.requested_media().vendor_id);
    235   SetSizeToJobSettings(
    236       "media_size", settings.requested_media().size_microns, debug);
    237   SetMarginsToJobSettings("requested_custom_margins_in_points",
    238                           settings.requested_custom_margins_in_points(),
    239                           debug);
    240   const PageSetup& page_setup = settings.page_setup_device_units();
    241   SetMarginsToJobSettings(
    242       "effective_margins", page_setup.effective_margins(), debug);
    243   SetSizeToJobSettings("physical_size", page_setup.physical_size(), debug);
    244   SetRectToJobSettings("overlay_area", page_setup.overlay_area(), debug);
    245   SetRectToJobSettings("content_area", page_setup.content_area(), debug);
    246   SetRectToJobSettings("printable_area", page_setup.printable_area(), debug);
    247 }
    248 
    249 }  // namespace printing
    250