chrome/browser/ui/libgtk2ui/print_dialog_gtk2.cc

   1 // Copyright 2014 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 "chrome/browser/ui/libgtk2ui/print_dialog_gtk2.h"
   6
   7 #include <gtk/gtkunixprint.h>
   8
   9 #include <algorithm>
  10 #include <cmath>
  11 #include <string>
  12 #include <vector>
  13
  14 #include "base/bind.h"
  15 #include "base/files/file_util.h"
  16 #include "base/files/file_util_proxy.h"
  17 #include "base/lazy_instance.h"
  18 #include "base/logging.h"
  19 #include "base/message_loop/message_loop_proxy.h"
  20 #include "base/strings/utf_string_conversions.h"
  21 #include "base/values.h"
  22 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
  23 #include "chrome/browser/ui/libgtk2ui/printing_gtk2_util.h"
  24 #include "printing/metafile.h"
  25 #include "printing/print_job_constants.h"
  26 #include "printing/print_settings.h"
  27 #include "ui/aura/window.h"
  28 #include "ui/views/widget/desktop_aura/x11_desktop_handler.h"
  29
  30 using content::BrowserThread;
  31 using printing::PageRanges;
  32 using printing::PrintSettings;
  33
  34 namespace {
  35
  36 // CUPS Duplex attribute and values.
  37 const char kCUPSDuplex[] = "cups-Duplex";
  38 const char kDuplexNone[] = "None";
  39 const char kDuplexTumble[] = "DuplexTumble";
  40 const char kDuplexNoTumble[] = "DuplexNoTumble";
  41
  42 int kPaperSizeTresholdMicrons = 100;
  43 int kMicronsInMm = 1000;
  44
  45 // Checks whether gtk_paper_size can be used to represent user selected media.
  46 // In fuzzy match mode checks that paper sizes are "close enough" (less than
  47 // 1mm difference). In the exact mode, looks for the paper with the same PPD
  48 // name and "close enough" size.
  49 bool PaperSizeMatch(GtkPaperSize* gtk_paper_size,
  50                     const PrintSettings::RequestedMedia& media,
  51                     bool fuzzy_match) {
  52   if (!gtk_paper_size) {
  53     return false;
  54   }
  55   gfx::Size paper_size_microns(
  56       static_cast<int>(gtk_paper_size_get_width(gtk_paper_size, GTK_UNIT_MM) *
  57                        kMicronsInMm + 0.5),
  58       static_cast<int>(gtk_paper_size_get_height(gtk_paper_size, GTK_UNIT_MM) *
  59                        kMicronsInMm + 0.5));
  60   int diff = std::max(
  61       std::abs(paper_size_microns.width() - media.size_microns.width()),
  62       std::abs(paper_size_microns.height() - media.size_microns.height()));
  63   if (fuzzy_match) {
  64     return diff <= kPaperSizeTresholdMicrons;
  65   }
  66   return !media.vendor_id.empty() &&
  67          media.vendor_id == gtk_paper_size_get_ppd_name(gtk_paper_size) &&
  68          diff <= kPaperSizeTresholdMicrons;
  69 }
  70
  71 // Looks up a paper size matching (in terms of PaperSizeMatch) the user selected
  72 // media in the paper size list reported by GTK. Returns NULL if there's no
  73 // match found.
  74 GtkPaperSize* FindPaperSizeMatch(GList* gtk_paper_sizes,
  75                                  const PrintSettings::RequestedMedia& media) {
  76   GtkPaperSize* first_fuzzy_match = NULL;
  77   for (GList* p = gtk_paper_sizes; p && p->data; p = g_list_next(p)) {
  78     GtkPaperSize* gtk_paper_size = static_cast<GtkPaperSize*>(p->data);
  79     if (PaperSizeMatch(gtk_paper_size, media, false)) {
  80       return gtk_paper_size;
  81     }
  82     if (!first_fuzzy_match && PaperSizeMatch(gtk_paper_size, media, true)) {
  83       first_fuzzy_match = gtk_paper_size;
  84     }
  85   }
  86   return first_fuzzy_match;
  87 }
  88
  89 class StickyPrintSettingGtk {
  90  public:
  91   StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) {
  92   }
  93   ~StickyPrintSettingGtk() {
  94     NOTREACHED();  // Intended to be used with a Leaky LazyInstance.
  95   }
  96
  97   GtkPrintSettings* settings() {
  98     return last_used_settings_;
  99   }
 100
 101   void SetLastUsedSettings(GtkPrintSettings* settings) {
 102     DCHECK(last_used_settings_);
 103     g_object_unref(last_used_settings_);
 104     last_used_settings_ = gtk_print_settings_copy(settings);
 105   }
 106
 107  private:
 108   GtkPrintSettings* last_used_settings_;
 109
 110   DISALLOW_COPY_AND_ASSIGN(StickyPrintSettingGtk);
 111 };
 112
 113 base::LazyInstance<StickyPrintSettingGtk>::Leaky g_last_used_settings =
 114     LAZY_INSTANCE_INITIALIZER;
 115
 116 // Helper class to track GTK printers.
 117 class GtkPrinterList {
 118  public:
 119   GtkPrinterList() : default_printer_(NULL) {
 120     gtk_enumerate_printers(SetPrinter, this, NULL, TRUE);
 121   }
 122
 123   ~GtkPrinterList() {
 124     for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
 125          it < printers_.end(); ++it) {
 126       g_object_unref(*it);
 127     }
 128   }
 129
 130   // Can return NULL if there's no default printer. E.g. Printer on a laptop
 131   // is "home_printer", but the laptop is at work.
 132   GtkPrinter* default_printer() {
 133     return default_printer_;
 134   }
 135
 136   // Can return NULL if the printer cannot be found due to:
 137   // - Printer list out of sync with printer dialog UI.
 138   // - Querying for non-existant printers like 'Print to PDF'.
 139   GtkPrinter* GetPrinterWithName(const std::string& name) {
 140     if (name.empty())
 141       return NULL;
 142
 143     for (std::vector<GtkPrinter*>::iterator it = printers_.begin();
 144          it < printers_.end(); ++it) {
 145       if (gtk_printer_get_name(*it) == name) {
 146         return *it;
 147       }
 148     }
 149
 150     return NULL;
 151   }
 152
 153  private:
 154   // Callback function used by gtk_enumerate_printers() to get all printer.
 155   static gboolean SetPrinter(GtkPrinter* printer, gpointer data) {
 156     GtkPrinterList* printer_list = reinterpret_cast<GtkPrinterList*>(data);
 157     if (gtk_printer_is_default(printer))
 158       printer_list->default_printer_ = printer;
 159
 160     g_object_ref(printer);
 161     printer_list->printers_.push_back(printer);
 162
 163     return FALSE;
 164   }
 165
 166   std::vector<GtkPrinter*> printers_;
 167   GtkPrinter* default_printer_;
 168 };
 169
 170 }  // namespace
 171
 172 // static
 173 printing::PrintDialogGtkInterface* PrintDialogGtk2::CreatePrintDialog(
 174     PrintingContextLinux* context) {
 175   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 176   return new PrintDialogGtk2(context);
 177 }
 178
 179 PrintDialogGtk2::PrintDialogGtk2(PrintingContextLinux* context)
 180     : context_(context),
 181       dialog_(NULL),
 182       gtk_settings_(NULL),
 183       page_setup_(NULL),
 184       printer_(NULL) {
 185 }
 186
 187 PrintDialogGtk2::~PrintDialogGtk2() {
 188   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 189
 190   if (dialog_) {
 191     aura::Window* parent = libgtk2ui::GetAuraTransientParent(dialog_);
 192     if (parent) {
 193       parent->RemoveObserver(this);
 194       libgtk2ui::ClearAuraTransientParent(dialog_);
 195     }
 196     gtk_widget_destroy(dialog_);
 197     dialog_ = NULL;
 198   }
 199   if (gtk_settings_) {
 200     g_object_unref(gtk_settings_);
 201     gtk_settings_ = NULL;
 202   }
 203   if (page_setup_) {
 204     g_object_unref(page_setup_);
 205     page_setup_ = NULL;
 206   }
 207   if (printer_) {
 208     g_object_unref(printer_);
 209     printer_ = NULL;
 210   }
 211 }
 212
 213 void PrintDialogGtk2::UseDefaultSettings() {
 214   DCHECK(!page_setup_);
 215   DCHECK(!printer_);
 216
 217   // |gtk_settings_| is a new copy.
 218   gtk_settings_ =
 219       gtk_print_settings_copy(g_last_used_settings.Get().settings());
 220   page_setup_ = gtk_page_setup_new();
 221
 222   PrintSettings settings;
 223   InitPrintSettings(&settings);
 224 }
 225
 226 bool PrintDialogGtk2::UpdateSettings(printing::PrintSettings* settings) {
 227   if (!gtk_settings_) {
 228     gtk_settings_ =
 229         gtk_print_settings_copy(g_last_used_settings.Get().settings());
 230   }
 231
 232   scoped_ptr<GtkPrinterList> printer_list(new GtkPrinterList);
 233   printer_ = printer_list->GetPrinterWithName(
 234       base::UTF16ToUTF8(settings->device_name()));
 235   if (printer_) {
 236     g_object_ref(printer_);
 237     gtk_print_settings_set_printer(gtk_settings_,
 238                                    gtk_printer_get_name(printer_));
 239     if (!page_setup_) {
 240       page_setup_ = gtk_printer_get_default_page_size(printer_);
 241     }
 242   }
 243
 244   gtk_print_settings_set_n_copies(gtk_settings_, settings->copies());
 245   gtk_print_settings_set_collate(gtk_settings_, settings->collate());
 246
 247 #if defined(USE_CUPS)
 248   std::string color_value;
 249   std::string color_setting_name;
 250   printing::GetColorModelForMode(settings->color(), &color_setting_name,
 251                                  &color_value);
 252   gtk_print_settings_set(gtk_settings_, color_setting_name.c_str(),
 253                          color_value.c_str());
 254
 255   if (settings->duplex_mode() != printing::UNKNOWN_DUPLEX_MODE) {
 256     const char* cups_duplex_mode = NULL;
 257     switch (settings->duplex_mode()) {
 258       case printing::LONG_EDGE:
 259         cups_duplex_mode = kDuplexNoTumble;
 260         break;
 261       case printing::SHORT_EDGE:
 262         cups_duplex_mode = kDuplexTumble;
 263         break;
 264       case printing::SIMPLEX:
 265         cups_duplex_mode = kDuplexNone;
 266         break;
 267       default:  // UNKNOWN_DUPLEX_MODE
 268         NOTREACHED();
 269         break;
 270     }
 271     gtk_print_settings_set(gtk_settings_, kCUPSDuplex, cups_duplex_mode);
 272   }
 273 #endif
 274   if (!page_setup_)
 275     page_setup_ = gtk_page_setup_new();
 276
 277   if (page_setup_ && !settings->requested_media().IsDefault()) {
 278     const PrintSettings::RequestedMedia& requested_media =
 279         settings->requested_media();
 280     GtkPaperSize* gtk_current_paper_size =
 281         gtk_page_setup_get_paper_size(page_setup_);
 282     if (!PaperSizeMatch(gtk_current_paper_size, requested_media,
 283                         true /*fuzzy_match*/)) {
 284       GList* gtk_paper_sizes =
 285           gtk_paper_size_get_paper_sizes(false /*include_custom*/);
 286       if (gtk_paper_sizes) {
 287         GtkPaperSize* matching_gtk_paper_size =
 288             FindPaperSizeMatch(gtk_paper_sizes, requested_media);
 289         if (matching_gtk_paper_size) {
 290           VLOG(1) << "Using listed paper size";
 291           gtk_page_setup_set_paper_size(page_setup_, matching_gtk_paper_size);
 292         } else {
 293           VLOG(1) << "Using custom paper size";
 294           GtkPaperSize* custom_size = gtk_paper_size_new_custom(
 295               requested_media.vendor_id.c_str(),
 296               requested_media.vendor_id.c_str(),
 297               requested_media.size_microns.width() / kMicronsInMm,
 298               requested_media.size_microns.height() / kMicronsInMm,
 299               GTK_UNIT_MM);
 300           gtk_page_setup_set_paper_size(page_setup_, custom_size);
 301           gtk_paper_size_free(custom_size);
 302         }
 303         g_list_free_full(gtk_paper_sizes,
 304                          reinterpret_cast<GDestroyNotify>(gtk_paper_size_free));
 305       }
 306     } else {
 307       VLOG(1) << "Using default paper size";
 308     }
 309   }
 310
 311   gtk_print_settings_set_orientation(
 312       gtk_settings_,
 313       settings->landscape() ? GTK_PAGE_ORIENTATION_LANDSCAPE :
 314                               GTK_PAGE_ORIENTATION_PORTRAIT);
 315
 316   InitPrintSettings(settings);
 317   return true;
 318 }
 319
 320 void PrintDialogGtk2::ShowDialog(
 321     gfx::NativeView parent_view,
 322     bool has_selection,
 323     const PrintingContextLinux::PrintSettingsCallback& callback) {
 324   callback_ = callback;
 325
 326   dialog_ = gtk_print_unix_dialog_new(NULL, NULL);
 327   libgtk2ui::SetGtkTransientForAura(dialog_, parent_view);
 328   if (parent_view)
 329     parent_view->AddObserver(this);
 330   g_signal_connect(dialog_, "delete-event",
 331                    G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 332
 333
 334   // Set modal so user cannot focus the same tab and press print again.
 335   gtk_window_set_modal(GTK_WINDOW(dialog_), TRUE);
 336
 337   // Since we only generate PDF, only show printers that support PDF.
 338   // TODO(thestig) Add more capabilities to support?
 339   GtkPrintCapabilities cap = static_cast<GtkPrintCapabilities>(
 340       GTK_PRINT_CAPABILITY_GENERATE_PDF |
 341       GTK_PRINT_CAPABILITY_PAGE_SET |
 342       GTK_PRINT_CAPABILITY_COPIES |
 343       GTK_PRINT_CAPABILITY_COLLATE |
 344       GTK_PRINT_CAPABILITY_REVERSE);
 345   gtk_print_unix_dialog_set_manual_capabilities(GTK_PRINT_UNIX_DIALOG(dialog_),
 346                                                 cap);
 347   gtk_print_unix_dialog_set_embed_page_setup(GTK_PRINT_UNIX_DIALOG(dialog_),
 348                                              TRUE);
 349   gtk_print_unix_dialog_set_support_selection(GTK_PRINT_UNIX_DIALOG(dialog_),
 350                                               TRUE);
 351   gtk_print_unix_dialog_set_has_selection(GTK_PRINT_UNIX_DIALOG(dialog_),
 352                                           has_selection);
 353   gtk_print_unix_dialog_set_settings(GTK_PRINT_UNIX_DIALOG(dialog_),
 354                                      gtk_settings_);
 355   g_signal_connect(dialog_, "response", G_CALLBACK(OnResponseThunk), this);
 356   gtk_widget_show(dialog_);
 357
 358   // We need to call gtk_window_present after making the widgets visible to make
 359   // sure window gets correctly raised and gets focus.
 360   int time = views::X11DesktopHandler::get()->wm_user_time_ms();
 361   gtk_window_present_with_time(GTK_WINDOW(dialog_), time);
 362 }
 363
 364 void PrintDialogGtk2::PrintDocument(const printing::MetafilePlayer& metafile,
 365                                     const base::string16& document_name) {
 366   // This runs on the print worker thread, does not block the UI thread.
 367   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 368
 369   // The document printing tasks can outlive the PrintingContext that created
 370   // this dialog.
 371   AddRef();
 372
 373   bool success = base::CreateTemporaryFile(&path_to_pdf_);
 374
 375   if (success) {
 376     base::File file;
 377     file.Initialize(path_to_pdf_,
 378                     base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
 379     success = metafile.SaveTo(&file);
 380     file.Close();
 381     if (!success)
 382       base::DeleteFile(path_to_pdf_, false);
 383   }
 384
 385   if (!success) {
 386     LOG(ERROR) << "Saving metafile failed";
 387     // Matches AddRef() above.
 388     Release();
 389     return;
 390   }
 391
 392   // No errors, continue printing.
 393   BrowserThread::PostTask(
 394       BrowserThread::UI,
 395       FROM_HERE,
 396       base::Bind(&PrintDialogGtk2::SendDocumentToPrinter, this, document_name));
 397 }
 398
 399 void PrintDialogGtk2::AddRefToDialog() {
 400   AddRef();
 401 }
 402
 403 void PrintDialogGtk2::ReleaseDialog() {
 404   Release();
 405 }
 406
 407 void PrintDialogGtk2::OnResponse(GtkWidget* dialog, int response_id) {
 408   int num_matched_handlers = g_signal_handlers_disconnect_by_func(
 409       dialog_, reinterpret_cast<gpointer>(&OnResponseThunk), this);
 410   CHECK_EQ(1, num_matched_handlers);
 411
 412   gtk_widget_hide(dialog_);
 413
 414   switch (response_id) {
 415     case GTK_RESPONSE_OK: {
 416       if (gtk_settings_)
 417         g_object_unref(gtk_settings_);
 418       gtk_settings_ = gtk_print_unix_dialog_get_settings(
 419           GTK_PRINT_UNIX_DIALOG(dialog_));
 420
 421       if (printer_)
 422         g_object_unref(printer_);
 423       printer_ = gtk_print_unix_dialog_get_selected_printer(
 424           GTK_PRINT_UNIX_DIALOG(dialog_));
 425       g_object_ref(printer_);
 426
 427       if (page_setup_)
 428         g_object_unref(page_setup_);
 429       page_setup_ = gtk_print_unix_dialog_get_page_setup(
 430           GTK_PRINT_UNIX_DIALOG(dialog_));
 431       g_object_ref(page_setup_);
 432
 433       // Handle page ranges.
 434       PageRanges ranges_vector;
 435       gint num_ranges;
 436       bool print_selection_only = false;
 437       switch (gtk_print_settings_get_print_pages(gtk_settings_)) {
 438         case GTK_PRINT_PAGES_RANGES: {
 439           GtkPageRange* gtk_range =
 440               gtk_print_settings_get_page_ranges(gtk_settings_, &num_ranges);
 441           if (gtk_range) {
 442             for (int i = 0; i < num_ranges; ++i) {
 443               printing::PageRange range;
 444               range.from = gtk_range[i].start;
 445               range.to = gtk_range[i].end;
 446               ranges_vector.push_back(range);
 447             }
 448             g_free(gtk_range);
 449           }
 450           break;
 451         }
 452         case GTK_PRINT_PAGES_SELECTION:
 453           print_selection_only = true;
 454           break;
 455         case GTK_PRINT_PAGES_ALL:
 456           // Leave |ranges_vector| empty to indicate print all pages.
 457           break;
 458         case GTK_PRINT_PAGES_CURRENT:
 459         default:
 460           NOTREACHED();
 461           break;
 462       }
 463
 464       PrintSettings settings;
 465       settings.set_ranges(ranges_vector);
 466       settings.set_selection_only(print_selection_only);
 467       InitPrintSettingsGtk(gtk_settings_, page_setup_, &settings);
 468       context_->InitWithSettings(settings);
 469       callback_.Run(PrintingContextLinux::OK);
 470       callback_.Reset();
 471       return;
 472     }
 473     case GTK_RESPONSE_DELETE_EVENT:  // Fall through.
 474     case GTK_RESPONSE_CANCEL: {
 475       callback_.Run(PrintingContextLinux::CANCEL);
 476       callback_.Reset();
 477       return;
 478     }
 479     case GTK_RESPONSE_APPLY:
 480     default: {
 481       NOTREACHED();
 482     }
 483   }
 484 }
 485
 486 void PrintDialogGtk2::SendDocumentToPrinter(
 487     const base::string16& document_name) {
 488   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 489
 490   // If |printer_| is NULL then somehow the GTK printer list changed out under
 491   // us. In which case, just bail out.
 492   if (!printer_) {
 493     // Matches AddRef() in PrintDocument();
 494     Release();
 495     return;
 496   }
 497
 498   // Save the settings for next time.
 499   g_last_used_settings.Get().SetLastUsedSettings(gtk_settings_);
 500
 501   GtkPrintJob* print_job = gtk_print_job_new(
 502       base::UTF16ToUTF8(document_name).c_str(),
 503       printer_,
 504       gtk_settings_,
 505       page_setup_);
 506   gtk_print_job_set_source_file(print_job, path_to_pdf_.value().c_str(), NULL);
 507   gtk_print_job_send(print_job, OnJobCompletedThunk, this, NULL);
 508 }
 509
 510 // static
 511 void PrintDialogGtk2::OnJobCompletedThunk(GtkPrintJob* print_job,
 512                                          gpointer user_data,
 513                                          GError* error) {
 514   static_cast<PrintDialogGtk2*>(user_data)->OnJobCompleted(print_job, error);
 515 }
 516
 517 void PrintDialogGtk2::OnJobCompleted(GtkPrintJob* print_job, GError* error) {
 518   if (error)
 519     LOG(ERROR) << "Printing failed: " << error->message;
 520   if (print_job)
 521     g_object_unref(print_job);
 522   base::FileUtilProxy::DeleteFile(
 523       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE).get(),
 524       path_to_pdf_,
 525       false,
 526       base::FileUtilProxy::StatusCallback());
 527   // Printing finished. Matches AddRef() in PrintDocument();
 528   Release();
 529 }
 530
 531 void PrintDialogGtk2::InitPrintSettings(PrintSettings* settings) {
 532   InitPrintSettingsGtk(gtk_settings_, page_setup_, settings);
 533   context_->InitWithSettings(*settings);
 534 }
 535
 536 void PrintDialogGtk2::OnWindowDestroying(aura::Window* window) {
 537   DCHECK_EQ(libgtk2ui::GetAuraTransientParent(dialog_), window);
 538
 539   libgtk2ui::ClearAuraTransientParent(dialog_);
 540   window->RemoveObserver(this);
 541   Release();
 542 }