printing/print_settings.cc

   1 // Copyright (c) 2012 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.h"
   6
   7 #include "base/atomic_sequence_num.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/logging.h"
  10 #include "printing/print_job_constants.h"
  11 #include "printing/units.h"
  12
  13 namespace printing {
  14
  15 base::LazyInstance<std::string>::Leaky g_user_agent;
  16
  17 void SetAgent(const std::string& user_agent) {
  18   g_user_agent.Get() = user_agent;
  19 }
  20
  21 const std::string& GetAgent() {
  22   return g_user_agent.Get();
  23 }
  24
  25 #if defined(USE_CUPS)
  26 void GetColorModelForMode(
  27     int color_mode, std::string* color_setting_name, std::string* color_value) {
  28 #if defined(OS_MACOSX)
  29   constexpr char kCUPSColorMode[] = "ColorMode";
  30   constexpr char kCUPSColorModel[] = "ColorModel";
  31   constexpr char kCUPSPrintoutMode[] = "PrintoutMode";
  32   constexpr char kCUPSProcessColorModel[] = "ProcessColorModel";
  33   constexpr char kCUPSBrotherMonoColor[] = "BRMonoColor";
  34   constexpr char kCUPSBrotherPrintQuality[] = "BRPrintQuality";
  35 #else
  36   constexpr char kCUPSColorMode[] = "cups-ColorMode";
  37   constexpr char kCUPSColorModel[] = "cups-ColorModel";
  38   constexpr char kCUPSPrintoutMode[] = "cups-PrintoutMode";
  39   constexpr char kCUPSProcessColorModel[] = "cups-ProcessColorModel";
  40   constexpr char kCUPSBrotherMonoColor[] = "cups-BRMonoColor";
  41   constexpr char kCUPSBrotherPrintQuality[] = "cups-BRPrintQuality";
  42 #endif  // defined(OS_MACOSX)
  43
  44   color_setting_name->assign(kCUPSColorModel);
  45   switch (color_mode) {
  46     case GRAY:
  47       color_value->assign(kGray);
  48       break;
  49     case COLOR:
  50       color_value->assign(kColor);
  51       break;
  52     case CMYK:
  53       color_value->assign(kCMYK);
  54       break;
  55     case CMY:
  56       color_value->assign(kCMY);
  57       break;
  58     case KCMY:
  59       color_value->assign(kKCMY);
  60       break;
  61     case CMY_K:
  62       color_value->assign(kCMY_K);
  63       break;
  64     case BLACK:
  65       color_value->assign(kBlack);
  66       break;
  67     case GRAYSCALE:
  68       color_value->assign(kGrayscale);
  69       break;
  70     case RGB:
  71       color_value->assign(kRGB);
  72       break;
  73     case RGB16:
  74       color_value->assign(kRGB16);
  75       break;
  76     case RGBA:
  77       color_value->assign(kRGBA);
  78       break;
  79     case COLORMODE_COLOR:
  80       color_setting_name->assign(kCUPSColorMode);
  81       color_value->assign(kColor);
  82       break;
  83     case COLORMODE_MONOCHROME:
  84       color_setting_name->assign(kCUPSColorMode);
  85       color_value->assign(kMonochrome);
  86       break;
  87     case HP_COLOR_COLOR:
  88       color_setting_name->assign(kColor);
  89       color_value->assign(kColor);
  90       break;
  91     case HP_COLOR_BLACK:
  92       color_setting_name->assign(kColor);
  93       color_value->assign(kBlack);
  94       break;
  95     case PRINTOUTMODE_NORMAL:
  96       color_setting_name->assign(kCUPSPrintoutMode);
  97       color_value->assign(kNormal);
  98       break;
  99     case PRINTOUTMODE_NORMAL_GRAY:
 100       color_setting_name->assign(kCUPSPrintoutMode);
 101       color_value->assign(kNormalGray);
 102       break;
 103     case PROCESSCOLORMODEL_CMYK:
 104       color_setting_name->assign(kCUPSProcessColorModel);
 105       color_value->assign(kCMYK);
 106       break;
 107     case PROCESSCOLORMODEL_GREYSCALE:
 108       color_setting_name->assign(kCUPSProcessColorModel);
 109       color_value->assign(kGreyscale);
 110       break;
 111     case PROCESSCOLORMODEL_RGB:
 112       color_setting_name->assign(kCUPSProcessColorModel);
 113       color_value->assign(kRGB);
 114       break;
 115     case BROTHER_CUPS_COLOR:
 116       color_setting_name->assign(kCUPSBrotherMonoColor);
 117       color_value->assign(kFullColor);
 118       break;
 119     case BROTHER_CUPS_MONO:
 120       color_setting_name->assign(kCUPSBrotherMonoColor);
 121       color_value->assign(kMono);
 122       break;
 123     case BROTHER_BRSCRIPT3_COLOR:
 124       color_setting_name->assign(kCUPSBrotherPrintQuality);
 125       color_value->assign(kColor);
 126       break;
 127     case BROTHER_BRSCRIPT3_BLACK:
 128       color_setting_name->assign(kCUPSBrotherPrintQuality);
 129       color_value->assign(kBlack);
 130       break;
 131     default:
 132       color_value->assign(kGrayscale);
 133       break;
 134   }
 135 }
 136 #endif  // defined(USE_CUPS)
 137
 138 bool IsColorModelSelected(int color_mode) {
 139   return (color_mode != GRAY && color_mode != BLACK &&
 140           color_mode != PRINTOUTMODE_NORMAL_GRAY &&
 141           color_mode != COLORMODE_MONOCHROME &&
 142           color_mode != PROCESSCOLORMODEL_GREYSCALE &&
 143           color_mode != BROTHER_CUPS_MONO &&
 144           color_mode != BROTHER_BRSCRIPT3_BLACK &&
 145           color_mode != HP_COLOR_BLACK);
 146 }
 147
 148 // Global SequenceNumber used for generating unique cookie values.
 149 static base::AtomicSequenceNumber cookie_seq;
 150
 151 PrintSettings::PrintSettings() {
 152   Clear();
 153 }
 154
 155 PrintSettings::PrintSettings(const PrintSettings& other) = default;
 156
 157 PrintSettings::~PrintSettings() = default;
 158
 159 void PrintSettings::Clear() {
 160   ranges_.clear();
 161   selection_only_ = false;
 162   margin_type_ = DEFAULT_MARGINS;
 163   title_.clear();
 164   url_.clear();
 165   display_header_footer_ = false;
 166   should_print_backgrounds_ = false;
 167   collate_ = false;
 168   color_ = UNKNOWN_COLOR_MODEL;
 169   copies_ = 0;
 170   duplex_mode_ = UNKNOWN_DUPLEX_MODE;
 171   device_name_.clear();
 172   requested_media_ = RequestedMedia();
 173   page_setup_device_units_.Clear();
 174   dpi_ = gfx::Size();
 175   scale_factor_ = 1.0f;
 176   rasterize_pdf_ = false;
 177   landscape_ = false;
 178   supports_alpha_blend_ = true;
 179 #if defined(OS_WIN)
 180   print_text_with_gdi_ = false;
 181   printer_type_ = PrintSettings::PrinterType::TYPE_NONE;
 182 #endif
 183   is_modifiable_ = true;
 184   pages_per_sheet_ = 1;
 185 }
 186
 187 void PrintSettings::SetPrinterPrintableArea(
 188     const gfx::Size& physical_size_device_units,
 189     const gfx::Rect& printable_area_device_units,
 190     bool landscape_needs_flip) {
 191   int units_per_inch = device_units_per_inch();
 192   int header_footer_text_height = 0;
 193   if (display_header_footer_) {
 194     // Hard-code text_height = 0.5cm = ~1/5 of inch.
 195     header_footer_text_height = ConvertUnit(kSettingHeaderFooterInterstice,
 196                                             kPointsPerInch, units_per_inch);
 197   }
 198
 199   PageMargins margins;
 200   bool small_paper_size = false;
 201   switch (margin_type_) {
 202     case DEFAULT_MARGINS: {
 203       // Default margins 1.0cm = ~2/5 of an inch, unless a page dimension is
 204       // less than 2.54 cm = ~1 inch, in which case set the margins in that
 205       // dimension to 0.
 206       static constexpr double kCmInMicrons = 10000;
 207       int margin_printer_units =
 208           ConvertUnit(kCmInMicrons, kMicronsPerInch, units_per_inch);
 209       int min_size_printer_units = units_per_inch;
 210       margins.header = header_footer_text_height;
 211       margins.footer = header_footer_text_height;
 212       if (physical_size_device_units.height() > min_size_printer_units) {
 213         margins.top = margin_printer_units;
 214         margins.bottom = margin_printer_units;
 215       } else {
 216         margins.top = 0;
 217         margins.bottom = 0;
 218         small_paper_size = true;
 219       }
 220       if (physical_size_device_units.width() > min_size_printer_units) {
 221         margins.left = margin_printer_units;
 222         margins.right = margin_printer_units;
 223       } else {
 224         margins.left = 0;
 225         margins.right = 0;
 226         small_paper_size = true;
 227       }
 228       break;
 229     }
 230     case NO_MARGINS:
 231     case PRINTABLE_AREA_MARGINS: {
 232       margins.header = 0;
 233       margins.footer = 0;
 234       margins.top = 0;
 235       margins.bottom = 0;
 236       margins.left = 0;
 237       margins.right = 0;
 238       break;
 239     }
 240     case CUSTOM_MARGINS: {
 241       margins.header = 0;
 242       margins.footer = 0;
 243       margins.top = ConvertUnitDouble(
 244           requested_custom_margins_in_points_.top,
 245           kPointsPerInch,
 246           units_per_inch);
 247       margins.bottom = ConvertUnitDouble(
 248           requested_custom_margins_in_points_.bottom,
 249           kPointsPerInch,
 250           units_per_inch);
 251       margins.left = ConvertUnitDouble(
 252           requested_custom_margins_in_points_.left,
 253           kPointsPerInch,
 254           units_per_inch);
 255       margins.right = ConvertUnitDouble(
 256           requested_custom_margins_in_points_.right,
 257           kPointsPerInch,
 258           units_per_inch);
 259       break;
 260     }
 261     default: {
 262       NOTREACHED();
 263     }
 264   }
 265
 266   if ((margin_type_ == DEFAULT_MARGINS ||
 267        margin_type_ == PRINTABLE_AREA_MARGINS) &&
 268       !small_paper_size) {
 269     page_setup_device_units_.SetRequestedMargins(margins);
 270   } else {
 271     page_setup_device_units_.ForceRequestedMargins(margins);
 272   }
 273   page_setup_device_units_.Init(physical_size_device_units,
 274                                 printable_area_device_units,
 275                                 header_footer_text_height);
 276   if (landscape_ && landscape_needs_flip)
 277     page_setup_device_units_.FlipOrientation();
 278 }
 279
 280 void PrintSettings::SetCustomMargins(
 281     const PageMargins& requested_margins_in_points) {
 282   requested_custom_margins_in_points_ = requested_margins_in_points;
 283   margin_type_ = CUSTOM_MARGINS;
 284 }
 285
 286 int PrintSettings::NewCookie() {
 287   // A cookie of 0 is used to mark a document as unassigned, count from 1.
 288   return cookie_seq.GetNext() + 1;
 289 }
 290
 291 void PrintSettings::SetOrientation(bool landscape) {
 292   if (landscape_ != landscape) {
 293     landscape_ = landscape;
 294     page_setup_device_units_.FlipOrientation();
 295   }
 296 }
 297
 298 }  // namespace printing