Add support for printing selection only flag. This only adds the flag to the ...

chrome/browser/printing/win_printing_context.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/printing/win_printing_context.h"
 
 #include <winspool.h>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 134 matching lines @@
       dialog_box_(NULL),
       dialog_box_dismissed_(false),
       abort_printing_(false),
       in_print_job_(false) {
 }
 
 PrintingContext::~PrintingContext() {
   ResetSettings();
 }
 
-PrintingContext::Result PrintingContext::AskUserForSettings(HWND window,
-                                                            int max_pages) {
+PrintingContext::Result PrintingContext::AskUserForSettings(
+    HWND window,
+    int max_pages,
+    bool has_selection) {
   DCHECK(window);
   DCHECK(!in_print_job_);
   dialog_box_dismissed_ = false;
   // Show the OS-dependent dialog box.
   // If the user press
   // - OK, the settings are reset and reinitialized with the new settings. OK is
   //   returned.
   // - Apply then Cancel, the settings are reset and reinitialized with the new
   //   settings. CANCEL is returned.
   // - Cancel, the settings are not changed, the previous setting, if it was
   //   initialized before, are kept. CANCEL is returned.
   // On failure, the settings are reset and FAILED is returned.
   PRINTDLGEX dialog_options = { sizeof(PRINTDLGEX) };
   dialog_options.hwndOwner = window;
-  // Disables the Current Page and Selection radio buttons since WebKit can't
-  // print a part of the webpage and we don't know which page is the current
-  // one.
+  // Disable options we don't support currently.
   // TODO(maruel):  Reuse the previously loaded settings!
   dialog_options.Flags = PD_RETURNDC | PD_USEDEVMODECOPIESANDCOLLATE  |
-                         PD_NOSELECTION | PD_NOCURRENTPAGE | PD_HIDEPRINTTOFILE;
+                         PD_NOCURRENTPAGE | PD_HIDEPRINTTOFILE;
+  if (!has_selection)
+    dialog_options.Flags |= PD_NOSELECTION;
+
   PRINTPAGERANGE ranges[32];
   dialog_options.nStartPage = START_PAGE_GENERAL;
   if (max_pages) {
     // Default initialize to print all the pages.
     memset(ranges, 0, sizeof(ranges));
     ranges[0].nFromPage = 1;
     ranges[0].nToPage = max_pages;
     dialog_options.nPageRanges = 1;
     dialog_options.nMaxPageRanges = arraysize(ranges);
     dialog_options.nMaxPage = max_pages;
@@ skipping 59 matching lines @@
 
 #ifndef NDEBUG
   page_number_ = -1;
 #endif
 }
 
 PrintingContext::Result PrintingContext::NewDocument(
     const std::wstring& document_name) {
   DCHECK(!in_print_job_);
   if (!hdc_)
-    return OnErrror();
+    return OnError();
 
   // Set the flag used by the AbortPrintJob dialog procedure.
   abort_printing_ = false;
 
   in_print_job_ = true;
 
   // Register the application's AbortProc function with GDI.
   if (SP_ERROR == SetAbortProc(hdc_, &AbortProc))
-    return OnErrror();
+    return OnError();
 
   DOCINFO di = { sizeof(DOCINFO) };
   di.lpszDocName = document_name.c_str();
 
   // Is there a debug dump directory specified? If so, force to print to a file.
   std::wstring debug_dump_path;
   if (!g_browser_process || !g_browser_process->print_job_manager()) {
     // Happens only inside a unit test.
     debug_dump_path = L".";
   } else {
@@ skipping 14 matching lines @@
     file_util::ReplaceIllegalCharacters(&filename, '_');
     file_util::AppendToPath(&debug_dump_path, filename);
     di.lpszOutput = debug_dump_path.c_str();
   }
 
   DCHECK_EQ(MessageLoop::current()->NestableTasksAllowed(), false);
   // Begin a print job by calling the StartDoc function.
   // NOTE: StartDoc() starts a message loop. That causes a lot of problems with
   // IPC. Make sure recursive task processing is disabled.
   if (StartDoc(hdc_, &di) <= 0)
-    return OnErrror();
+    return OnError();
 
 #ifndef NDEBUG
   page_number_ = 0;
 #endif
   return OK;
 }
 
 PrintingContext::Result PrintingContext::NewPage() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
   // Inform the driver that the application is about to begin sending data.
   if (StartPage(hdc_) <= 0)
-    return OnErrror();
+    return OnError();
 
 #ifndef NDEBUG
   ++page_number_;
 #endif
 
   return OK;
 }
 
 PrintingContext::Result PrintingContext::PageDone() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
   if (EndPage(hdc_) <= 0)
-    return OnErrror();
+    return OnError();
   return OK;
 }
 
 PrintingContext::Result PrintingContext::DocumentDone() {
   if (abort_printing_)
     return CANCEL;
   DCHECK(in_print_job_);
 
   // Inform the driver that document has ended.
   if (EndDoc(hdc_) <= 0)
-    return OnErrror();
+    return OnError();
 
   ResetSettings();
   return OK;
 }
 
 void PrintingContext::Cancel() {
   abort_printing_ = true;
   in_print_job_ = false;
   if (hdc_)
     CancelDC(hdc_);
   DismissDialog();
 }
 
 void PrintingContext::DismissDialog() {
   if (dialog_box_) {
     DestroyWindow(dialog_box_);
     dialog_box_dismissed_ = true;
   }
 }
 
