callisto-debian/gtk2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor the gtk_print_operation_run() code and add an _async version.

Browse Source 
2006-04-24  Matthias Clasen  <mclasen@redhat.com>

	* gtk/gtk.symbols:
	* gtk/gtkprintoperation.c (gtk_print_operation_run_async): Refactor the
	gtk_print_operation_run() code and add an _async version.

	* gtk/gtkprintoperation-private.h:
	* gtk/gtkprintoperation-unix.c
	(_gtk_print_operation_platform_backend_run_dialog_async)
	(gtk_print_run_page_setup_dialog_async): Variants of the run functions
	which don't call gtk_dialog_run(), but only show the dialog and return,
	and handle the response in a signal handler.

	* gtk/gtkprintoperation-win32.c (gtk_print_run_page_setup_dialog_async)
	(_gtk_print_operation_platform_backend_run_dialog_async): Implement these
	by calling the sync versions.
This commit is contained in:
Matthias Clasen
2006-04-24 17:00:44 +00:00
committed by Matthias Clasen
parent 7261cff2d7
commit 2e9cc2f693
7 changed files with 408 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -15,6 +15,21 @@
2006-04-24 Matthias Clasen <mclasen@redhat.com> 2006-04-24 Matthias Clasen <mclasen@redhat.com>
* gtk/gtk.symbols:
* gtk/gtkprintoperation.c (gtk_print_operation_run_async): Refactor the
gtk_print_operation_run() code and add an _async version.
* gtk/gtkprintoperation-private.h:
* gtk/gtkprintoperation-unix.c
(_gtk_print_operation_platform_backend_run_dialog_async)
(gtk_print_run_page_setup_dialog_async): Variants of the run functions
which don't call gtk_dialog_run(), but only show the dialog and return,
and handle the response in a signal handler.
* gtk/gtkprintoperation-win32.c (gtk_print_run_page_setup_dialog_async)
(_gtk_print_operation_platform_backend_run_dialog_async): Implement these
by calling the sync versions.
* gtk/gtkprintoperation-unix.c: Cleanups. * gtk/gtkprintoperation-unix.c: Cleanups.
* gtk/gtkpagesetupunixdialog.c (gtk_page_setup_unix_dialog_get_page_setup): * gtk/gtkpagesetupunixdialog.c (gtk_page_setup_unix_dialog_get_page_setup):

15
ChangeLog.pre-2-10
View File

@ -15,6 +15,21 @@
2006-04-24 Matthias Clasen <mclasen@redhat.com> 2006-04-24 Matthias Clasen <mclasen@redhat.com>
* gtk/gtk.symbols:
* gtk/gtkprintoperation.c (gtk_print_operation_run_async): Refactor the
gtk_print_operation_run() code and add an _async version.
* gtk/gtkprintoperation-private.h:
* gtk/gtkprintoperation-unix.c
(_gtk_print_operation_platform_backend_run_dialog_async)
(gtk_print_run_page_setup_dialog_async): Variants of the run functions
which don't call gtk_dialog_run(), but only show the dialog and return,
and handle the response in a signal handler.
* gtk/gtkprintoperation-win32.c (gtk_print_run_page_setup_dialog_async)
(_gtk_print_operation_platform_backend_run_dialog_async): Implement these
by calling the sync versions.
* gtk/gtkprintoperation-unix.c: Cleanups. * gtk/gtkprintoperation-unix.c: Cleanups.
* gtk/gtkpagesetupunixdialog.c (gtk_page_setup_unix_dialog_get_page_setup): * gtk/gtkpagesetupunixdialog.c (gtk_page_setup_unix_dialog_get_page_setup):

3
gtk/gtk.symbols
View File

