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.
PaperSizeMatch(GtkPaperSize * gtk_paper_size,const PrintSettings::RequestedMedia & media,bool fuzzy_match)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.
FindPaperSizeMatch(GList * gtk_paper_sizes,const PrintSettings::RequestedMedia & media)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:
StickyPrintSettingGtk()91 StickyPrintSettingGtk() : last_used_settings_(gtk_print_settings_new()) {
92 }
~StickyPrintSettingGtk()93 ~StickyPrintSettingGtk() {
94 NOTREACHED(); // Intended to be used with a Leaky LazyInstance.
95 }
96
settings()97 GtkPrintSettings* settings() {
98 return last_used_settings_;
99 }
100
SetLastUsedSettings(GtkPrintSettings * settings)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:
GtkPrinterList()119 GtkPrinterList() : default_printer_(NULL) {
120 gtk_enumerate_printers(SetPrinter, this, NULL, TRUE);
121 }
122
~GtkPrinterList()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.
default_printer()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'.
GetPrinterWithName(const std::string & name)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.
SetPrinter(GtkPrinter * printer,gpointer data)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
CreatePrintDialog(PrintingContextLinux * context)173 printing::PrintDialogGtkInterface* PrintDialogGtk2::CreatePrintDialog(
174 PrintingContextLinux* context) {
175 DCHECK_CURRENTLY_ON(BrowserThread::UI);
176 return new PrintDialogGtk2(context);
177 }
178
PrintDialogGtk2(PrintingContextLinux * context)179 PrintDialogGtk2::PrintDialogGtk2(PrintingContextLinux* context)
180 : context_(context),
181 dialog_(NULL),
182 gtk_settings_(NULL),
183 page_setup_(NULL),
184 printer_(NULL) {
185 }
186
~PrintDialogGtk2()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
UseDefaultSettings()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
UpdateSettings(printing::PrintSettings * settings)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
ShowDialog(gfx::NativeView parent_view,bool has_selection,const PrintingContextLinux::PrintSettingsCallback & callback)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
PrintDocument(const printing::MetafilePlayer & metafile,const base::string16 & document_name)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
AddRefToDialog()399 void PrintDialogGtk2::AddRefToDialog() {
400 AddRef();
401 }
402
ReleaseDialog()403 void PrintDialogGtk2::ReleaseDialog() {
404 Release();
405 }
406
OnResponse(GtkWidget * dialog,int response_id)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
SendDocumentToPrinter(const base::string16 & document_name)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
OnJobCompletedThunk(GtkPrintJob * print_job,gpointer user_data,GError * error)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
OnJobCompleted(GtkPrintJob * print_job,GError * error)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
InitPrintSettings(PrintSettings * settings)531 void PrintDialogGtk2::InitPrintSettings(PrintSettings* settings) {
532 InitPrintSettingsGtk(gtk_settings_, page_setup_, settings);
533 context_->InitWithSettings(*settings);
534 }
535
OnWindowDestroying(aura::Window * window)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 }
543