bool ClientPrintHandlerGtk::OnPrintDialog(
bool has_selection,
CefRefPtr<CefPrintDialogCallback> callback) {
dialog_callback_ = callback;
// TODO(cef): Identify the correct parent window.
GtkWindow* parent = NULL;
// TODO(estade): We need a window title here.
dialog_ = gtk_print_unix_dialog_new(NULL, parent);
g_signal_connect(dialog_, "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
// Set modal so user cannot focus the same tab and press print again.
gtk_window_set_modal(GTK_WINDOW(dialog_), TRUE);
// Since we only generate PDF, only show printers that support PDF.
// TODO(thestig) Add more capabilities to support?
GtkPrintCapabilities cap = static_cast<GtkPrintCapabilities>(
GTK_PRINT_CAPABILITY_GENERATE_PDF |
GTK_PRINT_CAPABILITY_PAGE_SET |
GTK_PRINT_CAPABILITY_COPIES |
GTK_PRINT_CAPABILITY_COLLATE |
GTK_PRINT_CAPABILITY_REVERSE);
gtk_print_unix_dialog_set_manual_capabilities(GTK_PRINT_UNIX_DIALOG(dialog_),
cap);
gtk_print_unix_dialog_set_embed_page_setup(GTK_PRINT_UNIX_DIALOG(dialog_),
TRUE);
gtk_print_unix_dialog_set_support_selection(GTK_PRINT_UNIX_DIALOG(dialog_),
TRUE);
gtk_print_unix_dialog_set_has_selection(GTK_PRINT_UNIX_DIALOG(dialog_),
has_selection);
gtk_print_unix_dialog_set_settings(GTK_PRINT_UNIX_DIALOG(dialog_),
gtk_settings_);
g_signal_connect(dialog_, "response", G_CALLBACK(OnDialogResponseThunk),
this);
gtk_widget_show(dialog_);
return true;
}
gint
yad_print_run (void)
{
GtkWidget *dlg;
GtkWidget *box, *img, *lbl;
gchar *uri, *job_name = NULL;
GtkPrintCapabilities pcap;
GtkPrintOperationAction act = GTK_PRINT_OPERATION_ACTION_PRINT;
gint resp, ret = 0;
GError *err = NULL;
/* check if file is exists */
if (options.common_data.uri && options.common_data.uri[0])
{
if (!g_file_test (options.common_data.uri, G_FILE_TEST_EXISTS))
{
g_printerr (_("File %s not found.\n"), options.common_data.uri);
return 1;
}
}
else
{
g_printerr (_("Filename is not specified.\n"));
return 1;
}
/* create print dialog */
dlg = gtk_print_unix_dialog_new (options.data.dialog_title, NULL);
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (dlg), TRUE);
pcap = GTK_PRINT_CAPABILITY_PAGE_SET | GTK_PRINT_CAPABILITY_COPIES |
GTK_PRINT_CAPABILITY_COLLATE | GTK_PRINT_CAPABILITY_REVERSE |
GTK_PRINT_CAPABILITY_NUMBER_UP | GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT;
if (options.common_data.preview && options.print_data.type != YAD_PRINT_RAW)
pcap |= GTK_PRINT_CAPABILITY_PREVIEW;
gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dlg), pcap);
if (!settings.print_settings)
settings.print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dlg));
uri = g_build_filename (g_get_current_dir (), "yad.pdf", NULL);
gtk_print_settings_set (settings.print_settings, "output-uri", g_filename_to_uri (uri, NULL, NULL));
g_free (uri);
gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dlg), settings.print_settings);
if (settings.page_setup)
gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dlg), settings.page_setup);
/* set window behavior */
gtk_widget_set_name (dlg, "yad-dialog-window");
if (options.data.sticky)
gtk_window_stick (GTK_WINDOW (dlg));
gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed);
gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop);
gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
/* set window size and position */
if (!options.data.geometry)
{
gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height);
if (options.data.center)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
else if (options.data.mouse)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
}
else
{
/* parse geometry, if given. must be after showing widget */
gtk_widget_realize (dlg);
gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry);
}
/* create yad's top box */
if (options.data.dialog_text || options.data.dialog_image)
{
#if !GTK_CHECK_VERSION(3,0,0)
box = gtk_hbox_new (FALSE, 0);
#else
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
if (options.data.dialog_image)
{
GdkPixbuf *pb = NULL;
pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON);
img = gtk_image_new_from_pixbuf (pb);
if (pb)
g_object_unref (pb);
gtk_widget_set_name (img, "yad-dialog-image");
gtk_box_pack_start (GTK_BOX (box), img, FALSE, FALSE, 2);
}
if (options.data.dialog_text)
{
gchar *buf = g_strcompress (options.data.dialog_text);
lbl = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (lbl), buf);
else
gtk_label_set_text (GTK_LABEL (lbl), buf);
gtk_widget_set_name (lbl, "yad-dialog-label");
gtk_label_set_selectable (GTK_LABEL (lbl), options.data.selectable_labels);
gtk_misc_set_alignment (GTK_MISC (lbl), options.data.text_align, 0.5);
if (options.data.geometry || options.data.width != -1)
gtk_label_set_line_wrap (GTK_LABEL (lbl), TRUE);
gtk_box_pack_start (GTK_BOX (box), lbl, TRUE, TRUE, 2);
g_signal_connect (G_OBJECT (lbl), "size-allocate", G_CALLBACK (size_allocate_cb), NULL);
g_free (buf);
}
/* add tob box to dialog */
gtk_widget_show_all (box);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), box, TRUE, TRUE, 5);
gtk_box_reorder_child (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), box, 0);
}
do
{
resp = gtk_dialog_run (GTK_DIALOG (dlg));
switch (resp)
{
case GTK_RESPONSE_APPLY: /* ask for preview */
act = GTK_PRINT_OPERATION_ACTION_PREVIEW;
case GTK_RESPONSE_OK: /* run print */
settings.print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dlg));
settings.page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dlg));
job_name = g_strdup_printf ("yad-%s-%d", g_path_get_basename (options.common_data.uri), getpid ());
if (options.print_data.type != YAD_PRINT_RAW)
{
/* print text or image */
GtkPrintOperation *op = gtk_print_operation_new ();
gtk_print_operation_set_unit (op, GTK_UNIT_POINTS);
gtk_print_operation_set_print_settings (op, settings.print_settings);
gtk_print_operation_set_default_page_setup (op, settings.page_setup);
gtk_print_operation_set_job_name (op, job_name);
switch (options.print_data.type)
{
case YAD_PRINT_TEXT:
g_signal_connect (G_OBJECT (op), "begin-print", G_CALLBACK (begin_print_text), NULL);
g_signal_connect (G_OBJECT (op), "draw-page", G_CALLBACK (draw_page_text), NULL);
break;
case YAD_PRINT_IMAGE:
gtk_print_operation_set_n_pages (op, 1);
g_signal_connect (G_OBJECT (op), "draw-page", G_CALLBACK (draw_page_image), NULL);
break;
default:;
}
if (gtk_print_operation_run (op, act, NULL, &err) == GTK_PRINT_OPERATION_RESULT_ERROR)
{
g_printerr (_("Printing failed: %s\n"), err->message);
ret = 1;
}
}
else
{
/* print raw ps or pdf data */
GtkPrinter *prnt;
GtkPrintJob *job;
prnt = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dlg));
if (g_str_has_suffix (options.common_data.uri, ".ps"))
{
if (!gtk_printer_accepts_ps (prnt))
{
g_printerr (_("Printer doesn't support ps format.\n"));
ret = 1;
}
}
else if (g_str_has_suffix (options.common_data.uri, ".pdf"))
{
if (!gtk_printer_accepts_pdf (prnt))
{
g_printerr (_("Printer doesn't support pdf format.\n"));
ret = 1;
}
}
else
{
g_printerr (_("This file type is not supported for raw printing.\n"));
ret = 1;
}
if (ret == 1)
break;
job = gtk_print_job_new (job_name, prnt, settings.print_settings, settings.page_setup);
if (gtk_print_job_set_source_file (job, options.common_data.uri, &err))
{
gtk_print_job_send (job, (GtkPrintJobCompleteFunc) raw_print_done, &ret, NULL);
gtk_main ();
}
else
{
g_printerr (_("Load source file failed: %s\n"), err->message);
ret = 1;
}
}
break;
default:
ret = 1;
break;
}
}
while (resp == GTK_RESPONSE_APPLY);
gtk_widget_destroy (dlg);
write_settings ();
return ret;
}
/* void showPrintDialog (in nsIDOMWindow parent,
in nsIWebBrowserPrint webBrowserPrint,
in nsIPrintSettings printSettings); */
NS_IMETHODIMP
GeckoPrintService::ShowPrintDialog (nsIDOMWindow *aParent,
nsIWebBrowserPrint *aWebBrowserPrint,
nsIPrintSettings *aSettings)
{
GaleonEmbedShell *shell;
GeckoPrintSession *session = GeckoPrintSession::FromSettings (aSettings);
NS_ENSURE_TRUE (session, NS_ERROR_INVALID_POINTER);
shell = galeon_shell_get_embed_shell (galeon_shell);
nsresult rv;
PRBool haveSelection = PR_FALSE;
rv = aSettings->GetPrintOptions(nsIPrintSettings::kEnableSelectionRB, &haveSelection);
NS_ENSURE_SUCCESS (rv, rv);
PRInt16 frameUI = nsIPrintSettings::kFrameEnableAll;
rv = aSettings->GetHowToEnableFrameUI (&frameUI);
NS_ENSURE_SUCCESS (rv, rv);
GtkWindow *parent = GTK_WINDOW (GaleonUtils::FindGtkParent (aParent));
NS_ENSURE_TRUE(parent, NS_ERROR_INVALID_POINTER);
GtkWidget *custom_tab = NULL,
*frame_box = NULL,
*print_frames_normal = NULL,
*print_frames_selected = NULL,
*print_frames_separately = NULL;
GError *gerror = NULL;
guint builder_ret;
GtkBuilder *builder = gtk_builder_new ();
builder_ret = gtk_builder_add_from_file (builder, SHARE_DIR "/print-tab.xml", &gerror);
if (builder_ret) {
/* Build the custom tab */
custom_tab = GTK_WIDGET (gtk_builder_get_object (builder, "custom_tab_container"));
gul_gui_connect_checkbutton_to_gconf (GTK_WIDGET (gtk_builder_get_object (builder, "print_bg_colors_checkbutton")),
CONF_PRINT_BG_COLORS);
gul_gui_connect_checkbutton_to_gconf (GTK_WIDGET (gtk_builder_get_object (builder, "print_bg_images_checkbutton")),
CONF_PRINT_BG_IMAGES);
gul_gui_connect_checkbutton_to_gconf (GTK_WIDGET (gtk_builder_get_object (builder, "print_date_checkbutton")),
CONF_PRINT_DATE);
gul_gui_connect_checkbutton_to_gconf (GTK_WIDGET (gtk_builder_get_object (builder, "print_page_numbers_checkbutton")),
CONF_PRINT_PAGE_NUMBERS);
gul_gui_connect_checkbutton_to_gconf (GTK_WIDGET (gtk_builder_get_object (builder, "print_page_title_checkbutton")),
CONF_PRINT_PAGE_TITLE);
gul_gui_connect_checkbutton_to_gconf (GTK_WIDGET (gtk_builder_get_object (builder, "print_page_url_checkbutton")),
CONF_PRINT_PAGE_URL);
frame_box = GTK_WIDGET (gtk_builder_get_object (builder, "frame_box"));
print_frames_normal = GTK_WIDGET (gtk_builder_get_object (builder, "print_frames_normal"));
print_frames_selected = GTK_WIDGET (gtk_builder_get_object (builder, "print_frames_selected"));
print_frames_separately = GTK_WIDGET (gtk_builder_get_object (builder, "print_frames_separately"));
/* FIXME: store/load from pref */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (print_frames_normal), TRUE);
if (frameUI == nsIPrintSettings::kFrameEnableAll) {
/* Allow all frame options */
gtk_widget_set_sensitive (frame_box, TRUE);
} else if (frameUI == nsIPrintSettings::kFrameEnableAsIsAndEach) {
/* Allow all except "selected frame" */
gtk_widget_set_sensitive (frame_box, TRUE);
gtk_widget_set_sensitive (print_frames_selected, FALSE);
/* Preselect this one, since the default above only prints _one page_ ! */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (print_frames_separately), TRUE);
}
}
/* FIXME: this sucks! find some way to do all of this async! */
GtkWidget *dialog = gtk_print_unix_dialog_new (NULL /* FIXME title */,
GTK_WINDOW (parent));
GtkPrintUnixDialog *print_dialog = GTK_PRINT_UNIX_DIALOG (dialog);
GtkPrintCapabilities capabilities =
GtkPrintCapabilities (GTK_PRINT_CAPABILITY_PAGE_SET |
GTK_PRINT_CAPABILITY_COPIES |
GTK_PRINT_CAPABILITY_COLLATE |
GTK_PRINT_CAPABILITY_REVERSE |
GTK_PRINT_CAPABILITY_SCALE |
GTK_PRINT_CAPABILITY_GENERATE_PS);
#ifdef HAVE_GECKO_1_9
capabilities = GtkPrintCapabilities (capabilities | GTK_PRINT_CAPABILITY_GENERATE_PDF);
#endif
gtk_print_unix_dialog_set_manual_capabilities (print_dialog, capabilities);
gtk_print_unix_dialog_set_page_setup (print_dialog,
galeon_embed_shell_get_page_setup (shell));
gtk_print_unix_dialog_set_settings (print_dialog,
galeon_embed_shell_get_print_settings (shell));
PRInt16 printFrames = nsIPrintSettings::kNoFrames;
if (builder_ret) {
g_object_ref_sink (custom_tab);
gtk_print_unix_dialog_add_custom_tab (print_dialog, custom_tab,
gtk_label_new (_("Options"))); /* FIXME better name! */
g_object_unref (custom_tab);
g_object_unref (builder);
if (frameUI != nsIPrintSettings::kFrameEnableNone) {
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (print_frames_normal))) {
printFrames = nsIPrintSettings::kFramesAsIs;
} else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (print_frames_selected))) {
printFrames = nsIPrintSettings::kSelectedFrame;
} if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (print_frames_separately))) {
printFrames = nsIPrintSettings::kEachFrameSep;
}
}
}
int response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
GtkPrinter *printer = gtk_print_unix_dialog_get_selected_printer (print_dialog);
if (response != GTK_RESPONSE_OK || !printer) {
gtk_widget_destroy (dialog);
return NS_ERROR_ABORT;
}
GtkPageSetup *pageSetup = gtk_print_unix_dialog_get_page_setup (print_dialog); /* no reference owned */
galeon_embed_shell_set_page_setup (shell, pageSetup);
GtkPrintSettings *settings = gtk_print_unix_dialog_get_settings (print_dialog);
galeon_embed_shell_set_print_settings (shell, settings);
/* We copy the setup and settings so we can modify them to unset
* options handled by gecko.
*/
GtkPageSetup *pageSetupCopy = gtk_page_setup_copy (pageSetup);
pageSetup = pageSetupCopy;
GtkPrintSettings *settingsCopy = gtk_print_settings_copy (settings);
g_object_unref (settings);
settings = settingsCopy;
rv = session->SetSettings (aSettings, settings, pageSetup, printer);
/* Now translate the settings to nsIPrintSettings */
if (NS_SUCCEEDED (rv)) {
nsCString sourceFile;
session->GetSourceFile (sourceFile);
if (!sourceFile.IsEmpty ()) {
rv = TranslateSettings (settings, pageSetup, printer, sourceFile, printFrames, PR_TRUE, aSettings);
} else {
rv = NS_ERROR_FAILURE;
}
}
gtk_widget_destroy (dialog);
g_object_unref (settings);
g_object_unref (pageSetup);
return rv;
}
