← Back to branch summary

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

« back to all changes in this revision

Viewing changes to pp_layout_carousel_pageview.cpp

  • 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.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pp_layout_carousel_pageview.cpp
1
 
 
2
 
#include <math.h>
3
 
#include <stdio.h>
4
 
#include <gtk/gtkmain.h>
5
 
#include <gtk/gtksignal.h>
6
 
#include <gtk/gtkdnd.h>
7
 
#include <gtk/gtkmenu.h>
8
 
 
9
 
#include "support/layoutrectangle.h"
10
 
#include "stpui_widgets/stpui_combo.h"
11
 
#include "support/progressbar.h"
12
 
 
13
 
#include "pp_layout_carousel_pageview.h"
14
 
 
15
 
#define PAGEVIEW_DEFAULT_WIDTH 250
16
 
#define PAGEVIEW_DEFAULT_HEIGHT 320
17
 
 
18
 
 
19
 
enum {
20
 
        CHANGED_SIGNAL,
21
 
        REFLOW_SIGNAL,
22
 
        SELECTIONCHANGED_SIGNAL,
23
 
        POPUPMENU_SIGNAL,
24
 
        LAST_SIGNAL
25
 
};
26
 
 
27
 
static guint pp_layout_carousel_pageview_signals[LAST_SIGNAL] = { 0 };
28
 
 
29
 
static void pp_layout_carousel_pageview_class_init               (pp_Layout_Carousel_PageViewClass     *klass);
30
 
static void pp_layout_carousel_pageview_init                     (pp_Layout_Carousel_PageView          *pageview);
31
 
static void pp_layout_carousel_pageview_realize                  (GtkWidget        *widget);
32
 
static void pp_layout_carousel_pageview_size_request             (GtkWidget        *widget,
33
 
                                               GtkRequisition   *requisition);
34
 
static void pp_layout_carousel_pageview_size_allocate            (GtkWidget        *widget,
35
 
                                               GtkAllocation    *allocation);
36
 
static gboolean pp_layout_carousel_pageview_expose               (GtkWidget        *widget,
37
 
                                               GdkEventExpose   *event);
38
 
static gboolean pp_layout_carousel_pageview_button_press         (GtkWidget        *widget,
39
 
                                               GdkEventButton   *event);
40
 
static gboolean pp_layout_carousel_pageview_button_release       (GtkWidget        *widget,
41
 
                                               GdkEventButton   *event);
42
 
static gboolean pp_layout_carousel_pageview_motion_notify        (GtkWidget        *widget,
43
 
                                               GdkEventMotion   *event);
44
 
 
45
 
 
46
 
#define TARGET_URI_LIST 1
47
 
 
48
 
 
49
 
static GtkTargetEntry dnd_file_drop_types[] = {
50
 
        { "text/uri-list", 0, TARGET_URI_LIST }
51
 
};
52
 
static gint dnd_file_drop_types_count = 1;
53
 
 
54
 
static void get_dnd_data(GtkWidget *widget, GdkDragContext *context,
55
 
                                     gint x, gint y,
56
 
                                     GtkSelectionData *selection_data, guint info,
57
 
                                     guint time, gpointer data)
58
 
{
59
 
        gchar *urilist=g_strdup((const gchar *)selection_data->data);
60
 
        int lastpage=0;
61
 
        pp_Layout_Carousel_PageView *pv=PP_LAYOUT_CAROUSEL_PAGEVIEW(widget);
62
 
        ProgressBar progress("Adding images...",false);
63
 
        while(*urilist)
64
 
        {
65
 
                if(strncmp(urilist,"file:",5))
66
 
                {
67
 
                        g_print("Warning: only local files (file://) are currently supported\n");
68
 
                        while(*urilist && *urilist!='\n' && *urilist!='\r')
69
 
                                ++urilist;
70
 
                        while(*urilist=='\n' || *urilist=='\r')
71
 
                                *urilist++;
72
 
                }
73
 
                else
74
 
                {
75
 
                        gchar *uri=urilist;
76
 
                        while(*urilist && *urilist!='\n' && *urilist!='\r')
77
 
                                ++urilist;
78
 
                        if(*urilist)
79
 
                        {
80
 
                                while(*urilist=='\n' || *urilist=='\r')
81
 
                                        *urilist++=0;
82
 
                                gchar *filename=g_filename_from_uri(uri,NULL,NULL);
83
 
                                lastpage=pv->layout->AddImage(filename);
84
 
                                pp_layout_carousel_pageview_refresh(pv);
85
 
                                g_signal_emit_by_name (GTK_OBJECT (pv), "changed");
86
 
                                progress.DoProgress(0,0);
87
 
                        }
88
 
                }
89
 
        }
90
 
        pp_layout_carousel_pageview_set_page(pv,lastpage);
91
 
        g_signal_emit_by_name (GTK_OBJECT (pv), "changed");
92
 
}
93
 
 
94
 
 
95
 
/* Local data */
96
 
 
97
 
static GtkWidgetClass *parent_class = NULL;
98
 
 
99
 
GType
100
 
pp_layout_carousel_pageview_get_type ()
101
 
{
102
 
  static GType pageview_type = 0;
103
 
 
104
 
  if (!pageview_type)
105
 
    {
106
 
      static const GTypeInfo pageview_info =
107
 
      {
108
 
        sizeof (pp_Layout_Carousel_PageViewClass),
109
 
        NULL,
110
 
        NULL,
111
 
        (GClassInitFunc) pp_layout_carousel_pageview_class_init,
112
 
        NULL,
113
 
        NULL,
114
 
        sizeof (pp_Layout_Carousel_PageView),
115
 
        0,
116
 
        (GInstanceInitFunc) pp_layout_carousel_pageview_init,
117
 
      };
118
 
 
119
 
      pageview_type = g_type_register_static (GTK_TYPE_WIDGET, "pp_Layout_Carousel_PageView", &pageview_info, GTypeFlags(0));
120
 
    }
121
 
 
122
 
  return pageview_type;
123
 
}
124
 
 
125
 
 
126
 
