← Back to branch summary

~ubuntu-branches/ubuntu/karmic/photoprint/karmic

« back to all changes in this revision

Viewing changes to pp_layout_single.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Milan Zamazal
  • Date: 2007-05-01 16:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20070501163213-k0gaendx7grjlmk5
Tags: upstream-0.3.5
Import upstream version 0.3.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
pp_layout_single.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/gtkdialog.h>
8
 
#include <gtk/gtkscrolledwindow.h>
9
 
 
10
 
#include "stpui_widgets/stpui_combo.h"
11
 
#include "support/tiffsave.h"
12
 
#include "layout.h"
13
 
#include "dialogs.h"
14
 
#include "pp_pageextent.h"
15
 
#include "pp_layout_single_pageview.h"
16
 
#include "pp_layout_single.h"
17
 
 
18
 
enum {
19
 
        CHANGED_SIGNAL,
20
 
        POPUPMENU_SIGNAL,
21
 
        SELECTIONCHANGED_SIGNAL,
22
 
        LAST_SIGNAL
23
 
};
24
 
 
25
 
static guint pp_layout_single_signals[LAST_SIGNAL] = { 0 };
26
 
 
27
 
static void pp_layout_single_class_init (pp_Layout_SingleClass *klass);
28
 
static void pp_layout_single_init (pp_Layout_Single *stpuicombo);
29
 
 
30
 
 
31
 
static void reflow(GtkWidget *wid,gpointer *ob)
32
 
{
33
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
34
 
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(lo->pageview);
35
 
        Layout_Single *l=(Layout_Single*)lo->state->layout;
36
 
        l->Reflow();
37
 
        pp_layout_single_pageview_refresh(PP_LAYOUT_SINGLE_PAGEVIEW(pv));
38
 
 
39
 
        int pages=l->GetPages();
40
 
        gtk_widget_set_sensitive(lo->page,pages!=1);
41
 
        gtk_spin_button_set_range(GTK_SPIN_BUTTON(lo->page),1.0,pages);
42
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
43
 
}
44
 
 
45
 
 
46
 
static void pe_changed(GtkWidget *wid,gpointer *ob)
47
 
{
48
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
49
 
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(lo->pageview);
50
 
        pp_layout_single_pageview_refresh(pv);
51
 
        g_signal_emit(G_OBJECT (ob),pp_layout_single_signals[CHANGED_SIGNAL], 0);
52
 
}
53
 
 
54
 
 
55
 
static void hscale_changed(GtkWidget *wid,gpointer *ob)
56
 
{
57
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
58
 
 
59
 
        int hs=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lo->hscale));
60
 
        Layout_Single *l=(Layout_Single *)lo->state->layout;
61
 
        int page=l->GetCurrentPage();
62
 
        Layout_Single_ImageInfo *ii=l->ImageAt(page);
63
 
 
64
 
        if(ii)
65
 
        {
66
 
                if(hs>=10 && hs<=1000)
67
 
                        ii->hscale=hs;
68
 
        }
69
 
 
70
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
71
 
}
72
 
 
73
 
 
74
 
static void vscale_changed(GtkWidget *wid,gpointer *ob)
75
 
{
76
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
77
 
 
78
 
        int vs=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lo->vscale));
79
 
        Layout_Single *l=(Layout_Single *)lo->state->layout;
80
 
        int page=l->GetCurrentPage();
81
 
        Layout_Single_ImageInfo *ii=l->ImageAt(page);
82
 
 
83
 
        if(ii)
84
 
        {
85
 
                if(vs>=10 && vs<=1000)
86
 
                        ii->vscale=vs;  
87
 
        }
88
 
 
89
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
90
 
}
91
 
 
92
 
 
93
 
static void page_changed(GtkWidget *wid,gpointer *ob)
94
 
{
95
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
96
 
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(lo->pageview);
97
 
 
98
 
        pp_layout_single_pageview_set_page(pv,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lo->page))-1);
