src/ui/dialog/inkscape-preferences.cpp

   1 /**
   2  * \brief Inkscape Preferences dialog
   3  *
   4  * Authors:
   5  *   Carl Hetherington
   6  *   Marco Scholten
   7  *
   8  * Copyright (C) 2004, 2006 Authors
   9  *
  10  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 #include <gtkmm/frame.h>
  18 #include <gtkmm/scrolledwindow.h>
  19
  20 #include "prefs-utils.h"
  21 #include "inkscape-preferences.h"
  22 #include "verbs.h"
  23 #include "selcue.h"
  24 #include <iostream>
  25 #include "enums.h"
  26 #include "inkscape.h"
  27 #include "desktop-handles.h"
  28 #include "message-stack.h"
  29 #include "style.h"
  30 #include "selection.h"
  31 #include "selection-chemistry.h"
  32 #include "xml/repr.h"
  33
  34 namespace Inkscape {
  35 namespace UI {
  36 namespace Dialog {
  37
  38 InkscapePreferences::InkscapePreferences()
  39     : Dialog ("dialogs.preferences", SP_VERB_DIALOG_DISPLAY),
  40       _max_dialog_width(0),
  41       _max_dialog_height(0),
  42       _current_page(0)
  43 {
  44     //get the width of a spinbutton
  45     Gtk::SpinButton* sb = new Gtk::SpinButton;
  46     sb->set_width_chars(6);
  47     this->get_vbox()->add(*sb);
  48     this->show_all_children();
  49     _sb_width = sb->size_request().width;
  50     this->get_vbox()->remove(*sb);
  51     delete sb;
  52
  53     //Main HBox
  54     Gtk::HBox* hbox_list_page = Gtk::manage(new Gtk::HBox());
  55     hbox_list_page->set_border_width(12);
  56     hbox_list_page->set_spacing(12);
  57     this->get_vbox()->add(*hbox_list_page);
  58
  59
  60     //Pagelist
  61     Gtk::Frame* list_frame = Gtk::manage(new Gtk::Frame());
  62     Gtk::ScrolledWindow* scrolled_window = Gtk::manage(new Gtk::ScrolledWindow());
  63     hbox_list_page->pack_start(*list_frame, false, true, 0);
  64     _page_list.set_headers_visible(false);
  65     scrolled_window->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
  66     scrolled_window->add(_page_list);
  67     list_frame->set_shadow_type(Gtk::SHADOW_IN);
  68     list_frame->add(*scrolled_window);
  69     _page_list_model = Gtk::TreeStore::create(_page_list_columns);
  70     _page_list.set_model(_page_list_model);
  71     _page_list.append_column("id",_page_list_columns._col_id);
  72         Glib::RefPtr<Gtk::TreeSelection> _page_list_selection = _page_list.get_selection();
  73         _page_list_selection->signal_changed().connect(sigc::mem_fun(*this, &InkscapePreferences::on_pagelist_selection_changed));
  74         _page_list_selection->set_mode(Gtk::SELECTION_BROWSE);
  75
  76     //Pages
  77     Gtk::VBox* vbox_page = Gtk::manage(new Gtk::VBox());
  78     Gtk::Frame* title_frame = Gtk::manage(new Gtk::Frame());
  79     hbox_list_page->pack_start(*vbox_page, true, true, 0);
  80     title_frame->add(_page_title);
  81     vbox_page->pack_start(*title_frame, false, false, 0);
  82     vbox_page->pack_start(_page_frame, true, true, 0);
  83     _page_frame.set_shadow_type(Gtk::SHADOW_IN);
  84     title_frame->set_shadow_type(Gtk::SHADOW_IN);
  85
  86     initPageMouse();
  87     initPageScrolling();
  88     initPageSteps();
  89     initPageTools();
  90     initPageWindows();
  91     initPageClones();
  92     initPageTransforms();
  93     initPageSelecting();
  94     initPageMisc();
  95
  96     //calculate the size request for this dialog
  97     this->show_all_children();
  98     _page_list.expand_all();
  99     _page_list_model->foreach_iter(sigc::mem_fun(*this, &InkscapePreferences::SetMaxDialogSize));
 100     this->set_size_request(_max_dialog_width, _max_dialog_height);
 101     _page_list.collapse_all();
 102
 103     //Select page todo: select last
 104     Gtk::TreeModel::iterator iter = _page_list_model->children().begin();
 105     if(iter)
 106       _page_list_selection->select(iter);
 107 }
 108
 109 InkscapePreferences::~InkscapePreferences()
 110 {
 111 }
 112
 113 Gtk::TreeModel::iterator InkscapePreferences::AddPage(DialogPage& p, Glib::ustring title)
 114 {
 115     Gtk::TreeModel::iterator iter = _page_list_model->append();
 116     Gtk::TreeModel::Row row = *iter;
 117     row[_page_list_columns._col_id] = title;
 118     row[_page_list_columns._col_page] = &p;
 119     return iter;
 120 }
 121
 122 Gtk::TreeModel::iterator InkscapePreferences::AddPage(DialogPage& p, Glib::ustring title, Gtk::TreeModel::iterator parent)
 123 {
 124     Gtk::TreeModel::iterator iter = _page_list_model->append((*parent).children());
 125     Gtk::TreeModel::Row row = *iter;
 126     row[_page_list_columns._col_id] = title;
 127     row[_page_list_columns._col_page] = &p;
 128     return iter;
 129 }
 130
 131 void InkscapePreferences::initPageMouse()
 132 {
 133     this->AddPage(_page_mouse, _("Mouse"));
 134     _mouse_sens.init ( "options.cursortolerance", "value", 0.0, 30.0, 1.0, 1.0, 8.0, true, false);
 135     _page_mouse.add_line( false, _("Grab sensitivity:"), _mouse_sens, _("pixels"),
 136                            _("How close on the screen you need to be to an object to be able to grab it with mouse (in screen pixels)"), false);
 137     _mouse_thres.init ( "options.dragtolerance", "value", 0.0, 20.0, 1.0, 1.0, 4.0, true, false);
 138     _page_mouse.add_line( false, _("Click/drag threshold:"), _mouse_thres, _("pixels"),
 139                            _("Maximum mouse drag (in screen pixels) which is considered a click, not a drag"), false);
 140 }
 141
 142 void InkscapePreferences::initPageScrolling()
 143 {
 144     this->AddPage(_page_scrolling, _("Scrolling"));
 145     _scroll_wheel.init ( "options.wheelscroll", "value", 0.0, 1000.0, 1.0, 1.0, 40.0, true, false);
 146     _page_scrolling.add_line( false, _("Mouse wheel scrolls by:"), _scroll_wheel, _("pixels"),
 147                            _("One mouse wheel notch scrolls by this distance in screen pixels (horizontally with Shift)"), false);
 148     _page_scrolling.add_group_header( _("Ctrl+arrows"));
 149     _scroll_arrow_px.init ( "options.keyscroll", "value", 0.0, 1000.0, 1.0, 1.0, 10.0, true, false);
 150     _page_scrolling.add_line( true, _("Scroll by:"), _scroll_arrow_px, _("pixels"),
 151                            _("Pressing Ctrl+arrow key scrolls by this distance (in screen pixels)"), false);
 152     _scroll_arrow_acc.init ( "options.scrollingacceleration", "value", 0.0, 5.0, 0.01, 1.0, 0.35, false, false);
 153     _page_scrolling.add_line( true, _("Acceleration:"), _scroll_arrow_acc, "",
 154                            _("Pressing and holding Ctrl+arrow will gradually speed up scrolling (0 for no acceleration)"), false);
 155     _page_scrolling.add_group_header( _("Autoscrolling"));
 156     _scroll_auto_speed.init ( "options.autoscrollspeed", "value", 0.0, 5.0, 0.01, 1.0, 0.7, false, false);
 157     _page_scrolling.add_line( true, _("Speed:"), _scroll_auto_speed, "",
 158                            _("How fast the canvas autoscrolls when you drag beyond canvas edge (0 to turn autoscroll off)"), false);
 159     _scroll_auto_thres.init ( "options.autoscrolldistance", "value", -600.0, 600.0, 1.0, 1.0, -10.0, true, false);
 160     _page_scrolling.add_line( true, _("Threshold:"), _scroll_auto_thres, _("pixels"),
 161                            _("How far (in screen pixels) you need to be from the canvas edge to trigger autoscroll; positive is outside the canvas, negative is within the canvas"), false);
 162 }
 163
 164 void InkscapePreferences::initPageSteps()
 165 {
 166     this->AddPage(_page_steps, _("Steps"));
 167
 168     _steps_arrow.init ( "options.nudgedistance", "value", 0.0, 3000.0, 0.01, 1.0, 2.0, false, false);
 169     _page_steps.add_line( false, _("Arrow keys move by:"), _steps_arrow, _("px"),
 170                           _("Pressing an arrow key moves selected object(s) or node(s) by this distance (in px units)"), false);
 171     _steps_scale.init ( "options.defaultscale", "value", 0.0, 3000.0, 0.01, 1.0, 2.0, false, false);
 172     _page_steps.add_line( false, _("> and < scale by:"), _steps_scale, _("px"),
 173                           _("Pressing > or < scales selection up or down by this increment (in px units)"), false);
 174     _steps_inset.init ( "options.defaultoffsetwidth", "value", 0.0, 3000.0, 0.01, 1.0, 2.0, false, false);
 175     _page_steps.add_line( false, _("Inset/Outset by:"), _steps_inset, _("px"),
 176                           _("Inset and Outset commands displace the path by this distance (in px units)"), false);
 177     _steps_compass.init ( _("Compass-like display of angles"), "options.compassangledisplay", "value", true);
 178     _page_windows.add_line( false, "", _steps_compass, "",
 179                             _("When on, angles are displayed with 0 at north, 0 to 360 range, positive clockwise; otherwise with 0 at east, -180 to 180 range, positive counterclockwise"));
 180     int const num_items = 12;
 181     Glib::ustring labels[num_items] = {"90", "60", "45", "30", "15", "10", "7.5", "6", "3", "2", "1", _("None")};
 182     int values[num_items] = {2, 3, 4, 6, 12, 18, 24, 30, 60, 90, 180, 0};
 183     _steps_rot_snap.set_size_request(_sb_width);
 184     _steps_rot_snap.init("options.rotationsnapsperpi", "value", labels, values, num_items, 12);
 185     _page_steps.add_line( false, _("Rotation snaps every:"), _steps_rot_snap, _("degrees"),
 186                            _("Rotating with Ctrl pressed snaps every that much degrees; also, pressing [ or ] rotates by this amount"), false);
 187     _steps_zoom.init ( "options.zoomincrement", "value", 101.0, 500.0, 1.0, 1.0, 1.414213562, true, true);
 188     _page_steps.add_line( false, _("Zoom in/out by:"), _steps_zoom, _("%"),
 189                           _("Zoom tool click, +/- keys, and middle click zoom in and out by this multiplier"), false);
 190 }
 191
 192 void InkscapePreferences::AddSelcueCheckbox(DialogPage& p, const std::string& prefs_path, bool def_value)
 193 {
 194     PrefCheckButton* cb = Gtk::manage( new PrefCheckButton);
 195     cb->init ( _("Show selection cue"), prefs_path, "selcue", def_value);
 196     p.add_line( false, "", *cb, "", _("Whether selected objects display a selection cue (the same as in selector)"));
 197 }
 198
 199 void InkscapePreferences::AddGradientCheckbox(DialogPage& p, const std::string& prefs_path, bool def_value)
 200 {
 201     PrefCheckButton* cb = Gtk::manage( new PrefCheckButton);
 202     cb->init ( _("Enable gradient editing"), prefs_path, "gradientdrag", def_value);
 203     p.add_line( false, "", *cb, "", _("Whether selected objects display gradient editing controls"));
 204 }
 205
 206 void InkscapePreferences::AddNewObjectsStyle(DialogPage& p, const std::string& prefs_path)
 207 {
 208     PrefRadioButton* current = Gtk::manage( new PrefRadioButton);
 209     PrefRadioButton* own = Gtk::manage( new PrefRadioButton);
 210     Gtk::Button* button = Gtk::manage( new Gtk::Button(_("Take from selection"),true));
 211
 212     own->changed_signal.connect( sigc::mem_fun(*button, &Gtk::Button::set_sensitive) );
 213     button->signal_clicked().connect(sigc::bind( sigc::ptr_fun(InkscapePreferences::StyleFromSelectionToTool), prefs_path.c_str() ) );
 214
 215     current->init ( _("Last used style"), prefs_path, "usecurrent", 1, true, 0);
 216     own->init ( _("This tool's own style:"), prefs_path, "usecurrent", 0, false, current);
 217
 218     p.add_group_header( _("Create new objects with:"));
 219     p.add_line( true, "", *current, "",
 220                 _("Apply the style you last set on an object"));
 221     p.add_line( true, "", *own, "",
 222                 _("Each tool may store its own style to apply to the newly created objects. Use the button below to set it."));
 223     p.add_line( true, "", *button, "",
 224                 _("Remember the style of the (first) selected object as this tool's style"));
 225 }
 226
 227 void InkscapePreferences::StyleFromSelectionToTool(gchar const *prefs_path)
 228 {
 229     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 230     if (desktop == NULL)
 231         return;
 232
 233     Inkscape::Selection *selection = SP_DT_SELECTION(desktop);
 234
 235     if (selection->isEmpty()) {
 236         SP_DT_MSGSTACK(desktop)->flash(Inkscape::ERROR_MESSAGE,
 237                                        _("<b>No objects selected</b> to take the style from."));
 238         return;
 239     }
 240     SPItem *item = selection->singleItem();
 241     if (!item) {
 242         /* TODO: If each item in the selection has the same style then don't consider it an error.
 243          * Maybe we should try to handle multiple selections anyway, e.g. the intersection of the
 244          * style attributes for the selected items. */
 245         SP_DT_MSGSTACK(desktop)->flash(Inkscape::ERROR_MESSAGE,
 246                                        _("<b>More than one object selected.</b>  Cannot take style from multiple objects."));
 247         return;
 248     }
 249
 250     SPCSSAttr *css = take_style_from_item (item);
 251
 252     if (!css) return;
 253
 254     // only store text style for the text tool
 255     if (!g_strrstr ((const gchar *) prefs_path, "text")) {
 256         css = sp_css_attr_unset_text (css);
 257     }
 258
 259     // we cannot store properties with uris - they will be invalid in other documents
 260     css = sp_css_attr_unset_uris (css);
 261
 262     sp_repr_css_change (inkscape_get_repr (INKSCAPE, prefs_path), css, "style");
 263     sp_repr_css_attr_unref (css);
 264 }
 265
 266 void InkscapePreferences::initPageTools()
 267 {
 268     Gtk::TreeModel::iterator iter_tools = this->AddPage(_page_tools, _("Tools"));
 269
 270     //Selector
 271     this->AddPage(_page_selector, _("Selector"), iter_tools);
 272
 273     AddSelcueCheckbox(_page_selector, "tools.select", false);
 274     _page_selector.add_group_header( _("When transforming, show:"));
 275     _t_sel_trans_obj.init ( _("Objects"), "tools.select", "show", "content", true, 0);
 276     _page_selector.add_line( true, "", _t_sel_trans_obj, "",
 277                             _("Show the actual objects when moving or transforming"));
 278     _t_sel_trans_outl.init ( _("Box outline"), "tools.select", "show", "outline", false, &_t_sel_trans_obj);
 279     _page_selector.add_line( true, "", _t_sel_trans_outl, "",
 280                             _("Show only a box outline of the objects when moving or transforming"));
 281     _page_selector.add_group_header( _("Per-object selection cue:"));
 282     _t_sel_cue_none.init ( _("None"), "options.selcue", "value", Inkscape::SelCue::NONE, false, 0);
 283     _page_selector.add_line( true, "", _t_sel_cue_none, "",
 284                             _("No per-object selection indication"));
 285     _t_sel_cue_mark.init ( _("Mark"), "options.selcue", "value", Inkscape::SelCue::MARK, true, &_t_sel_cue_none);
 286     _page_selector.add_line( true, "", _t_sel_cue_mark, "",
 287                             _("Each selected object has a diamond mark in the top left corner"));
 288     _t_sel_cue_box.init ( _("Box"), "options.selcue", "value", Inkscape::SelCue::BBOX, false, &_t_sel_cue_none);
 289     _page_selector.add_line( true, "", _t_sel_cue_box, "",
 290                             _("Each selected object displays its bounding box"));
 291     _page_selector.add_group_header( _("Default scale origin:"));
 292     _t_sel_org_edge.init ( _("Opposite bounding box edge"), "tools.select", "scale_origin", "bbox", true, 0);
 293     _page_selector.add_line( true, "", _t_sel_org_edge, "",
 294                             _("Default scale origin will be on the bounding box of the item"));
 295     _t_sel_org_node.init ( _("Farthest opposite node"), "tools.select", "scale_origin", "points", false, &_t_sel_org_edge);
 296     _page_selector.add_line( true, "", _t_sel_org_node, "",
 297                             _("Default scale origin will be on the bounding box of the item's points"));
 298     //Node
 299     this->AddPage(_page_node, _("Node"), iter_tools);
 300     AddSelcueCheckbox(_page_node, "tools.nodes", true);
 301     AddGradientCheckbox(_page_node, "tools.nodes", true);
 302     //Zoom
 303     this->AddPage(_page_zoom, _("Zoom"), iter_tools);
 304     AddSelcueCheckbox(_page_zoom, "tools.zoom", true);
 305     AddGradientCheckbox(_page_zoom, "tools.zoom", false);
 306     //Shapes
 307     Gtk::TreeModel::iterator iter_shapes = this->AddPage(_page_shapes, _("Shapes"), iter_tools);
 308     this->AddSelcueCheckbox(_page_shapes, "tools.shapes", true);
 309     this->AddGradientCheckbox(_page_shapes, "tools.shapes", true);
 310     //Rectangle
 311     this->AddPage(_page_rectangle, _("Rectangle"), iter_shapes);
 312     this->AddNewObjectsStyle(_page_rectangle, "tools.shapes.rect");
 313     //ellipse
 314     this->AddPage(_page_ellipse, _("Ellipse"), iter_shapes);
 315     this->AddNewObjectsStyle(_page_ellipse, "tools.shapes.arc");
 316     //star
 317     this->AddPage(_page_star, _("Star"), iter_shapes);
 318     this->AddNewObjectsStyle(_page_star, "tools.shapes.star");
 319     //spiral
 320     this->AddPage(_page_spiral, _("Spiral"), iter_shapes);
 321     this->AddNewObjectsStyle(_page_spiral, "tools.shapes.spiral");
 322     //Pencil
 323     this->AddPage(_page_pencil, _("Pencil"), iter_tools);
 324     this->AddSelcueCheckbox(_page_pencil, "tools.freehand.pencil", true);
 325     _t_pencil_tolerance.init ( "tools.freehand.pencil", "tolerance", 0.0, 100.0, 0.5, 1.0, 10.0, false, false);
 326     _page_pencil.add_line( false, _("Tolerance:"), _t_pencil_tolerance, "",
 327                            _("This value affects the amount of smoothing applied to freehand lines; lower values produce more uneven paths with more nodes"),
 328                            false );
 329     this->AddNewObjectsStyle(_page_pencil, "tools.freehand.pencil");
 330     //Pen
 331     this->AddPage(_page_pen, _("Pen"), iter_tools);
 332     this->AddSelcueCheckbox(_page_pen, "tools.freehand.pen", true);
 333     this->AddNewObjectsStyle(_page_pen, "tools.freehand.pen");
 334     //Calligraphy
 335     this->AddPage(_page_calligraphy, _("Calligraphy"), iter_tools);
 336     this->AddNewObjectsStyle(_page_calligraphy, "tools.calligraphic");
 337     //Text
 338     this->AddPage(_page_text, _("Text"), iter_tools);
 339     this->AddSelcueCheckbox(_page_text, "tools.text", true);
 340     this->AddGradientCheckbox(_page_text, "tools.text", true);
 341     this->AddNewObjectsStyle(_page_text, "tools.text");
 342     //Gradient
 343     this->AddPage(_page_gradient, _("Gradient"), iter_tools);
 344     this->AddSelcueCheckbox(_page_gradient, "tools.gradient", true);
 345     //Connector
 346     this->AddPage(_page_connector, _("Connector"), iter_tools);
 347     this->AddSelcueCheckbox(_page_connector, "tools.connector", true);
 348     //Dropper
 349     this->AddPage(_page_dropper, _("Dropper"), iter_tools);
 350     this->AddSelcueCheckbox(_page_dropper, "tools.dropper", true);
 351     this->AddGradientCheckbox(_page_dropper, "tools.dropper", true);
 352 }
 353
 354 void InkscapePreferences::initPageWindows()
 355 {
 356     _win_save_geom.init ( _("Save window geometry"), "options.savewindowgeometry", "value", true);
 357     _win_hide_task.init ( _("Dialogs are hidden in taskbar"), "options.dialogsskiptaskbar", "value", true);
 358     _win_zoom_resize.init ( _("Zoom when window is resized"), "options.stickyzoom", "value", false);
 359     _win_ontop_none.init ( _("None"), "options.transientpolicy", "value", 0, false, 0);
 360     _win_ontop_normal.init ( _("Normal"), "options.transientpolicy", "value", 1, true, &_win_ontop_none);
 361     _win_ontop_agressive.init ( _("Aggressive"), "options.transientpolicy", "value", 2, false, &_win_ontop_none);
 362
 363     _page_windows.add_line( false, "", _win_save_geom, "",
 364                             _("Save the window size and position with each document (only for Inkscape SVG format)"));
 365     _page_windows.add_line( false, "", _win_hide_task, "",
 366                             _("Whether dialog windows are to be hidden in the window manager taskbar"));
 367     _page_windows.add_line( false, "", _win_zoom_resize, "",
 368                             _("Zoom drawing when document window is resized, to keep the same area visible (this is the default which can be changed in any window using the button above the right scrollbar)"));
 369     _page_windows.add_group_header( _("Dialogs on top:"));
 370     _page_windows.add_line( true, "", _win_ontop_none, "",
 371                             _("Dialogs are treated as regular windows"));
 372     _page_windows.add_line( true, "", _win_ontop_normal, "",
 373                             _("Dialogs stay on top of document windows"));
 374     _page_windows.add_line( true, "", _win_ontop_agressive, "",
 375                             _("Same as Normal but may work better with some window managers"));
 376
 377     this->AddPage(_page_windows, _("Windows"));
 378 }
 379
 380 void InkscapePreferences::initPageClones()
 381 {
 382     _clone_option_parallel.init ( _("Move in parallel"), "options.clonecompensation", "value",
 383                                   SP_CLONE_COMPENSATION_PARALLEL, true, 0);
 384     _clone_option_stay.init ( _("Stay unmoved"), "options.clonecompensation", "value",
 385                                   SP_CLONE_COMPENSATION_UNMOVED, false, &_clone_option_parallel);
 386     _clone_option_transform.init ( _("Move according to transform"), "options.clonecompensation", "value",
 387                                   SP_CLONE_COMPENSATION_NONE, false, &_clone_option_parallel);
 388     _clone_option_unlink.init ( _("Are unlinked"), "options.cloneorphans", "value",
 389                                   SP_CLONE_ORPHANS_UNLINK, true, 0);
 390     _clone_option_delete.init ( _("Are deleted"), "options.cloneorphans", "value",
 391                                   SP_CLONE_ORPHANS_DELETE, false, &_clone_option_unlink);
 392
 393     _page_clones.add_group_header( _("When the original moves, its clones and linked offsets:"));
 394     _page_clones.add_line( true, "", _clone_option_parallel, "",
 395                            _("Clones are translated by the same vector as their original."));
 396     _page_clones.add_line( true, "", _clone_option_stay, "",
 397                            _("Clones preserve their positions when their original is moved."));
 398     _page_clones.add_line( true, "", _clone_option_transform, "",
 399                            _("Each clone moves according to the value of its transform= attribute. For example, a rotated clone will move in a different direction than its original."));
 400     _page_clones.add_group_header( _("When the original is deleted, its clones:"));
 401     _page_clones.add_line( true, "", _clone_option_unlink, "",
 402                            _("Orphaned clones are converted to regular objects."));
 403     _page_clones.add_line( true, "", _clone_option_delete, "",
 404                            _("Orphaned clones are deleted along with their original."));
 405
 406     this->AddPage(_page_clones, _("Clones"));
 407 }
 408
 409 void InkscapePreferences::initPageTransforms()
 410 {
 411     _trans_scale_stroke.init ( _("Scale stroke width"), "options.transform", "stroke", true);
 412     _trans_scale_corner.init ( _("Scale rounded corners in rectangles"), "options.transform", "rectcorners", false);
 413     _trans_gradient.init ( _("Transform gradients"), "options.transform", "gradient", true);
 414     _trans_pattern.init ( _("Transform patterns"), "options.transform", "pattern", false);
 415     _trans_optimized.init ( _("Normal"), "options.preservetransform", "value", 0, true, 0);
 416     _trans_preserved.init ( _("Aggressive"), "options.preservetransform", "value", 1, false, &_trans_optimized);
 417
 418     _page_transforms.add_line( false, "", _trans_scale_stroke, "",
 419                                _("When scaling objects, scale the stroke width by the same proportion"));
 420     _page_transforms.add_line( false, "", _trans_scale_corner, "",
 421                                _("When scaling rectangles, scale the radii of rounded corners"));
 422     _page_transforms.add_line( false, "", _trans_gradient, "",
 423                                _("Transform gradients (in fill or stroke) along with the objects"));
 424     _page_transforms.add_line( false, "", _trans_pattern, "",
 425                                _("Transform patterns (in fill or stroke) along with the objects"));
 426     _page_transforms.add_group_header( _("Store transformation:"));
 427     _page_transforms.add_line( true, "", _trans_optimized, "",
 428                                _("If possible, apply transformation to objects without adding a transform= attribute"));
 429     _page_transforms.add_line( true, "", _trans_preserved, "",
 430                                _("Always store transformation as a transform= attribute on objects"));
 431
 432     this->AddPage(_page_transforms, _("Transforms"));
 433 }
 434
 435 void InkscapePreferences::initPageSelecting()
 436 {
 437     _sel_current.init ( _("Select only within current layer"), "options.kbselection", "inlayer", true);
 438     _sel_hidden.init ( _("Ignore hidden objects"), "options.kbselection", "onlyvisible", true);
 439     _sel_locked.init ( _("Ignore locked objects"), "options.kbselection", "onlysensitive", true);
 440
 441     _page_select.add_group_header( _("Ctrl+A, Tab, Shift+Tab:"));
 442     _page_select.add_line( true, "", _sel_current, "",
 443                            _("Uncheck this to make keyboard selection commands work on objects in all layers"));
 444     _page_select.add_line( true, "", _sel_hidden, "",
 445                            _("Uncheck this to be able to select objects that are hidden (either by themselves or by being in a hidden group or layer)"));
 446     _page_select.add_line( true, "", _sel_locked, "",
 447                            _("Uncheck this to be able to select objects that are locked (either by themselves or by being in a locked group or layer)"));
 448
 449     this->AddPage(_page_select, _("Selecting"));
 450 }
 451
 452
 453 void InkscapePreferences::initPageMisc()
 454 {
 455     _misc_export.init("dialogs.export.defaultxdpi", "value", 0.0, 6000.0, 1.0, 1.0, 1.0, true, false);
 456     _page_misc.add_line( false, _("Default export resolution:"), _misc_export, _("dpi"),
 457                            _("Default bitmap resolution (in dots per inch) in the Export dialog"), false);
 458     _misc_imp_bitmap.init( _("Import bitmap as <image>"), "options.importbitmapsasimages", "value", true);
 459     _page_misc.add_line( false, "", _misc_imp_bitmap, "",
 460                            _("When on, an imported bitmap creates an <image> element; otherwise it is a rectangle with bitmap fill"), true);
 461     _misc_comment.init( _("Add label comments to printing output"), "printing.debug", "show-label-comments", false);
 462     _page_misc.add_line( false, "", _misc_comment, "",
 463                            _("When on, a comment will be added to the raw print output, marking the rendered output for an object with its label"), true);
 464     _misc_scripts.init( _("Enable script effects (requires restart) - EXPERIMENTAL"), "extensions", "show-effects-menu", false);
 465     _page_misc.add_line( false, "", _misc_scripts, "",
 466                            _("When on, the effects menu is enabled, allowing external effect scripts to be called, requires restart before effective - EXPERIMENTAL"), true);
 467     _misc_recent.init("options.maxrecentdocuments", "value", 0.0, 1000.0, 1.0, 1.0, 1.0, true, false);
 468     _page_misc.add_line( false, _("Max recent documents:"), _misc_recent, "",
 469                            _("The maximum length of the Open Recent list in the File menu"), false);
 470     _misc_simpl.init("options.simplifythreshold", "value", 0.0, 1.0, 0.001, 0.01, 0.002, false, false);
 471     _page_misc.add_line( false, _("Simplification threshold:"), _misc_simpl, "",
 472                            _("How strong is the Simplify command by default. If you invoke this command several times in quick succession, it will act more and more aggressively; invoking it again after a pause restores the default threshold."), false);
 473     int const num_items = 5;
 474     Glib::ustring labels[num_items] = {_("None"), _("2x2"), _("4x4"), _("8x8"), _("16x16")};
 475     int values[num_items] = {0, 1, 2, 3, 4};
 476     _misc_overs_bitmap.set_size_request(_sb_width);
 477     _misc_overs_bitmap.init("options.bitmapoversample", "value", labels, values, num_items, 1);
 478     _page_misc.add_line( false, _("Oversample bitmaps:"), _misc_overs_bitmap, "", "", false);
 479
 480     this->AddPage(_page_misc, _("Misc"));
 481 }
 482
 483 bool InkscapePreferences::SetMaxDialogSize(const Gtk::TreeModel::iterator& iter)
 484 {
 485     Gtk::TreeModel::Row row = *iter;
 486     DialogPage* page = row[_page_list_columns._col_page];
 487     _page_frame.add(*page);
 488     this->show_all_children();
 489     _max_dialog_width=std::max(_max_dialog_width, this->size_request().width);
 490     _max_dialog_height=std::max(_max_dialog_height, this->size_request().height);
 491     _page_frame.remove();
 492     return false;
 493 }
 494
 495 void InkscapePreferences::on_pagelist_selection_changed()
 496 {
 497     // show new selection
 498     Glib::RefPtr<Gtk::TreeSelection> selection = _page_list.get_selection();
 499     Gtk::TreeModel::iterator iter = selection->get_selected();
 500     if(iter)
 501     {
 502         if (_current_page)
 503             _page_frame.remove();
 504         Gtk::TreeModel::Row row = *iter;
 505         _current_page = row[_page_list_columns._col_page];
 506         _page_title.set_markup("<span size='large'><b>" + row[_page_list_columns._col_id] + "</b></span>");
 507         _page_frame.add(*_current_page);
 508         _current_page->show();
 509     }
 510 }
 511
 512 } // namespace Dialog
 513 } // namespace UI
 514 } // namespace Inkscape
 515
 516 /*
 517   Local Variables:
 518   mode:c++
 519   c-file-style:"stroustrup"
 520   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 521   indent-tabs-mode:nil
 522   fill-column:99
 523   End:
 524 */
 525 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :