printing/backend/win_helper.h

   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 #ifndef PRINTING_BACKEND_WIN_HELPER_H_
   6 #define PRINTING_BACKEND_WIN_HELPER_H_
   7
   8 #include <objidl.h>
   9 #include <prntvpt.h>
  10 #include <winspool.h>
  11 #include <xpsprint.h>
  12
  13 #include <string>
  14
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/strings/string16.h"
  17 #include "base/win/scoped_handle.h"
  18 #include "printing/printing_export.h"
  19
  20 // These are helper functions for dealing with Windows Printing.
  21 namespace printing {
  22
  23 struct PRINTING_EXPORT PrinterBasicInfo;
  24
  25 class PrinterHandleTraits {
  26  public:
  27   typedef HANDLE Handle;
  28
  29   static bool CloseHandle(HANDLE handle) {
  30     return ::ClosePrinter(handle) != FALSE;
  31   }
  32
  33   static bool IsHandleValid(HANDLE handle) {
  34     return handle != NULL;
  35   }
  36
  37   static HANDLE NullHandle() {
  38     return NULL;
  39   }
  40
  41  private:
  42   DISALLOW_IMPLICIT_CONSTRUCTORS(PrinterHandleTraits);
  43 };
  44
  45 class ScopedPrinterHandle
  46     : public base::win::GenericScopedHandle<PrinterHandleTraits,
  47                                             base::win::DummyVerifierTraits> {
  48  public:
  49   bool OpenPrinter(const wchar_t* printer) {
  50     HANDLE temp_handle;
  51     // ::OpenPrinter may return error but assign some value into handle.
  52     if (::OpenPrinter(const_cast<LPTSTR>(printer), &temp_handle, NULL)) {
  53       Set(temp_handle);
  54     }
  55     return IsValid();
  56   }
  57
  58  private:
  59   typedef base::win::GenericScopedHandle<PrinterHandleTraits,
  60                                          base::win::DummyVerifierTraits> Base;
  61 };
  62
  63 class PrinterChangeHandleTraits {
  64  public:
  65   typedef HANDLE Handle;
  66
  67   static bool CloseHandle(HANDLE handle) {
  68     ::FindClosePrinterChangeNotification(handle);
  69     return true;
  70   }
  71
  72   static bool IsHandleValid(HANDLE handle) {
  73     return handle != NULL;
  74   }
  75
  76   static HANDLE NullHandle() {
  77     return NULL;
  78   }
  79
  80  private:
  81   DISALLOW_IMPLICIT_CONSTRUCTORS(PrinterChangeHandleTraits);
  82 };
  83
  84 typedef base::win::GenericScopedHandle<PrinterChangeHandleTraits,
  85                                        base::win::DummyVerifierTraits>
  86     ScopedPrinterChangeHandle;
  87
  88 // Wrapper class to wrap the XPS APIs (PTxxx APIs). This is needed because these
  89 // APIs are not available by default on XP. We could delayload prntvpt.dll but
  90 // this would mean having to add that to every binary that links with
  91 // printing.lib (which is a LOT of binaries). So choosing the GetProcAddress
  92 // route instead).
  93 class PRINTING_EXPORT XPSModule {
  94  public:
  95   // All the other methods can ONLY be called after a successful call to Init.
  96   // Init can be called many times and by multiple threads.
  97   static bool Init();
  98   static HRESULT OpenProvider(const base::string16& printer_name,
  99                               DWORD version,
 100                               HPTPROVIDER* provider);
 101   static HRESULT GetPrintCapabilities(HPTPROVIDER provider,
 102                                       IStream* print_ticket,
 103                                       IStream* capabilities,
 104                                       BSTR* error_message);
 105   static HRESULT ConvertDevModeToPrintTicket(HPTPROVIDER provider,
 106                                              ULONG devmode_size_in_bytes,
 107                                              PDEVMODE devmode,
 108                                              EPrintTicketScope scope,
 109                                              IStream* print_ticket);
 110   static HRESULT ConvertPrintTicketToDevMode(
 111       HPTPROVIDER provider,
 112       IStream* print_ticket,
 113       EDefaultDevmodeType base_devmode_type,
 114       EPrintTicketScope scope,
 115       ULONG* devmode_byte_count,
 116       PDEVMODE* devmode,
 117       BSTR* error_message);
 118   static HRESULT MergeAndValidatePrintTicket(HPTPROVIDER provider,
 119                                              IStream* base_ticket,
 120                                              IStream* delta_ticket,
 121                                              EPrintTicketScope scope,
 122                                              IStream* result_ticket,
 123                                              BSTR* error_message);
 124   static HRESULT ReleaseMemory(PVOID buffer);
 125   static HRESULT CloseProvider(HPTPROVIDER provider);
 126
 127  private:
 128   XPSModule() { }
 129   static bool InitImpl();
 130 };
 131
 132 // See comments in cc file explaining why we need this.
 133 class PRINTING_EXPORT ScopedXPSInitializer {
 134  public:
 135   ScopedXPSInitializer();
 136   ~ScopedXPSInitializer();
 137
 138   bool initialized() const { return initialized_; }
 139
 140  private:
 141   bool initialized_;
 142 };
 143
 144 // Wrapper class to wrap the XPS Print APIs (these are different from the PTxxx
 145 // which deal with the XML Print Schema). This is needed because these
 146 // APIs are only available on Windows 7 and higher.
 147 class PRINTING_EXPORT XPSPrintModule {
 148  public:
 149   // All the other methods can ONLY be called after a successful call to Init.
 150   // Init can be called many times and by multiple threads.
 151   static bool Init();
 152   static HRESULT StartXpsPrintJob(
 153       const LPCWSTR printer_name,
 154       const LPCWSTR job_name,
 155       const LPCWSTR output_file_name,
 156       HANDLE progress_event,
 157       HANDLE completion_event,
 158       UINT8* printable_pages_on,
 159       UINT32 printable_pages_on_count,
 160       IXpsPrintJob **xps_print_job,
 161       IXpsPrintJobStream **document_stream,
 162       IXpsPrintJobStream **print_ticket_stream);
 163  private:
 164   XPSPrintModule() { }
 165   static bool InitImpl();
 166 };
 167
 168 PRINTING_EXPORT bool InitBasicPrinterInfo(HANDLE printer,
 169                                           PrinterBasicInfo* printer_info);
 170
 171 PRINTING_EXPORT std::string GetDriverInfo(HANDLE printer);
 172
 173 PRINTING_EXPORT scoped_ptr<DEVMODE, base::FreeDeleter> XpsTicketToDevMode(
 174     const base::string16& printer_name,
 175     const std::string& print_ticket);
 176
 177 // Creates default DEVMODE and sets color option. Some devices need special
 178 // workaround for color.
 179 PRINTING_EXPORT scoped_ptr<DEVMODE, base::FreeDeleter> CreateDevModeWithColor(
 180     HANDLE printer,
 181     const base::string16& printer_name,
 182     bool color);
 183
 184 // Creates new DEVMODE. If |in| is not NULL copy settings from there.
 185 PRINTING_EXPORT scoped_ptr<DEVMODE, base::FreeDeleter> CreateDevMode(
 186     HANDLE printer,
 187     DEVMODE* in);
 188
 189 // Prompts for new DEVMODE. If |in| is not NULL copy settings from there.
 190 PRINTING_EXPORT scoped_ptr<DEVMODE, base::FreeDeleter> PromptDevMode(
 191     HANDLE printer,
 192     const base::string16& printer_name,
 193     DEVMODE* in,
 194     HWND window,
 195     bool* canceled);
 196
 197 }  // namespace printing
 198
 199 #endif  // PRINTING_BACKEND_WIN_HELPER_H_