99
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
100
 
}
101
 
 
102
 
 
103
 
static void pageview_changed(GtkWidget *wid,gpointer *ob)
104
 
{
105
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
106
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
107
 
}
108
 
 
109
 
 
110
 
static void pageview_popupmenu(GtkWidget *wid,gpointer *ob)
111
 
{
112
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
113
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[POPUPMENU_SIGNAL], 0);
114
 
}
115
 
 
116
 
 
117
 
static void pageview_selectionchanged(GtkWidget *wid,gpointer *ob)
118
 
{
119
 
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
120
 
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[SELECTIONCHANGED_SIGNAL], 0);
121
 
}
122
 
 
123
 
 
124
 
void pp_layout_single_refresh(pp_Layout_Single *ob)
125
 
{
126
 
        ob->state->layout->LayoutToDB(ob->state->layoutdb);
127
 
 
128
 
        int pages=ob->state->layout->GetPages();
129
 
        int currentpage=ob->state->layout->GetCurrentPage();
130
 
 
131
 
        gtk_widget_set_sensitive(ob->page,pages!=1);
132
 
        if(pages>1)
133
 
        {
134
 
                gtk_spin_button_set_range(GTK_SPIN_BUTTON(ob->page),1.0,pages);
135
 
                gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->page),currentpage+1);
136
 
        }
137
 
 
138
 
        Layout_Single *l=(Layout_Single *)ob->state->layout;
139
 
        Layout_Single_ImageInfo *ii=l->ImageAt(currentpage);
140
 
        gtk_widget_set_sensitive(ob->hscale,ii!=0);
141
 
        gtk_widget_set_sensitive(ob->vscale,ii!=0);
142
 
        if(ii)
143
 
        {
144
 
                gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->hscale),ii->hscale);
145
 
                gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->vscale),ii->vscale);
146
 
        }
147
 
        
148
 
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(ob->pageview);
149
 
        if(pv)
150
 
                pp_layout_single_pageview_refresh(pv);
151
 
 
152
 
        pp_pageextent_refresh(PP_PAGEEXTENT(ob->pageextent));
153
 
}
154
 
 
155
 
 
156
 
void pp_layout_single_set_unit(GtkWidget *wid,enum Units unit)
157
 
{
158
 
        pp_Layout_Single *ob=PP_LAYOUT_SINGLE(wid);
159
 
        pp_pageextent_set_unit(PP_PAGEEXTENT(ob->pageextent),unit);
160
 
}
161
 
 
162
 
 
163
 
GtkWidget*
164
 
pp_layout_single_new (PhotoPrint_State *state)
165
 
{
166
 
        pp_Layout_Single *ob=PP_LAYOUT_SINGLE(g_object_new (pp_layout_single_get_type (), NULL));
167
 
 
168
 
        gtk_container_set_border_width(GTK_CONTAINER(&ob->hbox),10);
169
 
        
170
 
        ob->state=state;
171
 
        
172
 
        GtkWidget *vbox;
173
 
        GtkWidget *vbox2;
174
 
        GtkWidget *hbox;
175
 
        GtkWidget *label;
176
 
        GtkWidget *tmp;
177
 
 
178
 
        ob->sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
179
 
        
180
 
        GtkWidget *frame = gtk_frame_new (NULL);
181
 
        gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
182
 
        gtk_box_pack_start(GTK_BOX (&ob->hbox), frame,TRUE,TRUE,0);
183
 
        gtk_widget_show (frame); 
184
 
        
185
 
        ob->pageview = pp_layout_single_pageview_new ((Layout_Single *)ob->state->layout);
186
 
        g_signal_connect(G_OBJECT(ob->pageview),"changed",G_CALLBACK(pageview_changed),ob);
187
 
        g_signal_connect(G_OBJECT(ob->pageview),"reflow",G_CALLBACK(reflow),ob);
188
 
        g_signal_connect(G_OBJECT(ob->pageview),"popupmenu",G_CALLBACK(pageview_popupmenu),ob);
189
 
        g_signal_connect(G_OBJECT(ob->pageview),"selection_changed",G_CALLBACK(pageview_selectionchanged),ob);
190
 
 
191
 
        gtk_container_add (GTK_CONTAINER (frame), ob->pageview);
192
 
        gtk_widget_show (ob->pageview);
193
 
 
194
 
        GtkWidget *scrollwin=gtk_scrolled_window_new(NULL,NULL);
195
 
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
196
 
                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
197
 
        vbox = gtk_vbox_new (FALSE, 5);
198
 
        gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin), vbox);
199
 
        gtk_box_pack_start(GTK_BOX(&ob->hbox),scrollwin,FALSE,FALSE,0);
200
 
        gtk_widget_show (vbox);
201
 
        gtk_widget_show (scrollwin);
202
 
 
203
 
 
204
 
        // Scale
205
 
        
206
 
        frame=gtk_frame_new("Scale");
207
 
        gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,0);
208
 
        gtk_container_set_border_width(GTK_CONTAINER(frame),5);
209
 
        gtk_widget_show(frame);
210
 
 
211
 
        vbox2=gtk_vbox_new(FALSE,0);
212
 
        gtk_container_add(GTK_CONTAINER(frame),vbox2);
213
 
        gtk_widget_show(vbox2);
214
 
 
215
 
 
216
 
        //    HScale spin button
217
 
 
218
 
        hbox=gtk_hbox_new(FALSE,0);
219
 
        
220
 
        label=gtk_label_new("H: (%)");
221
 
        gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,5);
222
 
        gtk_widget_show(label);
223
 
 
224
 
        ob->hscale=gtk_spin_button_new_with_range(10.0,1000.0,1.0);
225
 
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->hscale),100);
226
 
        g_signal_connect(G_OBJECT(ob->hscale),"value-changed",G_CALLBACK(hscale_changed),ob);
227
 
        gtk_widget_show(ob->hscale);
228
 
 
229
 
        gtk_size_group_add_widget(GTK_SIZE_GROUP(ob->sizegroup),ob->hscale);
230
 
        gtk_box_pack_start(GTK_BOX(hbox),ob->hscale,FALSE,FALSE,5);
231
 
 
232
 
        gtk_box_pack_start(GTK_BOX(vbox2),hbox,FALSE,FALSE,5);
233
 
        gtk_widget_show(hbox);
234
 
 
235
 
        
236
 
        //    VScale spin button
237
 
 
238
 
        hbox=gtk_hbox_new(FALSE,0);
239
 
        
240
 
        label=gtk_label_new("V (%):");
241
 
        gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,5);
242
 
        gtk_widget_show(label);
243
 
 
244
 
        ob->vscale=gtk_spin_button_new_with_range(10.0,1000.0,1.0);
245
 
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->vscale),100);
246
 
        g_signal_connect(G_OBJECT(ob->vscale),"value-changed",G_CALLBACK(vscale_changed),ob);
247
 
        gtk_widget_show(ob->vscale);
248
 
 
249
 
        gtk_size_group_add_widget(GTK_SIZE_GROUP(ob->sizegroup),ob->vscale);
250
 
        gtk_box_pack_start(GTK_BOX(hbox),ob->vscale,FALSE,FALSE,5);
251
 
 
252
 
        gtk_box_pack_start(GTK_BOX(vbox2),hbox,FALSE,FALSE,5);
253
 
        gtk_widget_show(hbox);
254
 
 
255
 
        // PageExtent
256
 
 
257
 
        ob->pageextent=pp_pageextent_new((Layout_Single *)ob->state->layout,ob->state,ob->sizegroup);
258
 
        g_signal_connect(G_OBJECT(ob->pageextent),"changed",G_CALLBACK(pe_changed),ob);
259
 
        gtk_box_pack_start(GTK_BOX(vbox),ob->pageextent,FALSE,FALSE,0);
260
 
        gtk_widget_show(ob->pageextent);
261
 
 
262
 
 
263
 
        // Spacer box
264
 
 
265
 
        tmp=gtk_vbox_new(FALSE,0);
266
 
        gtk_box_pack_start(GTK_BOX(vbox),tmp,TRUE,TRUE,0);
267
 
        gtk_widget_show(tmp);
268
 
 
269
 
 
270
 
        // Page number
271
 
 
272
 
        hbox=gtk_hbox_new(FALSE,5);
273
 
        label=gtk_label_new("Page:");
274
 
        gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,0);
275
 
        gtk_widget_show(label);
276
 
 
277
 
        ob->page=gtk_spin_button_new_with_range(1.0,2.0,1.0);
278
 
        g_signal_connect(G_OBJECT(ob->page),"value-changed",G_CALLBACK(page_changed),ob);
279
 
        gtk_widget_show(ob->page);
280
 
 
281
 
        gtk_box_pack_start(GTK_BOX(hbox),ob->page,FALSE,FALSE,0);
282
 
 
283
 
 
284
 
        gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
285
 
        gtk_widget_show(hbox);
286
 
 
287
 
        g_object_unref(G_OBJECT(ob->sizegroup));
288
 
        ob->sizegroup=NULL;
289
 
 
290
 
        pp_layout_single_refresh(ob);
291
 
 
292
 
        return(GTK_WIDGET(ob));
293
 
}
294
 
 
295
 
 
296
 
GType
297
 
pp_layout_single_get_type (void)
298
 
{
299
 
        static GType stpuic_type = 0;
300
 
 
301
 
        if (!stpuic_type)
302
 
        {
303
 
                static const GTypeInfo pp_layout_single_info =
304
 
                {
305
 
                        sizeof (pp_Layout_SingleClass),
306
 
                        NULL, /* base_init */
307
 
                        NULL, /* base_finalize */
308
 
                        (GClassInitFunc) pp_layout_single_class_init,
309
 
                        NULL, /* class_finalize */
310
 
                        NULL, /* class_data */
311
 
                        sizeof (pp_Layout_Single),
312
 
                        0,
313
 
                        (GInstanceInitFunc) pp_layout_single_init,
314
 
                };
315
 
                stpuic_type = g_type_register_static (GTK_TYPE_HBOX, "pp_Layout_Single", &pp_layout_single_info, (GTypeFlags)0);
316
 
        }
317
 
        return stpuic_type;
318
 
}
319
 
 
320
 
 
321
 
static void
322
 
pp_layout_single_class_init (pp_Layout_SingleClass *klass)
323
 
{
324
 
        pp_layout_single_signals[CHANGED_SIGNAL] =
325
 
        g_signal_new ("changed",
326
 
                G_TYPE_FROM_CLASS (klass),
327
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
328
 
                G_STRUCT_OFFSET (pp_Layout_SingleClass, changed),
329
 
                NULL, NULL,
330
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
331
 
        pp_layout_single_signals[POPUPMENU_SIGNAL] =
332
 
        g_signal_new ("popupmenu",
333
 
                G_TYPE_FROM_CLASS (klass),
334
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
335
 
                G_STRUCT_OFFSET (pp_Layout_SingleClass, popupmenu),
336
 
                NULL, NULL,
337
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
338
 
        pp_layout_single_signals[SELECTIONCHANGED_SIGNAL] =
339
 
        g_signal_new ("selection_changed",
340
 
                G_TYPE_FROM_CLASS (klass),
341
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
342
 
                G_STRUCT_OFFSET (pp_Layout_SingleClass, selection_changed),
343
 
                NULL, NULL,
344
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
345
 
}
346
 
 
347
 
 
348
 
static void
349
 
pp_layout_single_init (pp_Layout_Single *ob)
350
 
{
351
 
        ob->state=NULL;
352
 
        ob->pageview=NULL;
353
 
}
 
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/gtkdialog.h>
 
8
#include <gtk/gtkscrolledwindow.h>
 
9
 
 
10
#include "stpui_widgets/stpui_combo.h"
 
11
#include "support/tiffsave.h"
 
12
#include "layout.h"
 
13
#include "dialogs.h"
 
14
#include "pp_pageextent.h"
 
15
#include "pp_layout_single_pageview.h"
 
16
#include "pp_layout_single.h"
 
17
 
 
18
#include "config.h"
 
19
#include "gettext.h"
 
20
#define _(x) gettext(x)
 
21
 
 
22
enum {
 
23
        CHANGED_SIGNAL,
 
24
        POPUPMENU_SIGNAL,
 
25
        SELECTIONCHANGED_SIGNAL,
 
26
        LAST_SIGNAL
 
27
};
 
28
 
 
29
static guint pp_layout_single_signals[LAST_SIGNAL] = { 0 };
 
30
 
 
31
static void pp_layout_single_class_init (pp_Layout_SingleClass *klass);
 
32
static void pp_layout_single_init (pp_Layout_Single *stpuicombo);
 
33
 
 
34
 
 
35
static void reflow(GtkWidget *wid,gpointer *ob)
 
36
{
 
37
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
38
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(lo->pageview);
 
39
        Layout_Single *l=(Layout_Single*)lo->state->layout;
 
40
        l->Reflow();
 
41
        pp_layout_single_pageview_refresh(PP_LAYOUT_SINGLE_PAGEVIEW(pv));
 
42
 
 
43
        int pages=l->GetPages();
 
44
        gtk_widget_set_sensitive(lo->page,pages!=1);
 
45
        gtk_spin_button_set_range(GTK_SPIN_BUTTON(lo->page),1.0,pages);
 
46
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
 
47
}
 
48
 
 
49
 
 
50
static void pe_changed(GtkWidget *wid,gpointer *ob)
 
51
{
 
52
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
53
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(lo->pageview);
 
54
        pp_layout_single_pageview_refresh(pv);
 
55
        g_signal_emit(G_OBJECT (ob),pp_layout_single_signals[CHANGED_SIGNAL], 0);
 
56
}
 
57
 
 
58
 
 
59
static void hscale_changed(GtkWidget *wid,gpointer *ob)
 
60
{
 
61
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
62
 
 
63
        int hs=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lo->hscale));
 
64
        Layout_Single *l=(Layout_Single *)lo->state->layout;
 
65
        int page=l->GetCurrentPage();
 
66
        Layout_Single_ImageInfo *ii=l->ImageAt(page);
 
67
 
 
68
        if(ii)
 
69
        {
 
70
                if(hs>=10 && hs<=1000)
 
71
                        ii->hscale=hs;
 
72
        }
 
73
 
 
74
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
 
75
}
 
76
 
 
77
 
 
78
static void vscale_changed(GtkWidget *wid,gpointer *ob)
 
79
{
 
80
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
81
 
 
82
        int vs=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lo->vscale));
 
83
        Layout_Single *l=(Layout_Single *)lo->state->layout;
 
84
        int page=l->GetCurrentPage();
 
85
        Layout_Single_ImageInfo *ii=l->ImageAt(page);
 
86
 
 
87
        if(ii)
 
88
        {
 
89
                if(vs>=10 && vs<=1000)
 
90
                        ii->vscale=vs;  
 
91
        }
 
92
 
 
93
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
 
94
}
 
95
 
 
96
 
 
97
static void page_changed(GtkWidget *wid,gpointer *ob)
 
98
{
 
99
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
100
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(lo->pageview);
 
101
 
 
102
        pp_layout_single_pageview_set_page(pv,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(lo->page))-1);
 
103
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
 
104
}
 
105
 
 
106
 
 
107
static void pageview_changed(GtkWidget *wid,gpointer *ob)
 
108
{
 
109
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
110
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[CHANGED_SIGNAL], 0);
 
111
}
 
