← Back to branch summary

~valavanisalex/ubuntu/oneiric/inkscape/inkscape_0.48.1-2ubuntu4

« back to all changes in this revision

Viewing changes to src/dialogs/export.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2006-07-06 22:03:02 UTC
  • mto: (2.4.1 sid) (1.4.1 upstream) (45.1.3 maverick)
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: james.westby@ubuntu.com-20060706220302-itgso3qgxdaxjmcy
Tags: upstream-0.44
Import upstream version 0.44

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dialogs/export.cpp
19
19
# include "config.h"
20
20
#endif
21
21
 
22
 
#include <iostream>
23
 
#include <math.h>
24
 
#include <string.h>
25
 
#include <glib.h>
26
22
#include <gtk/gtk.h>
 
23
#include <gtkmm/box.h>
 
24
#include <gtkmm/buttonbox.h>
 
25
#include <gtkmm/label.h>
 
26
#include <gtkmm/widget.h>
 
27
#include <gtkmm/togglebutton.h>
 
28
#include <gtkmm/entry.h>
 
29
#include <gtkmm/image.h>
 
30
#include <gtkmm/stockid.h>
 
31
#include <gtkmm/stock.h>
27
32
 
28
 
#include "xml/repr.h"
29
33
#include <glibmm/i18n.h>
30
34
#include "helper/unit-menu.h"
31
35
#include "helper/units.h"
32
36
#include "unit-constants.h"
33
37
#include "helper/window.h"
34
 
#include "widgets/spw-utilities.h"
35
 
#include "inkscape.h"
36
38
#include "inkscape-private.h"
37
 
#include "dir-util.h"
38
39
#include "document.h"
39
40
#include "desktop-handles.h"
40
41
#include "sp-item.h"
48
49
#include "../verbs.h"
49
50
#include "../interface.h"
50
51
 
51
 
#include "extension/extension.h"
52
52
#include "extension/output.h"
53
53
#include "extension/db.h"
54
54
 
55
55
#include "io/sys.h"
56
56
 
57
 
#include "export.h"
58
57
 
59
58
#define SP_EXPORT_MIN_SIZE 1.0
60
59
 
65
64
static void sp_export_area_toggled   ( GtkToggleButton *tb, GtkObject *base );
66
65
static void sp_export_export_clicked ( GtkButton *button, GtkObject *base );
67
66
static void sp_export_browse_clicked ( GtkButton *button, gpointer userdata );
68
 
static void sp_export_browse_store   ( GtkButton *button, gpointer userdata );
69
 
 
70
67
 
71
68
static void sp_export_area_x_value_changed       ( GtkAdjustment *adj, 
72
69
                                                   GtkObject *base);
83
80
static void sp_export_bitmap_width_value_changed ( GtkAdjustment *adj, 
84
81
                                                   GtkObject *base);
85
82
                                                   
 
83
static void sp_export_bitmap_height_value_changed ( GtkAdjustment *adj, 
 
84
                                                   GtkObject *base);
 
85
                                                   
86
86
static void sp_export_xdpi_value_changed         ( GtkAdjustment *adj, 
87
87
                                                   GtkObject *base);
88
88
                                           
157
157
    gtk_window_get_position ((GtkWindow *) dlg, &x, &y);
158
158
    gtk_window_get_size ((GtkWindow *) dlg, &w, &h);
159
159
 
 
160
    if (x<0) x=0;
 
161
    if (y<0) y=0;
 
162
 
160
163
    prefs_set_int_attribute (prefs_path, "x", x);
161
164
    prefs_set_int_attribute (prefs_path, "y", y);
162
165
    prefs_set_int_attribute (prefs_path, "w", w);
184
187
    \param  sensitive  Whether the spin button is sensitive or not
185
188
    \param  cb   Callback for when this spin button is changed (optional)
186
189
    \param  dlg  Export dialog the spin button is being placed in
187
 
 
 
190
 
188
191
*/
189
192
static void
190
 