static void
127
 
pp_layout_carousel_pageview_class_init (pp_Layout_Carousel_PageViewClass *cl)
128
 
{
129
 
        GtkObjectClass *object_class;
130
 
        GtkWidgetClass *widget_class;
131
 
        
132
 
        object_class = (GtkObjectClass*) cl;
133
 
        widget_class = (GtkWidgetClass*) cl;
134
 
        
135
 
        parent_class = GTK_WIDGET_CLASS(gtk_type_class (gtk_widget_get_type ()));
136
 
        
137
 
        widget_class->realize = pp_layout_carousel_pageview_realize;
138
 
        widget_class->expose_event = pp_layout_carousel_pageview_expose;
139
 
        widget_class->size_request = pp_layout_carousel_pageview_size_request;
140
 
        widget_class->size_allocate = pp_layout_carousel_pageview_size_allocate;
141
 
        widget_class->button_press_event = pp_layout_carousel_pageview_button_press;
142
 
        widget_class->button_release_event = pp_layout_carousel_pageview_button_release;
143
 
        widget_class->motion_notify_event = pp_layout_carousel_pageview_motion_notify;
144
 
 
145
 
        pp_layout_carousel_pageview_signals[CHANGED_SIGNAL] =
146
 
        g_signal_new ("changed",
147
 
                G_TYPE_FROM_CLASS (cl),
148
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
149
 
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, changed),
150
 
                NULL, NULL,
151
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
152
 
        pp_layout_carousel_pageview_signals[REFLOW_SIGNAL] =
153
 
        g_signal_new ("reflow",
154
 
                G_TYPE_FROM_CLASS (cl),
155
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
156
 
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, reflow),
157
 
                NULL, NULL,
158
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
159
 
        pp_layout_carousel_pageview_signals[SELECTIONCHANGED_SIGNAL] =
160
 
        g_signal_new ("selection_changed",
161
 
                G_TYPE_FROM_CLASS (cl),
162
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
163
 
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, selection_changed),
164
 
                NULL, NULL,
165
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
166
 
        pp_layout_carousel_pageview_signals[REFLOW_SIGNAL] =
167
 
        g_signal_new ("popupmenu",
168
 
                G_TYPE_FROM_CLASS (cl),
169
 
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
170
 
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, popupmenu),
171
 
                NULL, NULL,
172
 
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
173
 
}
174
 
 
175
 
 
176
 
static void
177
 
pp_layout_carousel_pageview_init (pp_Layout_Carousel_PageView *pageview)
178
 
{
179
 
        pageview->button = 0;
180
 
        pageview->timer = 0;
181
 
        pageview->selected=NULL;
182
 
}
183
 
 
184
 
 
185
 
GtkWidget*
186
 
pp_layout_carousel_pageview_new (Layout_Carousel *layout)
187
 