112
 
 
113
 
 
114
static void pageview_popupmenu(GtkWidget *wid,gpointer *ob)
 
115
{
 
116
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
117
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[POPUPMENU_SIGNAL], 0);
 
118
}
 
119
 
 
120
 
 
121
static void pageview_selectionchanged(GtkWidget *wid,gpointer *ob)
 
122
{
 
123
        pp_Layout_Single *lo=(pp_Layout_Single *)ob;
 
124
        g_signal_emit(G_OBJECT (lo),pp_layout_single_signals[SELECTIONCHANGED_SIGNAL], 0);
 
125
}
 
126
 
 
127
 
 
128
void pp_layout_single_refresh(pp_Layout_Single *ob)
 
129
{
 
130
        ob->state->layout->LayoutToDB(ob->state->layoutdb);
 
131
 
 
132
        int pages=ob->state->layout->GetPages();
 
133
        int currentpage=ob->state->layout->GetCurrentPage();
 
134
 
 
135
        gtk_widget_set_sensitive(ob->page,pages!=1);
 
136
        if(pages>1)
 
137
        {
 
138
                gtk_spin_button_set_range(GTK_SPIN_BUTTON(ob->page),1.0,pages);
 
139
                gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->page),currentpage+1);
 
140
        }
 
141
 
 
142
        Layout_Single *l=(Layout_Single *)ob->state->layout;
 
143
        Layout_Single_ImageInfo *ii=l->ImageAt(currentpage);
 
144
        gtk_widget_set_sensitive(ob->hscale,ii!=0);
 
145
        gtk_widget_set_sensitive(ob->vscale,ii!=0);
 
146
        if(ii)
 
147
        {
 
148
                gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->hscale),ii->hscale);
 
149
                gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->vscale),ii->vscale);
 
150
        }
 
151
        
 
152
        pp_Layout_Single_PageView *pv=PP_LAYOUT_SINGLE_PAGEVIEW(ob->pageview);
 
153
        if(pv)
 
154
                pp_layout_single_pageview_refresh(pv);
 
155
 
 
156
        pp_pageextent_refresh(PP_PAGEEXTENT(ob->pageextent));
 
157
}
 
158
 
 
159
 
 
160
void pp_layout_single_set_unit(GtkWidget *wid,enum Units unit)
 
161
{
 
162
        pp_Layout_Single *ob=PP_LAYOUT_SINGLE(wid);
 
163
        pp_pageextent_set_unit(PP_PAGEEXTENT(ob->pageextent),unit);
 
164
}
 
165
 
 
166
 
 
167
GtkWidget*
 
168
pp_layout_single_new (PhotoPrint_State *state)
 
169
{
 
170
        pp_Layout_Single *ob=PP_LAYOUT_SINGLE(g_object_new (pp_layout_single_get_type (), NULL));
 
171
 
 
172
        gtk_container_set_border_width(GTK_CONTAINER(&ob->hbox),10);
 
173
        
 
174
        ob->state=state;
 
175
        
 
176
        GtkWidget *vbox;
 
177
        GtkWidget *vbox2;
 
178
        GtkWidget *hbox;
 
179
        GtkWidget *label;
 
180
        GtkWidget *tmp;
 
181
 
 
182
        ob->sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
183
        
 
184
        GtkWidget *frame = gtk_frame_new (NULL);
 
185
        gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
 
186
        gtk_box_pack_start(GTK_BOX (&ob->hbox), frame,TRUE,TRUE,0);
 
187
        gtk_widget_show (frame); 
 
188
        
 
189
        ob->pageview = pp_layout_single_pageview_new ((Layout_Single *)ob->state->layout);
 
190
        g_signal_connect(G_OBJECT(ob->pageview),"changed",G_CALLBACK(pageview_changed),ob);
 
191
        g_signal_connect(G_OBJECT(ob->pageview),"reflow",G_CALLBACK(reflow),ob);
 
192
        g_signal_connect(G_OBJECT(ob->pageview),"popupmenu",G_CALLBACK(pageview_popupmenu),ob);
 
193
        g_signal_connect(G_OBJECT(ob->pageview),"selection_changed",G_CALLBACK(pageview_selectionchanged),ob);
 
194
 
 
195
        gtk_container_add (GTK_CONTAINER (frame), ob->pageview);
 
196
        gtk_widget_show (ob->pageview);
 
197
 
 
198
        GtkWidget *scrollwin=gtk_scrolled_window_new(NULL,NULL);
 
199
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
 
200
                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 
201
        vbox = gtk_vbox_new (FALSE, 5);
 
202
        gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrollwin), vbox);
 