@ -2643,6 +2643,7 @@ gtk_print_operation_set_unit
gtk_print_operation_set_show_dialog gtk_print_operation_set_show_dialog
gtk_print_operation_set_pdf_target gtk_print_operation_set_pdf_target
gtk_print_operation_run gtk_print_operation_run
gtk_print_operation_run_async
gtk_print_operation_get_status gtk_print_operation_get_status
gtk_print_operation_get_status_string gtk_print_operation_get_status_string
gtk_print_operation_is_finished gtk_print_operation_is_finished
@ -2653,6 +2654,7 @@ gtk_print_operation_is_finished
#if IN_FILE(__GTK_PRINT_OPERATION_UNIX_C__) #if IN_FILE(__GTK_PRINT_OPERATION_UNIX_C__)
#ifdef G_OS_UNIX #ifdef G_OS_UNIX
gtk_print_run_page_setup_dialog gtk_print_run_page_setup_dialog
gtk_print_run_page_setup_dialog_async
#endif #endif
#endif #endif
#endif #endif
@ -2661,6 +2663,7 @@ gtk_print_run_page_setup_dialog
#if IN_FILE(__GTK_PRINT_OPERATION_WIN32_C__) #if IN_FILE(__GTK_PRINT_OPERATION_WIN32_C__)
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
gtk_print_run_page_setup_dialog gtk_print_run_page_setup_dialog
gtk_print_run_page_setup_dialog_async
#endif #endif
#endif #endif
#endif #endif

12
gtk/gtkprintoperation-private.h
View File