sp_export_spinbutton_new ( gchar *key, float val, float min, float max, 
 
193
sp_export_spinbutton_new ( gchar *key, float val, float min, float max,
191
194
                           float step, float page, GtkWidget *us,
192
 
                           GtkWidget *t, int x, int y, 
 
195
                           GtkWidget *t, int x, int y,
193
196
                           const gchar *ll, const gchar *lr,
194
197
                           int digits, unsigned int sensitive,
195
198
                           GCallback cb, GtkWidget *dlg )
197
200
    GtkObject *a = gtk_adjustment_new (val, min, max, step, page, page);
198
201
    gtk_object_set_data (a, "key", key);
199
202
    gtk_object_set_data (GTK_OBJECT (dlg), (const gchar *)key, a);
200
 
    
 
203
 
201
204
    if (us) {
202
 
        sp_unit_selector_add_adjustment ( SP_UNIT_SELECTOR (us), 
 
205
        sp_unit_selector_add_adjustment ( SP_UNIT_SELECTOR (us),
203
206
                                          GTK_ADJUSTMENT (a) );
204
207
    }
205
 
    
 
208
 
206
209
    int pos = 0;
207
210
 
208
211
    GtkWidget *l = NULL;
209
212
 
210
213
    if (ll) {
211
 
    
 
214
 
212
215
        l = gtk_label_new_with_mnemonic ((const gchar *)ll);
213
216
        gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
214
 
        gtk_table_attach ( GTK_TABLE (t), l, x + pos, x + pos + 1, y, y + 1, 
 
217
        gtk_table_attach ( GTK_TABLE (t), l, x + pos, x + pos + 1, y, y + 1,
215
218
                           (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0 );
216
219
        gtk_widget_set_sensitive (l, sensitive);
217
220
        pos += 1;
218
 
    
 
221
 
219
222
    }
220
223
 
221
224
    GtkWidget *sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 1.0, digits);
222
 
    gtk_table_attach ( GTK_TABLE (t), sb, x + pos, x + pos + 1, y, y + 1, 
 
225
    gtk_table_attach ( GTK_TABLE (t), sb, x + pos, x + pos + 1, y, y + 1,
223
226
                       (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0 );
224
227
    gtk_widget_set_size_request (sb, 80, -1);
225
228
    gtk_widget_set_sensitive (sb, sensitive);
228
231
    if (ll) { gtk_label_set_mnemonic_widget (GTK_LABEL(l), sb); }
229
232
 
230
233
    if (lr) {
231
 
    
 
234
 
232
235
        l = gtk_label_new_with_mnemonic ((const gchar *)lr);
233
236
        gtk_misc_set_alignment (GTK_MISC (l), 0.0, 0.5);
234
 
        gtk_table_attach ( GTK_TABLE (t), l, x + pos, x + pos + 1, y, y + 1, 
 
237
        gtk_table_attach ( GTK_TABLE (t), l, x + pos, x + pos + 1, y, y + 1,
235
238
                           (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0 );
236
239
        gtk_widget_set_sensitive (l, sensitive);
237
240
        pos += 1;
239
242
        gtk_label_set_mnemonic_widget (GTK_LABEL(l), sb);
240
243
    }
241
244
 
242
 
    if (cb) 
 
245
    if (cb)
243
246
        gtk_signal_connect (a, "value_changed", cb, dlg);
244
247
 
245
248
    return;
246
249
} // end of sp_export_spinbutton_new()
247
250
 
248
251
 
249
 
static GtkWidget *
250
 
sp_export_dialog_area_frame (GtkWidget * dlg)
 
252
static Gtk::VBox *
 
253
sp_export_dialog_area_box (GtkWidget * dlg)
251
254
{
252
 
    GtkWidget * f, * t, * hb, * b, * us, * l, * vb, * unitbox;
 
255
    Gtk::VBox* vb = new Gtk::VBox(false, 3);
253
256
 
254
 
    f = gtk_frame_new (_("Export area"));
255
 
    vb = gtk_vbox_new (FALSE, 2);
256
 
    gtk_container_add (GTK_CONTAINER (f), vb);
 
257
    Gtk::Label* lbl = new Gtk::Label(_("<big><b>Export area</b></big>"), Gtk::ALIGN_LEFT);
 
258
    lbl->set_use_markup(true);
 
259
    vb->pack_start(*lbl);
257
260
 
258
261
    /* Units box */
259
 
    unitbox = gtk_hbox_new (FALSE, 0);
260
 
    gtk_container_set_border_width (GTK_CONTAINER (unitbox), 4);
 
262
    Gtk::HBox* unitbox = new Gtk::HBox(false, 0);
261
263
    /* gets added to the vbox later, but the unit selector is needed
262
264
       earlier than that */
263
265
 
264
 
    us = sp_unit_selector_new (SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
 
266
    Gtk::Widget* us = Glib::wrap(sp_unit_selector_new (SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE));
265
267
    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
266
268
    if (desktop)
267
 
        sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us), SP_DT_NAMEDVIEW(desktop)->doc_units);
268
 
    gtk_box_pack_end (GTK_BOX (unitbox), us, FALSE, FALSE, 0);
269
 
    l = gtk_label_new (_("Units:"));
270
 
    gtk_box_pack_end (GTK_BOX (unitbox), l, FALSE, FALSE, 3);
271
 
    gtk_object_set_data (GTK_OBJECT (dlg), "units", us);
272
 
 
273
 
    hb = gtk_hbox_new (TRUE, 0);
274
 
    gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
275
 
    gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 3);
276
 
 
 
269
        sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us->gobj()), sp_desktop_namedview(desktop)->doc_units);
 
270
    unitbox->pack_end(*us, false, false, 0);
 
271
    Gtk::Label* l = new Gtk::Label(_("Units:"));
 
272
    unitbox->pack_end(*l, false, false, 3);
 
273
    gtk_object_set_data (GTK_OBJECT (dlg), "units", us->gobj());
 
274
 
 
275
    Gtk::HBox* togglebox = new Gtk::HBox(true, 0);
 
276
 
 
277
    Gtk::ToggleButton* b;
277
278
    for (int i = 0; i < SELECTION_NUMBER_OF; i++) {
278
 
        b = gtk_toggle_button_new_with_mnemonic (_(selection_labels[i]));
279
 
        gtk_object_set_data (GTK_OBJECT (b), "key", GINT_TO_POINTER(i));
280
 
        gtk_object_set_data (GTK_OBJECT (dlg), selection_names[i], b);
281
 
        gtk_box_pack_start (GTK_BOX (hb), b, FALSE, TRUE, 0);
282
 
        gtk_signal_connect ( GTK_OBJECT (b), "clicked", 
 
279
        b = new Gtk::ToggleButton(_(selection_labels[i]), true);
 
280
        b->set_data("key", GINT_TO_POINTER(i));
 
281
        gtk_object_set_data (GTK_OBJECT (dlg), selection_names[i], b->gobj());
 
282
        togglebox->pack_start(*b, false, true, 0);
 
283
        gtk_signal_connect ( GTK_OBJECT (b->gobj()), "clicked", 
283
284
                             GTK_SIGNAL_FUNC (sp_export_area_toggled), dlg );
284
285
    }
285
286
 
290
291
    g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", 
291
292
                       G_CALLBACK (sp_export_selection_changed), dlg );
292
293
    
293
 
    t = gtk_table_new (2, 6, FALSE);
294
 
    gtk_box_pack_start(GTK_BOX(vb), t, FALSE, FALSE, 0);
295
 
    gtk_table_set_row_spacings (GTK_TABLE (t), 4);
296
 
    gtk_table_set_col_spacings (GTK_TABLE (t), 4);
297
 
    gtk_container_set_border_width (GTK_CONTAINER (t), 4);
 
294
    Gtk::Table* t = new Gtk::Table(2, 6, FALSE);
 
295
    t->set_row_spacings (4);
 
296
    t->set_col_spacings (4);
298
297
 
299
 
    sp_export_spinbutton_new ( "x0", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us, 
300
 
                               t, 0, 0, _("_x0:"), NULL, EXPORT_COORD_PRECISION, 1,
 
298
    sp_export_spinbutton_new ( "x0", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us->gobj(), 
 
299
                               GTK_WIDGET(t->gobj()), 0, 0, _("_x0:"), NULL, EXPORT_COORD_PRECISION, 1,
301
300
                               G_CALLBACK ( sp_export_area_x_value_changed), 
302
301
                               dlg );
303
302
 
304
 
    sp_export_spinbutton_new ( "x1", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us, 
305
 
                               t, 2, 0, _("x_1:"), NULL, EXPORT_COORD_PRECISION, 1,
 
303
    sp_export_spinbutton_new ( "x1", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us->gobj(), 
 
304
                               GTK_WIDGET(t->gobj()), 2, 0, _("x_1:"), NULL, EXPORT_COORD_PRECISION, 1,
306
305
                               G_CALLBACK (sp_export_area_x_value_changed), 
307
306
                               dlg );
308
307
 
309
308
    sp_export_spinbutton_new ( "width", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, 
310
 
                               us, t, 4, 0, _("Width:"), NULL, EXPORT_COORD_PRECISION, 1,
 
309
                               us->gobj(), GTK_WIDGET(t->gobj()), 4, 0, _("Width:"), NULL, EXPORT_COORD_PRECISION, 1,
311
310
                               G_CALLBACK 
312
311
                                   (sp_export_area_width_value_changed), 
313
312
                               dlg );
314
313
 
315
 
    sp_export_spinbutton_new ( "y0", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us, 
316
 
                               t, 0, 1, _("_y0:"), NULL, EXPORT_COORD_PRECISION, 1,
 
314
    sp_export_spinbutton_new ( "y0", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us->gobj(), 
 
315
                               GTK_WIDGET(t->gobj()), 0, 1, _("_y0:"), NULL, EXPORT_COORD_PRECISION, 1,
317
316
                               G_CALLBACK (sp_export_area_y_value_changed), 
318
317
                               dlg );
319
318
 
320
 
    sp_export_spinbutton_new ( "y1", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us, 
321
 
                               t, 2, 1, _("y_1:"), NULL, EXPORT_COORD_PRECISION, 1,
 
319
    sp_export_spinbutton_new ( "y1", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, us->gobj(), 
 
320
                               GTK_WIDGET(t->gobj()), 2, 1, _("y_1:"), NULL, EXPORT_COORD_PRECISION, 1,
322
321
                               G_CALLBACK (sp_export_area_y_value_changed), 
323
322
                               dlg );
324
323
 
325
324
    sp_export_spinbutton_new ( "height", 0.0, -1000000.0, 1000000.0, 0.1, 1.0, 
326
 
                               us, t, 4, 1, _("Height:"), NULL, EXPORT_COORD_PRECISION, 1,
 
325
                               us->gobj(), GTK_WIDGET(t->gobj()), 4, 1, _("Height:"), NULL, EXPORT_COORD_PRECISION, 1,
327
326
                               G_CALLBACK (sp_export_area_height_value_changed), 
328
327
                               dlg );
329
328
 
330
 
    /* Adding in the unit box */
331
 
    gtk_box_pack_start(GTK_BOX(vb), unitbox, FALSE, FALSE, 0);
 
329
    vb->pack_start(*togglebox, false, false, 3);
 
330
    vb->pack_start(*t, false, false, 0);
 
331
    vb->pack_start(*unitbox, false, false, 0);
332
332
 
333
 
    return f;
334
 
} // end of sp_export_dialog_area_frame
 
333
    return vb;
 
334
} // end of sp_export_dialog_area_box
335
335
 
336
336
 
337
337
void
338
338
sp_export_dialog (void)
339
339
{
340
340
    if (!dlg) {
341
 
        GtkWidget *vb, *hb;
 
341
        Gtk::VBox* vb;
 
342
        Gtk::HBox* hb;
342
343
 
343
344
        gchar title[500];
344
345
        sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_FILE_EXPORT), title);
345
346
 
346
347
        dlg = sp_window_new (title, TRUE);
347
 
        
 
348
 
348
349
        if (x == -1000 || y == -1000) {
349
350
            x = prefs_get_int_attribute (prefs_path, "x", 0);
350
351
            y = prefs_get_int_attribute (prefs_path, "y", 0);
351
352
        }
352
 
        
 
353
 
353
354
        if (w ==0 || h == 0) {
354
355
            w = prefs_get_int_attribute (prefs_path, "w", 0);
355
356
            h = prefs_get_int_attribute (prefs_path, "h", 0);
356
357
        }
357
 
        
 
358
 
 
359
        if (x<0) x=0;
 
360
        if (y<0) y=0;
 
361
 
358
362
        if (x != 0 || y != 0) {
359
363
            gtk_window_move ((GtkWindow *) dlg, x, y);
360
364
        } else {
361
365
            gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
362
366
        }
363
 
        
364
 
        if (w && h) 
 
367
 
 
368
        if (w && h)
365
369
            gtk_window_resize ((GtkWindow *) dlg, w, h);
366
 
        
 
370
 
367
371
        sp_transientize (dlg);
368
372
        wd.win = dlg;
369
373
        wd.stop = 0;
370
 
        
371
 
        g_signal_connect   ( G_OBJECT (INKSCAPE), "activate_desktop", 
 
374
 
 
375
        g_signal_connect   ( G_OBJECT (INKSCAPE), "activate_desktop",
372
376
                             G_CALLBACK (sp_transientize_callback), &wd);
373
 
                            
374
 
        gtk_signal_connect ( GTK_OBJECT (dlg), "event", 
 
377
 
 
378
        gtk_signal_connect ( GTK_OBJECT (dlg), "event",
375
379
                             GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
376
 
                             
377
 
        gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", 
 
380
 
 
381
        gtk_signal_connect ( GTK_OBJECT (dlg), "destroy",
378
382
                             G_CALLBACK (sp_export_dialog_destroy), dlg);
379
 
                             
380
 
        gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", 
381
 
                             G_CALLBACK (sp_export_dialog_delete), dlg);
382
 
                             
383
 
        g_signal_connect   ( G_OBJECT (INKSCAPE), "shut_down", 
384
 
                             G_CALLBACK (sp_export_dialog_delete), dlg);
385
 
                             
386
 
        g_signal_connect   ( G_OBJECT (INKSCAPE), "dialogs_hide", 
 
383
 
 
384
        gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event",
 
385
                             G_CALLBACK (sp_export_dialog_delete), dlg);
 
386
 
 
387
        g_signal_connect   ( G_OBJECT (INKSCAPE), "shut_down",
 
388
                             G_CALLBACK (sp_export_dialog_delete), dlg);
 
389
 
 
390
        g_signal_connect   ( G_OBJECT (INKSCAPE), "dialogs_hide",
387
391
                             G_CALLBACK (sp_dialog_hide), dlg);
388
 
                             
389
 
        g_signal_connect   ( G_OBJECT (INKSCAPE), "dialogs_unhide", 
 
392
 
 
393
        g_signal_connect   ( G_OBJECT (INKSCAPE), "dialogs_unhide",
390
394
                             G_CALLBACK (sp_dialog_unhide), dlg);
391
395
 
392
396
        GtkTooltips *tt = gtk_tooltips_new();
393
 
                             
394
 
        vb = gtk_vbox_new (FALSE, 4);
395
 
        gtk_container_set_border_width (GTK_CONTAINER (vb), 0);
396
 
        gtk_container_add (GTK_CONTAINER (dlg), vb);
 
397
 
 
398
        vb = new Gtk::VBox(false, 3);
 
399
        vb->set_border_width(3);
 
400
        gtk_container_add (GTK_CONTAINER (dlg), GTK_WIDGET(vb->gobj()));
397
401
 
398
402
        /* Export area frame */
399
403
        {
400
 
            GtkWidget *f = sp_export_dialog_area_frame(dlg);
401
 
            gtk_box_pack_start (GTK_BOX (vb), f, FALSE, FALSE, 0);
 
404
            Gtk::VBox *area_box = sp_export_dialog_area_box(dlg);
 
405
            area_box->set_border_width(3);
 
406
            vb->pack_start(*area_box, false, false, 0);
402
407
        }
403
408
 
404
409
        /* Bitmap size frame */
405
410
        {
406
 
            GtkWidget *f = gtk_frame_new (_("Bitmap size"));
407
 
            gtk_box_pack_start (GTK_BOX (vb), f, FALSE, FALSE, 0);
408
 
            GtkWidget *t = gtk_table_new (2, 5, FALSE);
409
 
            gtk_table_set_row_spacings (GTK_TABLE (t), 4);
410
 
            gtk_table_set_col_spacings (GTK_TABLE (t), 4);
411
 
            gtk_container_set_border_width (GTK_CONTAINER (t), 4);
412
 
            gtk_container_add (GTK_CONTAINER (f), t);
 
411
            Gtk::VBox *size_box = new Gtk::VBox(false, 3);
 
412
            size_box->set_border_width(3);
 
413
 
 
414
            Gtk::Label* lbl = new Gtk::Label(_("<big><b>Bitmap size</b></big>"), Gtk::ALIGN_LEFT);
 
415
            lbl->set_use_markup(true);
 
416
            size_box->pack_start(*lbl, false, false, 0);
 
417
            const int rows = 2;
 
418
            const int cols = 5;
 
419
            const bool homogeneous = false;
 
420
            Gtk::Table *t = new Gtk::Table(rows, cols, homogeneous);
 
421
            t->set_row_spacings (4);
 
422
            t->set_col_spacings (4);
 
423
            size_box->pack_start(*t);
413
424
 
414
425
            sp_export_spinbutton_new ( "bmwidth", 16.0, 1.0, 1000000.0, 1.0, 10.0, 
415
 
                                       NULL, t, 0, 0,
 
426
                                       NULL, GTK_WIDGET(t->gobj()), 0, 0,
416
427
                                       _("_Width:"), _("pixels at"), 0, 1,
417
428
                                       G_CALLBACK 
418
429
                                       (sp_export_bitmap_width_value_changed), 
422
433
                                       prefs_get_double_attribute 
423
434
                                       ( "dialogs.export.defaultxdpi", 
424
435
                                         "value", DPI_BASE), 
425
 
                                       1.0, 9600.0, 0.1, 1.0, NULL, t, 3, 0,
 
436
                                       0.01, 100000.0, 0.1, 1.0, NULL, GTK_WIDGET(t->gobj()), 3, 0,
426
437
                                       NULL, _("dp_i"), 2, 1,
427
438
                                       G_CALLBACK (sp_export_xdpi_value_changed), 
428
439
                                       dlg );
429
440
 
430
 
            sp_export_spinbutton_new ( "bmheight", 16.0, 1.0, 1000000.0, 1, 10.0, 
431
 
                                       NULL, t, 0, 1, _("Height:"), _("pixels at"), 
432
 
                                       0, 0, NULL, dlg );
 
441
            sp_export_spinbutton_new ( "bmheight", 16.0, 1.0, 1000000.0, 1.0, 10.0, 
 
442
                                       NULL, GTK_WIDGET(t->gobj()), 0, 1, 
 
443
                                       _("Height:"), _("pixels at"), 0, 1, 
 
444
                                       G_CALLBACK
 
445
                                       (sp_export_bitmap_height_value_changed), 
 
446
                                       dlg );
433
447
 
434
448
            /** \todo
435
449
             * Needs fixing: there's no way to set ydpi currently, so we use  
438
452
            sp_export_spinbutton_new ( "ydpi", prefs_get_double_attribute 
439
453
                                       ( "dialogs.export.defaultxdpi", 
440
454
                                         "value", DPI_BASE), 
441
 
                                       1.0, 9600.0, 0.1, 1.0, NULL, t, 3, 1,
 
455
                                       0.01, 100000.0, 0.1, 1.0, NULL, GTK_WIDGET(t->gobj()), 3, 1,
442
456
                                       NULL, _("dpi"), 2, 0, NULL, dlg );
 
457
 
 
458
            vb->pack_start(*size_box);
443
459
        }
444
460
 
445
461
        /* File entry */
446
462
        {
447
 
            GtkWidget *frame = gtk_frame_new ("");
448
 
            GtkWidget *flabel = gtk_label_new_with_mnemonic (_("_Filename"));
449
 
            gtk_frame_set_label_widget (GTK_FRAME(frame), flabel);
450
 
            gtk_box_pack_start (GTK_BOX (vb), frame, FALSE, FALSE, 0);
451
 
 
452
 
            GtkWidget *fe = gtk_entry_new ();
 
463
            Gtk::VBox* file_box = new Gtk::VBox(false, 3);
 
464
            file_box->set_border_width(3);
 
465
 
 
466
            // true = has mnemonic
 
467
            Gtk::Label *flabel = new Gtk::Label(_("<big><b>_Filename</b></big>"), Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER, true);
 
468
            flabel->set_use_markup(true);
 
469
            file_box->pack_start(*flabel, false, false, 0);
 
470
 
 
471
            Gtk::Entry *fe = new Gtk::Entry();
453
472
 
454
473
            /*
455
 
             * set the default filename to be that of the current path + document 
 
474
             * set the default filename to be that of the current path + document
456
475
             * with .png extension
457
476
             *
458
477
             * One thing to notice here is that this filename may get
488
507
                        extension_point[0] = '\0';
489
508
 
490
509
                        final_name = g_strconcat(uri_copy, ".png", NULL);
491
 
                        gtk_entry_set_text (GTK_ENTRY (fe), final_name);
 
510
                        fe->set_text(final_name);
492
511
 
493
512
                        g_free(final_name);
494
513
                        g_free(uri_copy);
495
514
                    }
496
515
                } else {
497
516
                    name = g_strconcat(uri, ".png", NULL);
498
 
                    gtk_entry_set_text (GTK_ENTRY (fe), name);
 
517
                    fe->set_text(name);
499
518
                    g_free(name);
500
 
                } 
 
519
                }
501
520
 
502
 
                doc_export_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(fe)));
 
521
                doc_export_name = g_strdup(fe->get_text().c_str());
503
522
            }
504
 
            g_signal_connect ( G_OBJECT (fe), "changed", 
 
523
            g_signal_connect ( G_OBJECT (fe->gobj()), "changed",
505
524
                               G_CALLBACK (sp_export_filename_modified), dlg);
506
 
        
507
 
            hb = gtk_hbox_new (FALSE, 5);
508
 
            gtk_container_add (GTK_CONTAINER (frame), hb);
509
 
            gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
 
525
 
 
526
            hb = new Gtk::HBox(FALSE, 5);
510
527
 
511
528
            {
512
 
                GtkWidget *b = gtk_button_new_with_mnemonic (_("_Browse..."));
513
 
                gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 4);
514
 
                g_signal_connect ( G_OBJECT (b), "clicked", 
 
529
                // true = has mnemonic
 
530
                Gtk::Button *b = new Gtk::Button();
 
531
 
 
532
                Gtk::HBox* pixlabel = new Gtk::HBox(false, 3);
 
533
                Gtk::Image *im = new Gtk::Image(Gtk::StockID(Gtk::Stock::INDEX),
 
534
                        Gtk::ICON_SIZE_BUTTON);
 
535
                pixlabel->pack_start(*im);
 
536
 
 
537
                Gtk::Label *l = new Gtk::Label();
 
538
                l->set_markup_with_mnemonic(_("_Browse..."));
 
539
                pixlabel->pack_start(*l);
 
540
 
 
541
                b->add(*pixlabel);
 
542
 
 
543
                hb->pack_end (*b, false, false, 4);
 
544
                g_signal_connect ( G_OBJECT (b->gobj()), "clicked",
515
545
                                   G_CALLBACK (sp_export_browse_clicked), NULL );
516
546
            }
517
547
 
518
 
            gtk_box_pack_start (GTK_BOX (hb), fe, TRUE, TRUE, 0);
519
 
            gtk_object_set_data (GTK_OBJECT (dlg), "filename", fe);
 
548
            hb->pack_start (*fe, true, true, 0);
 
549
            file_box->add(*hb);
 
550
            gtk_object_set_data (GTK_OBJECT (dlg), "filename", fe->gobj());
520
551
            gtk_object_set_data (GTK_OBJECT (dlg), "filename-modified", (gpointer)FALSE);
521
 
            original_name = g_strdup(gtk_entry_get_text (GTK_ENTRY (fe)));
 
552
            original_name = g_strdup(fe->get_text().c_str());
522
553
            // pressing enter in the filename field is the same as clicking export:
523
 
            g_signal_connect ( G_OBJECT (fe), "activate", 
 
554
            g_signal_connect ( G_OBJECT (fe->gobj()), "activate",
524
555
                               G_CALLBACK (sp_export_export_clicked), dlg );
525
556
            // focus is in the filename initially:
526
 
            gtk_widget_grab_focus (GTK_WIDGET (fe));
 
557
            fe->grab_focus();
527
558
 
528
559
            // mnemonic in frame label moves focus to filename:
529
 
            gtk_label_set_mnemonic_widget (GTK_LABEL(flabel), fe);
 
560
            flabel->set_mnemonic_widget(*fe);
 
561
 
 
562
            vb->pack_start(*file_box);
530
563
        }
531
564
 
532
565
        /* Buttons */
533
 
        hb = gtk_hbox_new (FALSE, 0);
534
 
        gtk_box_pack_end (GTK_BOX (vb), hb, FALSE, FALSE, 0);
 
566
        Gtk::HButtonBox* bb = new Gtk::HButtonBox(Gtk::BUTTONBOX_END);
 
567
        bb->set_border_width(3);
535
568
 
536
569
        {
537
 
            GtkWidget *b = gtk_button_new ();
538
 
            GtkWidget *l = gtk_label_new ("");
539
 
            gtk_label_set_markup_with_mnemonic (GTK_LABEL(l), _(" <b>_Export</b> "));
540
 
            gtk_container_add (GTK_CONTAINER(b), l);
541
 
            gtk_tooltips_set_tip (tt, b, _("Export the bitmap file with these settings"), NULL);
542
 
            gtk_signal_connect ( GTK_OBJECT (b), "clicked", 
 
570
            Gtk::Button *b = new Gtk::Button();
 
571
            Gtk::HBox* image_label = new Gtk::HBox(false, 3);
 
572
            Gtk::Image *im = new Gtk::Image(Gtk::StockID(Gtk::Stock::APPLY),
 
573
                    Gtk::ICON_SIZE_BUTTON);
 
574
            image_label->pack_start(*im);
 
575
 
 
576
            Gtk::Label *l = new Gtk::Label();
 
577
            l->set_markup_with_mnemonic(_("_Export"));
 
578
            image_label->pack_start(*l);
 
579
 
 
580
            b->add(*image_label);
 
581
            gtk_tooltips_set_tip (tt, GTK_WIDGET(b->gobj()), _("Export the bitmap file with these settings"), NULL);
 
582
            gtk_signal_connect ( GTK_OBJECT (b->gobj()), "clicked",
543
583
                                 GTK_SIGNAL_FUNC (sp_export_export_clicked), dlg );
544
 
            gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
 
584
            bb->pack_end(*b, false, false, 0);
545
585
        }
546
586
 
547
 
        gtk_widget_show_all (vb);
548
 
  
 
587
        vb->pack_end(*bb, false, false, 0);
 
588
        vb->show_all();
 
589
 
549
590
    } // end of if (!dlg)
550
591
 
551
592
    sp_export_find_default_selection(dlg);
552
593
 
553
594
    gtk_window_present ((GtkWindow *) dlg);
554
 
    
 
595
 
555
596
    return;
556
597
} // end of sp_export_dialog()
557
598
 
560
601
{
561
602
    selection_type key = SELECTION_NUMBER_OF;
562
603
 
563
 
    if ((SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
 
604
    if ((sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
564
605
        key = SELECTION_SELECTION;
565
606
    }
566
607
 
570
611
        int i = SELECTION_NUMBER_OF;
571
612
 
572
613
        what = prefs_get_string_attribute ("dialogs.export.exportarea", "value");
573
 
        
 
614
 
574
615
        if (what != NULL) {
575
616
            for (i = 0; i < SELECTION_NUMBER_OF; i++) {
576
617
                if (!strcmp (what, selection_names[i])) {
608
649
    current_key = (selection_type)(GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(base), "selection-type")));
609
650
 
610
651
    if ((current_key == SELECTION_DRAWING || current_key == SELECTION_PAGE) &&
611
 
            (SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty() == false &&
 
652
            (sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty() == false &&
612
653
            was_empty) {
613
 
        gtk_toggle_button_set_active 
614
 
            ( GTK_TOGGLE_BUTTON ( gtk_object_get_data (base, selection_names[SELECTION_SELECTION])), 
 
654
        gtk_toggle_button_set_active
 
655
            ( GTK_TOGGLE_BUTTON ( gtk_object_get_data (base, selection_names[SELECTION_SELECTION])),
615
656
              TRUE );
616
657
    }
617
 
    was_empty = (SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty();
 
658
    was_empty = (sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty();
618
659
 
619
660
    current_key = (selection_type)(GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(base), "selection-type")));
620
661
 
643
684
        case SELECTION_DRAWING:
644
685
            if ( SP_ACTIVE_DESKTOP ) {
645
686
                SPDocument *doc;
646
 
                NRRect bbox;
647
 
                doc = SP_DT_DOCUMENT (SP_ACTIVE_DESKTOP);
648
 
                sp_item_bbox_desktop (SP_ITEM (SP_DOCUMENT_ROOT (doc)), &bbox);
 
687
                doc = sp_desktop_document (SP_ACTIVE_DESKTOP);
 
688
                NR::Rect bbox = sp_item_bbox_desktop (SP_ITEM (SP_DOCUMENT_ROOT (doc)));
649
689
 
650
 
                if (!(bbox.x0 > bbox.x1 && bbox.y0 > bbox.y1)) { 
651
 
                    sp_export_set_area (base, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
 
690
                if (!(bbox.min()[NR::X] > bbox.max()[NR::X] &&
 
691
                      bbox.min()[NR::Y] > bbox.max()[NR::Y])) {
 
692
                    sp_export_set_area (base, bbox.min()[NR::X],
 
693
                                              bbox.min()[NR::Y],
 
694
                                              bbox.max()[NR::X],
 
695
                                              bbox.max()[NR::Y]);
652
696
                }
653
697
            }
654
698
            break;
655
699
        case SELECTION_SELECTION:
656
 
            if ((SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
 
700
            if ((sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
657
701
                NRRect bbox;
658
 
                (SP_DT_SELECTION (SP_ACTIVE_DESKTOP))->bounds(&bbox);
 
702
                (sp_desktop_selection (SP_ACTIVE_DESKTOP))->bounds(&bbox);
659
703
                sp_export_set_area (base, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
660
704
            }
661
705
            break;
694
738
    gtk_object_set_data(GTK_OBJECT(base), "selection-type", (gpointer)key);
695
739
 
696
740
    if (old_key != key) {
697
 
        gtk_toggle_button_set_active 
698
 
            ( GTK_TOGGLE_BUTTON ( gtk_object_get_data (base, selection_names[old_key])), 
 
741
        gtk_toggle_button_set_active
 
742
            ( GTK_TOGGLE_BUTTON ( gtk_object_get_data (base, selection_names[old_key])),
699
743
              FALSE );
700
744
    }
701
745
 
702
746
    if ( SP_ACTIVE_DESKTOP )
703
747
    {
704
748
        SPDocument *doc;
705
 
        NRRect bbox;
706
 
        doc = SP_DT_DOCUMENT (SP_ACTIVE_DESKTOP);
707
 
        
 
749
        NR::Rect bbox;
 
750
        doc = sp_desktop_document (SP_ACTIVE_DESKTOP);
 
751
 
708
752
        /* Notice how the switch is used to 'fall through' here to get
709
753
           various backups.  If you modify this without noticing you'll
710
754
           probabaly screw something up. */
711
755
        switch (key) {
712
756
            case SELECTION_SELECTION:
713
 
                if ((SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty() == false)
 
757
                if ((sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty() == false)
714
758
                {
715
 
                    (SP_DT_SELECTION (SP_ACTIVE_DESKTOP))->bounds(&bbox);
 
759
                    bbox = (sp_desktop_selection (SP_ACTIVE_DESKTOP))->bounds();
716
760
                    /* Only if there is a selection that we can set
717
761
                       do we break, otherwise we fall through to the
718
762
                       drawing */
724
768
                /** \todo 
725
769
                 * This returns wrong values if the document has a viewBox.
726
770
                 */
727
 
                sp_item_bbox_desktop (SP_ITEM (SP_DOCUMENT_ROOT (doc)), &bbox);
 
771
                bbox = sp_item_bbox_desktop (SP_ITEM (SP_DOCUMENT_ROOT (doc)));
728
772
                
729
773
                /* If the drawing is valid, then we'll use it and break
730
774
                   otherwise we drop through to the page settings */
731
 
                if (!(bbox.x0 > bbox.x1 && bbox.y0 > bbox.y1)) { 
 
775
                if (!(bbox.min()[NR::X] > bbox.max()[NR::X] &&
 
776
                      bbox.min()[NR::Y] > bbox.max()[NR::Y])) { 
732
777
                    // std::cout << "Using selection: DRAWING" << std::endl;
733
778
                    key = SELECTION_DRAWING;
734
779
                    break;
735
780
                }
736
781
            case SELECTION_PAGE:
737
 
                bbox.x0 = 0.0;
738
 
                bbox.y0 = 0.0;
739
 
                bbox.x1 = sp_document_width (doc);
740
 
                bbox.y1 = sp_document_height (doc);
 
782
                bbox = NR::Rect(NR::Point(0.0, 0.0), 
 
783
                                NR::Point(sp_document_width(doc), sp_document_height(doc))
 
784
                                );
 
785
 
741
786
                // std::cout << "Using selection: PAGE" << std::endl;
742
787
                key = SELECTION_PAGE;
743
788
                break;
751
796
                                     "value", selection_names[key]);
752
797
 
753
798
        if (key != SELECTION_CUSTOM) {
754
 
            sp_export_set_area (base, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
 
799
            sp_export_set_area (base, bbox.min()[NR::X],
 
800
                                      bbox.min()[NR::Y],
 
801
                                      bbox.max()[NR::X],
 
802
                                      bbox.max()[NR::Y]);
755
803
        }
756
804
    
757
805
    } // end of if ( SP_ACTIVE_DESKTOP )
792
840
                        filename = g_strdup("");
793
841
                    }
794
842
                }
795
 
 
796
843
                break;
797
844
            }
798
845
            case SELECTION_SELECTION:
799
 
                if ((SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
 
846
                if ((sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
800
847
                    const GSList * reprlst;
801
848
                    bool filename_search = TRUE;
802
849
                    bool xdpi_search = TRUE;
803
850
                    bool ydpi_search = TRUE;
804
851
 
805
 
                    reprlst = SP_DT_SELECTION(SP_ACTIVE_DESKTOP)->reprList();
 
852
                    reprlst = sp_desktop_selection(SP_ACTIVE_DESKTOP)->reprList();
806
853
                    for(; reprlst != NULL &&
807
854
                            filename_search &&
808
855
                            xdpi_search &&
840
887
                       one that's nice */
841
888
                    if (filename == NULL) {
842
889
                        const gchar * id = NULL;
843
 
                        reprlst = SP_DT_SELECTION(SP_ACTIVE_DESKTOP)->reprList();
 
890
                        reprlst = sp_desktop_selection(SP_ACTIVE_DESKTOP)->reprList();
844
891
                        for(; reprlst != NULL; reprlst = reprlst->next) {
845
892
                            Inkscape::XML::Node * repr = (Inkscape::XML::Node *)reprlst->data;
846
893
                            if (repr->attribute("id")) {
859
906
                            // std::cout << "Directory from dialog" << std::endl;
860
907
                            directory = g_dirname(file_entry_text);
861
908
                        }
862
 
                        
 
909
 
863
910
                        if (directory == NULL) {
864
911
                            /* Grab document directory */
865
912
                            if (SP_DOCUMENT_URI(SP_ACTIVE_DOCUMENT)) {
902
949
            sp_export_value_set(base, "ydpi", ydpi);
903
950
        }
904
951
    }
905
 
   
 
952
 
906
953
    return;
907
954
} // end of sp_export_area_toggled()
908
955
 
927
974
{
928
975
    GtkWidget *prg;
929
976
    int evtcount;
930
 
    
931
 
    if (g_object_get_data ((GObject *) data, "cancel")) 
 
977
 
 
978
    if (g_object_get_data ((GObject *) data, "cancel"))
932
979
        return FALSE;
933
 
    
 
980
 
934
981
    prg = (GtkWidget *) g_object_get_data ((GObject *) data, "progress");
935
982
    gtk_progress_bar_set_fraction ((GtkProgressBar *) prg, value);
936
 
    
 
983
 
937
984
    evtcount = 0;
938
985
    while ((evtcount < 16) && gdk_events_pending ()) {
939
986
            gtk_main_iteration_do (FALSE);
940
987
            evtcount += 1;
941
988
    }
942
 
    
 
989
 
943
990
    gtk_main_iteration_do (FALSE);
944
991
 
945
992
    return TRUE;
946
 
    
 
993
 
947
994
} // end of sp_export_progress_callback()
948
995
 
949
996
/// Called when export button is clicked
989
1036
    }
990
1037
    g_free(dirname);
991
1038
 
992
 
    SPNamedView *nv = SP_DT_NAMEDVIEW(SP_ACTIVE_DESKTOP);
 
1039
    SPNamedView *nv = sp_desktop_namedview(SP_ACTIVE_DESKTOP);
993
1040
    GtkWidget *dlg, *prg, *btn; /* progressbar-stuff */
994
1041
    char *fn;
995
1042
    gchar *text;
1022
1069
    gtk_widget_show_all (dlg);
1023
1070
    
1024
1071
    /* Do export */
1025
 
    if (!sp_export_png_file (SP_DT_DOCUMENT (SP_ACTIVE_DESKTOP), filename, 
 
1072
    if (!sp_export_png_file (sp_desktop_document (SP_ACTIVE_DESKTOP), filename, 
1026
1073
                             x0, y0, x1, y1, width, height, 
1027
1074
                             nv->pagecolor, 
1028
1075
                             sp_export_progress_callback, base)) {
1033
1080
        g_free(safeFile);
1034
1081
        g_free(error);
1035
1082
    }
1036
 
            
 
1083
 
1037
1084
    /* Reset the filename so that it can be changed again by changing
1038
1085
       selections and all that */
1039
1086
    g_free(original_name);
1057
1104
 
1058
1105
            temp_string = repr->attribute("inkscape:export-filename");
1059
1106
            if (temp_string == NULL || strcmp(temp_string, filename)) {
1060
 
                sp_repr_set_attr(repr, "inkscape:export-filename", filename);
 
1107
                repr->setAttribute("inkscape:export-filename", filename);
1061
1108
                modified = TRUE;
1062
1109
            }
1063
1110
            temp_string = repr->attribute("inkscape:export-xdpi");
1070
1117
                sp_repr_set_svg_double(repr, "inkscape:export-ydpi", ydpi);
1071
1118
                modified = TRUE;
1072
1119
            }
1073
 
            
 
1120
 
1074
1121
            if (modified)
1075
 
                sp_repr_set_attr(repr, "sodipodi:modified", "TRUE");
 
1122
                repr->setAttribute("sodipodi:modified", "TRUE");
1076
1123
            sp_document_set_undo_sensitive(doc, saved);
1077
1124
            break;
1078
1125
        }
1083
1130
 
1084
1131
            bool saved = sp_document_get_undo_sensitive(doc);
1085
1132
            sp_document_set_undo_sensitive(doc, FALSE);
1086
 
            reprlst = SP_DT_SELECTION(SP_ACTIVE_DESKTOP)->reprList();
 
1133
            reprlst = sp_desktop_selection(SP_ACTIVE_DESKTOP)->reprList();
1087
1134
 
1088
1135
            for(; reprlst != NULL; reprlst = reprlst->next) {
1089
1136
                Inkscape::XML::Node * repr = (Inkscape::XML::Node *)reprlst->data;
1091
1138
 
1092
1139
                if (repr->attribute("id") == NULL ||
1093
1140
                        !(g_strrstr(filename, repr->attribute("id")) != NULL &&
1094
 
                          (!SP_DOCUMENT_URI(SP_ACTIVE_DOCUMENT) || 
 
1141
                          (!SP_DOCUMENT_URI(SP_ACTIVE_DOCUMENT) ||
1095
1142
                            strcmp(g_dirname(filename), g_dirname(SP_DOCUMENT_URI(SP_ACTIVE_DOCUMENT))) == 0))) {
1096
1143
                    temp_string = repr->attribute("inkscape:export-filename");
1097
1144
                    if (temp_string == NULL || strcmp(temp_string, filename)) {
1098
 
                        sp_repr_set_attr(repr, "inkscape:export-filename", filename);
 
1145
                        repr->setAttribute("inkscape:export-filename", filename);
1099
1146
                        modified = TRUE;
1100
1147
                    }
1101
1148
                }
1113
1160
 
1114
1161
            if (modified) {
1115
1162
                Inkscape::XML::Node * repr = sp_document_repr_root(doc);
1116
 
                sp_repr_set_attr(repr, "sodipodi:modified", "TRUE");
 
1163
                repr->setAttribute("sodipodi:modified", "TRUE");
1117
1164
            }
1118
1165
 
1119
1166
            sp_document_set_undo_sensitive(doc, saved);
1123
1170
            break;
1124
1171
    }
1125
1172
 
1126
 
    
 
1173
 
1127
1174
    return;
1128
1175
} // end of sp_export_export_clicked()
1129
1176
 
1134
1181
    GtkWidget *fs, *fe;
1135
1182
    const gchar *filename;
1136
1183
 
1137
 
    fs = gtk_file_selection_new (_("Select a filename for exporting"));
 
1184
    fs = gtk_file_chooser_dialog_new (_("Select a filename for exporting"),
 
1185
                                      NULL,
 
1186
                                      GTK_FILE_CHOOSER_ACTION_SAVE,
 
1187
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
1188
                                      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
 
1189
                                      NULL );
 
1190
 
1138
1191
    fe = (GtkWidget *)g_object_get_data (G_OBJECT (dlg), "filename");
1139
1192
 
1140
1193
    sp_transientize (fs);
1147
1200
        filename = homedir_path(NULL);
1148
1201
    }
1149
1202
 
1150
 
    gtk_file_selection_set_filename (GTK_FILE_SELECTION (fs), filename);
1151
 
 
1152
 
    g_signal_connect ( GTK_OBJECT (GTK_FILE_SELECTION (fs)->ok_button),
1153
 
                       "clicked",
1154
 
                       G_CALLBACK (sp_export_browse_store),
1155
 
                       (gpointer) fs );
1156
 
 
1157
 
    g_signal_connect_swapped ( GTK_OBJECT (GTK_FILE_SELECTION (fs)->ok_button),
1158
 
                               "clicked",
1159
 
                               G_CALLBACK (gtk_widget_destroy),
1160
 
                               (gpointer) fs );
1161
 
 
1162
 
    g_signal_connect_swapped ( GTK_OBJECT 
1163
 
                                   (GTK_FILE_SELECTION (fs)->cancel_button),
1164
 
                               "clicked",
1165
 
                               G_CALLBACK (gtk_widget_destroy),
1166
 
                               (gpointer) fs );
1167
 
 
1168
 
    gtk_widget_show (fs);
1169
 
    
 
1203
    gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (fs), filename);
 
1204
 
 
1205
    if (gtk_dialog_run (GTK_DIALOG (fs)) == GTK_RESPONSE_ACCEPT)
 
1206
    {
 
1207
        gchar *file;
 
1208
 
 
1209
        file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fs));
 
1210
        gchar * utf8file = g_filename_to_utf8( file, -1, NULL, NULL, NULL );
 
1211
        gtk_entry_set_text (GTK_ENTRY (fe), utf8file);
 
1212
        g_free(utf8file);
 
1213
 
 
1214
        g_object_set_data (G_OBJECT (dlg), "filename", fe);
 
1215
        g_free(file);
 
1216
    }
 
1217
 
 
1218
    gtk_widget_destroy (fs);
 
1219
 
1170
1220
    return;
1171
1221
} // end of sp_export_browse_clicked()
1172
1222
 
1173
 
/// Called when OK clicked in file dialog
1174
 
static void
1175
 
sp_export_browse_store (GtkButton *button, gpointer userdata)
1176
 
{
1177
 
    GtkWidget *fs = (GtkWidget *)userdata, *fe;
1178
 
    const gchar *file;
1179
 
 
1180
 
    fe = (GtkWidget *)g_object_get_data (G_OBJECT (dlg), "filename");
1181
 
 
1182
 
    file = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1183
 
    gchar * utf8file = g_filename_to_utf8( file, -1, NULL, NULL, NULL );
1184
 
    gtk_entry_set_text (GTK_ENTRY (fe), utf8file);
1185
 
    g_free(utf8file);
1186
 
 
1187
 
    g_object_set_data (G_OBJECT (dlg), "filename", fe);
1188
 
 
1189
 
    return;
1190
 
} // end of sp_export_browse_store()
1191
 
 
 
1223
// TODO: Move this to nr-rect-fns.h.
1192
1224
static bool
1193
 
sp_export_bbox_equal(NR::Rect &one, NR::Rect &two)
 
1225
sp_export_bbox_equal(NR::Rect const &one, NR::Rect const &two)
1194
1226
{ 
1195
 
    // FIXME: make this an NR::Rect method
1196
 
    double epsilon = 1.0 / pow (10, EXPORT_COORD_PRECISION);
 
1227
    double const epsilon = pow(10.0, -EXPORT_COORD_PRECISION);
1197
1228
    return (
1198
1229
        (fabs(one.min()[NR::X] - two.min()[NR::X]) < epsilon) &&
1199
1230
        (fabs(one.min()[NR::Y] - two.min()[NR::Y]) < epsilon) &&
1223
1254
    that, so for this to work for them - it needs to check on that level
1224
1255
    of accuracy.
1225
1256
 
1226
 
    \todo finish writing this up 
 
1257
    \todo finish writing this up
1227
1258
*/
1228
1259
static void
1229
1260
sp_export_detect_size(GtkObject * base) {
1251
1282
        // std::cout << "Looking at: " << selection_names[this_test[i]] << std::endl;
1252
1283
        switch (this_test[i]) {
1253
1284
            case SELECTION_SELECTION:
1254
 
                if ((SP_DT_SELECTION(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
1255
 
                    NR::Rect bbox = (SP_DT_SELECTION (SP_ACTIVE_DESKTOP))->bounds();
 
1285
                if ((sp_desktop_selection(SP_ACTIVE_DESKTOP))->isEmpty() == false) {
 
1286
                    NR::Rect bbox = (sp_desktop_selection (SP_ACTIVE_DESKTOP))->bounds();
1256
1287
 
1257
1288
                    //std::cout << "Selection " << bbox;
1258
1289
                    if (sp_export_bbox_equal(bbox,current_bbox)) {
1261
1292
                }
1262
1293
                break;
1263
1294
            case SELECTION_DRAWING: {
1264
 
                SPDocument *doc = SP_DT_DOCUMENT (SP_ACTIVE_DESKTOP);
 
1295
                SPDocument *doc = sp_desktop_document (SP_ACTIVE_DESKTOP);
1265
1296
 
1266
1297
                NR::Rect bbox = sp_item_bbox_desktop (SP_ITEM (SP_DOCUMENT_ROOT (doc)));
1267
1298
 
1275
1306
            case SELECTION_PAGE: {
1276
1307
                SPDocument *doc;
1277
1308
 
1278
 
                doc = SP_DT_DOCUMENT (SP_ACTIVE_DESKTOP);
 
1309
                doc = sp_desktop_document (SP_ACTIVE_DESKTOP);
1279
1310
 
1280
1311
                NR::Point x(0.0, 0.0);
1281
1312
                NR::Point y(sp_document_width(doc),
1317
1348
 
1318
1349
    if (gtk_object_get_data (base, "update"))
1319
1350
        return;
1320
 
        
1321
 
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data 
1322
 
            (base, "units"))) 
 
1351
 
 
1352
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
 
1353
            (base, "units")))
1323
1354
    {
1324
1355
        return;
1325
1356
    }
1326
 
    
 
1357
 
1327
1358
    gtk_object_set_data ( base, "update", GUINT_TO_POINTER (TRUE) );
1328
1359
 
1329
1360
    x0 = sp_export_value_get_px (base, "x0");
1336
1367
        const gchar *key;
1337
1368
        width = SP_EXPORT_MIN_SIZE;
1338
1369
        key = (const gchar *)gtk_object_get_data (GTK_OBJECT (adj), "key");
1339
 
        
 
1370
 
1340
1371
        if (!strcmp (key, "x0")) {
1341
1372
            x1 = x0 + width * DPI_BASE / xdpi;
1342
1373
            sp_export_value_set_px (base, "x1", x1);
1364
1395
 
1365
1396
    if (gtk_object_get_data (base, "update"))
1366
1397
        return;
1367
 
    
1368
 
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data 
1369
 
           (base, "units"))) 
 
1398
 
 
1399
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
 
1400
           (base, "units")))
1370
1401
    {
1371
1402
        return;
1372
1403
    }
1373
 
       
 
1404
 
1374
1405
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (TRUE));
1375
1406
 
1376
1407
    y0 = sp_export_value_get_px (base, "y0");
1398
1429
    sp_export_detect_size(base);
1399
1430
 
1400
1431
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (FALSE));
1401
 
    
 
1432
 
1402
1433
    return;
1403
1434
} // end of sp_export_area_y_value_changed()
1404
1435
 
1408
1439
{
1409
1440
    float x0, x1, xdpi, width, bmwidth;
1410
1441
 
1411
 
    if (gtk_object_get_data (base, "update")) 
 
1442
    if (gtk_object_get_data (base, "update"))
1412
1443
        return;
1413
 
    
1414
 
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data 
 
1444
 
 
1445
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
1415
1446
           (base, "units"))) {
1416
1447
        return;
1417
1448
    }
1418
 
    
 
1449
 
1419
1450
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (TRUE));
1420
1451
 
1421
1452
    x0 = sp_export_value_get_px (base, "x0");
1425
1456
    bmwidth = floor (width * xdpi / DPI_BASE + 0.5);
1426
1457
 
1427
1458
    if (bmwidth < SP_EXPORT_MIN_SIZE) {
1428
 
    
 
1459
 
1429
1460
        bmwidth = SP_EXPORT_MIN_SIZE;
1430
1461
        width = bmwidth * DPI_BASE / xdpi;
1431
1462
        sp_export_value_set_px (base, "width", width);
1448
1479
 
1449
1480
    if (gtk_object_get_data (base, "update"))
1450
1481
        return;
1451
 
    
1452
 
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data 
 
1482
 
 
1483
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
1453
1484
           (base, "units"))) {
1454
1485
        return;
1455
1486
    }
1456
 
    
 
1487
 
1457
1488
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (TRUE));
1458
1489
 
1459
1490
    y0 = sp_export_value_get_px (base, "y0");
1472
1503
    sp_export_value_set (base, "bmheight", bmheight);
1473
1504
 
1474
1505
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (FALSE));
1475
 
    
 
1506
 
1476
1507
    return;
1477
1508
} // end of sp_export_area_height_value_changed()
1478
1509
 
1499
1530
    return;
1500
1531
} // end of sp_export_set_image_y()
1501
1532
 
 
1533
/**
 
1534
    \brief  A function to set the xdpi
 
1535
    \param  base  The export dialog
 
1536
 
 
1537
    This function grabs all of the x values and then figures out the
 
1538
    new bitmap size based on the changing dpi value.  The dpi value is
 
1539
    gotten from the xdpi setting as these can not currently be independent.
 
1540
*/
 
1541
static void
 
1542
sp_export_set_image_x (GtkObject *base)
 
1543
{
 
1544
    float x0, x1, xdpi;
 
1545
 
 
1546
    x0 = sp_export_value_get_px (base, "x0");
 
1547
    x1 = sp_export_value_get_px (base, "x1");
 
1548
    xdpi = sp_export_value_get (base, "xdpi");
 
1549
 
 
1550
    sp_export_value_set (base, "ydpi", xdpi);
 
1551
    sp_export_value_set (base, "bmwidth", (x1 - x0) * xdpi / DPI_BASE);
 
1552
 
 
1553
    return;
 
1554
} // end of sp_export_set_image_x()
 
1555
 
1502
1556
/// Called when pixel width is changed
1503
1557
static void
1504
1558
sp_export_bitmap_width_value_changed (GtkAdjustment *adj, GtkObject *base)
1505
1559
{
1506
1560
    float x0, x1, bmwidth, xdpi;
1507
1561
 
1508
 
    if (gtk_object_get_data (base, "update")) 
 
1562
    if (gtk_object_get_data (base, "update"))
1509
1563
        return;
1510
 
        
1511
 
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data 
 
1564
 
 
1565
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
1512
1566
           (base, "units"))) {
1513
1567
       return;
1514
1568
    }
1515
 
    
 
1569
 
1516
1570
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (TRUE));
1517
1571
 
1518
1572
    x0 = sp_export_value_get_px (base, "x0");
1534
1588
    return;
1535
1589
} // end of sp_export_bitmap_width_value_changed()
1536
1590
 
 
1591
/// Called when pixel height is changed
 
1592
static void
 
1593
sp_export_bitmap_height_value_changed (GtkAdjustment *adj, GtkObject *base)
 
1594
{
 
1595
    float y0, y1, bmheight, xdpi;
 
1596
 
 
1597
    if (gtk_object_get_data (base, "update"))
 
1598
        return;
 
1599
 
 
1600
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
 
1601
           (base, "units"))) {
 
1602
       return;
 
1603
    }
 
1604
 
 
1605
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (TRUE));
 
1606
 
 
1607
    y0 = sp_export_value_get_px (base, "y0");
 
1608
    y1 = sp_export_value_get_px (base, "y1");
 
1609
    bmheight = sp_export_value_get (base, "bmheight");
 
1610
 
 
1611
    if (bmheight < SP_EXPORT_MIN_SIZE) {
 
1612
        bmheight = SP_EXPORT_MIN_SIZE;
 
1613
        sp_export_value_set (base, "bmheight", bmheight);
 
1614
    }
 
1615
 
 
1616
    xdpi = bmheight * DPI_BASE / (y1 - y0);
 
1617
    sp_export_value_set (base, "xdpi", xdpi);
 
1618
 
 
1619
    sp_export_set_image_x (base);
 
1620
 
 
1621
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (FALSE));
 
1622
 
 
1623
    return;
 
1624
} // end of sp_export_bitmap_width_value_changed()
 
1625
 
1537
1626
/**
1538
1627
    \brief  A function to adjust the bitmap width when the xdpi value changes
1539
1628
    \param  adj  The adjustment that was changed
1545
1634
    units change, we also assume that everyone is being updated appropriately
1546
1635
    and there is nothing for us to do.
1547
1636
 
1548
 
    If we're the highest level function, we set the update flag, and 
 
1637
    If we're the highest level function, we set the update flag, and
1549
1638
    continue on our way.
1550
1639
 
1551
1640
    All of the values are grabbed using the \c sp_export_value_get functions
1567
1656
{
1568
1657
    float x0, x1, xdpi, bmwidth;
1569
1658
 
1570
 
    if (gtk_object_get_data (base, "update")) 
 
1659
    if (gtk_object_get_data (base, "update"))
1571
1660
        return;
1572
 
    
1573
 
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data 
 
1661
 
 
1662
    if (sp_unit_selector_update_test ((SPUnitSelector *)gtk_object_get_data
1574
1663
           (base, "units"))) {
1575
1664
       return;
1576
1665
    }
1577
 
    
 
1666
 
1578
1667
    gtk_object_set_data (base, "update", GUINT_TO_POINTER (TRUE));
1579
1668
 
1580
1669
    x0 = sp_export_value_get_px (base, "x0");
1588
1677
 
1589
1678
    if (bmwidth < SP_EXPORT_MIN_SIZE) {
1590
1679
        bmwidth = SP_EXPORT_MIN_SIZE;
1591
 
        if (x1 != x0) 
 
1680
        if (x1 != x0)
1592
1681
            xdpi = bmwidth * DPI_BASE / (x1 - x0);
1593
 
        else 
 
1682
        else
1594
1683
            xdpi = DPI_BASE;
1595
1684
        sp_export_value_set (base, "xdpi", xdpi);
1596
1685
    }
1698
1787
    adj = (GtkAdjustment *)gtk_object_get_data (base, key);
1699
1788
 
1700
1789
    return adj->value;
1701
 
} // end of sp_export_value_get()
 
1790
}
1702
1791
 
1703
1792
/**
1704
1793
    \brief  Grabs a value in the export dialog and converts the unit