{
188
 
        pp_Layout_Carousel_PageView *pageview;
189
 
 
190
 
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW(g_object_new (pp_layout_carousel_pageview_get_type (), NULL));
191
 
 
192
 
        gtk_drag_dest_set(GTK_WIDGET(pageview),
193
 
                          GtkDestDefaults(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP),
194
 
                          dnd_file_drop_types, dnd_file_drop_types_count,
195
 
                          GdkDragAction(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
196
 
        g_signal_connect(G_OBJECT(pageview), "drag_data_received",
197
 
                         G_CALLBACK(get_dnd_data), NULL);
198
 
 
199
 
        pageview->layout=layout;
200
 
 
201
 
        return GTK_WIDGET (pageview);
202
 
}
203
 
 
204
 
 
205
 
static void
206
 
pp_layout_carousel_pageview_realize (GtkWidget *widget)
207
 
{
208
 
  pp_Layout_Carousel_PageView *pageview;
209
 
  GdkWindowAttr attributes;
210
 
  gint attributes_mask;
211
 
 
212
 
  g_return_if_fail (widget != NULL);
213
 
  g_return_if_fail (PP_IS_PAGEVIEW (widget));
214
 
 
215
 
  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
216
 
  pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
217
 
 
218
 
  attributes.x = widget->allocation.x;
219
 
  attributes.y = widget->allocation.y;
220
 
  attributes.width = widget->allocation.width;
221
 
  attributes.height = widget->allocation.height;
222
 
  attributes.wclass = GDK_INPUT_OUTPUT;
223
 
  attributes.window_type = GDK_WINDOW_CHILD;
224
 
  attributes.event_mask = gtk_widget_get_events (widget) | 
225
 
    GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | 
226
 
    GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
227
 
    GDK_POINTER_MOTION_HINT_MASK;
228
 
  attributes.visual = gtk_widget_get_visual (widget);
229
 
  attributes.colormap = gtk_widget_get_colormap (widget);
230
 
 
231
 
  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
232
 
  widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
233
 
 
234
 
  widget->style = gtk_style_attach (widget->style, widget->window);
235
 
 
236
 
  gdk_window_set_user_data (widget->window, widget);
237
 
 
238
 
  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
239
 
}
240
 
 
241
 
 
242
 
static void 
243
 
pp_layout_carousel_pageview_size_request (GtkWidget      *widget,
244
 
                       GtkRequisition *requisition)
245
 
{
246
 
  requisition->width = PAGEVIEW_DEFAULT_WIDTH;
247
 
  requisition->height = PAGEVIEW_DEFAULT_HEIGHT;
248
 
}
249
 
 
250
 
 
251
 
static void
252
 
pp_layout_carousel_pageview_size_allocate (GtkWidget     *widget,
253
 
                        GtkAllocation *allocation)
254
 
{
255
 
  pp_Layout_Carousel_PageView *pageview;
256
 
 
257
 
  g_return_if_fail (widget != NULL);
258
 
  g_return_if_fail (PP_IS_PAGEVIEW (widget));
259
 
  g_return_if_fail (allocation != NULL);
260
 
 
261
 
  widget->allocation = *allocation;
262
 
  pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
263
 
 
264
 
  if (GTK_WIDGET_REALIZED (widget))
265
 
    {
266
 
 
267
 
      gdk_window_move_resize (widget->window,
268
 
                              allocation->x, allocation->y,
269
 
                              allocation->width, allocation->height);
270
 
 
271
 
    }
272
 
}
273
 
 
274
 
 
275
 
static gboolean
276
 
pp_layout_carousel_pageview_expose( GtkWidget      *widget,
277
 
                 GdkEventExpose *event )
278
 
{
279
 
        pp_Layout_Carousel_PageView *pageview;
280
 
 
281
 
        g_return_val_if_fail (widget != NULL, FALSE);
282
 
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
283
 
        g_return_val_if_fail (event != NULL, FALSE);
284
 
 
285
 
        if (event->count > 0)
286
 
                return FALSE;
287
 
  
288
 
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
289
 
 
290
 
                
291
 
        pageview->height=widget->allocation.height;
292
 
        pageview->width=(pageview->layout->pagewidth*pageview->height)/pageview->layout->pageheight;
293
 
        if(pageview->width>widget->allocation.width)
294
 
        {
295
 
                pageview->width=widget->allocation.width;
296
 
                pageview->height=(pageview->layout->pageheight*pageview->width)/pageview->layout->pagewidth;    
297
 
        }
298
 
        pageview->top=(widget->allocation.height-pageview->height)/2;
299
 
        pageview->left=(widget->allocation.width-pageview->width)/2;
300
 
 
301
 
        gdk_draw_rectangle (widget->window,
302
 
                widget->style->light_gc[widget->state],TRUE,
303
 
                pageview->left,pageview->top,
304
 
                pageview->width,pageview->height);
305
 
 
306
 
        pageview->scale=pageview->width;
307
 
        pageview->scale/=pageview->layout->pagewidth;
308
 
 
309
 
        pageview->layout->GetImageableArea();
310
 
 
311
 
        LayoutRectangle sr(pageview->layout->leftmargin,pageview->layout->topmargin,
312
 
                pageview->layout->imageablewidth,pageview->layout->imageableheight);
313
 
        sr.Scale(pageview->scale);
314
 
 
315
 
        pageview->layout->DrawPreview(widget,pageview->left+sr.x,pageview->top+sr.y,sr.w,sr.h);
316
 
 
317
 
        gdk_draw_rectangle (widget->window,
318
 
                widget->style->mid_gc[widget->state],FALSE,
319
 
                pageview->left+sr.x,pageview->top+sr.y,sr.w,sr.h);
320
 
 
321
 
        Layout_ImageInfo *ii=pageview->layout->FirstSelected();
322
 
        while(ii)
323
 
        {
324
 
                if(ii->page==pageview->layout->GetCurrentPage())
325
 
                {
326
 
                        LayoutRectangle *s=ii->GetBounds();
327
 
                        s->Scale(pageview->scale);
328
 
 
329
 
                        gdk_draw_rectangle (widget->window,
330
 
                                widget->style->dark_gc[widget->state],FALSE,
331
 
                                pageview->left+s->x,pageview->top+s->y,s->w,s->h);
332
 
                        gdk_draw_rectangle (widget->window,
333
 
                                widget->style->dark_gc[widget->state],FALSE,
334
 
                                pageview->left+s->x-1,pageview->top+s->y-1,s->w+2,s->h+2);
335
 
                        delete s;
336
 
                }
337
 
                ii=pageview->layout->NextSelected();
338
 
        }
339
 
 
340
 
 
341
 
        return FALSE;
342
 
}
343
 
 
344
 
 
345
 
static gboolean
346
 
pp_layout_carousel_pageview_button_press( GtkWidget      *widget,
347
 
                       GdkEventButton *event )
348
 
{
349
 
        pp_Layout_Carousel_PageView *pageview;
350
 
        
351
 
        g_return_val_if_fail (widget != NULL, FALSE);
352
 
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
353
 
        g_return_val_if_fail (event != NULL, FALSE);
354
 
        
355
 
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
356
 
        
357
 
        int x=int(event->x-pageview->left);
358
 
        int y=int(event->y-pageview->top);
359
 
        bool shift=(event->state&GDK_SHIFT_MASK)!=0;
360
 
        bool ctrl=(event->state&GDK_CONTROL_MASK)!=0;
361
 
 
362
 
        if(x>0 && y>0 && x<pageview->width && y<pageview->height && pageview->scale>0.0)
363
 
        {
364
 
                double sx=x/pageview->scale;
365
 
                double sy=y/pageview->scale;
366
 
                Layout_ImageInfo *prevselected=pageview->selected;
367
 
                pageview->selected=pageview->layout->ImageAtCoord(int(sx),int(sy));
368
 
                switch(event->button)
369
 
                {
370
 
                        case 1:
371
 
                                if(!(shift||ctrl))
372
 
                                {
373
 
                                                if(pageview->selected && pageview->selected->allowcropping)
374
 
                                                {
375
 
                                                        pageview->dragging=true;
376
 
                                                        pageview->init_x=x;
377
 
                                                        pageview->init_y=y;
378
 
                                                        pageview->init_hpan=pageview->selected->crop_hpan;
379
 
                                                        pageview->init_vpan=pageview->selected->crop_vpan;
380
 
                                                        gtk_grab_add(widget);
381
 
                                                        cerr << "Commencing drag..." << endl;
382
 
                                                }
383
 
                                                else
384
 
                                                        pageview->dragging=false;
385
 
                                                pageview->layout->SelectNone();
386
 
                                }
387
 
                                if(pageview->selected)
388
 
                                {
389
 
                                        if(ctrl)
390
 
                                                pageview->selected->ToggleSelected();
391
 
                                        else if(shift)
392
 
                                        {
393
 
                                                if(prevselected)
394
 
                                                {
395
 
                                                        Layout_ImageInfo *ii=pageview->layout->FirstImage();
396
 
                                                        bool selecting=false;
397
 
                                                        while(ii)
398
 
                                                        {
399
 
                                                                if((ii==prevselected) || (ii==pageview->selected))
400
 
                                                                {
401
 
                                                                        if(selecting)
402
 
                                                                                ii->SetSelected(true);
403
 
                                                                        selecting^=true;
404
 
                                                                }
405
 
                                                                if(selecting)
406
 
                                                                        ii->SetSelected(true);
407
 
                                                                ii=pageview->layout->NextImage();
408
 
                                                        }
409
 
                                                }
410
 
                                                else
411
 
                                                        pageview->selected->SetSelected(true);                                  
412
 
                                        }
413
 
                                        else
414
 
                                                pageview->selected->SetSelected(true);
415
 
                                }
416
 
                                pp_layout_carousel_pageview_refresh(pageview);
417
 
                                g_signal_emit_by_name (GTK_OBJECT (pageview), "selection_changed");
418
 
                                break;
419
 
                        case 3:
420
 
                                if(!(shift||ctrl))
421
 
                                {
422
 
                                        if(pageview->selected)
423
 
                                        {
424
 
                                                if(!pageview->selected->GetSelected())
425
 
                                                        pageview->layout->SelectNone();
426
 
                                        }
427
 
                                        else
428
 
                                                pageview->layout->SelectNone();                                         
429
 
                                }
430
 
                                if(pageview->selected)
431
 
                                {
432
 
                                        pageview->selected->SetSelected(true);
433
 
                                        pp_layout_carousel_pageview_refresh(pageview);
434
 
                                        g_signal_emit_by_name (GTK_OBJECT (pageview), "selection_changed");
435
 
                                        g_signal_emit_by_name (GTK_OBJECT (pageview), "popupmenu");
436
 
                                }
437
 
                                break;
438
 
                        default:
439
 
                                break;  
440
 
                }
441
 
        }       
442
 
        return FALSE;
443
 
}
444
 
 
445
 
 
446
 
static gboolean
447
 
pp_layout_carousel_pageview_motion_notify( GtkWidget      *widget,
448
 
                        GdkEventMotion *event )
449
 
{
450
 
        pp_Layout_Carousel_PageView *pageview;
451
 
        g_return_val_if_fail (widget != NULL, FALSE);
452
 
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
453
 
        g_return_val_if_fail (event != NULL, FALSE);
454
 
        
455
 
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
456
 
 
457
 
        Layout_ImageInfo *ii=pageview->selected;
458
 
 
459
 
        if (pageview->dragging && ii)
460
 
    {
461
 
                int x,y;
462
 
                GdkModifierType mods;
463
 
                gdk_window_get_pointer (widget->window, &x, &y, &mods);
464
 
                        
465
 
                int dx=(x-pageview->init_x);
466
 
                int dy=(y-pageview->init_y);
467
 
 
468
 
                int hp=pageview->init_hpan-dx;
469
 
                int vp=pageview->init_vpan-dy;
470
 
                if(hp<0) hp=0;
471
 
                if(hp>LAYOUT_RECTANGLE_PANNING_MAX) hp=LAYOUT_RECTANGLE_PANNING_MAX;
472
 
                if(vp<0) vp=0;
473
 
                if(vp>LAYOUT_RECTANGLE_PANNING_MAX) vp=LAYOUT_RECTANGLE_PANNING_MAX;
474
 
 
475
 
                ii->crop_hpan=LayoutRectangle_Alignment(hp);
476
 
                ii->crop_vpan=LayoutRectangle_Alignment(vp);
477
 
 
478
 
                pageview->layout->FlushPreview();
479
 
                cerr << "Dragging: " << hp << ", " << vp << endl;
480
 
 
481
 
                gtk_widget_queue_draw (GTK_WIDGET (pageview));
482
 
        }
483
 
        return FALSE;
484
 
}
485
 
 
486
 
 
487
 
static gboolean
488
 
pp_layout_carousel_pageview_button_release( GtkWidget      *widget,
489
 
                         GdkEventButton *event )
490
 
{
491
 
        pp_Layout_Carousel_PageView *pageview;
492
 
        g_return_val_if_fail (widget != NULL, FALSE);
493
 
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
494
 
        g_return_val_if_fail (event != NULL, FALSE);
495
 
        
496
 
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
497
 
 
498
 
        switch(event->button)
499
 
        {
500
 
                case 1: if (event->button==1)
501
 
                        pageview->dragging=false;
502
 
                        gtk_grab_remove(widget);
503
 
                        cerr << "Ending drag..." << endl;
504
 
                        break;
505
 
                default:
506
 
                        break;
507
 
        }
508
 
//      g_signal_emit_by_name (GTK_OBJECT (pageview->adjustment), "value_changed");
509
 
        return FALSE;
510
 
}
511
 
 
512
 
 
513
 
void pp_layout_carousel_pageview_refresh(pp_Layout_Carousel_PageView *pv)
514
 
{
515
 
        gtk_widget_queue_draw (GTK_WIDGET (pv));
516
 
}
517
 
 
518
 
 
519
 
void pp_layout_carousel_pageview_set_page(pp_Layout_Carousel_PageView *pv,int page)
520
 
{
521
 
        pv->layout->SetCurrentPage(page);
522
 
        pp_layout_carousel_pageview_refresh(pv);
523
 
}
 
1
 
 
2
#include <math.h>
 
3
#include <stdio.h>
 
4
#include <gtk/gtkmain.h>
 
5
#include <gtk/gtksignal.h>
 
6
#include <gtk/gtkdnd.h>
 
7
#include <gtk/gtkmenu.h>
 
8
 
 
9
#include "support/layoutrectangle.h"
 
10
#include "stpui_widgets/stpui_combo.h"
 
11
#include "support/progressbar.h"
 
12
 
 
13
#include "pp_layout_carousel_pageview.h"
 
14
 
 
15
#define PAGEVIEW_DEFAULT_WIDTH 250
 
16
#define PAGEVIEW_DEFAULT_HEIGHT 320
 
17
 
 
18
 
 
19
enum {
 
20
        CHANGED_SIGNAL,
 
21
        REFLOW_SIGNAL,
 
22
        SELECTIONCHANGED_SIGNAL,
 
23
        POPUPMENU_SIGNAL,
 
24
        LAST_SIGNAL
 
25
};
 
26
 
 
27
static guint pp_layout_carousel_pageview_signals[LAST_SIGNAL] = { 0 };
 
28
 
 
29
static void pp_layout_carousel_pageview_class_init               (pp_Layout_Carousel_PageViewClass     *klass);
 
30
static void pp_layout_carousel_pageview_init                     (pp_Layout_Carousel_PageView          *pageview);
 
31
static void pp_layout_carousel_pageview_realize                  (GtkWidget        *widget);
 
32
static void pp_layout_carousel_pageview_size_request             (GtkWidget        *widget,
 
33
                                               GtkRequisition   *requisition);
 
34
static void pp_layout_carousel_pageview_size_allocate            (GtkWidget        *widget,
 
35
                                               GtkAllocation    *allocation);
 
36
static gboolean pp_layout_carousel_pageview_expose               (GtkWidget        *widget,
 
37
                                               GdkEventExpose   *event);
 
38
static gboolean pp_layout_carousel_pageview_button_press         (GtkWidget        *widget,
 
39
                                               GdkEventButton   *event);
 
40
static gboolean pp_layout_carousel_pageview_button_release       (GtkWidget        *widget,
 
41
                                               GdkEventButton   *event);
 
42
static gboolean pp_layout_carousel_pageview_motion_notify        (GtkWidget        *widget,
 
43
                                               GdkEventMotion   *event);
 
44
 
 
45
 
 
46
#define TARGET_URI_LIST 1
 
47
 
 
48
 
 
49
static GtkTargetEntry dnd_file_drop_types[] = {
 
50
        { "text/uri-list", 0, TARGET_URI_LIST }
 
51
};
 
52
static gint dnd_file_drop_types_count = 1;
 
53
 
 
54
static void get_dnd_data(GtkWidget *widget, GdkDragContext *context,
 
55
                                     gint x, gint y,
 
56
                                     GtkSelectionData *selection_data, guint info,
 
57
                                     guint time, gpointer data)
 
58
{
 
59
        gchar *urilist=g_strdup((const gchar *)selection_data->data);
 
60
        int lastpage=0;
 
61
        pp_Layout_Carousel_PageView *pv=PP_LAYOUT_CAROUSEL_PAGEVIEW(widget);
 
62
        ProgressBar progress("Adding images...",false);
 
63
        while(*urilist)
 
64
        {
 
65
                if(strncmp(urilist,"file:",5))
 
66
                {
 
67
                        g_print("Warning: only local files (file://) are currently supported\n");
 
68
                        while(*urilist && *urilist!='\n' && *urilist!='\r')
 
69
                                ++urilist;
 
70
                        while(*urilist=='\n' || *urilist=='\r')
 
71
                                *urilist++;
 
72
                }
 
73
                else
 
74
                {
 
75
                        gchar *uri=urilist;
 
76
                        while(*urilist && *urilist!='\n' && *urilist!='\r')
 
77
                                ++urilist;
 
78
                        if(*urilist)
 
79
                        {
 
80
                                while(*urilist=='\n' || *urilist=='\r')
 
81
                                        *urilist++=0;
 
82
                                gchar *filename=g_filename_from_uri(uri,NULL,NULL);
 
83
                                lastpage=pv->layout->AddImage(filename);
 
84
                                pp_layout_carousel_pageview_refresh(pv);
 
85
                                g_signal_emit_by_name (GTK_OBJECT (pv), "changed");
 
86
                                progress.DoProgress(0,0);
 
87
                        }
 
88
                }
 
89
        }
 
90
        pp_layout_carousel_pageview_set_page(pv,lastpage);
 
91
        g_signal_emit_by_name (GTK_OBJECT (pv), "changed");
 
92
}
 
93
 
 
94
 
 
95
/* Local data */
 
96
 
 
97
static GtkWidgetClass *parent_class = NULL;
 
98
 
 
99
GType
 
100
pp_layout_carousel_pageview_get_type ()
 
101
{
 
102
  static GType pageview_type = 0;
 
103
 
 
104
  if (!pageview_type)
 
105
    {
 
106
      static const GTypeInfo pageview_info =
 
107
      {
 
108
        sizeof (pp_Layout_Carousel_PageViewClass),
 
109
        NULL,
 
110
        NULL,
 
111
        (GClassInitFunc) pp_layout_carousel_pageview_class_init,
 
112
        NULL,
 
113
        NULL,
 
114
        sizeof (pp_Layout_Carousel_PageView),
 
115
        0,
 
116
        (GInstanceInitFunc) pp_layout_carousel_pageview_init,
 
117
      };
 
118
 
 
119
      pageview_type = g_type_register_static (GTK_TYPE_WIDGET, "pp_Layout_Carousel_PageView", &pageview_info, GTypeFlags(0));
 
120
    }
 
121
 
 
122
  return pageview_type;
 
123
}
 
124
 
 
125
 
 
126
static void
 
127
pp_layout_carousel_pageview_class_init (pp_Layout_Carousel_PageViewClass *cl)
 
128
{
 
129
        GtkObjectClass *object_class;
 
130
        GtkWidgetClass *widget_class;
 
131
        
 
132
        object_class = (GtkObjectClass*) cl;
 
133
        widget_class = (GtkWidgetClass*) cl;
 
134
        
 
135
        parent_class = GTK_WIDGET_CLASS(gtk_type_class (gtk_widget_get_type ()));
 
136
        
 
137
        widget_class->realize = pp_layout_carousel_pageview_realize;
 
138
        widget_class->expose_event = pp_layout_carousel_pageview_expose;
 
139
        widget_class->size_request = pp_layout_carousel_pageview_size_request;
 
140
        widget_class->size_allocate = pp_layout_carousel_pageview_size_allocate;
 
141
        widget_class->button_press_event = pp_layout_carousel_pageview_button_press;
 
142
        widget_class->button_release_event = pp_layout_carousel_pageview_button_release;
 
143
        widget_class->motion_notify_event = pp_layout_carousel_pageview_motion_notify;
 
144
 
 
145
        pp_layout_carousel_pageview_signals[CHANGED_SIGNAL] =
 
146
        g_signal_new ("changed",
 
147
                G_TYPE_FROM_CLASS (cl),
 
148
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
149
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, changed),
 
150
                NULL, NULL,
 
151
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
152
        pp_layout_carousel_pageview_signals[REFLOW_SIGNAL] =
 
153
        g_signal_new ("reflow",
 
154
                G_TYPE_FROM_CLASS (cl),
 
155
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
156
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, reflow),
 
157
                NULL, NULL,
 
158
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
159
        pp_layout_carousel_pageview_signals[SELECTIONCHANGED_SIGNAL] =
 
160
        g_signal_new ("selection_changed",
 
161
                G_TYPE_FROM_CLASS (cl),
 
162
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
163
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, selection_changed),
 
164
                NULL, NULL,
 
165
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
166
        pp_layout_carousel_pageview_signals[REFLOW_SIGNAL] =
 
167
        g_signal_new ("popupmenu",
 
168
                G_TYPE_FROM_CLASS (cl),
 
169
                GSignalFlags(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
 
170
                G_STRUCT_OFFSET (pp_Layout_Carousel_PageViewClass, popupmenu),
 
171
                NULL, NULL,
 
172
                g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
173
}
 
174
 
 
175
 
 
176
static void
 
177
pp_layout_carousel_pageview_init (pp_Layout_Carousel_PageView *pageview)
 
178
{
 
179
        pageview->button = 0;
 
180
        pageview->timer = 0;
 
181
        pageview->selected=NULL;
 
182
}
 
183
 
 
184
 
 
185
GtkWidget*
 
186
pp_layout_carousel_pageview_new (Layout_Carousel *layout)
 
187
{
 
188
        pp_Layout_Carousel_PageView *pageview;
 
189
 
 
190
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW(g_object_new (pp_layout_carousel_pageview_get_type (), NULL));
 
191
 
 
192
        gtk_drag_dest_set(GTK_WIDGET(pageview),
 
193
                          GtkDestDefaults(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP),
 
194
                          dnd_file_drop_types, dnd_file_drop_types_count,
 
195
                          GdkDragAction(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
 
196
        g_signal_connect(G_OBJECT(pageview), "drag_data_received",
 
197
                         G_CALLBACK(get_dnd_data), NULL);
 
198
 
 
199
        pageview->layout=layout;
 
200
 
 
201
        return GTK_WIDGET (pageview);
 
202
}
 
203
 
 
204
 
 
205
static void
 
206
pp_layout_carousel_pageview_realize (GtkWidget *widget)
 
207
{
 
208
  pp_Layout_Carousel_PageView *pageview;
 
209
  GdkWindowAttr attributes;
 
210
  gint attributes_mask;
 
211
 
 
212
  g_return_if_fail (widget != NULL);
 
213
  g_return_if_fail (PP_IS_PAGEVIEW (widget));
 
214
 
 
215
  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 
216
  pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
 
217
 
 
218
  attributes.x = widget->allocation.x;
 
219
  attributes.y = widget->allocation.y;
 
220
  attributes.width = widget->allocation.width;
 
221
  attributes.height = widget->allocation.height;
 
222
  attributes.wclass = GDK_INPUT_OUTPUT;
 
223
  attributes.window_type = GDK_WINDOW_CHILD;
 
224
  attributes.event_mask = gtk_widget_get_events (widget) | 
 
225
    GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | 
 
226
    GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
 
227
    GDK_POINTER_MOTION_HINT_MASK;
 
228
  attributes.visual = gtk_widget_get_visual (widget);
 
229
  attributes.colormap = gtk_widget_get_colormap (widget);
 
230
 
 
231
  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 
232
  widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
 
233
 
 
234
  widget->style = gtk_style_attach (widget->style, widget->window);
 
235
 
 
236
  gdk_window_set_user_data (widget->window, widget);
 
237
 
 
238
  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
 
239
}
 
240
 
 
241
 
 
242
static void 
 
243
pp_layout_carousel_pageview_size_request (GtkWidget      *widget,
 
244
                       GtkRequisition *requisition)
 
245
{
 
246
  requisition->width = PAGEVIEW_DEFAULT_WIDTH;
 
247
  requisition->height = PAGEVIEW_DEFAULT_HEIGHT;
 
248
}
 
249
 
 
250
 
 
251
static void
 
252
pp_layout_carousel_pageview_size_allocate (GtkWidget     *widget,
 
253
                        GtkAllocation *allocation)
 
254
{
 
255
  pp_Layout_Carousel_PageView *pageview;
 
256
 
 
257
  g_return_if_fail (widget != NULL);
 
258
  g_return_if_fail (PP_IS_PAGEVIEW (widget));
 
259
  g_return_if_fail (allocation != NULL);
 
260
 
 
261
  widget->allocation = *allocation;
 
262
  pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
 
263
 
 
264
  if (GTK_WIDGET_REALIZED (widget))
 
265
    {
 
266
 
 
267
      gdk_window_move_resize (widget->window,
 
268
                              allocation->x, allocation->y,
 
269
                              allocation->width, allocation->height);
 
270
 
 
271
    }
 
272
}
 
273
 
 
274
 
 
275
static gboolean
 
276
pp_layout_carousel_pageview_expose( GtkWidget      *widget,
 
277
                 GdkEventExpose *event )
 
278
{
 
279
        pp_Layout_Carousel_PageView *pageview;
 
280
 
 
281
        g_return_val_if_fail (widget != NULL, FALSE);
 
282
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
 
283
        g_return_val_if_fail (event != NULL, FALSE);
 
284
 
 
285
        if (event->count > 0)
 
286
                return FALSE;
 
287
  
 
288
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
 
289
 
 
290
                
 
291
        pageview->height=widget->allocation.height;
 
292
        pageview->width=(pageview->layout->pagewidth*pageview->height)/pageview->layout->pageheight;
 
293
        if(pageview->width>widget->allocation.width)
 
294
        {
 
295
                pageview->width=widget->allocation.width;
 
296
                pageview->height=(pageview->layout->pageheight*pageview->width)/pageview->layout->pagewidth;    
 
297
        }
 
298
        pageview->top=(widget->allocation.height-pageview->height)/2;
 
299
        pageview->left=(widget->allocation.width-pageview->width)/2;
 
300
 
 
301
        pageview->scale=pageview->width;
 
302
        pageview->scale/=pageview->layout->pagewidth;
 
303
 
 
304
        pageview->layout->DrawPreview(widget,pageview->left,pageview->top,pageview->width,pageview->height);
 
305
 
 
306
        Layout_ImageInfo *ii=pageview->layout->FirstSelected();
 
307
        while(ii)
 
308
        {
 
309
                if(ii->page==pageview->layout->GetCurrentPage())
 
310
                {
 
311
                        LayoutRectangle *s=ii->GetBounds();
 
312
                        s->Scale(pageview->scale);
 
313
 
 
314
                        gdk_draw_rectangle (widget->window,
 
315
                                widget->style->dark_gc[widget->state],FALSE,
 
316
                                pageview->left+s->x,pageview->top+s->y,s->w,s->h);
 
317
                        gdk_draw_rectangle (widget->window,
 
318
                                widget->style->dark_gc[widget->state],FALSE,
 
319
                                pageview->left+s->x-1,pageview->top+s->y-1,s->w+2,s->h+2);
 
320
                        delete s;
 
321
                }
 
322
                ii=pageview->layout->NextSelected();
 
323
        }
 
324
 
 
325
 
 
326
        return FALSE;
 
327
}
 
328
 
 
329
 
 
330
static gboolean
 
331
pp_layout_carousel_pageview_button_press( GtkWidget      *widget,
 
332
                       GdkEventButton *event )
 
333
{
 
334
        pp_Layout_Carousel_PageView *pageview;
 
335
        
 
336
        g_return_val_if_fail (widget != NULL, FALSE);
 
337
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
 
338
        g_return_val_if_fail (event != NULL, FALSE);
 
339
        
 
340
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
 
341
        
 
342
        int x=int(event->x-pageview->left);
 
343
        int y=int(event->y-pageview->top);
 
344
        bool shift=(event->state&GDK_SHIFT_MASK)!=0;
 
345
        bool ctrl=(event->state&GDK_CONTROL_MASK)!=0;
 
346
 
 
347
        if(x>0 && y>0 && x<pageview->width && y<pageview->height && pageview->scale>0.0)
 
348
        {
 
349
                double sx=x/pageview->scale;
 
350
                double sy=y/pageview->scale;
 
351
                Layout_ImageInfo *prevselected=pageview->selected;
 
352
                pageview->selected=pageview->layout->ImageAtCoord(int(sx),int(sy));
 
353
                switch(event->button)
 
354
                {
 
355
                        case 1:
 
356
                                if(!(shift||ctrl))
 
357
                                {
 
358
                                                if(pageview->selected && pageview->selected->allowcropping)
 
359
                                                {
 
360
                                                        pageview->dragging=true;
 
361
                                                        pageview->init_x=x;
 
362
                                                        pageview->init_y=y;
 
363
                                                        pageview->init_hpan=pageview->selected->crop_hpan;
 
364
                                                        pageview->init_vpan=pageview->selected->crop_vpan;
 
365
                                                        gtk_grab_add(widget);
 
366
                                                        cerr << "Commencing drag..." << endl;
 
367
                                                }
 
368
                                                else
 
369
                                                        pageview->dragging=false;
 
370
                                                pageview->layout->SelectNone();
 
371
                                }
 
372
                                if(pageview->selected)
 
373
                                {
 
374
                                        if(ctrl)
 
375
                                                pageview->selected->ToggleSelected();
 
376
                                        else if(shift)
 
377
                                        {
 
378
                                                if(prevselected)
 
379
                                                {
 
380
                                                        Layout_ImageInfo *ii=pageview->layout->FirstImage();
 
381
                                                        bool selecting=false;
 
382
                                                        while(ii)
 
383
                                                        {
 
384
                                                                if((ii==prevselected) || (ii==pageview->selected))
 
385
                                                                {
 
386
                                                                        if(selecting)
 
387
                                                                                ii->SetSelected(true);
 
388
                                                                        selecting^=true;
 
389
                                                                }
 
390
                                                                if(selecting)
 
391
                                                                        ii->SetSelected(true);
 
392
                                                                ii=pageview->layout->NextImage();
 
393
                                                        }
 
394
                                                }
 
395
                                                else
 
396
                                                        pageview->selected->SetSelected(true);                                  
 
397
                                        }
 
398
                                        else
 
399
                                                pageview->selected->SetSelected(true);
 
400
                                }
 
401
                                pp_layout_carousel_pageview_refresh(pageview);
 
402
                                g_signal_emit_by_name (GTK_OBJECT (pageview), "selection_changed");
 
403
                                break;
 
404
                        case 3:
 
405
                                if(!(shift||ctrl))
 
406
                                {
 
407
                                        if(pageview->selected)
 
408
                                        {
 
409
                                                if(!pageview->selected->GetSelected())
 
410
                                                        pageview->layout->SelectNone();
 
411
                                        }
 
412
                                        else
 
413
                                                pageview->layout->SelectNone();                                         
 
414
                                }
 
415
                                if(pageview->selected)
 
416
                                {
 
417
                                        pageview->selected->SetSelected(true);
 
418
                                        pp_layout_carousel_pageview_refresh(pageview);
 
419
                                        g_signal_emit_by_name (GTK_OBJECT (pageview), "selection_changed");
 
420
                                        g_signal_emit_by_name (GTK_OBJECT (pageview), "popupmenu");
 
421
                                }
 
422
                                break;
 
423
                        default:
 
424
                                break;  
 
425
                }
 
426
        }       
 
427
        return FALSE;
 
428
}
 
429
 
 
430
 
 
431
static gboolean
 
432
pp_layout_carousel_pageview_motion_notify( GtkWidget      *widget,
 
433
                        GdkEventMotion *event )
 
434
{
 
435
        pp_Layout_Carousel_PageView *pageview;
 
436
        g_return_val_if_fail (widget != NULL, FALSE);
 
437
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
 
438
        g_return_val_if_fail (event != NULL, FALSE);
 
439
        
 
440
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
 
441
 
 
442
        Layout_ImageInfo *ii=pageview->selected;
 
443
 
 
444
        if (pageview->dragging && ii)
 
445
    {
 
446
                int x,y;
 
447
                GdkModifierType mods;
 
448
                gdk_window_get_pointer (widget->window, &x, &y, &mods);
 
449
                        
 
450
                int dx=(x-pageview->init_x);
 
451
                int dy=(y-pageview->init_y);
 
452
 
 
453
                int hp=pageview->init_hpan-dx;
 
454
                int vp=pageview->init_vpan-dy;
 
455
                if(hp<0) hp=0;
 
456
                if(hp>LAYOUT_RECTANGLE_PANNING_MAX) hp=LAYOUT_RECTANGLE_PANNING_MAX;
 
457
                if(vp<0) vp=0;
 
458
                if(vp>LAYOUT_RECTANGLE_PANNING_MAX) vp=LAYOUT_RECTANGLE_PANNING_MAX;
 
459
 
 
460
                ii->crop_hpan=LayoutRectangle_Alignment(hp);
 
461
                ii->crop_vpan=LayoutRectangle_Alignment(vp);
 
462
 
 
463
                pageview->layout->FlushPreview();
 
464
                cerr << "Dragging: " << hp << ", " << vp << endl;
 
465
 
 
466
                gtk_widget_queue_draw (GTK_WIDGET (pageview));
 
467
        }
 
468
        return FALSE;
 
469
}
 
470
 
 
471
 
 
472
static gboolean
 
473
pp_layout_carousel_pageview_button_release( GtkWidget      *widget,
 
474
                         GdkEventButton *event )
 
475
{
 
476
        pp_Layout_Carousel_PageView *pageview;
 
477
        g_return_val_if_fail (widget != NULL, FALSE);
 
478
        g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
 
479
        g_return_val_if_fail (event != NULL, FALSE);
 
480
        
 
481
        pageview = PP_LAYOUT_CAROUSEL_PAGEVIEW (widget);
 
482
 
 
483
        switch(event->button)
 
484
        {
 
485
                case 1: if (event->button==1)
 
486
                        pageview->dragging=false;
 
487
                        gtk_grab_remove(widget);
 
488
                        cerr << "Ending drag..." << endl;
 
489
                        break;
 
490
                default:
 
491
                        break;
 
492
        }
 
493
//      g_signal_emit_by_name (GTK_OBJECT (pageview->adjustment), "value_changed");
 
494
        return FALSE;
 
495
}
 
496
 
 
497
 
 
498
void pp_layout_carousel_pageview_refresh(pp_Layout_Carousel_PageView *pv)
 
499
{
 
500
        gtk_widget_queue_draw (GTK_WIDGET (pv));
 
501
}
 
502
 
 
503
 
 
504
void pp_layout_carousel_pageview_set_page(pp_Layout_Carousel_PageView *pv,int page)
 
505
{
 
506
        pv->layout->SetCurrentPage(page);
 
507
        pp_layout_carousel_pageview_refresh(pv);
 
508
}