@ -66,9 +66,15 @@ struct _GtkPrintOperationPrivate
}; };
GtkPrintOperationResult _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *operation, GtkPrintOperationResult _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *operation,
GtkWindow *parent, GtkWindow *parent,
gboolean *do_print, gboolean *do_print,
GError **error); GError **error);
typedef void (* GtkPrintOperationPrintFunc) (GtkPrintOperation *op);
void _gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation *op,
GtkWindow *parent,
GtkPrintOperationPrintFunc print_cb);
void _gtk_print_operation_set_status (GtkPrintOperation *op, void _gtk_print_operation_set_status (GtkPrintOperation *op,
GtkPrintStatus status, GtkPrintStatus status,

294
gtk/gtkprintoperation-unix.c
View File

@ -120,47 +120,76 @@ job_status_changed_cb (GtkPrintJob *job,
_gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL); _gtk_print_operation_set_status (op, gtk_print_job_get_status (job), NULL);
} }
GtkPrintOperationResult
_gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op, static GtkWidget *
GtkWindow *parent, get_print_dialog (GtkPrintOperation *op,
gboolean *do_print, GtkWindow *parent)
GError **error)
{ {
GtkWidget *pd; GtkWidget *pd;
GtkPrintOperationResult result;
GtkPageSetup *page_setup; GtkPageSetup *page_setup;
result = GTK_PRINT_OPERATION_RESULT_CANCEL;
if (op->priv->default_page_setup)
page_setup = gtk_page_setup_copy (op->priv->default_page_setup);
else
page_setup = gtk_page_setup_new ();
pd = gtk_print_unix_dialog_new (NULL, parent); pd = gtk_print_unix_dialog_new (NULL, parent);
if (op->priv->print_settings) if (op->priv->print_settings)
gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (pd), gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (pd),
op->priv->print_settings); op->priv->print_settings);
if (op->priv->default_page_setup)
page_setup = gtk_page_setup_copy (op->priv->default_page_setup);
else
page_setup = gtk_page_setup_new ();
gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd), page_setup); gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (pd),
page_setup);
g_object_unref (page_setup);
return pd;
}
*do_print = FALSE; typedef struct {
if (gtk_dialog_run (GTK_DIALOG (pd)) == GTK_RESPONSE_OK) GtkPrintOperation *op;
gboolean do_print;
GError **error;
GtkPrintOperationResult result;
GtkPrintOperationPrintFunc print_cb;
GDestroyNotify destroy;
} PrintResponseData;
static void
print_response_data_free (gpointer data)
{
PrintResponseData *rdata = data;
g_object_unref (rdata->op);
g_free (rdata);
}
static void
handle_print_response (GtkWidget *dialog,
gint response,
gpointer data)
{
GtkPrintUnixDialog *pd = GTK_PRINT_UNIX_DIALOG (dialog);
PrintResponseData *rdata = data;
GtkPrintOperation *op = rdata->op;
if (response == GTK_RESPONSE_OK)
{ {
GtkPrintOperationUnix *op_unix; GtkPrintOperationUnix *op_unix;
GtkPrinter *printer; GtkPrinter *printer;
GtkPrintSettings *settings; GtkPrintSettings *settings;
GtkPageSetup *page_setup;
rdata->result = GTK_PRINT_OPERATION_RESULT_APPLY;
result = GTK_PRINT_OPERATION_RESULT_APPLY;
printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (pd)); printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (pd));
if (printer == NULL) if (printer == NULL)
goto out; goto out;
*do_print = TRUE; rdata->do_print = TRUE;
settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (pd)); settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (pd));
page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (pd));
gtk_print_operation_set_print_settings (op, settings); gtk_print_operation_set_print_settings (op, settings);
op_unix = g_new0 (GtkPrintOperationUnix, 1); op_unix = g_new0 (GtkPrintOperationUnix, 1);
@ -169,13 +198,13 @@ _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
settings, settings,
page_setup); page_setup);
g_object_unref (settings); g_object_unref (settings);
op->priv->surface = gtk_print_job_get_surface (op_unix->job, error); rdata->op->priv->surface = gtk_print_job_get_surface (op_unix->job, rdata->error);
if (op->priv->surface == NULL) if (op->priv->surface == NULL)
{ {
*do_print = FALSE; rdata->do_print = FALSE;
op_unix_free (op_unix); op_unix_free (op_unix);
result = GTK_PRINT_OPERATION_RESULT_ERROR; rdata->result = GTK_PRINT_OPERATION_RESULT_ERROR;
goto out; goto out;
} }
@ -184,7 +213,7 @@ _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
g_signal_connect (op_unix->job, "status_changed", g_signal_connect (op_unix->job, "status_changed",
G_CALLBACK (job_status_changed_cb), op); G_CALLBACK (job_status_changed_cb), op);
op_unix->parent = parent; op_unix->parent = gtk_window_get_transient_for (GTK_WINDOW (pd));
op->priv->dpi_x = 72; op->priv->dpi_x = 72;
op->priv->dpi_y = 72; op->priv->dpi_y = 72;
@ -208,12 +237,126 @@ _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
op->priv->end_page = unix_end_page; op->priv->end_page = unix_end_page;
op->priv->end_run = unix_end_run; op->priv->end_run = unix_end_run;
out: out:
g_object_unref (page_setup); gtk_widget_destroy (GTK_WIDGET (pd));
gtk_widget_destroy (pd);
return result; if (rdata->print_cb)
{
if (rdata->do_print)
rdata->print_cb (op);
else
_gtk_print_operation_set_status (op, GTK_PRINT_STATUS_FINISHED_ABORTED, NULL);
}
if (rdata->destroy)
rdata->destroy (rdata);
}
void
_gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation *op,
GtkWindow *parent,
GtkPrintOperationPrintFunc print_cb)
{
GtkWidget *pd;
PrintResponseData *rdata;
rdata = g_new (PrintResponseData, 1);
rdata->op = g_object_ref (op);
rdata->do_print = FALSE;
rdata->result = GTK_PRINT_OPERATION_RESULT_CANCEL;
rdata->error = NULL;
rdata->print_cb = print_cb;
rdata->destroy = print_response_data_free;
pd = get_print_dialog (op, parent);
gtk_window_set_modal (GTK_WINDOW (pd), TRUE);
g_signal_connect (pd, "response",
G_CALLBACK (handle_print_response), rdata);
gtk_window_present (GTK_WINDOW (pd));
}
GtkPrintOperationResult
_gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
GtkWindow *parent,
gboolean *do_print,
GError **error)
{
GtkWidget *pd;
PrintResponseData rdata;
gint response;
rdata.op = op;
rdata.do_print = FALSE;
rdata.result = GTK_PRINT_OPERATION_RESULT_CANCEL;
rdata.error = error;
rdata.print_cb = NULL;
rdata.destroy = NULL;
pd = get_print_dialog (op, parent);
response = gtk_dialog_run (GTK_DIALOG (pd));
handle_print_response (pd, response, &rdata);
*do_print = rdata.do_print;
return rdata.result;
}
typedef struct {
GtkPageSetup *page_setup;
GFunc done_cb;
gpointer data;
GDestroyNotify destroy;
} PageSetupResponseData;
static void
page_setup_data_free (gpointer data)
{
PageSetupResponseData *rdata = data;
g_object_unref (rdata->page_setup);
g_free (rdata);
}
static void
handle_page_setup_response (GtkWidget *dialog,
gint response,
gpointer data)
{
GtkPageSetupUnixDialog *psd;
PageSetupResponseData *rdata = data;
psd = GTK_PAGE_SETUP_UNIX_DIALOG (dialog);
if (response == GTK_RESPONSE_OK)
rdata->page_setup = gtk_page_setup_unix_dialog_get_page_setup (psd);
gtk_widget_destroy (dialog);
if (rdata->done_cb)
rdata->done_cb (rdata->page_setup, rdata->data);
if (rdata->destroy)
rdata->destroy (rdata);
}
static GtkWidget *
get_page_setup_dialog (GtkWindow *parent,
GtkPageSetup *page_setup,
GtkPrintSettings *settings)
{
GtkWidget *dialog;
dialog = gtk_page_setup_unix_dialog_new (NULL, parent);
if (page_setup)
gtk_page_setup_unix_dialog_set_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
page_setup);
gtk_page_setup_unix_dialog_set_print_settings (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
settings);
return dialog;
} }
/** /**
@ -222,11 +365,14 @@ _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
* @page_setup: an existing #GtkPageSetup, or %NULL * @page_setup: an existing #GtkPageSetup, or %NULL
* @settings: a #GtkPrintSettings * @settings: a #GtkPrintSettings
* *
* Runs a page setup dialog, letting the user modify * Runs a page setup dialog, letting the user modify the values from
* the values from @page_setup. If the user cancels * @page_setup. If the user cancels the dialog, the returned #GtkPageSetup
* the dialog, the returned #GtkPageSetup is identical * is identical to the passed in @page_setup, otherwise it contains the
* to the passed in @page_setup, otherwise it contains * modifications done in the dialog.
* the modifications done in the dialog. *
* Note that this function may use a recursive mainloop to show the page
* setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
* a problem.
* *
* Return value: a new #GtkPageSetup * Return value: a new #GtkPageSetup
* *
@ -238,29 +384,69 @@ gtk_print_run_page_setup_dialog (GtkWindow *parent,
GtkPrintSettings *settings) GtkPrintSettings *settings)
{ {
GtkWidget *dialog; GtkWidget *dialog;
GtkPageSetup *new_page_setup; gint response;
PageSetupResponseData rdata;
dialog = gtk_page_setup_unix_dialog_new (NULL, parent); rdata.page_setup = NULL;
if (page_setup) rdata.done_cb = NULL;
gtk_page_setup_unix_dialog_set_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog), rdata.data = NULL;
page_setup); rdata.destroy = NULL;
gtk_page_setup_unix_dialog_set_print_settings (GTK_PAGE_SETUP_UNIX_DIALOG (dialog),
settings); dialog = get_page_setup_dialog (parent, page_setup, settings);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) response = gtk_dialog_run (GTK_DIALOG (dialog));
new_page_setup = gtk_page_setup_unix_dialog_get_page_setup (GTK_PAGE_SETUP_UNIX_DIALOG (dialog)); handle_page_setup_response (dialog, response, &rdata);
else
{ if (rdata.page_setup)
if (page_setup) return rdata.page_setup;
new_page_setup = gtk_page_setup_copy (page_setup); else if (page_setup)
else return gtk_page_setup_copy (page_setup);
new_page_setup = gtk_page_setup_new (); else
} return gtk_page_setup_new ();
gtk_widget_destroy (dialog);
return new_page_setup;
} }
/**
* gtk_print_run_page_setup_dialog_async:
* @parent: transient parent, or %NULL
* @page_setup: an existing #GtkPageSetup, or %NULL
* @settings: a #GtkPrintSettings
* @done_cb: a function to call when the user saves the modified page setup
* @data: user data to pass to @done_cb
*
* Runs a page setup dialog, letting the user modify the values from
* @page_setup.
*
* In contrast to gtk_print_run_page_setup_dialog(), this function
* returns after showing the page setup dialog on platforms that support
* this, and calls @done_cb from a signal handler for the ::response
* signal of the dialog.
*
* Since: 2.10
*/
void
gtk_print_run_page_setup_dialog_async (GtkWindow *parent,
GtkPageSetup *page_setup,
GtkPrintSettings *settings,
GtkPageSetupDoneFunc done_cb,
gpointer data)
{
GtkWidget *dialog;
PageSetupResponseData *rdata;
dialog = get_page_setup_dialog (parent, page_setup, settings);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
rdata = g_new (PageSetupResponseData, 1);
rdata->page_setup = NULL;
rdata->done_cb = done_cb;
rdata->data = data;
rdata->destroy = page_setup_data_free;
g_signal_connect (dialog, "response",
G_CALLBACK (handle_page_setup_response), rdata);
gtk_window_present (GTK_WINDOW (dialog));
}
#define __GTK_PRINT_OPERATION_UNIX_C__ #define __GTK_PRINT_OPERATION_UNIX_C__
#include "gtkaliasdef.c" #include "gtkaliasdef.c"