-PrintingContext::Result PrintingContext::OnErrror() {
+PrintingContext::Result PrintingContext::OnError() {
   // This will close hdc_ and clear settings_.
   ResetSettings();
   return abort_printing_ ? CANCEL : FAILED;
 }
 
 // static
 BOOL PrintingContext::AbortProc(HDC hdc, int nCode) {
   if (nCode) {
     // TODO(maruel):  Need a way to find the right instance to set. Should
     // leverage PrintJobManager here?
     // abort_printing_ = true;
   }
   return true;
 }
 
 bool PrintingContext::InitializeSettings(const DEVMODE& dev_mode,
                                          const std::wstring& new_device_name,
                                          const PRINTPAGERANGE* ranges,
-                                         int number_ranges) {
+                                         int number_ranges,
+                                         bool selection_only) {
   skia::PlatformDeviceWin::InitializeDC(hdc_);
   DCHECK(GetDeviceCaps(hdc_, CLIPCAPS));
   DCHECK(GetDeviceCaps(hdc_, RASTERCAPS) & RC_STRETCHDIB);
   DCHECK(GetDeviceCaps(hdc_, RASTERCAPS) & RC_BITMAP64);
   // Some printers don't advertise these.
   // DCHECK(GetDeviceCaps(hdc_, RASTERCAPS) & RC_SCALING);
   // DCHECK(GetDeviceCaps(hdc_, SHADEBLENDCAPS) & SB_CONST_ALPHA);
   // DCHECK(GetDeviceCaps(hdc_, SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
 
   // StretchDIBits() support is needed for printing.
   if (!(GetDeviceCaps(hdc_, RASTERCAPS) & RC_STRETCHDIB) ||
       !(GetDeviceCaps(hdc_, RASTERCAPS) & RC_BITMAP64)) {
     NOTREACHED();
     ResetSettings();
     return false;
   }
 
   DCHECK(!in_print_job_);
   DCHECK(hdc_);
   // Convert the PRINTPAGERANGE array to a PrintSettings::PageRanges vector.
   PageRanges ranges_vector;
   ranges_vector.reserve(number_ranges);
   for (int i = 0; i < number_ranges; ++i) {
     PageRange range;
     // Transfert from 1-based to 0-based.
     range.from = ranges[i].nFromPage - 1;
     range.to = ranges[i].nToPage - 1;
     ranges_vector.push_back(range);
   }
-  settings_.Init(hdc_, dev_mode, ranges_vector, new_device_name);
+  settings_.Init(hdc_,
+                 dev_mode,
+                 ranges_vector,
+                 new_device_name,
+                 selection_only);
   return true;
 }
 
 bool PrintingContext::GetPrinterSettings(HANDLE printer,
                                          const std::wstring& device_name) {
   DCHECK(!in_print_job_);
   scoped_array<uint8> buffer;
 
   // A PRINTER_INFO_9 structure specifying the per-user default printer
   // settings.
   GetPrinterHelper(printer, 9, &buffer);
   if (buffer.get()) {
     PRINTER_INFO_9* info_9 = reinterpret_cast<PRINTER_INFO_9*>(buffer.get());
     if (info_9->pDevMode != NULL) {
       if (!AllocateContext(device_name, info_9->pDevMode)) {
         ResetSettings();
         return false;
       }
-      return InitializeSettings(*info_9->pDevMode, device_name, NULL, 0);
+      return InitializeSettings(*info_9->pDevMode, device_name, NULL, 0, false);
     }
     buffer.reset();
   }
 
   // A PRINTER_INFO_8 structure specifying the global default printer settings.
   GetPrinterHelper(printer, 8, &buffer);
   if (buffer.get()) {
     PRINTER_INFO_8* info_8 = reinterpret_cast<PRINTER_INFO_8*>(buffer.get());
     if (info_8->pDevMode != NULL) {
       if (!AllocateContext(device_name, info_8->pDevMode)) {
         ResetSettings();
         return false;
       }
-      return InitializeSettings(*info_8->pDevMode, device_name, NULL, 0);
+      return InitializeSettings(*info_8->pDevMode, device_name, NULL, 0, false);
     }
     buffer.reset();
   }
 
   // A PRINTER_INFO_2 structure specifying the driver's default printer
   // settings.
   GetPrinterHelper(printer, 2, &buffer);
   if (buffer.get()) {
     PRINTER_INFO_2* info_2 = reinterpret_cast<PRINTER_INFO_2*>(buffer.get());
     if (info_2->pDevMode != NULL) {
       if (!AllocateContext(device_name, info_2->pDevMode)) {
         ResetSettings();
         return false;
       }
-      return InitializeSettings(*info_2->pDevMode, device_name, NULL, 0);
+      return InitializeSettings(*info_2->pDevMode, device_name, NULL, 0, false);
     }
     buffer.reset();
   }
   // Failed to retrieve the printer settings.
   ResetSettings();
   return false;
 }
 
 bool PrintingContext::AllocateContext(const std::wstring& printer_name,
                                       const DEVMODE* dev_mode) {
@@ skipping 26 matching lines @@
             reinterpret_cast<const wchar_t*>(
                 reinterpret_cast<const wchar_t*>(dev_names) +
                     dev_names->wDeviceOffset);
         GlobalUnlock(dialog_options.hDevNames);
       }
     }
 
     bool success = false;
     if (dev_mode && !device_name.empty()) {
       hdc_ = dialog_options.hDC;
+      PRINTPAGERANGE* page_ranges = NULL;
+      DWORD num_page_ranges = 0;
+      bool print_selection_only = false;
       if (dialog_options.Flags & PD_PAGENUMS) {
-        success = InitializeSettings(*dev_mode,
-                                     device_name,
-                                     dialog_options.lpPageRanges,
-                                     dialog_options.nPageRanges);
-      } else {
-        success = InitializeSettings(*dev_mode, device_name, NULL, 0);
+        page_ranges = dialog_options.lpPageRanges;
+        num_page_ranges = dialog_options.nPageRanges;
       }
+      if (dialog_options.Flags & PD_SELECTION) {
+        print_selection_only = true;
+      }
+      success = InitializeSettings(*dev_mode,
+                                   device_name,
+                                   dialog_options.lpPageRanges,
+                                   dialog_options.nPageRanges,
+                                   print_selection_only);
     }
 
     if (!success && dialog_options.hDC) {
       DeleteDC(dialog_options.hDC);
       hdc_ = NULL;
     }
 
     if (dev_mode) {
       GlobalUnlock(dialog_options.hDevMode);
     }
@@ skipping 43 matching lines @@
           reinterpret_cast<const wchar_t*>(
               reinterpret_cast<const wchar_t*>(dev_names) +
                   dev_names->wDeviceOffset);
       GlobalUnlock(dialog_options.hDevNames);
     }
   }
 
   bool success = false;
   if (dev_mode && !device_name.empty()) {
     hdc_ = dialog_options.hDC;
-    success = InitializeSettings(*dev_mode, device_name, NULL, 0);
+    success = InitializeSettings(*dev_mode, device_name, NULL, 0, false);
   }
 
   if (!success && dialog_options.hDC) {
     DeleteDC(dialog_options.hDC);
     hdc_ = NULL;
   }
 
   if (dev_mode) {
     GlobalUnlock(dialog_options.hDevMode);
   }
 
   if (dialog_options.hDevMode != NULL)
     GlobalFree(dialog_options.hDevMode);
   if (dialog_options.hDevNames != NULL)
     GlobalFree(dialog_options.hDevNames);
 
   return hdc_ ? OK : FAILED;
 }
 
 }  // namespace printing