203
        gtk_box_pack_start(GTK_BOX(&ob->hbox),scrollwin,FALSE,FALSE,0);
 
204
        gtk_widget_show (vbox);
 
205
        gtk_widget_show (scrollwin);
 
206
 
 
207
 
 
208
        // Scale
 
209
        
 
210
        frame=gtk_frame_new(_("Scale"));
 
211
        gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,0);
 
212
        gtk_container_set_border_width(GTK_CONTAINER(frame),5);
 
213
        gtk_widget_show(frame);
 
214
 
 
215
        vbox2=gtk_vbox_new(FALSE,0);
 
216
        gtk_container_add(GTK_CONTAINER(frame),vbox2);
 
217
        gtk_widget_show(vbox2);
 
218
 
 
219
 
 
220
        //    HScale spin button
 
221
 
 
222
        hbox=gtk_hbox_new(FALSE,0);
 
223
        
 
224
        label=gtk_label_new(_("H (%):"));
 
225
        gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,5);
 
226
        gtk_widget_show(label);
 
227
 
 
228
        ob->hscale=gtk_spin_button_new_with_range(10.0,1000.0,1.0);
 
229
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->hscale),100);
 
230
        g_signal_connect(G_OBJECT(ob->hscale),"value-changed",G_CALLBACK(hscale_changed),ob);
 
231
        gtk_widget_show(ob->hscale);
 
232
 
 
233
        gtk_size_group_add_widget(GTK_SIZE_GROUP(ob->sizegroup),ob->hscale);
 
234
        gtk_box_pack_start(GTK_BOX(hbox),ob->hscale,FALSE,FALSE,5);
 
235
 
 
236
        gtk_box_pack_start(GTK_BOX(vbox2),hbox,FALSE,FALSE,5);
 
237
        gtk_widget_show(hbox);
 
238
 
 
239
        
 
240
        //    VScale spin button
 
241
 
 
242
        hbox=gtk_hbox_new(FALSE,0);
 
243
        
 
244
        label=gtk_label_new(_("V (%):"));
 
245
        gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,5);
 
246
        gtk_widget_show(label);
 
247
 
 
248
        ob->vscale=gtk_spin_button_new_with_range(10.0,1000.0,1.0);
 
249
        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ob->vscale),100);
 
250
        g_signal_connect(G_OBJECT(ob->vscale),"value-changed",G_CALLBACK(vscale_changed),ob);
 
251
        gtk_widget_show(ob->vscale);
 
252
 
 
253
        gtk_size_group_add_widget(GTK_SIZE_GROUP(ob->sizegroup),ob->vscale);
 
254
        gtk_box_pack_start(GTK_BOX(hbox),ob->vscale,FALSE,FALSE,5);
 
255
 
 
256
        gtk_box_pack_start(GTK_BOX(vbox2),hbox,FALSE,FALSE,5);
 
257
        gtk_widget_show(hbox);
 
258
 
 
259
        // PageExtent
 
260
 
 
261
        ob->pageextent=pp_pageextent_new((Layout_Single *)ob->state->layout,ob->state,ob->sizegroup);
 
262
        g_signal_connect(G_OBJECT(ob->pageextent),"changed",G_CALLBACK(pe_changed),ob);
 
263
        gtk_box_pack_start(GTK_BOX(vbox),ob->pageextent,FALSE,FALSE,0);
 
264
        gtk_widget_show(ob->pageextent);
 
265
 
 
266
 
 
267
        // Spacer box
 
268
 
 
269
        tmp=gtk_vbox_new(FALSE,0);
 
270
        gtk_box_pack_start(GTK_BOX(vbox),tmp,TRUE,TRUE,0);
 
271
        gtk_widget_show(tmp);
 
272
 
 
273
 
 
274
        // Page number
 
275
 
 
276
        hbox=gtk_hbox_new(FALSE,5);
 
277
        label=gtk_label_new(_("Page:"));
 
278
        gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,0);
 
279
        gtk_widget_show(label);
 
280
 
 
281
        ob->page=gtk_spin_button_new_with_range(1.0,2.0,1.0);
 
282
        g_signal_connect(G_OBJECT(ob->page),"value-changed",G_CALLBACK(page_changed),ob);
 
283
        gtk_widget_show(ob->page);
 
284
 
 
285
        gtk_box_pack_start(GTK_BOX(hbox),ob->page,FALSE,FALSE,0);
 
286
 
 
287
 
 
288
        gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
 
289
        gtk_widget_show(hbox);
 
290
 
 
291
        g_object_unref(G_OBJECT(ob->sizegroup));
 
292
        ob->sizegroup=NULL;
 
293
 
 
294
        pp_layout_single_refresh(ob);
 
295
 
 
296
        return(GTK_WIDGET(ob));
 
297
}
 
298
 
 
299
 
 
300
GType
 
301
pp_layout_single_get_type (void)
 
302
{
 
303
        static GType stpuic_type = 0;
 
304
 
 
305
        if (!stpuic_type)
 
306
        {
 
307
                static const GTypeInfo pp_layout_single_info =
 
308
                {
 
309
                        sizeof (pp_Layout_SingleClass),
 
310
                        NULL, /* base_init */
 
311
                        NULL, /* base_finalize */
 
312
                        (GClassInitFunc) pp_layout_single_class_init,
 
313
                        NULL, /* class_finalize */
 
314
                        NULL, /* class_data */
 
315
                        sizeof (pp_Layout_Single),
 
316
                        0,
 
317
                        (GInstanceInitFunc) pp_layout_single_init,
 
318
                };
 
319
                stpuic_type = g_type_register_static (GTK_TYPE_HBOX, "pp_Layout_Single", &pp_layout_single_info, (GTypeFlags)0);
 
320
        }
 
321
        return stpuic_type;
 
322
}
 
323
 
 
324
 
 
325
static void
 
326
pp_layout_single_class_init (pp_Layout_SingleClass *klass)
 
327
{
 
328
        pp_layout_single_signals[CHANGED_SIGNAL] =
 
329
        g_signal_new ("changed",
 
330
                G_TYPE_FROM_CLASS (klass),
 
331
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
332
                G_STRUCT_OFFSET (pp_Layout_SingleClass, changed),
 
333
                NULL, NULL,
 
334
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
335
        pp_layout_single_signals[POPUPMENU_SIGNAL] =
 
336
        g_signal_new ("popupmenu",
 
337
                G_TYPE_FROM_CLASS (klass),
 
338
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
339
                G_STRUCT_OFFSET (pp_Layout_SingleClass, popupmenu),
 
340
                NULL, NULL,
 
341
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
342
        pp_layout_single_signals[SELECTIONCHANGED_SIGNAL] =
 
343
        g_signal_new ("selection_changed",
 
344
                G_TYPE_FROM_CLASS (klass),
 
345
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
346
                G_STRUCT_OFFSET (pp_Layout_SingleClass, selection_changed),
 
347
                NULL, NULL,
 
348
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
349
}
 
350
 
 
351
 
 
352
static void
 
353
pp_layout_single_init (pp_Layout_Single *ob)
 
354
{
 
355
        ob->state=NULL;
 
356
        ob->pageview=NULL;
 
357
}