28
gtk/gtkprintoperation-win32.c
View File

@ -1465,6 +1465,20 @@ _gtk_print_operation_platform_backend_run_dialog (GtkPrintOperation *op,
return result; return result;
} }
void
_gtk_print_operation_platform_backend_run_dialog_async (GtkPrintOperation *op,
GtkWindow *parent,
GtkPrintOperationPrintFunc print_cb)
{
gboolean do_print;
_gtk_print_operation_platform_backend_run_dialog (op, parent, &do_print, NULL);
if (do_print)
print_cb (op);
else
_gtk_print_operation_set_status (op, GTK_PRINT_STATUS_FINISHED_ABORTED, NULL);
}
GtkPageSetup * GtkPageSetup *
gtk_print_run_page_setup_dialog (GtkWindow *parent, gtk_print_run_page_setup_dialog (GtkWindow *parent,
GtkPageSetup *page_setup, GtkPageSetup *page_setup,
@ -1596,3 +1610,17 @@ gtk_print_run_page_setup_dialog (GtkWindow *parent,
return page_setup; return page_setup;
} }
void
gtk_print_run_page_setup_dialog_async (GtkWindow *parent,
GtkPageSetup *page_setup,
GtkPrintSettings *settings,
GtkPageSetupDoneFunc done_cb,
gpointer data)
{
GtkPageSetup *page_setup;
page_setup = gtk_print_run_page_setup_dialog (parent, page_setup, settings);
done_cb (page_setup, data);
g_object_unref (page_setup);
}

167
gtk/gtkprintoperation.c
View File

@ -950,84 +950,19 @@ run_pdf (GtkPrintOperation *op,
return GTK_PRINT_OPERATION_RESULT_APPLY; return GTK_PRINT_OPERATION_RESULT_APPLY;
} }
static GtkPrintOperationResult static void
run_print_dialog (GtkPrintOperation *op, print_pages (GtkPrintOperation *op)
GtkWindow *parent,
gboolean *do_print,
GError **error)
{
if (op->priv->pdf_target != NULL)
return run_pdf (op, parent, do_print, error);
/* This does:
* Open print dialog
* set print settings on dialog
* run dialog, if show_dialog set
* extract print settings from dialog
* create cairo surface and data for print job
* return correct result val
*/
return _gtk_print_operation_platform_backend_run_dialog (op,
parent,
do_print,
error);
}
/**
* gtk_print_operation_run:
* @op: a #GtkPrintOperation
* @parent: Transient parent of the dialog, or %NULL
* @error: Return location for errors, or %NULL
*
* Runs the print operation, by first letting the user modify
* print settings in the print dialog, and then print the
* document.
*
* Note that this function does not return until the rendering
* of all pages is complete. You can connect to the ::status-changed
* signal on @op to obtain some information about the progress
* of the print operation.
*
* <informalexample><programlisting>
* FIXME: need an example here
* </programlisting></informalexample>
*
* Return value: the result of the print operation. A return value
* of %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing
* was completed successfully. In this case, it is a good idea
* to obtain the used print settings with
* gtk_print_operation_get_print_settings() and store them for
* reuse with the next print operation.
*
* Since: 2.10
**/
GtkPrintOperationResult
gtk_print_operation_run (GtkPrintOperation *op,
GtkWindow *parent,
GError **error)
{ {
int page, range; int page, range;
GtkPageSetup *initial_page_setup, *page_setup; GtkPageSetup *initial_page_setup, *page_setup;
GtkPrintContext *print_context; GtkPrintContext *print_context;
cairo_t *cr; cairo_t *cr;
gboolean do_print;
int uncollated_copies, collated_copies; int uncollated_copies, collated_copies;
int i, j; int i, j;
GtkPageRange *ranges; GtkPageRange *ranges;
GtkPageRange one_range; GtkPageRange one_range;
int num_ranges; int num_ranges;
GtkPrintOperationResult result;
g_return_val_if_fail (GTK_IS_PRINT_OPERATION (op),
GTK_PRINT_OPERATION_RESULT_ERROR);
result = run_print_dialog (op, parent, &do_print, error);
if (!do_print)
{
_gtk_print_operation_set_status (op, GTK_PRINT_STATUS_FINISHED_ABORTED, NULL);
return result;
}
if (op->priv->manual_collation) if (op->priv->manual_collation)
{ {
uncollated_copies = op->priv->manual_num_copies; uncollated_copies = op->priv->manual_num_copies;
@ -1047,7 +982,7 @@ gtk_print_operation_run (GtkPrintOperation *op,
_gtk_print_operation_set_status (op, GTK_PRINT_STATUS_PREPARING, NULL); _gtk_print_operation_set_status (op, GTK_PRINT_STATUS_PREPARING, NULL);
g_signal_emit (op, signals[BEGIN_PRINT], 0, print_context); g_signal_emit (op, signals[BEGIN_PRINT], 0, print_context);
g_return_val_if_fail (op->priv->nr_of_pages > 0, GTK_PRINT_OPERATION_RESULT_ERROR); g_return_if_fail (op->priv->nr_of_pages > 0);
if (op->priv->print_pages == GTK_PRINT_PAGES_RANGES) if (op->priv->print_pages == GTK_PRINT_PAGES_RANGES)
{ {
@ -1145,7 +1080,101 @@ gtk_print_operation_run (GtkPrintOperation *op,
cairo_surface_finish (op->priv->surface); cairo_surface_finish (op->priv->surface);
op->priv->end_run (op); op->priv->end_run (op);
return GTK_PRINT_OPERATION_RESULT_APPLY; }
/**
* gtk_print_operation_run:
* @op: a #GtkPrintOperation
* @parent: Transient parent of the dialog, or %NULL
* @error: Return location for errors, or %NULL
*
* Runs the print operation, by first letting the user modify
* print settings in the print dialog, and then print the
* document.
*
* Note that this function does not return until the rendering of all
* pages is complete. You can connect to the ::status-changed signal on
* @op to obtain some information about the progress of the print operation.
* Furthermore, it may use a recursive mainloop to show the print dialog.
* See gtk_print_operation_run_async() if this is a problem.
*
* <informalexample><programlisting>
* FIXME: need an example here
* </programlisting></informalexample>
*
* Return value: the result of the print operation. A return value of
* %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was
* completed successfully. In this case, it is a good idea to obtain
* the used print settings with gtk_print_operation_get_print_settings()
* and store them for reuse with the next print operation.
*
* Since: 2.10
**/
GtkPrintOperationResult
gtk_print_operation_run (GtkPrintOperation *op,
GtkWindow *parent,
GError **error)
{
GtkPrintOperationResult result;
gboolean do_print;
g_return_val_if_fail (GTK_IS_PRINT_OPERATION (op),
GTK_PRINT_OPERATION_RESULT_ERROR);
if (op->priv->pdf_target != NULL)
result = run_pdf (op, parent, &do_print, error);
else
result = _gtk_print_operation_platform_backend_run_dialog (op,
parent,
&do_print,
error);
if (do_print)
print_pages (op);
else
_gtk_print_operation_set_status (op, GTK_PRINT_STATUS_FINISHED_ABORTED, NULL);
return result;
}
/**
* gtk_print_operation_run_async:
* @op: a #GtkPrintOperation
* @parent: Transient parent of the dialog, or %NULL
*
* Runs the print operation, by first letting the user modify
* print settings in the print dialog, and then print the
* document.
*
* In contrast to gtk_print_operation_run(), this function returns after
* showing the print dialog on platforms that support this, and handles
* the printing by connecting a signal handler to the ::response signal
* of the dialog.
*
* If you use this function, it is recommended that you store the modified
* #GtkPrintSettings in a ::begin-print or ::end-print signal handler.
*
* Since: 2.10
**/
void
gtk_print_operation_run_async (GtkPrintOperation *op,
GtkWindow *parent)
{
gboolean do_print;
g_return_if_fail (GTK_IS_PRINT_OPERATION (op));
if (op->priv->pdf_target != NULL)
{
run_pdf (op, parent, &do_print, NULL);
if (do_print)
print_pages (op);
else
_gtk_print_operation_set_status (op, GTK_PRINT_STATUS_FINISHED_ABORTED, NULL);
}
else
_gtk_print_operation_platform_backend_run_dialog_async (op,
parent,
print_pages);
} }