print_settings.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019 
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/logging.h"
9#include "printing/print_job_constants.h"
10#include "printing/units.h"
11
12namespace printing {
13
14#if defined(USE_CUPS)
15void GetColorModelForMode(
16    int color_mode, std::string* color_setting_name, std::string* color_value) {
17#if defined(OS_MACOSX)
18  const char kCUPSColorMode[] = "ColorMode";
19  const char kCUPSColorModel[] = "ColorModel";
20  const char kCUPSPrintoutMode[] = "PrintoutMode";
21  const char kCUPSProcessColorModel[] = "ProcessColorModel";
22#else
23  const char kCUPSColorMode[] = "cups-ColorMode";
24  const char kCUPSColorModel[] = "cups-ColorModel";
25  const char kCUPSPrintoutMode[] = "cups-PrintoutMode";
26  const char kCUPSProcessColorModel[] = "cups-ProcessColorModel";
27#endif  // defined(OS_MACOSX)
28
29  color_setting_name->assign(kCUPSColorModel);
30  switch (color_mode) {
31    case COLOR:
32      color_value->assign(kColor);
33      break;
34    case CMYK:
35      color_value->assign(kCMYK);
36      break;
37    case PRINTOUTMODE_NORMAL:
38      color_value->assign(kNormal);
39      color_setting_name->assign(kCUPSPrintoutMode);
40      break;
41    case PRINTOUTMODE_NORMAL_GRAY:
42      color_value->assign(kNormalGray);
43      color_setting_name->assign(kCUPSPrintoutMode);
44      break;
45    case RGB16:
46      color_value->assign(kRGB16);
47      break;
48    case RGBA:
49      color_value->assign(kRGBA);
50      break;
51    case RGB:
52      color_value->assign(kRGB);
53      break;
54    case CMY:
55      color_value->assign(kCMY);
56      break;
57    case CMY_K:
58      color_value->assign(kCMY_K);
59      break;
60    case BLACK:
61      color_value->assign(kBlack);
62      break;
63    case GRAY:
64      color_value->assign(kGray);
65      break;
66    case COLORMODE_COLOR:
67      color_setting_name->assign(kCUPSColorMode);
68      color_value->assign(kColor);
69      break;
70    case COLORMODE_MONOCHROME:
71      color_setting_name->assign(kCUPSColorMode);
72      color_value->assign(kMonochrome);
73      break;
74    case HP_COLOR_COLOR:
75      color_setting_name->assign(kColor);
76      color_value->assign(kColor);
77      break;
78    case HP_COLOR_BLACK:
79      color_setting_name->assign(kColor);
80      color_value->assign(kBlack);
81      break;
82    case PROCESSCOLORMODEL_CMYK:
83      color_setting_name->assign(kCUPSProcessColorModel);
84      color_value->assign(kCMYK);
85      break;
86    case PROCESSCOLORMODEL_GREYSCALE:
87      color_setting_name->assign(kCUPSProcessColorModel);
88      color_value->assign(kGreyscale);
89      break;
90    case PROCESSCOLORMODEL_RGB:
91      color_setting_name->assign(kCUPSProcessColorModel);
92      color_value->assign(kRGB);
93      break;
94    default:
95      color_value->assign(kGrayscale);
96      break;
97  }
98}
99#endif  // defined(USE_CUPS)
100
101bool isColorModelSelected(int model) {
102  return (model != GRAY &&
103          model != BLACK &&
104          model != PRINTOUTMODE_NORMAL_GRAY &&
105          model != COLORMODE_MONOCHROME &&
106          model != PROCESSCOLORMODEL_GREYSCALE &&
107          model != HP_COLOR_BLACK);
108}
109
110// Global SequenceNumber used for generating unique cookie values.
111static base::StaticAtomicSequenceNumber cookie_seq;
112
113PrintSettings::PrintSettings()
114    : min_shrink(1.25),
115      max_shrink(2.0),
116      desired_dpi(72),
117      selection_only(false),
118      margin_type(DEFAULT_MARGINS),
119      display_header_footer(false),
120      dpi_(0),
121      landscape_(false),
122      supports_alpha_blend_(true) {
123}
124
125PrintSettings::~PrintSettings() {
126}
127
128void PrintSettings::Clear() {
129  ranges.clear();
130  min_shrink = 1.25;
131  max_shrink = 2.;
132  desired_dpi = 72;
133  selection_only = false;
134  date = string16();
135  title = string16();
136  url = string16();
137  display_header_footer = false;
138  printer_name_.clear();
139  device_name_.clear();
140  page_setup_device_units_.Clear();
141  dpi_ = 0;
142  landscape_ = false;
143  supports_alpha_blend_ = true;
144}
145
146void PrintSettings::SetPrinterPrintableArea(
147    gfx::Size const& physical_size_device_units,
148    gfx::Rect const& printable_area_device_units,
149    int units_per_inch) {
150  int header_footer_text_height = 0;
151  if (display_header_footer) {
152    // Hard-code text_height = 0.5cm = ~1/5 of inch.
153    header_footer_text_height = ConvertUnit(kSettingHeaderFooterInterstice,
154                                            kPointsPerInch, units_per_inch);
155  }
156
157  PageMargins margins;
158  switch (margin_type) {
159    case DEFAULT_MARGINS: {
160      // Default margins 1.0cm = ~2/5 of an inch.
161      int margin_printer_units = ConvertUnit(1000, kHundrethsMMPerInch,
162                                             units_per_inch);
163      margins.header = header_footer_text_height;
164      margins.footer = header_footer_text_height;
165      margins.top = margin_printer_units;
166      margins.bottom = margin_printer_units;
167      margins.left = margin_printer_units;
168      margins.right = margin_printer_units;
169      break;
170    }
171    case NO_MARGINS:
172    case PRINTABLE_AREA_MARGINS: {
173      margins.header = 0;
174      margins.footer = 0;
175      margins.top = 0;
176      margins.bottom = 0;
177      margins.left = 0;
178      margins.right = 0;
179      break;
180    }
181    case CUSTOM_MARGINS: {
182      margins.header = 0;
183      margins.footer = 0;
184      margins.top = ConvertUnitDouble(
185          requested_custom_margins_in_points_.top,
186          kPointsPerInch,
187          units_per_inch);
188      margins.bottom = ConvertUnitDouble(
189          requested_custom_margins_in_points_.bottom,
190          kPointsPerInch,
191          units_per_inch);
192      margins.left = ConvertUnitDouble(
193          requested_custom_margins_in_points_.left,
194          kPointsPerInch,
195          units_per_inch);
196      margins.right = ConvertUnitDouble(
197          requested_custom_margins_in_points_.right,
198          kPointsPerInch,
199          units_per_inch);
200      break;
201    }
202    default: {
203      NOTREACHED();
204    }
205  }
206
207  if (margin_type == DEFAULT_MARGINS || margin_type == PRINTABLE_AREA_MARGINS)
208    page_setup_device_units_.SetRequestedMargins(margins);
209  else
210    page_setup_device_units_.ForceRequestedMargins(margins);
211
212  page_setup_device_units_.Init(physical_size_device_units,
213                                printable_area_device_units,
214                                header_footer_text_height);
215}
216
217void PrintSettings::SetCustomMargins(
218    const PageMargins& requested_margins_in_points) {
219  requested_custom_margins_in_points_ = requested_margins_in_points;
220  margin_type = CUSTOM_MARGINS;
221}
222
223bool PrintSettings::Equals(const PrintSettings& rhs) const {
224  // Do not test the display device name (printer_name_) for equality since it
225  // may sometimes be chopped off at 30 chars. As long as device_name is the
226  // same, that's fine.
227  return ranges == rhs.ranges &&
228      min_shrink == rhs.min_shrink &&
229      max_shrink == rhs.max_shrink &&
230      desired_dpi == rhs.desired_dpi &&
231      device_name_ == rhs.device_name_ &&
232      page_setup_device_units_.Equals(rhs.page_setup_device_units_) &&
233      dpi_ == rhs.dpi_ &&
234      landscape_ == rhs.landscape_;
235}
236
237int PrintSettings::NewCookie() {
238  // A cookie of 0 is used to mark a document as unassigned, count from 1.
239  return cookie_seq.GetNext() + 1;
240}
241
242void PrintSettings::SetOrientation(bool landscape) {
243  if (landscape_ != landscape) {
244    landscape_ = landscape;
245    page_setup_device_units_.FlipOrientation();
246  }
247}
248
249}  // namespace printing
250