1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
114
  
115
  
116
  
117
  
118
  
119
  
120
  
121
  
122
  
123
  
124
  
125
  
126
  
127
  
128
  
129
  
130
  
131
  
132
  
133
  
134
  
135
  
136
  
137
  
138
  
139
  
140
  
141
  
142
  
143
  
144
  
145
  
146
  
147
  
148
  
149
  
150
  
151
  
152
  
153
  
154
  
155
  
156
  
157
  
158
  
159
  
160
  
161
  
162
  
163
  
164
  
165
  
166
  
167
  
168
  
169
  
170
  
171
  
172
  
173
  
174
  
175
  
176
  
177
  
178
  
179
  
180
  
181
  
182
  
/* -*- C -*- */ 
require not_now; 
class GTK2.PrintOperation; 
inherit G.Object; 
inherit GTK2.PrintOperationPreview; 
 
//! GTK2.PrintOperation is the high-level, portable printing API. It looks a 
//! bit different than other GTK+ dialogs such as the GTK2.FileChooser, since 
//! some platforms don't expose enough infrastructure to implement a good print 
//! dialog. On such platforms, GTK2.PrintOperation uses the native print 
//! dialog. On platforms which do not provide a native print dialog, GTK+ uses 
//! its own, see GTK2.PrintUnixDialog. 
 
//! Properties: 
//! int allow-async 
//! int current-page 
//! GTK2.PageSetup default-page-setup 
//! string export-filename 
//! string job-name 
//! int n-pages 
//! GTK2.PrintSettings print-settings 
//! int show-progress 
//! GTK2.PrintStatus status 
//! string status-string 
//! int track-print-status 
//! int unit 
//! int use-full-page 
 
signal begin_print; 
signal create_custom_widget; 
signal custom_width_apply; 
signal done; 
signal draw_page; 
signal end_print; 
signal paginate; 
signal preview; 
signal request_page_setup; 
signal status_changed; 
 
void create(?mapping(string:mixed) props) 
//! Create a new GTK2.PrintOperation. 
{ 
  pgtk2_verify_not_inited(); 
  pgtk2_verify_setup(); 
  if (args) { 
    INIT_WITH_PROPS(GTK_TYPE_PRINT_OPERATION); 
    pgtk2_pop_n_elems(args); 
  } else { 
    GtkPrintOperation *gpo; 
    gpo=gtk_print_operation_new(); 
    THIS->obj=G_OBJECT(gpo); 
  } 
  pgtk2__init_this_object(); 
} 
 
void set_allow_async(int allow_async); 
//! Sets whether run() may return before the print operation is completed. 
//! Note that some platforms may not allow asynchronous operation. 
 
string get_error() 
//! Call this when the result of a print operation is 
//! GTK2.PRINT_OPERATION_RESULT_ERROR, either as returned by run(), or in 
//! the ::done signal handler. 
{ 
  pgtk2_verify_inited(); 
  pgtk2_pop_n_elems(args); 
  { 
    GError *error=NULL; 
    gtk_print_operation_get_error(GTK_PRINT_OPERATION(THIS->obj),&error); 
    push_string(make_shared_binary_string(error->message,strlen(error->message))); 
  } 
} 
 
void set_default_page_setup(GTK2.PageSetup def); 
//! Makes def the default page setup. 
 
+GTK2.PageSetup get_default_page_setup(); 
//! Returns the default page setup. 
 
void set_print_settings(GTK2.PrintSettings settings); 
//! Sets the print settings. 
 
+GTK2.PrintSettings get_print_settings(); 
//! Returns the current print settings; 
 
void set_job_name(string name); 
//! Sets the name of the print job.  The name is used to identify the job. 
//! <p> 
//! If you don't set a job name, GTK+ picks a default on by numbering 
//! successive print jobs. 
 
void set_n_pages(int n_pages); 
//! Sets the number of pages in the documnent. 
//! <p> 
//! This must be set to a positive nubmer before the rendering starts. 
 
void set_current_page(int cur_page); 
//! Sets the current page. 
//! <p> 
//! If this is called before run(), the user will be able to select to print 
//! only the current page. 
 
void set_use_full_page(int full_page); 
//! If full_page is true, the transformation for the cairo context obtained 
//! from GTK2.PrintContext 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 margin). 
 
void set_unit(int unit); 
//! Sets up the transformation for the cairo context obtained from 
//! GTK2.PrintContext in such a way that distances are measured in units of 
//! unit. 
 
void set_export_filename(string filename); 
//! Sets up the operation to generate a file instead of showing the print 
//! dialog.  The intended use of this function is for implementing 
//! "Export to PDF" actions.  Currently, PDF is the only supported format. 
//! <p> 
//! "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. 
 
void set_show_progress(int show_progress); 
//! If true, the print operation will show a progress dialog during the 
//! print operation. 
 
void set_track_print_status(int track_status); 
//! 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. 
//! <p> 
//! This function is often implemented using some form of polling, so it 
//! should not be enabled unless needed. 
 
void set_custom_tab_label(string label); 
//! Sets the label for the tab holding custom widgets. 
 
int run(int action, GTK2.Window parent) 
//! Runs the print operation, by first letting the user modify print settings 
//! in the print dialog, and then print the document. 
//! <p> 
//! Normally that this function does not return until the rendering of all 
//! pages is complete. You can connect to the ::status-changed signal to 
//! obtain some information about the progress of the print operation. 
//! Furthermore, it may use a recursive mainloop to show the print dialog. 
{ 
  pgtk2_verify_inited(); 
  { 
    struct object *o1; 
    INT_TYPE action; 
    GError *error=NULL; 
    GtkPrintOperationResult res; 
 
    get_all_args(NULL,args,"%i%o",&action,&o1); 
    res=gtk_print_operation_run(GTK_PRINT_OPERATION(THIS->obj), 
                        action,GTK_WINDOW(get_gobject(o1)),&error); 
    pgtk2_pop_n_elems(args); 
    push_int(res); 
  } 
} 
 
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. 
 
int get_status(); 
//! Returns the status of the print operation. 
 
string get_status_string(); 
//! Returns a string representation of the status of the print operation. 
 
int is_finished(); 
//! A convenience function to find out if the print operation is finished, 
//! either successfully (GTK2.PRINT_STATUS_FINISHED) or unsuccessfully 
//! (GTK2.PRINT_STATUS_FINISHED_ABORTED). 
 
 
endrequire;