« back to all changes in this revision
Viewing changes to pp_mainwindow.cpp
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Milan Zamazal
- Date: 2007-05-01 16:32:13 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20070501163213-ni1933khtg9fdvn5
Tags: 0.3.5-2
Move to unstable.
- files added:
- ABOUT-NLS
- effects
- m4
- po
- files removed:
- Makefile
- files modified:
- Makefile.am
- support/searchpath.cpp *
added
removed
pp_mainwindow.cpp
1
#include <string.h>
2
3
#include <gtk/gtkframe.h>
4
#include <gtk/gtksizegroup.h>
5
#include <gtk/gtklabel.h>
6
#include <gtk/gtkfilesel.h>
7
#include <gtk/gtkfilechooser.h>
8
#include <gtk/gtkfilechooserdialog.h>
9
#include <gtk/gtkdialog.h>
10
#include <gtk/gtkmenuitem.h>
11
#include <gtk/gtkcheckmenuitem.h>
12
#include <gtk/gtkmain.h>
13
14
#include "stpui_widgets/stpui_combo.h"
15
#include "support/progressbar.h"
16
#include "support/tiffsave.h"
1
#include <string.h>
2
3
#include <gtk/gtkframe.h>
4
#include <gtk/gtksizegroup.h>
5
#include <gtk/gtklabel.h>
6
#include <gtk/gtkfilesel.h>
7
#include <gtk/gtkfilechooser.h>
8
#include <gtk/gtkfilechooserdialog.h>
9
#include <gtk/gtkdialog.h>
10
#include <gtk/gtkmenuitem.h>
11
#include <gtk/gtkcheckmenuitem.h>
12
#include <gtk/gtkimage.h>
13
#include <gtk/gtkmain.h>
14
#include <gtk/gtkuimanager.h>
15
16
#include "stpui_widgets/stpui_combo.h"
17
#include "support/progressbar.h"
18
#include "support/tiffsave.h"
17
19
#include "support/pathsupport.h"
18
#include "layout.h"
19
#include "dialogs.h"
20
#include "support/generaldialogs.h"
20
#include "layout.h"
21
#include "dialogs.h"
22
#include "support/generaldialogs.h"
21
23
#include "pixbufthumbnail/egg-pixbuf-thumbnail.h"
22
#include "config.h"
23
24
#include "pp_mainwindow.h"
25
26
enum {
27
CHANGED_SIGNAL,
28
LAST_SIGNAL
29
};
30
31
static guint pp_mainwindow_signals[LAST_SIGNAL] = { 0 };
32
33
static void pp_mainwindow_class_init (pp_MainWindowClass *klass);
34
static void pp_mainwindow_init (pp_MainWindow *stpuicombo);
35
static void layout_changed(GtkWidget *wid,gpointer *ob);
36
37
// Functions invoked from the menus:
38
39
40
static void savegeometry(pp_MainWindow *mw)
41
{
42
gint x,y,w,h;
43
gtk_window_get_position(GTK_WINDOW(mw),&x,&y);
44
gtk_window_get_size(GTK_WINDOW(mw),&w,&h);
45
46
mw->state->SetInt("Win_X",x);
47
mw->state->SetInt("Win_Y",y);
48
mw->state->SetInt("Win_W",w);
49
mw->state->SetInt("Win_H",h);
50
}
51
52
53
static void layout_selection_changed(GtkWidget *wid,gpointer *ob)
54
{
55
pp_MainWindow *mw=(pp_MainWindow *)ob;
56
57
pp_Menu *m=PP_MENU(mw->menu);
58
PP_ROTATION rotation=m->rotation;
59
bool allowcropping=m->allowcropping;
60
bool removeimage=true;
61
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
62
if(ii)
63
{
64
allowcropping=ii->allowcropping;
65
rotation=ii->rotation;
66
}
67
else
68
removeimage=false;
69
70
while(ii)
71
{
72
if(rotation!=ii->rotation)
73
rotation=PP_ROTATION_NONE;
74
allowcropping&=ii->allowcropping;
75
ii=mw->state->layout->NextSelected();
76
}
77
78
g_signal_handlers_block_matched (G_OBJECT(mw->menu),G_SIGNAL_MATCH_DATA,
79
0, 0, NULL, NULL, mw);
80
pp_menu_set_menu_state(m,allowcropping,rotation,removeimage);
81
g_signal_handlers_unblock_matched (G_OBJECT(mw->menu),G_SIGNAL_MATCH_DATA,
82
0, 0, NULL, NULL, mw);
83
}
84
85
86
static void layout_popupmenu(GtkWidget *wid,gpointer *ob)
87
{
88
layout_selection_changed(NULL,ob);
89
pp_MainWindow *mw=(pp_MainWindow *)ob;
90
pp_Menu *menu=PP_MENU(mw->menu);
91
gtk_menu_popup(GTK_MENU(menu->popupmenubar),NULL,NULL,NULL,NULL,3,gtk_get_current_event_time());
92
}
93
94
95
static void rebuild(pp_MainWindow *mw)
96
{
97
try
98
{
99
ProgressBar p("Transferring images...",true,GTK_WIDGET(mw));
100
if(mw->state->NewLayout(&p))
101
{
102
gtk_widget_destroy(mw->layout);
103
104
if((mw->layout=mw->state->layout->CreateWidget()))
105
{
106
gtk_box_pack_start(GTK_BOX(mw->vbox),mw->layout,TRUE,TRUE,0);
107
gtk_widget_show(mw->layout);
108
g_signal_connect(G_OBJECT(mw->layout),"changed",G_CALLBACK(layout_changed),mw);
109
g_signal_connect(G_OBJECT(mw->layout),"popupmenu",G_CALLBACK(layout_popupmenu),mw);
110
g_signal_connect(G_OBJECT(mw->layout),"selection_changed",G_CALLBACK(layout_selection_changed),mw);
111
}
112
}
113
int caps=mw->state->layout->GetCapabilities();
114
pp_menu_set_layout_capabilities(PP_MENU(mw->menu),caps);
115
pp_mainwindow_refresh(mw);
116
}
117
catch(const char *err)
118
{
119
ErrorMessage_Dialog(err);
120
}
121
}
122
123
124
static void open_preset(GtkWidget *wid,gpointer *ob)
125
{
126
pp_MainWindow *mw=(pp_MainWindow *)ob;
127
char *filename=File_Dialog("Open preset...",mw->state->filename);
128
129
if(filename)
130
{
131
mw->state->SetFilename(filename);
132
mw->state->ParseFile();
133
134
g_free(filename);
135
136
rebuild(mw);
137
}
138
}
139
140
141
static void save_preset(GtkWidget *wid,gpointer *ob)
142
{
143
pp_MainWindow *mw=(pp_MainWindow *)ob;
144
savegeometry(mw);
145
mw->state->SaveFile();
146
}
147
148
149
static void save_as(GtkWidget *wid,gpointer *ob)
150
{
151
pp_MainWindow *mw=(pp_MainWindow *)ob;
152
savegeometry(mw);
153
char *filename=File_Save_Dialog("Save preset...",mw->state->filename,GTK_WIDGET(&mw->window));
154
155
if(filename)
156
{
157
mw->state->SetFilename(filename);
158
mw->state->SaveFile();
159
160
g_free(filename);
161
}
162
}
163
164
165
static void save_default(GtkWidget *wid,gpointer *ob)
166
{
167
pp_MainWindow *mw=(pp_MainWindow *)ob;
168
savegeometry(mw);
169
mw->state->SetDefaultFilename();
170
mw->state->SaveFile();
171
}
172
173
174
static void export_tiff(GtkWidget *wid,gpointer *ob)
175
{
176
pp_MainWindow *mw=(pp_MainWindow *)ob;
177
178
ExportTiff_Dialog(GTK_WINDOW(mw),*mw->state);
179
return;
180
181
gchar *filename=File_Dialog("Export TIFF...",NULL);
182
183
if(filename)
184
{
185
try
186
{
187
CMTransformFactory *factory=mw->state->profilemanager.GetTransformFactory();
188
ImageSource *is=mw->state->layout->GetImageSource(mw->state->layout->GetCurrentPage(),CM_COLOURDEVICE_PRINTER,factory);
189
cerr << "Got imagesource" << endl;
190
// FIXME - deal with multiple pages
191
if(is)
192
{
193
TIFFSaver ts(filename,is);
194
ProgressBar p("Saving TIFF",true,GTK_WIDGET(mw));
195
ts.SetProgress(&p);
196
ts.Save();
197
198
delete is;
199
}
200
if(factory)
201
delete factory;
202
}
203
catch (const char *err)
204
{
205
ErrorMessage_Dialog(err,GTK_WIDGET(mw));
206
}
207
g_free(filename);
208
}
209
}
210
211
212
static void print_setup(GtkWidget *wid,gpointer *ob)
213
{
214
pp_MainWindow *mw=(pp_MainWindow *)ob;
215
PrintSetup_Dialog(GTK_WINDOW(mw),*mw->state);
216
pp_mainwindow_refresh(mw);
217
}
218
219
220
static void do_paths(GtkWidget *wid,gpointer *ob)
221
{
222
pp_MainWindow *mw=(pp_MainWindow *)ob;
223
Paths_Dialog(GTK_WINDOW(mw),*mw->state);
224
pp_mainwindow_refresh(mw);
225
}
226
227
static void doprint(GtkWidget *wid,gpointer *ob)
228
{
229
pp_MainWindow *mw=(pp_MainWindow *)ob;
230
ProgressBar p("Generating print data...",true,GTK_WIDGET(mw));
231
232
try
233
{
234
mw->state->layout->Print(&p);
235
}
236
catch (const char *err)
237
{
238
ErrorMessage_Dialog(err,GTK_WIDGET(mw));
239
}
240
}
241
242
243
static void colour_management(GtkWidget *wid,gpointer *ob)
244
{
245
pp_MainWindow *mw=(pp_MainWindow *)ob;
246
ColourManagement_Dialog(GTK_WINDOW(mw),*mw->state);
247
mw->state->layout->FlushThumbnails();
248
pp_mainwindow_refresh(mw);
249
}
250
251
252
static void units(GtkWidget *wid,gpointer *ob)
253
{
254
pp_MainWindow *mw=(pp_MainWindow *)ob;
255
Units_Dialog(GTK_WINDOW(mw),*mw->state);
256
(mw->state->layout->SetUnitFunc())(mw->layout,mw->state->GetUnits());
257
}
258
259
260
static void scaling(GtkWidget *wid,gpointer *ob)
261
{
262
pp_MainWindow *mw=(pp_MainWindow *)ob;
263
Scaling_Dialog(GTK_WINDOW(mw),*mw->state);
264
}
265
266
267
// Preview widget for file-selector...
268
269
static void updatepreview(GtkWidget *fc,void *ud)
270
{
271
GtkWidget *preview=GTK_WIDGET(ud);
272
gchar *fn=gtk_file_chooser_get_preview_filename(GTK_FILE_CHOOSER(fc));
273
bool active=false;
274
if(fn)
24
#include "effects/effects_dialog.h"
25
#include "pp_menu_file.h"
26
#include "pp_menu_edit.h"
27
#include "pp_menu_layout.h"
28
#include "pp_menu_image.h"
29
#include "pp_menu_options.h"
30
#include "pp_menu_help.h"
31
32
#include "config.h"
33
#include "gettext.h"
34
#define _(x) gettext(x)
35
36
#include "pp_mainwindow.h"
37
38
enum {
39
CHANGED_SIGNAL,
40
LAST_SIGNAL
41
};
42
43
static guint pp_mainwindow_signals[LAST_SIGNAL] = { 0 };
44
45
static void pp_mainwindow_class_init (pp_MainWindowClass *klass);
46
static void pp_mainwindow_init (pp_MainWindow *stpuicombo);
47
static void layout_changed(GtkWidget *wid,gpointer *ob);
48
49
50
51
// Functions invoked from the menus:
52
53
54
static void savegeometry(pp_MainWindow *mw)
55
{
56
gint x,y,w,h;
57
gtk_window_get_position(GTK_WINDOW(mw),&x,&y);
58
gtk_window_get_size(GTK_WINDOW(mw),&w,&h);
59
60
mw->state->SetInt("Win_X",x);
61
mw->state->SetInt("Win_Y",y);
62
mw->state->SetInt("Win_W",w);
63
mw->state->SetInt("Win_H",h);
64
}
65
66
67
static void layout_selection_changed(GtkWidget *wid,gpointer *ob)
68
{
69
pp_MainWindow *mw=(pp_MainWindow *)ob;
70
71
PP_ROTATION rotation=ImageMenu_GetRotation(mw->uim);
72
bool allowcropping=ImageMenu_GetCropFlag(mw->uim);
73
bool removeimage=true;
74
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
75
if(ii)
275
76
{
276
GError *err=NULL;
277
GdkPixbuf *pb=egg_pixbuf_get_thumbnail_for_file(fn,EGG_PIXBUF_THUMBNAIL_NORMAL,&err);
278
if(pb)
279
{
280
gtk_image_set_from_pixbuf(GTK_IMAGE(preview),pb);
281
g_object_unref(pb);
282
active=true;
283
}
77
allowcropping=ii->allowcropping;
78
rotation=ii->rotation;
284
79
}
285
gtk_file_chooser_set_preview_widget_active(GTK_FILE_CHOOSER(fc),active);
286
}
287
288
289
static void add_image(GtkWidget *wid,gpointer *ob)
290
{
291
pp_MainWindow *mw=(pp_MainWindow *)ob;
292
PhotoPrint_State *state=mw->state;
293
#if 0
294
GtkWidget *sel=gtk_file_selection_new("Add images...");
295
gtk_file_selection_set_select_multiple(GTK_FILE_SELECTION(sel),TRUE);
296
if(mw->prevfile)
297
gtk_file_selection_set_filename(GTK_FILE_SELECTION(sel),mw->prevfile);
298
g_free(mw->prevfile);
299
mw->prevfile=NULL;
300
301
gint result=gtk_dialog_run(GTK_DIALOG(sel));
302
if(result==GTK_RESPONSE_OK)
303
{
304
gchar **f;
305
gchar **files=f=gtk_file_selection_get_selections(GTK_FILE_SELECTION(sel));
306
int count=0;
307
while(*f)
308
{
309
++count;
310
++f;
311
}
312
ProgressBar progress("Adding images...",true,GTK_WIDGET(mw));
313
f=files;
314
int i=0;
315
int lastpage=0;
316
while(*f)
317
{
318
pp_Menu *menu=PP_MENU(mw->menu);
319
lastpage=state->layout->AddImage(*f,menu->allowcropping,menu->rotation);
320
++f;
321
if(!(progress.DoProgress(i,count)))
322
break;
323
++i;
324
}
325
f--;
326
if(*f)
327
mw->prevfile=g_strdup(*f);
328
state->layout->SetCurrentPage(lastpage);
329
g_strfreev(files);
330
}
331
332
gtk_widget_destroy(GTK_WIDGET(sel));
333
#else
334
GtkWidget *sel;
335
336
sel = gtk_file_chooser_dialog_new ("Open File",
337
GTK_WINDOW(GTK_WINDOW(&mw->window)),
338
GTK_FILE_CHOOSER_ACTION_OPEN,
339
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
340
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
341
NULL);
342
343
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(sel),TRUE);
344
if(mw->prevfile)
345
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(sel),mw->prevfile);
346
80
else
347
{
348
#ifdef WIN32
349
char *dirname=substitute_homedir("$HOME\\My Documents\\My Pictures");
350
#else
351
char *dirname=substitute_homedir("$HOME");
352
#endif
353
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(sel),dirname);
354
}
355
g_free(mw->prevfile);
356
mw->prevfile=NULL;
357
358
GtkWidget *preview=gtk_image_new();
359
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(sel),GTK_WIDGET(preview));
360
g_signal_connect(G_OBJECT(sel),"selection-changed",G_CALLBACK(updatepreview),preview);
361
362
if (gtk_dialog_run (GTK_DIALOG (sel)) == GTK_RESPONSE_ACCEPT)
363
{
364
GSList *filenames=gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(sel));
365
GSList *current=filenames;
366
367
if(filenames)
368
{
369
int count=0;
370
while(current)
371
{
372
++count;
373
current=g_slist_next(current);
374
}
375
376
ProgressBar progress("Adding images...",true,GTK_WIDGET(mw));
377
378
current=filenames;
379
int i=0;
380
int lastpage=0;
381
while(current)
382
{
383
char *fn=(char *)current->data;
384
385
pp_Menu *menu=PP_MENU(mw->menu);
386
lastpage=state->layout->AddImage(fn,menu->allowcropping,menu->rotation);
387
388
if(!(progress.DoProgress(i,count)))
389
break;
390
++i;
391
392
current=g_slist_next(current);
393
if(!current)
394
mw->prevfile=g_strdup(fn);
395
g_free(fn);
396
}
397
state->layout->SetCurrentPage(lastpage);
398
g_slist_free(filenames);
81
removeimage=false;
82
83
while(ii)
84
{
85
if(rotation!=ii->rotation)
86
rotation=PP_ROTATION_NONE;
87
allowcropping&=ii->allowcropping;
88
ii=mw->state->layout->NextSelected();
89
}
90
91
ImageMenu_SetCropFlag(mw->uim,allowcropping);
92
ImageMenu_SetRotation(mw->uim,rotation);
93
}
94
95
96
static void layout_popupmenu(GtkWidget *wid,gpointer *ob)
97
{
98
layout_selection_changed(NULL,ob);
99
pp_MainWindow *mw=(pp_MainWindow *)ob;
100
ImageMenu_DoPopup(mw->uim);
101
}
102
103
104
static void layout_changed(GtkWidget *wid,gpointer *ob)
105
{
106
pp_MainWindow *mw=(pp_MainWindow *)ob;
107
108
if(mw->layout)
109
mw->state->layout->RefreshWidget(mw->layout);
110
}
111
112
113
void pp_mainwindow_refresh(pp_MainWindow *ob)
114
{
115
cerr << "Refreshing window" << endl;
116
if(ob->layout)
117
ob->state->layout->RefreshWidget(ob->layout);
118
119
LayoutMenu_SetLayout(ob->uim,ob->state->layout->GetType());
120
}
121
122
123
GtkWidget*
124
pp_mainwindow_new (PhotoPrint_State *state)
125
{
126
pp_MainWindow *ob=PP_MAINWINDOW(g_object_new (pp_mainwindow_get_type (), NULL));
127
128
gtk_window_set_title (GTK_WINDOW (ob), PACKAGE_STRING);
129
gtk_window_set_default_size(GTK_WINDOW(ob),state->FindInt("Win_W"),state->FindInt("Win_H"));
130
gtk_window_move(GTK_WINDOW(ob),state->FindInt("Win_X"),state->FindInt("Win_Y"));
131
ob->state=state;
132
133
ob->vbox=gtk_vbox_new(FALSE,0);
134
gtk_container_add(GTK_CONTAINER(ob),ob->vbox);
135
gtk_widget_show(ob->vbox);
136
137
138
139
GtkWidget *menubar;
140
GtkAccelGroup *accel_group;
141
ob->uim = gtk_ui_manager_new ();
142
143
BuildFileMenu(ob,ob->uim);
144
BuildEditMenu(ob,ob->uim);
145
BuildLayoutMenu(ob,ob->uim);
146
BuildImageMenu(ob,ob->uim);
147
BuildOptionsMenu(ob,ob->uim);
148
BuildHelpMenu(ob,ob->uim);
149
150
accel_group = gtk_ui_manager_get_accel_group (ob->uim);
151
gtk_window_add_accel_group (GTK_WINDOW (ob), accel_group);
152
153
GtkWidget *tmp;
154
tmp=gtk_ui_manager_get_widget(ob->uim,"/MainMenu/FileMenu/PrintPreview");
155
gtk_widget_set_sensitive(tmp,false);
156
tmp=gtk_ui_manager_get_widget(ob->uim,"/MainMenu/EditMenu/Cut");
157
gtk_widget_set_sensitive(tmp,false);
158
tmp=gtk_ui_manager_get_widget(ob->uim,"/MainMenu/EditMenu/Copy");
159
gtk_widget_set_sensitive(tmp,false);
160
tmp=gtk_ui_manager_get_widget(ob->uim,"/MainMenu/EditMenu/Paste");
161
gtk_widget_set_sensitive(tmp,false);
162
163
menubar = gtk_ui_manager_get_widget (ob->uim, "/MainMenu");
164
gtk_box_pack_start(GTK_BOX(ob->vbox),menubar,FALSE,TRUE,0);
165
gtk_widget_show(menubar);
166
167
168
if((ob->layout=state->layout->CreateWidget()))
169
{
170
gtk_box_pack_start(GTK_BOX(ob->vbox),ob->layout,TRUE,TRUE,0);
171
gtk_widget_show(ob->layout);
172
g_signal_connect(G_OBJECT(ob->layout),"changed",G_CALLBACK(layout_changed),ob);
173
g_signal_connect(G_OBJECT(ob->layout),"popupmenu",G_CALLBACK(layout_popupmenu),ob);
174
g_signal_connect(G_OBJECT(ob->layout),"selection_changed",G_CALLBACK(layout_selection_changed),ob);
175
}
176
177
int caps=ob->state->layout->GetCapabilities();
178
ImageMenu_SetLayoutCapabilities(ob->uim,caps);
179
180
pp_mainwindow_refresh(ob);
181
182
return(GTK_WIDGET(ob));
183
}
184
185
186
GType
187
pp_mainwindow_get_type (void)
188
{
189
static GType stpuic_type = 0;
190
191
if (!stpuic_type)
192
{
193
static const GTypeInfo pp_mainwindow_info =
194
{
195
sizeof (pp_MainWindowClass),
196
NULL, /* base_init */
197
NULL, /* base_finalize */
198
(GClassInitFunc) pp_mainwindow_class_init,
199
NULL, /* class_finalize */
200
NULL, /* class_data */
201
sizeof (pp_MainWindow),
202
0,
203
(GInstanceInitFunc) pp_mainwindow_init,
204
};
205
stpuic_type = g_type_register_static (GTK_TYPE_WINDOW, "pp_MainWindow", &pp_mainwindow_info, (GTypeFlags)0);
206
}
207
return stpuic_type;
208
}
209
210
211
static void
212
pp_mainwindow_class_init (pp_MainWindowClass *klass)
213
{
214
pp_mainwindow_signals[CHANGED_SIGNAL] =
215
g_signal_new ("changed",
216
G_TYPE_FROM_CLASS (klass),
217
GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
218
G_STRUCT_OFFSET (pp_MainWindowClass, changed),
219
NULL, NULL,
220
g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
221
}
222
223
224
static void
225
pp_mainwindow_init (pp_MainWindow *ob)
226
{
227
ob->state=NULL;
228
ob->layout=NULL;
229
ob->prevfile=NULL;
230
}
231
232
233
void pp_mainwindow_rebuild(pp_MainWindow *mw)
234
{
235
try
236
{
237
ProgressBar p(_("Transferring images..."),true,GTK_WIDGET(mw));
238
if(mw->state->NewLayout(&p))
239
{
240
gtk_widget_destroy(mw->layout);
241
242
if((mw->layout=mw->state->layout->CreateWidget()))
243
{
244
gtk_box_pack_start(GTK_BOX(mw->vbox),mw->layout,TRUE,TRUE,0);
245
gtk_widget_show(mw->layout);
246
g_signal_connect(G_OBJECT(mw->layout),"changed",G_CALLBACK(layout_changed),mw);
247
g_signal_connect(G_OBJECT(mw->layout),"popupmenu",G_CALLBACK(layout_popupmenu),mw);
248
g_signal_connect(G_OBJECT(mw->layout),"selection_changed",G_CALLBACK(layout_selection_changed),mw);
249
}
250
mw->state->layout->FlushThumbnails();
399
251
}
400
}
401
gtk_widget_destroy (sel);
402
#endif
403
pp_mainwindow_refresh(mw);
404
}
405
406
407
static void clearlayout(GtkWidget *wid,gpointer *ob)
408
{
409
pp_MainWindow *mw=(pp_MainWindow *)ob;
410
mw->state->layout->Clear();
411
pp_mainwindow_refresh(mw);
412
}
413
414
415
static void layoutsingle(GtkWidget *wid,gpointer *ob)
416
{
417
pp_MainWindow *mw=(pp_MainWindow *)ob;
418
mw->state->layoutdb.SetString("LayoutType","Single");
419
420
if(mw->layout)
421
mw->state->layout->LayoutToDB(mw->state->layoutdb);
422
423
rebuild(mw);
424
}
425
426
427
static void layoutmultiple(GtkWidget *wid,gpointer *ob)
428
{
429
pp_MainWindow *mw=(pp_MainWindow *)ob;
430
mw->state->layoutdb.SetString("LayoutType","NUp");
431
432
if(mw->layout)
433
mw->state->layout->LayoutToDB(mw->state->layoutdb);
434
435
rebuild(mw);
436
}
437
438
439
static void layoutcarousel(GtkWidget *wid,gpointer *ob)
440
{
441
pp_MainWindow *mw=(pp_MainWindow *)ob;
442
mw->state->layoutdb.SetString("LayoutType","Carousel");
443
444
if(mw->layout)
445
mw->state->layout->LayoutToDB(mw->state->layoutdb);
446
447
rebuild(mw);
448
}
449
450
451
static void layoutposter(GtkWidget *wid,gpointer *ob)
452
{
453
pp_MainWindow *mw=(pp_MainWindow *)ob;
454
mw->state->layoutdb.SetString("LayoutType","Poster");
455
456
if(mw->layout)
457
mw->state->layout->LayoutToDB(mw->state->layoutdb);
458
459
rebuild(mw);
460
}
461
462
463
static void layout_changed(GtkWidget *wid,gpointer *ob)
464
{
465
pp_MainWindow *mw=(pp_MainWindow *)ob;
466
467
if(mw->layout)
468
mw->state->layout->RefreshWidget(mw->layout);
469
}
470
471
472
static void layout_setbackground(GtkWidget *wid,gpointer *ob)
473
{
474
pp_MainWindow *mw=(pp_MainWindow *)ob;
475
static char *prevfile=NULL;
476
// Need to get existing filename...
477
478
char *bg=Background_Dialog(&mw->window,*mw->state,prevfile);
479
480
if(bg)
481
cerr << "Selected " << bg << endl;
482
483
mw->state->layout->SetBackground(bg);
484
// if(prevfile)
485
// free(prevfile);
486
prevfile=bg;
487
pp_mainwindow_refresh(mw);
488
}
489
490
491
static void about(GtkWidget *wid,gpointer *ob)
492
{
493
pp_MainWindow *mw=(pp_MainWindow *)ob;
494
About_Dialog(GTK_WINDOW(mw));
495
}
496
497
498
static void image_remove(GtkWidget *wid,gpointer *ob)
499
{
500
pp_MainWindow *mw=(pp_MainWindow *)ob;
501
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
502
while(ii)
503
{
504
delete ii;
505
ii=mw->state->layout->FirstSelected();
506
}
507
mw->state->layout->Reflow();
508
pp_mainwindow_refresh(mw);
509
}
510
511
512
static void image_allowcropping(GtkWidget *wid,gpointer *ob)
513
{
514
pp_MainWindow *mw=(pp_MainWindow *)ob;
515
pp_Menu *menu=PP_MENU(mw->menu);
516
bool checked=menu->allowcropping;
517
cerr << "Checked:" << checked << endl;
518
519
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
520
while(ii)
521
{
522
ii->allowcropping=checked;
523
ii=mw->state->layout->NextSelected();
524
}
525
pp_mainwindow_refresh(mw);
526
}
527
528
529
static void image_rotation(GtkWidget *wid,gpointer *ob)
530
{
531
pp_MainWindow *mw=(pp_MainWindow *)ob;
532
pp_Menu *menu=PP_MENU(mw->menu);
533
enum PP_ROTATION rotation=menu->rotation;
534
535
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
536
while(ii)
537
{
538
ii->rotation=rotation;
539
ii=mw->state->layout->NextSelected();
540
}
541
pp_mainwindow_refresh(mw);
542
}
543
544
545
static void image_setmask(GtkWidget *wid,gpointer *ob)
546
{
547
pp_MainWindow *mw=(pp_MainWindow *)ob;
548
static char *prevfile=NULL;
549
// Need to get existing filename...
550
551
char *mask=ImageMask_Dialog(&mw->window,*mw->state,prevfile);
552
553
if(mask)
554
cerr << "Selected " << mask << endl;
555
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
556
while(ii)
557
{
558
ii->SetMask(mask);
559
ii=mw->state->layout->NextSelected();
560
}
561
// if(prevfile)
562
// free(prevfile);
563
prevfile=mask;
564
pp_mainwindow_refresh(mw);
565
}
566
567
b'static void image_setcolourprofile(GtkWidget *wid,gpointer *ob)'
568
{
569
pp_MainWindow *mw=(pp_MainWindow *)ob;
570
static char *prevfile=NULL;
571
// Need to get existing filename...
572
573
Layout_ImageInfo *ii=mw->state->layout->FirstSelected();
574
if(ii)
575
SetCustomProfileDialog(&mw->window,*mw->state,ii);
576
pp_mainwindow_refresh(mw);
577
}
252
int caps=mw->state->layout->GetCapabilities();
253
ImageMenu_SetLayoutCapabilities(mw->uim,caps);
578
254
579
580
static void edit_selectall(GtkWidget *wid,gpointer *ob)
581
{
582
pp_MainWindow *mw=(pp_MainWindow *)ob;
583
mw->state->layout->SelectAll();
584
pp_mainwindow_refresh(mw);
585
}
586
587
588
static void edit_selectnone(GtkWidget *wid,gpointer *ob)
589
{
590
pp_MainWindow *mw=(pp_MainWindow *)ob;
591
mw->state->layout->SelectNone();
592
pp_mainwindow_refresh(mw);
593
}
594
595
596
void pp_mainwindow_refresh(pp_MainWindow *ob)
597
{
598
cerr << "Refreshing window" << endl;
599
if(ob->layout)
600
ob->state->layout->RefreshWidget(ob->layout);
601
602
if(ob->menu)
603
{
604
g_signal_handlers_block_matched (G_OBJECT(ob->menu),G_SIGNAL_MATCH_DATA,
605
0, 0, NULL, NULL, ob);
606
pp_menu_set_layout(PP_MENU(ob->menu),ob->state->layout->GetType());
607
pp_menu_refresh(PP_MENU(ob->menu));
608
g_signal_handlers_unblock_matched (G_OBJECT(ob->menu),G_SIGNAL_MATCH_DATA,
609
0, 0, NULL, NULL, ob);
610
}
611
}
612
613
614
GtkWidget*
615
pp_mainwindow_new (PhotoPrint_State *state)
616
{
617
pp_MainWindow *ob=PP_MAINWINDOW(g_object_new (pp_mainwindow_get_type (), NULL));
618
619
gtk_window_set_title (GTK_WINDOW (ob), PACKAGE_STRING);
620
gtk_window_set_default_size(GTK_WINDOW(ob),state->FindInt("Win_W"),state->FindInt("Win_H"));
621
gtk_window_move(GTK_WINDOW(ob),state->FindInt("Win_X"),state->FindInt("Win_Y"));
622
ob->state=state;
623
624
ob->vbox=gtk_vbox_new(FALSE,0);
625
gtk_container_add(GTK_CONTAINER(ob),ob->vbox);
626
gtk_widget_show(ob->vbox);
627
628
ob->menu=pp_menu_new();
629
gtk_window_add_accel_group (GTK_WINDOW (ob), pp_menu_get_accels(PP_MENU(ob->menu)));
630
gtk_box_pack_start(GTK_BOX(ob->vbox),ob->menu,FALSE,TRUE,0);
631
gtk_widget_show(ob->menu);
632
633
g_signal_connect(G_OBJECT(ob->menu),"file_openpreset",G_CALLBACK(open_preset),ob);
634
g_signal_connect(G_OBJECT(ob->menu),"file_savepreset",G_CALLBACK(save_preset),ob);
635
g_signal_connect(G_OBJECT(ob->menu),"file_saveas",G_CALLBACK(save_as),ob);
636
g_signal_connect(G_OBJECT(ob->menu),"file_savedefault",G_CALLBACK(save_default),ob);
637
g_signal_connect(G_OBJECT(ob->menu),"file_exporttiff",G_CALLBACK(export_tiff),ob);
638
g_signal_connect(G_OBJECT(ob->menu),"file_printsetup",G_CALLBACK(print_setup),ob);
639
g_signal_connect(G_OBJECT(ob->menu),"file_print",G_CALLBACK(doprint),ob);
640
641
g_signal_connect(G_OBJECT(ob->menu),"edit_selectall",G_CALLBACK(edit_selectall),ob);
642
g_signal_connect(G_OBJECT(ob->menu),"edit_selectnone",G_CALLBACK(edit_selectnone),ob);
643
644
g_signal_connect(G_OBJECT(ob->menu),"image_addimage",G_CALLBACK(add_image),ob);
645
g_signal_connect(G_OBJECT(ob->menu),"image_clearlayout",G_CALLBACK(clearlayout),ob);
646
647
g_signal_connect(G_OBJECT(ob->menu),"layout_single",G_CALLBACK(layoutsingle),ob);
648
g_signal_connect(G_OBJECT(ob->menu),"layout_multiple",G_CALLBACK(layoutmultiple),ob);
649
g_signal_connect(G_OBJECT(ob->menu),"layout_carousel",G_CALLBACK(layoutcarousel),ob);
650
g_signal_connect(G_OBJECT(ob->menu),"layout_poster",G_CALLBACK(layoutposter),ob);
651
g_signal_connect(G_OBJECT(ob->menu),"layout_setbackground",G_CALLBACK(layout_setbackground),ob);
652
653
g_signal_connect(G_OBJECT(ob->menu),"image_remove",G_CALLBACK(image_remove),ob);
654
g_signal_connect(G_OBJECT(ob->menu),"image_allowcropping",G_CALLBACK(image_allowcropping),ob);
655
g_signal_connect(G_OBJECT(ob->menu),"image_rotation",G_CALLBACK(image_rotation),ob);
656
g_signal_connect(G_OBJECT(ob->menu),"image_setmask",G_CALLBACK(image_setmask),ob);
657
g_signal_connect(G_OBJECT(ob->menu),"image_setcolourprofile",G_CALLBACK(image_setcolourprofile),ob);
658
659
g_signal_connect(G_OBJECT(ob->menu),"options_paths",G_CALLBACK(do_paths),ob);
660
g_signal_connect(G_OBJECT(ob->menu),"options_colourmanagement",G_CALLBACK(colour_management),ob);
661
g_signal_connect(G_OBJECT(ob->menu),"options_units",G_CALLBACK(units),ob);
662
g_signal_connect(G_OBJECT(ob->menu),"options_scaling",G_CALLBACK(scaling),ob);
663
664
g_signal_connect(G_OBJECT(ob->menu),"help_about",G_CALLBACK(about),ob);
665
666
if((ob->layout=state->layout->CreateWidget()))
667
{
668
gtk_box_pack_start(GTK_BOX(ob->vbox),ob->layout,TRUE,TRUE,0);
669
gtk_widget_show(ob->layout);
670
g_signal_connect(G_OBJECT(ob->layout),"changed",G_CALLBACK(layout_changed),ob);
671
g_signal_connect(G_OBJECT(ob->layout),"popupmenu",G_CALLBACK(layout_popupmenu),ob);
672
g_signal_connect(G_OBJECT(ob->layout),"selection_changed",G_CALLBACK(layout_selection_changed),ob);
673
}
674
int caps=ob->state->layout->GetCapabilities();
675
pp_menu_set_layout_capabilities(PP_MENU(ob->menu),caps);
676
677
pp_mainwindow_refresh(ob);
678
679
return(GTK_WIDGET(ob));
680
}
681
682
683
GType
684
pp_mainwindow_get_type (void)
685
{
686
static GType stpuic_type = 0;
687
688
if (!stpuic_type)
689
{
690
static const GTypeInfo pp_mainwindow_info =
691
{
692
sizeof (pp_MainWindowClass),
693
NULL, /* base_init */
694
NULL, /* base_finalize */
695
(GClassInitFunc) pp_mainwindow_class_init,
696
NULL, /* class_finalize */
697
NULL, /* class_data */
698
sizeof (pp_MainWindow),
699
0,
700
(GInstanceInitFunc) pp_mainwindow_init,
701
};
702
stpuic_type = g_type_register_static (GTK_TYPE_WINDOW, "pp_MainWindow", &pp_mainwindow_info, (GTypeFlags)0);
703
}
704
return stpuic_type;
705
}
706
707
708
static void
709
pp_mainwindow_class_init (pp_MainWindowClass *klass)
710
{
711
pp_mainwindow_signals[CHANGED_SIGNAL] =
712
g_signal_new ("changed",
713
G_TYPE_FROM_CLASS (klass),
714
GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
715
G_STRUCT_OFFSET (pp_MainWindowClass, changed),
716
NULL, NULL,
717
g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
718
}
719
720
721
static void
722
pp_mainwindow_init (pp_MainWindow *ob)
723
{
724
ob->state=NULL;
725
ob->layout=NULL;
726
ob->prevfile=NULL;
727
}
255
pp_mainwindow_refresh(mw);
256
}
257
catch(const char *err)
258
{
259
ErrorMessage_Dialog(err);
260
}
261
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1