PrintOperation

Description GtkPrintOperation is the high-level, portable printing API. It looks a bit different than other GTK+ dialogs such as the GtkFileChooser, since some platforms don't expose enough infrastructure to implement a good print dialog. On such platforms, GtkPrintOperation uses the native print dialog. On platforms which do not provide a native print dialog, GTK+ uses its own, see GtkPrintUnixDialog. The typical way to use the high-level printing API is to create a GtkPrintOperation object with gtk_print_operation_new() when the user selects to print. Then you set some properties on it, e.g. the page size, any GtkPrintSettings from previous print operations, the number of pages, the current page, etc. Then you start the print operation by calling gtk_print_operation_run(). It will then show a dialog, let the user select a printer and options. When the user finished the dialog various signals will be emitted on the GtkPrintOperation, the main one being ::draw-page, which you are supposed to catch and render the page on the provided GtkPrintContext using Cairo. By default GtkPrintOperation uses an external application to do print preview. To implement a custom print preview, an application must connect to the preview signal. The functions gtk_print_operation_print_preview_render_page(), gtk_print_operation_preview_end_preview() and gtk_print_operation_preview_is_selected() are useful when implementing a print preview. Printing support was added in GTK+ 2.10.

class PrintOperation : ObjectG , PrintOperationPreviewIF {}

Constructors

this
this(GtkPrintOperation* gtkPrintOperation)

Sets our main struct and passes it to the parent class

this
this()

Creates a new GtkPrintOperation. Since 2.10

Members

Functions

