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/printing_context_win.h"
6
7#include <algorithm>
8
9#include "base/strings/string_number_conversions.h"
10#include "base/strings/utf_string_conversions.h"
11#include "printing/backend/print_backend.h"
12#include "printing/backend/win_helper.h"
13#include "printing/print_settings_initializer_win.h"
14#include "printing/printed_document.h"
15#include "printing/printing_context_system_dialog_win.h"
16#include "printing/printing_utils.h"
17#include "printing/units.h"
18#include "skia/ext/platform_device.h"
19
20#if defined(USE_AURA)
21#include "ui/aura/remote_window_tree_host_win.h"
22#include "ui/aura/window.h"
23#endif
24
25namespace printing {
26
27// static
28scoped_ptr<PrintingContext> PrintingContext::Create(Delegate* delegate) {
29#if defined(DISABLE_BASIC_PRINTING)
30  return make_scoped_ptr<PrintingContext>(new PrintingContextWin(delegate));
31#else   // DISABLE_BASIC_PRINTING
32  return make_scoped_ptr<PrintingContext>(
33      new PrintingContextSytemDialogWin(delegate));
34#endif  // DISABLE_BASIC_PRINTING
35}
36
37PrintingContextWin::PrintingContextWin(Delegate* delegate)
38    : PrintingContext(delegate), context_(NULL) {
39}
40
41PrintingContextWin::~PrintingContextWin() {
42  ReleaseContext();
43}
44
45void PrintingContextWin::AskUserForSettings(
46    int max_pages,
47    bool has_selection,
48    const PrintSettingsCallback& callback) {
49  NOTIMPLEMENTED();
50}
51
52PrintingContext::Result PrintingContextWin::UseDefaultSettings() {
53  DCHECK(!in_print_job_);
54
55  scoped_refptr<PrintBackend> backend = PrintBackend::CreateInstance(NULL);
56  base::string16 default_printer =
57      base::UTF8ToWide(backend->GetDefaultPrinterName());
58  if (!default_printer.empty()) {
59    ScopedPrinterHandle printer;
60    if (printer.OpenPrinter(default_printer.c_str())) {
61      scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
62          CreateDevMode(printer.Get(), NULL);
63      if (InitializeSettings(default_printer, dev_mode.get()) == OK)
64        return OK;
65    }
66  }
67
68  ReleaseContext();
69
70  // No default printer configured, do we have any printers at all?
71  DWORD bytes_needed = 0;
72  DWORD count_returned = 0;
73  (void)::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
74                       NULL, 2, NULL, 0, &bytes_needed, &count_returned);
75  if (bytes_needed) {
76    DCHECK_GE(bytes_needed, count_returned * sizeof(PRINTER_INFO_2));
77    scoped_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]);
78    BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
79                              NULL, 2, printer_info_buffer.get(),
80                              bytes_needed, &bytes_needed,
81                              &count_returned);
82    if (ret && count_returned) {  // have printers
83      // Open the first successfully found printer.
84      const PRINTER_INFO_2* info_2 =
85          reinterpret_cast<PRINTER_INFO_2*>(printer_info_buffer.get());
86      const PRINTER_INFO_2* info_2_end = info_2 + count_returned;
87      for (; info_2 < info_2_end; ++info_2) {
88        ScopedPrinterHandle printer;
89        if (!printer.OpenPrinter(info_2->pPrinterName))
90          continue;
91        scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
92            CreateDevMode(printer.Get(), NULL);
93        if (InitializeSettings(info_2->pPrinterName, dev_mode.get()) == OK)
94          return OK;
95      }
96      if (context_)
97        return OK;
98    }
99  }
100
101  return OnError();
102}
103
104gfx::Size PrintingContextWin::GetPdfPaperSizeDeviceUnits() {
105  // Default fallback to Letter size.
106  gfx::SizeF paper_size(kLetterWidthInch, kLetterHeightInch);
107
108  // Get settings from locale. Paper type buffer length is at most 4.
109  const int paper_type_buffer_len = 4;
110  wchar_t paper_type_buffer[paper_type_buffer_len] = {0};
111  GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE, paper_type_buffer,
112                paper_type_buffer_len);
113  if (wcslen(paper_type_buffer)) {  // The call succeeded.
114    int paper_code = _wtoi(paper_type_buffer);
115    switch (paper_code) {
116      case DMPAPER_LEGAL:
117        paper_size.SetSize(kLegalWidthInch, kLegalHeightInch);
118        break;
119      case DMPAPER_A4:
120        paper_size.SetSize(kA4WidthInch, kA4HeightInch);
121        break;
122      case DMPAPER_A3:
123        paper_size.SetSize(kA3WidthInch, kA3HeightInch);
124        break;
125      default:  // DMPAPER_LETTER is used for default fallback.
126        break;
127    }
128  }
129  return gfx::Size(
130      paper_size.width() * settings_.device_units_per_inch(),
131      paper_size.height() * settings_.device_units_per_inch());
132}
133
134PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
135    bool external_preview,
136    bool show_system_dialog) {
137  DCHECK(!in_print_job_);
138  DCHECK(!external_preview) << "Not implemented";
139
140  ScopedPrinterHandle printer;
141  if (!printer.OpenPrinter(settings_.device_name().c_str()))
142    return OnError();
143
144  // Make printer changes local to Chrome.
145  // See MSDN documentation regarding DocumentProperties.
146  scoped_ptr<DEVMODE, base::FreeDeleter> scoped_dev_mode =
147      CreateDevModeWithColor(printer.Get(), settings_.device_name(),
148                             settings_.color() != GRAY);
149  if (!scoped_dev_mode)
150    return OnError();
151
152  {
153    DEVMODE* dev_mode = scoped_dev_mode.get();
154    dev_mode->dmCopies = std::max(settings_.copies(), 1);
155    if (dev_mode->dmCopies > 1) {  // do not change unless multiple copies
156      dev_mode->dmFields |= DM_COPIES;
157      dev_mode->dmCollate = settings_.collate() ? DMCOLLATE_TRUE :
158                                                  DMCOLLATE_FALSE;
159    }
160
161    switch (settings_.duplex_mode()) {
162      case LONG_EDGE:
163        dev_mode->dmFields |= DM_DUPLEX;
164        dev_mode->dmDuplex = DMDUP_VERTICAL;
165        break;
166      case SHORT_EDGE:
167        dev_mode->dmFields |= DM_DUPLEX;
168        dev_mode->dmDuplex = DMDUP_HORIZONTAL;
169        break;
170      case SIMPLEX:
171        dev_mode->dmFields |= DM_DUPLEX;
172        dev_mode->dmDuplex = DMDUP_SIMPLEX;
173        break;
174      default:  // UNKNOWN_DUPLEX_MODE
175        break;
176    }
177
178    dev_mode->dmFields |= DM_ORIENTATION;
179    dev_mode->dmOrientation = settings_.landscape() ? DMORIENT_LANDSCAPE :
180                                                      DMORIENT_PORTRAIT;
181
182    const PrintSettings::RequestedMedia& requested_media =
183        settings_.requested_media();
184    static const int kFromUm = 100;  // Windows uses 0.1mm.
185    int width = requested_media.size_microns.width() / kFromUm;
186    int height = requested_media.size_microns.height() / kFromUm;
187    unsigned id = 0;
188    if (base::StringToUint(requested_media.vendor_id, &id) && id) {
189      dev_mode->dmFields |= DM_PAPERSIZE;
190      dev_mode->dmPaperSize = static_cast<short>(id);
191    } else if (width > 0 && height > 0) {
192      dev_mode->dmFields |= DM_PAPERWIDTH;
193      dev_mode->dmPaperWidth = width;
194      dev_mode->dmFields |= DM_PAPERLENGTH;
195      dev_mode->dmPaperLength = height;
196    }
197  }
198
199  // Update data using DocumentProperties.
200  if (show_system_dialog) {
201    scoped_dev_mode = ShowPrintDialog(
202        printer.Get(), delegate_->GetParentView(), scoped_dev_mode.get());
203  } else {
204    scoped_dev_mode = CreateDevMode(printer.Get(), scoped_dev_mode.get());
205  }
206  // Set printer then refresh printer settings.
207  return InitializeSettings(settings_.device_name(), scoped_dev_mode.get());
208}
209
210PrintingContext::Result PrintingContextWin::InitWithSettings(
211    const PrintSettings& settings) {
212  DCHECK(!in_print_job_);
213
214  settings_ = settings;
215
216  // TODO(maruel): settings_.ToDEVMODE()
217  ScopedPrinterHandle printer;
218  if (!printer.OpenPrinter(settings_.device_name().c_str()))
219    return FAILED;
220
221  scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
222      CreateDevMode(printer.Get(), NULL);
223
224  return InitializeSettings(settings_.device_name(), dev_mode.get());
225}
226
227PrintingContext::Result PrintingContextWin::NewDocument(
228    const base::string16& document_name) {
229  DCHECK(!in_print_job_);
230  if (!context_)
231    return OnError();
232
233  // Set the flag used by the AbortPrintJob dialog procedure.
234  abort_printing_ = false;
235
236  in_print_job_ = true;
237
238  // Register the application's AbortProc function with GDI.
239  if (SP_ERROR == SetAbortProc(context_, &AbortProc))
240    return OnError();
241
242  DCHECK(SimplifyDocumentTitle(document_name) == document_name);
243  DOCINFO di = { sizeof(DOCINFO) };
244  di.lpszDocName = document_name.c_str();
245
246  // Is there a debug dump directory specified? If so, force to print to a file.
247  base::string16 debug_dump_path =
248      PrintedDocument::CreateDebugDumpPath(document_name,
249                                           FILE_PATH_LITERAL(".prn")).value();
250  if (!debug_dump_path.empty())
251    di.lpszOutput = debug_dump_path.c_str();
252
253  // No message loop running in unit tests.
254  DCHECK(!base::MessageLoop::current() ||
255         !base::MessageLoop::current()->NestableTasksAllowed());
256
257  // Begin a print job by calling the StartDoc function.
258  // NOTE: StartDoc() starts a message loop. That causes a lot of problems with
259  // IPC. Make sure recursive task processing is disabled.
260  if (StartDoc(context_, &di) <= 0)
261    return OnError();
262
263  return OK;
264}
265
266PrintingContext::Result PrintingContextWin::NewPage() {
267  if (abort_printing_)
268    return CANCEL;
269  DCHECK(context_);
270  DCHECK(in_print_job_);
271
272  // Intentional No-op. PdfMetafileSkia::SafePlayback takes care of calling
273  // ::StartPage().
274
275  return OK;
276}
277
278PrintingContext::Result PrintingContextWin::PageDone() {
279  if (abort_printing_)
280    return CANCEL;
281  DCHECK(in_print_job_);
282
283  // Intentional No-op. PdfMetafileSkia::SafePlayback takes care of calling
284  // ::EndPage().
285
286  return OK;
287}
288
289PrintingContext::Result PrintingContextWin::DocumentDone() {
290  if (abort_printing_)
291    return CANCEL;
292  DCHECK(in_print_job_);
293  DCHECK(context_);
294
295  // Inform the driver that document has ended.
296  if (EndDoc(context_) <= 0)
297    return OnError();
298
299  ResetSettings();
300  return OK;
301}
302
303void PrintingContextWin::Cancel() {
304  abort_printing_ = true;
305  in_print_job_ = false;
306  if (context_)
307    CancelDC(context_);
308}
309
310void PrintingContextWin::ReleaseContext() {
311  if (context_) {
312    DeleteDC(context_);
313    context_ = NULL;
314  }
315}
316
317gfx::NativeDrawingContext PrintingContextWin::context() const {
318  return context_;
319}
320
321// static
322BOOL PrintingContextWin::AbortProc(HDC hdc, int nCode) {
323  if (nCode) {
324    // TODO(maruel):  Need a way to find the right instance to set. Should
325    // leverage PrintJobManager here?
326    // abort_printing_ = true;
327  }
328  return true;
329}
330
331PrintingContext::Result PrintingContextWin::InitializeSettings(
332    const std::wstring& device_name,
333    DEVMODE* dev_mode) {
334  if (!dev_mode)
335    return OnError();
336
337  ReleaseContext();
338  context_ = CreateDC(L"WINSPOOL", device_name.c_str(), NULL, dev_mode);
339  if (!context_)
340    return OnError();
341
342  skia::InitializeDC(context_);
343
344  DCHECK(!in_print_job_);
345  settings_.set_device_name(device_name);
346  PrintSettingsInitializerWin::InitPrintSettings(
347      context_, *dev_mode, &settings_);
348
349  return OK;
350}
351
352HWND PrintingContextWin::GetRootWindow(gfx::NativeView view) {
353  HWND window = NULL;
354#if defined(USE_AURA)
355  if (view)
356    window = view->GetHost()->GetAcceleratedWidget();
357#else
358  if (view && IsWindow(view)) {
359    window = GetAncestor(view, GA_ROOTOWNER);
360  }
361#endif
362  if (!window) {
363    // TODO(maruel):  crbug.com/1214347 Get the right browser window instead.
364    return GetDesktopWindow();
365  }
366  return window;
367}
368
369scoped_ptr<DEVMODE, base::FreeDeleter> PrintingContextWin::ShowPrintDialog(
370    HANDLE printer,
371    gfx::NativeView parent_view,
372    DEVMODE* dev_mode) {
373  // Note that this cannot use ui::BaseShellDialog as the print dialog is
374  // system modal: opening it from a background thread can cause Windows to
375  // get the wrong Z-order which will make the print dialog appear behind the
376  // browser frame (but still being modal) so neither the browser frame nor
377  // the print dialog will get any input. See http://crbug.com/342697
378  // http://crbug.com/180997 for details.
379  base::MessageLoop::ScopedNestableTaskAllower allow(
380      base::MessageLoop::current());
381
382  bool canceled = false;
383  scoped_ptr<DEVMODE, base::FreeDeleter> result =
384      PromptDevMode(printer,
385                    settings_.device_name(),
386                    dev_mode,
387                    GetRootWindow(parent_view),
388                    &canceled);
389
390  if (canceled) {
391    result.reset();
392    abort_printing_ = true;
393  }
394
395  return result.Pass();
396}
397
398}  // namespace printing
399