| // Copyright (c) 2012 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 "printing/backend/print_backend.h" | |
| #include <objidl.h> | |
| #include <winspool.h> | |
| #include "base/memory/scoped_ptr.h" | |
| #include "base/strings/string_piece.h" | |
| #include "base/strings/utf_string_conversions.h" | |
| #include "base/win/scoped_bstr.h" | |
| #include "base/win/scoped_comptr.h" | |
| #include "base/win/scoped_hglobal.h" | |
| #include "printing/backend/print_backend_consts.h" | |
| #include "printing/backend/printing_info_win.h" | |
| #include "printing/backend/win_helper.h" | |
| namespace { | |
| HRESULT StreamOnHGlobalToString(IStream* stream, std::string* out) { | |
| DCHECK(stream); | |
| DCHECK(out); | |
| HGLOBAL hdata = NULL; | |
| HRESULT hr = GetHGlobalFromStream(stream, &hdata); | |
| if (SUCCEEDED(hr)) { | |
| DCHECK(hdata); | |
| base::win::ScopedHGlobal<char> locked_data(hdata); | |
| out->assign(locked_data.release(), locked_data.Size()); | |
| } | |
| return hr; | |
| } | |
| } // namespace | |
| namespace printing { | |
| class PrintBackendWin : public PrintBackend { | |
| public: | |
| PrintBackendWin() {} | |
| // PrintBackend implementation. | |
| virtual bool EnumeratePrinters(PrinterList* printer_list) OVERRIDE; | |
| virtual std::string GetDefaultPrinterName() OVERRIDE; | |
| virtual bool GetPrinterSemanticCapsAndDefaults( | |
| const std::string& printer_name, | |
| PrinterSemanticCapsAndDefaults* printer_info) OVERRIDE; | |
| virtual bool GetPrinterCapsAndDefaults( | |
| const std::string& printer_name, | |
| PrinterCapsAndDefaults* printer_info) OVERRIDE; | |
| virtual std::string GetPrinterDriverInfo( | |
| const std::string& printer_name) OVERRIDE; | |
| virtual bool IsValidPrinter(const std::string& printer_name) OVERRIDE; | |
| protected: | |
| virtual ~PrintBackendWin() {} | |
| }; | |
| bool PrintBackendWin::EnumeratePrinters(PrinterList* printer_list) { | |
| DCHECK(printer_list); | |
| DWORD bytes_needed = 0; | |
| DWORD count_returned = 0; | |
| const DWORD kLevel = 4; | |
| BOOL ret = EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS, NULL, | |
| kLevel, NULL, 0, &bytes_needed, &count_returned); | |
| if (!bytes_needed) | |
| return false; | |
| scoped_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]); | |
| ret = EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS, NULL, kLevel, | |
| printer_info_buffer.get(), bytes_needed, &bytes_needed, | |
| &count_returned); | |
| DCHECK(ret); | |
| if (!ret) | |
| return false; | |
| std::string default_printer = GetDefaultPrinterName(); | |
| PRINTER_INFO_4* printer_info = | |
| reinterpret_cast<PRINTER_INFO_4*>(printer_info_buffer.get()); | |
| for (DWORD index = 0; index < count_returned; index++) { | |
| ScopedPrinterHandle printer; | |
| PrinterBasicInfo info; | |
| if (printer.OpenPrinter(printer_info[index].pPrinterName) && | |
| InitBasicPrinterInfo(printer, &info)) { | |
| info.is_default = (info.printer_name == default_printer); | |
| printer_list->push_back(info); | |
| } | |
| } | |
| return true; | |
| } | |
| std::string PrintBackendWin::GetDefaultPrinterName() { | |
| DWORD size = MAX_PATH; | |
| TCHAR default_printer_name[MAX_PATH]; | |
| if (!::GetDefaultPrinter(default_printer_name, &size)) | |
| return std::string(); | |
| return WideToUTF8(default_printer_name); | |
| } | |
| bool PrintBackendWin::GetPrinterSemanticCapsAndDefaults( | |
| const std::string& printer_name, | |
| PrinterSemanticCapsAndDefaults* printer_info) { | |
| ScopedPrinterHandle printer_handle; | |
| if (!printer_handle.OpenPrinter(UTF8ToWide(printer_name).c_str())) { | |
| LOG(WARNING) << "Failed to open printer, error = " << GetLastError(); | |
| return false; | |
| } | |
| PrinterInfo5 info_5; | |
| if (!info_5.Init(printer_handle)) { | |
| return false; | |
| } | |
| DCHECK_EQ(info_5.get()->pPrinterName, UTF8ToUTF16(printer_name)); | |
| PrinterSemanticCapsAndDefaults caps; | |
| // Get printer capabilities. For more info see here: | |
| // http://msdn.microsoft.com/en-us/library/windows/desktop/dd183552(v=vs.85).aspx | |
| caps.color_changeable = (::DeviceCapabilities(info_5.get()->pPrinterName, | |
| info_5.get()->pPortName, | |
| DC_COLORDEVICE, | |
| NULL, | |
| NULL) == 1); | |
| caps.duplex_capable = (::DeviceCapabilities(info_5.get()->pPrinterName, | |
| info_5.get()->pPortName, | |
| DC_DUPLEX, | |
| NULL, | |
| NULL) == 1); | |
| UserDefaultDevMode user_settings; | |
| if (user_settings.Init(printer_handle)) { | |
| if ((user_settings.get()->dmFields & DM_COLOR) == DM_COLOR) | |
| caps.color_default = (user_settings.get()->dmColor == DMCOLOR_COLOR); | |
| if ((user_settings.get()->dmFields & DM_DUPLEX) == DM_DUPLEX) { | |
| switch (user_settings.get()->dmDuplex) { | |
| case DMDUP_SIMPLEX: | |
| caps.duplex_default = SIMPLEX; | |
| break; | |
| case DMDUP_VERTICAL: | |
| caps.duplex_default = LONG_EDGE; | |
| break; | |
| case DMDUP_HORIZONTAL: | |
| caps.duplex_default = SHORT_EDGE; | |
| break; | |
| default: | |
| NOTREACHED(); | |
| } | |
| } | |
| } else { | |
| LOG(WARNING) << "Fallback to color/simplex mode."; | |
| caps.color_default = caps.color_changeable; | |
| caps.duplex_default = SIMPLEX; | |
| } | |
| *printer_info = caps; | |
| return true; | |
| } | |
| bool PrintBackendWin::GetPrinterCapsAndDefaults( | |
| const std::string& printer_name, | |
| PrinterCapsAndDefaults* printer_info) { | |
| ScopedXPSInitializer xps_initializer; | |
| if (!xps_initializer.initialized()) { | |
| // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll) | |
| return false; | |
| } | |
| if (!IsValidPrinter(printer_name)) { | |
| return false; | |
| } | |
| DCHECK(printer_info); | |
| HPTPROVIDER provider = NULL; | |
| std::wstring printer_name_wide = UTF8ToWide(printer_name); | |
| HRESULT hr = XPSModule::OpenProvider(printer_name_wide, 1, &provider); | |
| if (provider) { | |
| base::win::ScopedComPtr<IStream> print_capabilities_stream; | |
| hr = CreateStreamOnHGlobal(NULL, TRUE, | |
| print_capabilities_stream.Receive()); | |
| DCHECK(SUCCEEDED(hr)); | |
| if (print_capabilities_stream) { | |
| base::win::ScopedBstr error; | |
| hr = XPSModule::GetPrintCapabilities(provider, | |
| NULL, | |
| print_capabilities_stream, | |
| error.Receive()); | |
| DCHECK(SUCCEEDED(hr)); | |
| if (FAILED(hr)) { | |
| return false; | |
| } | |
| hr = StreamOnHGlobalToString(print_capabilities_stream.get(), | |
| &printer_info->printer_capabilities); | |
| DCHECK(SUCCEEDED(hr)); | |
| printer_info->caps_mime_type = "text/xml"; | |
| } | |
| ScopedPrinterHandle printer_handle; | |
| if (printer_handle.OpenPrinter(printer_name_wide.c_str())) { | |
| LONG devmode_size = DocumentProperties( | |
| NULL, printer_handle, const_cast<LPTSTR>(printer_name_wide.c_str()), | |
| NULL, NULL, 0); | |
| if (devmode_size <= 0) | |
| return false; | |
| scoped_ptr<BYTE[]> devmode_out_buffer(new BYTE[devmode_size]); | |
| DEVMODE* devmode_out = | |
| reinterpret_cast<DEVMODE*>(devmode_out_buffer.get()); | |
| DocumentProperties( | |
| NULL, printer_handle, const_cast<LPTSTR>(printer_name_wide.c_str()), | |
| devmode_out, NULL, DM_OUT_BUFFER); | |
| base::win::ScopedComPtr<IStream> printer_defaults_stream; | |
| hr = CreateStreamOnHGlobal(NULL, TRUE, | |
| printer_defaults_stream.Receive()); | |
| DCHECK(SUCCEEDED(hr)); | |
| if (printer_defaults_stream) { | |
| hr = XPSModule::ConvertDevModeToPrintTicket(provider, | |
| devmode_size, | |
| devmode_out, | |
| kPTJobScope, | |
| printer_defaults_stream); | |
| DCHECK(SUCCEEDED(hr)); | |
| if (SUCCEEDED(hr)) { | |
| hr = StreamOnHGlobalToString(printer_defaults_stream.get(), | |
| &printer_info->printer_defaults); | |
| DCHECK(SUCCEEDED(hr)); | |
| printer_info->defaults_mime_type = "text/xml"; | |
| } | |
| } | |
| } | |
| XPSModule::CloseProvider(provider); | |
| } | |
| return true; | |
| } | |
| // Gets the information about driver for a specific printer. | |
| std::string PrintBackendWin::GetPrinterDriverInfo( | |
| const std::string& printer_name) { | |
| ScopedPrinterHandle printer; | |
| if (!printer.OpenPrinter(UTF8ToWide(printer_name).c_str())) { | |
| return std::string(); | |
| } | |
| return GetDriverInfo(printer); | |
| } | |
| bool PrintBackendWin::IsValidPrinter(const std::string& printer_name) { | |
| ScopedPrinterHandle printer_handle; | |
| return printer_handle.OpenPrinter(UTF8ToWide(printer_name).c_str()); | |
| } | |
| scoped_refptr<PrintBackend> PrintBackend::CreateInstance( | |
| const base::DictionaryValue* print_backend_settings) { | |
| return new PrintBackendWin; | |
| } | |
| } // namespace printing |