addOnBeginPrint
void addOnBeginPrint(void delegate(PrintContext, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted after the user has finished changing print settings in the dialog, before the actual rendering starts. A typical use for ::begin-print is to use the parameters from the GtkPrintContext and paginate the document accordingly, and then set the number of pages with gtk_print_operation_set_n_pages(). Since 2.10

addOnCreateCustomWidget
void addOnCreateCustomWidget(GObject* delegate(PrintOperation) dlg, ConnectFlags connectFlags)

Emitted when displaying the print dialog. If you return a widget in a handler for this signal it will be added to a custom tab in the print dialog. You typically return a container widget with multiple widgets in it. The print dialog owns the returned widget, and its lifetime is not controlled by the application. However, the widget is guaranteed to stay around until the "custom-widget-apply" signal is emitted on the operation. Then you can read out any information you need from the widgets. Since 2.10

addOnCustomWidgetApply
void addOnCustomWidgetApply(void delegate(Widget, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted right before "begin-print" if you added a custom widget in the "create-custom-widget" handler. When you get this signal you should read the information from the custom widgets, as the widgets are not guaraneed to be around at a later time. Since 2.10

addOnDone
void addOnDone(void delegate(GtkPrintOperationResult, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted when the print operation run has finished doing everything required for printing. result gives you information about what happened during the run. If result is GTK_PRINT_OPERATION_RESULT_ERROR then you can call gtk_print_operation_get_error() for more information. If you enabled print status tracking then gtk_print_operation_is_finished() may still return FALSE after "done" was emitted. Since 2.10

addOnDrawPage
void addOnDrawPage(void delegate(PrintContext, gint, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted for every page that is printed. The signal handler must render the page_nr's page onto the cairo context obtained from context using gtk_print_context_get_cairo_context(). Use gtk_print_operation_set_use_full_page() and gtk_print_operation_set_unit() before starting the print operation to set up the transformation of the cairo context according to your needs. Since 2.10

addOnEndPrint
void addOnEndPrint(void delegate(PrintContext, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted after all pages have been rendered. A handler for this signal can clean up any resources that have been allocated in the "begin-print" handler. Since 2.10

addOnPaginate
void addOnPaginate(bool delegate(PrintContext, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted after the "begin-print" signal, but before the actual rendering starts. It keeps getting emitted until a connected signal handler returns TRUE. The ::paginate signal is intended to be used for paginating a document in small chunks, to avoid blocking the user interface for a long time. The signal handler should update the number of pages using gtk_print_operation_set_n_pages(), and return TRUE if the document has been completely paginated. If you don't need to do pagination in chunks, you can simply do it all in the ::begin-print handler, and set the number of pages from there. TRUE if pagination is complete Since 2.10

addOnPreview
void addOnPreview(bool delegate(GtkPrintOperationPreview*, PrintContext, Window, PrintOperation) dlg, ConnectFlags connectFlags)

Gets emitted when a preview is requested from the native dialog. The default handler for this signal uses an external viewer application to preview. To implement a custom print preview, an application must return TRUE from its handler for this signal. In order to use the provided context for the preview implementation, it must be given a suitable cairo context with gtk_print_context_set_cairo_context(). The custom preview implementation can use gtk_print_operation_preview_is_selected() and gtk_print_operation_preview_render_page() to find pages which are selected for print and render them. The preview must be finished by calling gtk_print_operation_preview_end_preview() (typically in response to the user clicking a close button). TRUE if the listener wants to take over control of the preview Since 2.10

addOnRequestPageSetup
void addOnRequestPageSetup(void delegate(PrintContext, gint, PageSetup, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted once for every page that is printed, to give the application a chance to modify the page setup. Any changes done to setup will be in force only for printing this page. Since 2.10

addOnStatusChanged
void addOnStatusChanged(void delegate(PrintOperation) dlg, ConnectFlags connectFlags)

Emitted at between the various phases of the print operation. See GtkPrintStatus for the phases that are being discriminated. Use gtk_print_operation_get_status() to find out the current status. Since 2.10

addOnUpdateCustomWidget
void addOnUpdateCustomWidget(void delegate(Widget, PageSetup, PrintSettings, PrintOperation) dlg, ConnectFlags connectFlags)

Emitted after change of selected printer. The actual page setup and print settings are passed to the custom widget, which can actualize itself according to this change. Since 2.18

cancel
void cancel()

Cancels a running print operation. This function may be called from a "begin-print", "paginate" or "draw-page" signal handler to stop the currently running print operation. Since 2.10

drawPageFinish
void drawPageFinish()

Signalize that drawing of particular page is complete. It is called after completion of page drawing (e.g. drawing in another thread). If gtk_print_operation_set_defer_drawing() was called before, then this function has to be called by application. In another case it is called by the library itself. Since 2.16

getDefaultPageSetup
PageSetup getDefaultPageSetup()

Returns the default page setup, see gtk_print_operation_set_default_page_setup(). Since 2.10

getEmbedPageSetup
int getEmbedPageSetup()

Gets the value of "embed-page-setup" property. Since 2.18

getError
void getError()

Call this when the result of a print operation is GTK_PRINT_OPERATION_RESULT_ERROR, either as returned by gtk_print_operation_run(), or in the "done" signal handler. The returned GError will contain more details on what went wrong. Since 2.10

getHasSelection
int getHasSelection()

Gets the value of "has-selection" property. Since 2.18

getNPagesToPrint
int getNPagesToPrint()

Returns the number of pages that will be printed. Note that this value is set during print preparation phase (GTK_PRINT_STATUS_PREPARING), so this function should never be called before the data generation phase (GTK_PRINT_STATUS_GENERATING_DATA). You can connect to the "status-changed" signal and call gtk_print_operation_get_n_pages_to_print() when print status is GTK_PRINT_STATUS_GENERATING_DATA. This is typically used to track the progress of print operation. Since 2.18

getPrintOperationStruct
GtkPrintOperation* getPrintOperationStruct()
Undocumented in source. Be warned that the author may not have intended to support it.
getPrintSettings
PrintSettings getPrintSettings()

Returns the current print settings. Note that the return value is NULL until either gtk_print_operation_set_print_settings() or gtk_print_operation_run() have been called. Since 2.10

getStatus
GtkPrintStatus getStatus()

Returns the status of the print operation. Also see gtk_print_operation_get_status_string(). Since 2.10

getStatusString
string getStatusString()

Returns a string representation of the status of the print operation. The string is translated and suitable for displaying the print status e.g. in a GtkStatusbar. Use gtk_print_operation_get_status() to obtain a status value that is suitable for programmatic use. Since 2.10

getStruct
void* getStruct()

the main Gtk struct as a void*

getSupportSelection
int getSupportSelection()

Gets the value of "support-selection" property. Since 2.18

isFinished
int isFinished()

A convenience function to find out if the print operation is finished, either successfully (GTK_PRINT_STATUS_FINISHED) or unsuccessfully (GTK_PRINT_STATUS_FINISHED_ABORTED). Note: when you enable print status tracking the print operation can be in a non-finished state even after done has been called, as the operation status then tracks the print job status on the printer. Since 2.10

run
GtkPrintOperationResult run(GtkPrintOperationAction action, Window parent)

Runs the print operation, by first letting the user modify print settings in the print dialog, and then print the document. Normally 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. If you call gtk_print_operation_set_allow_async() or set the "allow-async" property the operation will run asynchronously if this is supported on the platform. The "done" signal will be emitted with the result of the operation when the it is done (i.e. when the dialog is canceled, or when the print succeeds or fails). Note that gtk_print_operation_run() can only be called once on a given GtkPrintOperation. Since 2.10

setAllowAsync
void setAllowAsync(int allowAsync)

Sets whether the gtk_print_operation_run() may return before the print operation is completed. Note that some platforms may not allow asynchronous operation. Since 2.10

setCurrentPage
void setCurrentPage(int currentPage)

Sets the current page. If this is called before gtk_print_operation_run(), the user will be able to select to print only the current page. Note that this only makes sense for pre-paginated documents. Since 2.10

setCustomTabLabel
void setCustomTabLabel(string label)

Sets the label for the tab holding custom widgets. Since 2.10

setDefaultPageSetup
void setDefaultPageSetup(PageSetup defaultPageSetup)

Makes default_page_setup the default page setup for op. This page setup will be used by gtk_print_operation_run(), but it can be overridden on a per-page basis by connecting to the "request-page-setup" signal. Since 2.10

setDeferDrawing
void setDeferDrawing()

Sets up the GtkPrintOperation to wait for calling of gtk_print_operation_draw_page_finish() from application. It can be used for drawing page in another thread. This function must be called in the callback of "draw-page" signal. Since 2.16

setEmbedPageSetup
void setEmbedPageSetup(int embed)

Embed page size combo box and orientation combo box into page setup page. Selected page setup is stored as default page setup in GtkPrintOperation. Since 2.18

setExportFilename
void setExportFilename(string filename)

Sets up the GtkPrintOperation to generate a file instead of showing the print dialog. The indended use of this function is for implementing "Export to PDF" actions. Currently, PDF is the only supported format. "Print to PDF" support is independent of this and is done by letting the user pick the "Print to PDF" item from the list of printers in the print dialog. Since 2.10

setHasSelection
void setHasSelection(int hasSelection)

Sets whether there is a selection to print. Application has to set number of pages to which the selection will draw by gtk_print_operation_set_n_pages() in a callback of "begin-print". Since 2.18

setJobName
void setJobName(string jobName)

Sets the name of the print job. The name is used to identify the job (e.g. in monitoring applications like eggcups). If you don't set a job name, GTK+ picks a default one by numbering successive print jobs. Since 2.10

setNPages
void setNPages(int nPages)

Sets the number of pages in the document. This must be set to a positive number before the rendering starts. It may be set in a "begin-print" signal hander. Note that the page numbers passed to the "request-page-setup" and "draw-page" signals are 0-based, i.e. if the user chooses to print all pages, the last ::draw-page signal will be for page n_pages - 1. Since 2.10

setPrintSettings
void setPrintSettings(PrintSettings printSettings)

Sets the print settings for op. This is typically used to re-establish print settings from a previous print operation, see gtk_print_operation_run(). Since 2.10

setShowProgress
void setShowProgress(int showProgress)

If show_progress is TRUE, the print operation will show a progress dialog during the print operation. Since 2.10

setStruct
void setStruct(GObject* obj)
Undocumented in source. Be warned that the author may not have intended to support it.
setSupportSelection
void setSupportSelection(int supportSelection)

Sets whether selection is supported by GtkPrintOperation. Since 2.18

setTrackPrintStatus
void setTrackPrintStatus(int trackStatus)

If track_status is TRUE, the print operation will try to continue report on the status of the print job in the printer queues and printer. This can allow your application to show things like "out of paper" issues, and when the print job actually reaches the printer. This function is often implemented using some form of polling, so it should not be enabled unless needed. Since 2.10

setUnit
void setUnit(GtkUnit unit)

Sets up the transformation for the cairo context obtained from GtkPrintContext in such a way that distances are measured in units of unit. Since 2.10

setUseFullPage
void setUseFullPage(int fullPage)

If full_page is TRUE, the transformation for the cairo context obtained from GtkPrintContext puts the origin at the top left corner of the page (which may not be the top left corner of the sheet, depending on page orientation and the number of pages per sheet). Otherwise, the origin is at the top left corner of the imageable area (i.e. inside the margins). Since 2.10

Mixins

__anonymous
mixin PrintOperationPreviewT!(GtkPrintOperation)
Undocumented in source.

Static functions

callBackBeginPrint
void callBackBeginPrint(GtkPrintOperation* operationStruct, GtkPrintContext* context, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackCreateCustomWidget
void callBackCreateCustomWidget(GtkPrintOperation* operationStruct, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackCustomWidgetApply
void callBackCustomWidgetApply(GtkPrintOperation* operationStruct, GtkWidget* widget, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackDone
void callBackDone(GtkPrintOperation* operationStruct, GtkPrintOperationResult result, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackDrawPage
void callBackDrawPage(GtkPrintOperation* operationStruct, GtkPrintContext* context, gint pageNr, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackEndPrint
void callBackEndPrint(GtkPrintOperation* operationStruct, GtkPrintContext* context, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackPaginate
gboolean callBackPaginate(GtkPrintOperation* operationStruct, GtkPrintContext* context, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackPreview
gboolean callBackPreview(GtkPrintOperation* operationStruct, GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkWindow* parent, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackRequestPageSetup
void callBackRequestPageSetup(GtkPrintOperation* operationStruct, GtkPrintContext* context, gint pageNr, GtkPageSetup* setup, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackStatusChanged
void callBackStatusChanged(GtkPrintOperation* operationStruct, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
callBackUpdateCustomWidget
void callBackUpdateCustomWidget(GtkPrintOperation* operationStruct, GtkWidget* widget, GtkPageSetup* setup, GtkPrintSettings* settings, PrintOperation _printOperation)
Undocumented in source. Be warned that the author may not have intended to support it.
gtkPrintRunPageSetupDialog
PageSetup gtkPrintRunPageSetupDialog(Window parent, PageSetup pageSetup, PrintSettings settings)

Runs a page setup dialog, letting the user modify the values from page_setup. If the user cancels the dialog, the returned GtkPageSetup is identical to the passed in page_setup, otherwise it contains 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. Since 2.10

gtkPrintRunPageSetupDialogAsync
void gtkPrintRunPageSetupDialogAsync(Window parent, PageSetup pageSetup, PrintSettings settings, GtkPageSetupDoneFunc doneCb, void* data)

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

Variables

connectedSignals
int[string] connectedSignals;
gtkPrintOperation
GtkPrintOperation* gtkPrintOperation;

the main Gtk struct

onBeginPrintListeners
void delegate(PrintContext, PrintOperation)[] onBeginPrintListeners;
Undocumented in source.
onCreateCustomWidgetListeners
GObject* delegate(PrintOperation)[] onCreateCustomWidgetListeners;
Undocumented in source.
onCustomWidgetApplyListeners
void delegate(Widget, PrintOperation)[] onCustomWidgetApplyListeners;
Undocumented in source.
onDoneListeners
void delegate(GtkPrintOperationResult, PrintOperation)[] onDoneListeners;
Undocumented in source.
onDrawPageListeners
void delegate(PrintContext, gint, PrintOperation)[] onDrawPageListeners;
Undocumented in source.
onEndPrintListeners
void delegate(PrintContext, PrintOperation)[] onEndPrintListeners;
Undocumented in source.
onPaginateListeners
bool delegate(PrintContext, PrintOperation)[] onPaginateListeners;
Undocumented in source.
onPreviewListeners
bool delegate(GtkPrintOperationPreview*, PrintContext, Window, PrintOperation)[] onPreviewListeners;
Undocumented in source.
onRequestPageSetupListeners
void delegate(PrintContext, gint, PageSetup, PrintOperation)[] onRequestPageSetupListeners;
Undocumented in source.
onStatusChangedListeners
void delegate(PrintOperation)[] onStatusChangedListeners;
Undocumented in source.
onUpdateCustomWidgetListeners
void delegate(Widget, PageSetup, PrintSettings, PrintOperation)[] onUpdateCustomWidgetListeners;
Undocumented in source.

Inherited Members

From ObjectG

gObject
GObject* gObject;

the main Gtk struct

getObjectGStruct
GObject* getObjectGStruct()
Undocumented in source. Be warned that the author may not have intended to support it.
getStruct
void* getStruct()

the main Gtk struct as a void*

isGcRoot
bool isGcRoot;
Undocumented in source.
destroyNotify
void destroyNotify(ObjectG obj)
Undocumented in source. Be warned that the author may not have intended to support it.
toggleNotify
void toggleNotify(ObjectG obj, GObject* object, int isLastRef)
Undocumented in source. Be warned that the author may not have intended to support it.
~this
~this()
Undocumented in source.
getDObject
RT getDObject(U obj)

Gets a D Object from the objects table of associations.

setStruct
void setStruct(GObject* obj)
Undocumented in source. Be warned that the author may not have intended to support it.
setProperty
void setProperty(string propertyName, int value)
setProperty
void setProperty(string propertyName, string value)
setProperty
void setProperty(string propertyName, long value)
setProperty
void setProperty(string propertyName, ulong value)
unref
void unref()
Undocumented in source. Be warned that the author may not have intended to support it.
doref
ObjectG doref()
Undocumented in source. Be warned that the author may not have intended to support it.
connectedSignals
int[string] connectedSignals;
onNotifyListeners
void delegate(ParamSpec, ObjectG)[] onNotifyListeners;
Undocumented in source.
addOnNotify
void addOnNotify(void delegate(ParamSpec, ObjectG) dlg, ConnectFlags connectFlags)

The notify signal is emitted on an object when one of its properties has been changed. Note that getting this signal doesn't guarantee that the value of the property has actually changed, it may also be emitted when the setter for the property is called to reinstate the previous value. This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the It is important to note that you must use canonical parameter names as detail strings for the notify signal. See Also GParamSpecObject, g_param_spec_object()

callBackNotify
void callBackNotify(GObject* gobjectStruct, GParamSpec* pspec, ObjectG _objectG)
Undocumented in source. Be warned that the author may not have intended to support it.
classInstallProperty
void classInstallProperty(GObjectClass* oclass, uint propertyId, ParamSpec pspec)

Installs a new property. This is usually done in the class initializer. Note that it is possible to redefine a property in a derived class, by installing a property with the same name. This can be useful at times, e.g. to change the range of allowed values or the default value.

classInstallProperties
void classInstallProperties(GObjectClass* oclass, ParamSpec[] pspecs)

Installs new properties from an array of GParamSpecs. This is usually done in the class initializer. The property id of each property is the index of each GParamSpec in the pspecs array. The property id of 0 is treated specially by GObject and it should not be used to store a GParamSpec. This function should be used if you plan to use a static array of GParamSpecs and g_object_notify_by_pspec(). For instance, this Since 2.26

classFindProperty
ParamSpec classFindProperty(GObjectClass* oclass, string propertyName)

Looks up the GParamSpec for a property of a class.

classListProperties
ParamSpec[] classListProperties(GObjectClass* oclass)

Get an array of GParamSpec* for all properties of a class.

classOverrideProperty
void classOverrideProperty(GObjectClass* oclass, uint propertyId, string name)

Registers property_id as referring to a property with the name name in a parent class or in an interface implemented by oclass. This allows this class to override a property implementation in a parent class or to provide the implementation of a property from an interface. Note Internally, overriding is implemented by creating a property of type GParamSpecOverride; generally operations that query the properties of the object class, such as g_object_class_find_property() or g_object_class_list_properties() will return the overridden property. However, in one case, the construct_properties argument of the constructor virtual function, the GParamSpecOverride is passed instead, so that the param_id field of the GParamSpec will be correct. For virtually all uses, this makes no difference. If you need to get the overridden property, you can call g_param_spec_get_redirect_target(). Since 2.4

interfaceInstallProperty
void interfaceInstallProperty(void* iface, ParamSpec pspec)

Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property. This function is meant to be called from the interface's default vtable initialization function (the class_init member of GTypeInfo.) It must not be called after after class_init has been called for any object types implementing this interface. Since 2.4

interfaceFindProperty
ParamSpec interfaceFindProperty(void* iface, string propertyName)

Find the GParamSpec with the given name for an interface. Generally, the interface vtable passed in as g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). Since 2.4

interfaceListProperties
ParamSpec[] interfaceListProperties(void* iface)

Lists the properties of an interface.Generally, the interface vtable passed in as g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek(). Since 2.4

doref
void* doref(void* object)

Increases the reference count of object.

unref
void unref(void* object)

Decreases the reference count of object. When its reference count drops to 0, the object is finalized (i.e. its memory is freed).

refSink
void* refSink(void* object)

Increase the reference count of object, and possibly remove the floating reference, if object has a floating reference. In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one. Since 2.10

clearObject
void clearObject(ObjectG objectPtr)

Clears a reference to a GObject. object_ptr must not be NULL. If the reference is NULL then this function does nothing. Otherwise, the reference count of the object is decreased and the pointer is set to NULL. This function is threadsafe and modifies the pointer atomically, using memory barriers where needed. A macro is also included that allows this function to be used without pointer casts. Since 2.28

isFloating
int isFloating(void* object)

Checks whether object has a floating reference. Since 2.10

forceFloating
void forceFloating()

This function is intended for GObject implementations to re-enforce a floating object reference. Doing this is seldomly required: all GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink(). Since 2.10

weakRef
void weakRef(GWeakNotify notify, void* data)

Adds a weak reference callback to an object. Weak references are used for notification when an object is finalized. They are called "weak references" because they allow you to safely hold a pointer to an object without calling g_object_ref() (g_object_ref() adds a strong reference, that is, forces the object to stay alive).

weakUnref
void weakUnref(GWeakNotify notify, void* data)

Removes a weak reference callback to an object.

addWeakPointer
void addWeakPointer(void** weakPointerLocation)

Adds a weak reference from weak_pointer to object to indicate that the pointer located at weak_pointer_location is only valid during the lifetime of object. When the object is finalized, weak_pointer will be set to NULL.

removeWeakPointer
void removeWeakPointer(void** weakPointerLocation)

Removes a weak reference from object that was previously added using g_object_add_weak_pointer(). The weak_pointer_location has to match the one used with g_object_add_weak_pointer().

addToggleRef
void addToggleRef(GToggleNotify notify, void* data)

Increases the reference count of the object by one and sets a callback to be called when all other references to the object are dropped, or when this is already the last reference to the object and another reference is established. This functionality is intended for binding object to a proxy object managed by another memory manager. This is done with two paired references: the strong reference added by g_object_add_toggle_ref() and a reverse reference to the proxy object which is either a strong reference or weak reference. The setup is that when there are no other references to object, only a weak reference is held in the reverse direction from object to the proxy object, but when there are other references held to object, a strong reference is held. The notify callback is called when the reference from object to the proxy object should be toggled from strong to weak (is_last_ref true) or weak to strong (is_last_ref false). Since a (normal) reference must be held to the object before calling g_object_toggle_ref(), the initial state of the reverse link is always strong. Multiple toggle references may be added to the same gobject, however if there are multiple toggle references to an object, none of them will ever be notified until all but one are removed. For this reason, you should only ever use a toggle reference if there is important state in the proxy object. Since 2.8

removeToggleRef
void removeToggleRef(GToggleNotify notify, void* data)

Removes a reference added with g_object_add_toggle_ref(). The reference count of the object is decreased by one. Since 2.8

notify
void notify(string propertyName)

Emits a "notify" signal for the property property_name on object. When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.

notifyByPspec
void notifyByPspec(ParamSpec pspec)

Emits a "notify" signal for the property specified by pspec on object. This function omits the property name lookup, hence it is faster than g_object_notify(). One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with Since 2.26

freezeNotify
void freezeNotify()

Increases the freeze count on object. If the freeze count is non-zero, the emission of "notify" signals on object is stopped. The signals are queued until the freeze count is decreased to zero. This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.

thawNotify
void thawNotify()

Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on object and when it reaches zero, all queued "notify" signals are emitted. It is an error to call this function when the freeze count is zero.

getData
void* getData(string key)

Gets a named field from the objects table of associations (see g_object_set_data()).

setData
void setData(string key, void* data)

Each object carries around a table of associations from strings to pointers. This function lets you set an association. If the object already had an association with that name, the old association will be destroyed.

setDataFull
void setDataFull(string key, void* data, GDestroyNotify destroy)

Like g_object_set_data() except it adds notification for when the association is destroyed, either by setting it to a different value or when the object is destroyed. Note that the destroy callback is not called if data is NULL.

stealData
void* stealData(string key)

Remove a specified datum from the object's data associations, without invoking the association's destroy handler.

getQdata
void* getQdata(GQuark quark)

This function gets back user data pointers stored via g_object_set_qdata().

setQdata
void setQdata(GQuark quark, void* data)

This sets an opaque, named pointer on an object. The name is specified through a GQuark (retrived e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the object with g_object_get_qdata() until the object is finalized. Setting a previously set user data pointer, overrides (frees) the old pointer set, using NULL as pointer essentially removes the data stored.

setQdataFull
void setQdataFull(GQuark quark, void* data, GDestroyNotify destroy)

This function works like g_object_set_qdata(), but in addition, a void (*destroy) (gpointer) function may be specified which is called with data as argument when the object is finalized, or the data is being overwritten by a call to g_object_set_qdata() with the same quark.

stealQdata
void* stealQdata(GQuark quark)

This function gets back user data pointers stored via g_object_set_qdata() and removes the data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update

setProperty
void setProperty(string propertyName, Value value)

Sets a property on an object.

getProperty
void getProperty(string propertyName, Value value)

Gets a property of an object. value must have been initialized to the expected type of the property (or a type to which the expected type can be transformed) using g_value_init(). In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset(). Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.

setValist
void setValist(string firstPropertyName, void* varArgs)

Sets properties on an object.

getValist
void getValist(string firstPropertyName, void* varArgs)

Gets properties of an object. In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref(). See g_object_get().

watchClosure
void watchClosure(Closure closure)

This function essentially limits the life time of the closure to the life time of the object. That is, when the object is finalized, the closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the closure, to ensure that an extra reference count is held on object during invocation of the closure. Usually, this function will be called on closures that use this object as closure data.

runDispose
void runDispose()

Releases all references to other objects. This can be used to break reference cycles. This functions should only be called from object system implementations.

From PrintOperationPreviewIF

getPrintOperationPreviewTStruct
GtkPrintOperationPreview* getPrintOperationPreviewTStruct()
Undocumented in source.
getStruct
void* getStruct()

the main Gtk struct as a void*

onUpdateCustomWidgetListeners
void delegate(Widget, PageSetup, PrintSettings, PrintOperationPreviewIF)[] onUpdateCustomWidgetListeners()
addOnUpdateCustomWidget
void addOnUpdateCustomWidget(void delegate(Widget, PageSetup, PrintSettings, PrintOperationPreviewIF) dlg, ConnectFlags connectFlags)

Emitted after change of selected printer. The actual page setup and print settings are passed to the custom widget, which can actualize itself according to this change. Since 2.18

onGotPageSizeListeners
void delegate(GtkPrintContext*, PageSetup, PrintOperationPreviewIF)[] onGotPageSizeListeners()
Undocumented in source.
addOnGotPageSize
void addOnGotPageSize(void delegate(GtkPrintContext*, PageSetup, PrintOperationPreviewIF) dlg, ConnectFlags connectFlags)

The ::got-page-size signal is emitted once for each page that gets rendered to the preview. A handler for this signal should update the context according to page_setup and set up a suitable cairo context, using gtk_print_context_set_cairo_context().

onReadyListeners
void delegate(GtkPrintContext*, PrintOperationPreviewIF)[] onReadyListeners()
Undocumented in source.
addOnReady
void addOnReady(void delegate(GtkPrintContext*, PrintOperationPreviewIF) dlg, ConnectFlags connectFlags)

The ::ready signal gets emitted once per preview operation, before the first page is rendered. A handler for this signal can be used for setup tasks. See Also GtkPrintContext, GtkPrintUnixDialog

endPreview
void endPreview()

Ends a preview. This function must be called to finish a custom print preview. Since 2.10

isSelected
int isSelected(int pageNr)

Returns whether the given page is included in the set of pages that have been selected for printing. Since 2.10

renderPage
void renderPage(int pageNr)

Renders a page to the preview, using the print context that was passed to the "preview" handler together with preview. A custom iprint preview should use this function in its ::expose handler to render the currently selected page. Note that this function requires a suitable cairo context to be associated with the print context. Since 2.10

Meta