src/ui/dialog/inkscape-preferences.cpp

   1 /**
   2  * \brief Inkscape Preferences dialog
   3  *
   4  * Authors:
   5  *   Carl Hetherington
   6  *   Marco Scholten
   7  *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
   8  *   Bruno Dilly <bruno.dilly@gmail.com>
   9  *
  10  * Copyright (C) 2004-2007 Authors
  11  *
  12  * Released under GNU GPL.  Read the file 'COPYING' for more information.
  13  */
  14
  15 #ifdef HAVE_CONFIG_H
  16 # include <config.h>
  17 #endif
  18
  19 #include <gtkmm/main.h>
  20 #include <gtkmm/frame.h>
  21 #include <gtkmm/scrolledwindow.h>
  22 #include <gtkmm/alignment.h>
  23
  24 #include "prefs-utils.h"
  25 #include "inkscape-preferences.h"
  26 #include "verbs.h"
  27 #include "selcue.h"
  28 #include "unit-constants.h"
  29 #include <iostream>
  30 #include "enums.h"
  31 #include "inkscape.h"
  32 #include "desktop-handles.h"
  33 #include "message-stack.h"
  34 #include "style.h"
  35 #include "selection.h"
  36 #include "selection-chemistry.h"
  37 #include "xml/repr.h"
  38 #include "ui/widget/style-swatch.h"
  39 #include "display/nr-filter-gaussian.h"
  40 #include "color-profile-fns.h"
  41 #include "display/canvas-grid.h"
  42
  43 namespace Inkscape {
  44 namespace UI {
  45 namespace Dialog {
  46
  47 InkscapePreferences::InkscapePreferences()
  48     : UI::Widget::Panel ("", "dialogs.preferences", SP_VERB_DIALOG_DISPLAY),
  49       _max_dialog_width(0),
  50       _max_dialog_height(0),
  51       _current_page(0)
  52 {
  53     //get the width of a spinbutton
  54     Gtk::SpinButton* sb = new Gtk::SpinButton;
  55     sb->set_width_chars(6);
  56     _getContents()->add(*sb);
  57     show_all_children();
  58     Gtk::Requisition sreq;
  59     sb->size_request(sreq);
  60     _sb_width = sreq.width;
  61     _getContents()->remove(*sb);
  62     delete sb;
  63
  64     //Main HBox
  65     Gtk::HBox* hbox_list_page = Gtk::manage(new Gtk::HBox());
  66     hbox_list_page->set_border_width(12);
  67     hbox_list_page->set_spacing(12);
  68     _getContents()->add(*hbox_list_page);
  69
  70     //Pagelist
  71     Gtk::Frame* list_frame = Gtk::manage(new Gtk::Frame());
  72     Gtk::ScrolledWindow* scrolled_window = Gtk::manage(new Gtk::ScrolledWindow());
  73     hbox_list_page->pack_start(*list_frame, false, true, 0);
  74     _page_list.set_headers_visible(false);
  75     scrolled_window->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
  76     scrolled_window->add(_page_list);
  77     list_frame->set_shadow_type(Gtk::SHADOW_IN);
  78     list_frame->add(*scrolled_window);
  79     _page_list_model = Gtk::TreeStore::create(_page_list_columns);
  80     _page_list.set_model(_page_list_model);
  81     _page_list.append_column("name",_page_list_columns._col_name);
  82         Glib::RefPtr<Gtk::TreeSelection> page_list_selection = _page_list.get_selection();
  83         page_list_selection->signal_changed().connect(sigc::mem_fun(*this, &InkscapePreferences::on_pagelist_selection_changed));
  84         page_list_selection->set_mode(Gtk::SELECTION_BROWSE);
  85
  86     //Pages
  87     Gtk::VBox* vbox_page = Gtk::manage(new Gtk::VBox());
  88     Gtk::Frame* title_frame = Gtk::manage(new Gtk::Frame());
  89     hbox_list_page->pack_start(*vbox_page, true, true, 0);
  90     title_frame->add(_page_title);
  91     vbox_page->pack_start(*title_frame, false, false, 0);
  92     vbox_page->pack_start(_page_frame, true, true, 0);
  93     _page_frame.set_shadow_type(Gtk::SHADOW_IN);
  94     title_frame->set_shadow_type(Gtk::SHADOW_IN);
  95
  96     initPageMouse();
  97     initPageScrolling();
  98     initPageSteps();
  99     initPageTools();
 100     initPageWindows();
 101     initPageClones();
 102     initPageMasks();
 103     initPageTransforms();
 104     initPageFilters();
 105     initPageSelecting();
 106     initPageImportExport();
 107     initPageCMS();
 108     initPageGrids();
 109     initPageMisc();
 110
 111     signalPresent().connect(sigc::mem_fun(*this, &InkscapePreferences::_presentPages));
 112
 113     //calculate the size request for this dialog
 114     this->show_all_children();
 115     _page_list.expand_all();
 116     _page_list_model->foreach_iter(sigc::mem_fun(*this, &InkscapePreferences::SetMaxDialogSize));
 117     _getContents()->set_size_request(_max_dialog_width, _max_dialog_height);
 118     _page_list.collapse_all();
 119 }
 120
 121 InkscapePreferences::~InkscapePreferences()
 122 {
 123 }
 124
 125 Gtk::TreeModel::iterator InkscapePreferences::AddPage(DialogPage& p, Glib::ustring title, int id)
 126 {
 127     return AddPage(p, title, Gtk::TreeModel::iterator() , id);
 128 }
 129
 130 Gtk::TreeModel::iterator InkscapePreferences::AddPage(DialogPage& p, Glib::ustring title, Gtk::TreeModel::iterator parent, int id)
 131 {
 132     Gtk::TreeModel::iterator iter;
 133     if (parent)
 134        iter = _page_list_model->append((*parent).children());
 135     else
 136        iter = _page_list_model->append();
 137     Gtk::TreeModel::Row row = *iter;
 138     row[_page_list_columns._col_name] = title;
 139     row[_page_list_columns._col_id] = id;
 140     row[_page_list_columns._col_page] = &p;
 141     return iter;
 142 }
 143
 144 void InkscapePreferences::initPageMouse()
 145 {
 146     this->AddPage(_page_mouse, _("Mouse"), PREFS_PAGE_MOUSE);
 147     _mouse_sens.init ( "options.cursortolerance", "value", 0.0, 30.0, 1.0, 1.0, 8.0, true, false);
 148     _page_mouse.add_line( false, _("Grab sensitivity:"), _mouse_sens, _("pixels"),
 149                            _("How close on the screen you need to be to an object to be able to grab it with mouse (in screen pixels)"), false);
 150     _mouse_thres.init ( "options.dragtolerance", "value", 0.0, 20.0, 1.0, 1.0, 4.0, true, false);
 151     _page_mouse.add_line( false, _("Click/drag threshold:"), _mouse_thres, _("pixels"),
 152                            _("Maximum mouse drag (in screen pixels) which is considered a click, not a drag"), false);
 153
 154     _mouse_use_ext_input.init( _("Use pressure-sensitive tablet (requires restart)"), "options.useextinput", "value", true);
 155     _page_mouse.add_line(true, "",_mouse_use_ext_input, "",
 156                         _("Use the capabilities of a tablet or other pressure-sensitive device. Disable this only if you have problems with the tablet (you can still use it as a mouse)"));
 157
 158 }
 159
 160 void InkscapePreferences::initPageScrolling()
 161 {
 162     this->AddPage(_page_scrolling, _("Scrolling"), PREFS_PAGE_SCROLLING);
 163     _scroll_wheel.init ( "options.wheelscroll", "value", 0.0, 1000.0, 1.0, 1.0, 40.0, true, false);
 164     _page_scrolling.add_line( false, _("Mouse wheel scrolls by:"), _scroll_wheel, _("pixels"),
 165                            _("One mouse wheel notch scrolls by this distance in screen pixels (horizontally with Shift)"), false);
 166     _page_scrolling.add_group_header( _("Ctrl+arrows"));
 167     _scroll_arrow_px.init ( "options.keyscroll", "value", 0.0, 1000.0, 1.0, 1.0, 10.0, true, false);
 168     _page_scrolling.add_line( true, _("Scroll by:"), _scroll_arrow_px, _("pixels"),
 169                            _("Pressing Ctrl+arrow key scrolls by this distance (in screen pixels)"), false);
 170     _scroll_arrow_acc.init ( "options.scrollingacceleration", "value", 0.0, 5.0, 0.01, 1.0, 0.35, false, false);
 171     _page_scrolling.add_line( true, _("Acceleration:"), _scroll_arrow_acc, "",
 172                            _("Pressing and holding Ctrl+arrow will gradually speed up scrolling (0 for no acceleration)"), false);
 173     _page_scrolling.add_group_header( _("Autoscrolling"));
 174     _scroll_auto_speed.init ( "options.autoscrollspeed", "value", 0.0, 5.0, 0.01, 1.0, 0.7, false, false);
 175     _page_scrolling.add_line( true, _("Speed:"), _scroll_auto_speed, "",
 176                            _("How fast the canvas autoscrolls when you drag beyond canvas edge (0 to turn autoscroll off)"), false);
 177     _scroll_auto_thres.init ( "options.autoscrolldistance", "value", -600.0, 600.0, 1.0, 1.0, -10.0, true, false);
 178     _page_scrolling.add_line( true, _("Threshold:"), _scroll_auto_thres, _("pixels"),
 179                            _("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);
 180     _scroll_space.init ( _("Left mouse button pans when Space is pressed"), "options.spacepans", "value", false);
 181     _page_scrolling.add_line( false, "", _scroll_space, "",
 182                             _("When on, pressing and holding Space and dragging with left mouse button pans canvas (as in Adobe Illustrator). When off, Space temporarily switches to Selector tool (default)."));
 183     _wheel_zoom.init ( _("Mouse wheel zooms by default"), "options.wheelzooms", "value", false);
 184     _page_scrolling.add_line( false, "", _wheel_zoom, "",
 185                             _("When on, mouse wheel zooms without Ctrl and scrolls canvas with Ctrl; when off, it zooms with Ctrl and scrolls without Ctrl."));
 186 }
 187
 188 void InkscapePreferences::initPageSteps()
 189 {
 190     this->AddPage(_page_steps, _("Steps"), PREFS_PAGE_STEPS);
 191
 192     _steps_arrow.init ( "options.nudgedistance", "value", 0.0, 1000.0, 0.01, 1.0, 2.0, false, false);
 193     //nudgedistance is limited to 1000 in select-context.cpp: use the same limit here
 194     _page_steps.add_line( false, _("Arrow keys move by:"), _steps_arrow, _("px"),
 195                           _("Pressing an arrow key moves selected object(s) or node(s) by this distance (in px units)"), false);
 196     _steps_scale.init ( "options.defaultscale", "value", 0.0, 1000.0, 0.01, 1.0, 2.0, false, false);
 197     //defaultscale is limited to 1000 in select-context.cpp: use the same limit here
 198     _page_steps.add_line( false, _("> and < scale by:"), _steps_scale, _("px"),
 199                           _("Pressing > or < scales selection up or down by this increment (in px units)"), false);
 200     _steps_inset.init ( "options.defaultoffsetwidth", "value", 0.0, 3000.0, 0.01, 1.0, 2.0, false, false);
 201     _page_steps.add_line( false, _("Inset/Outset by:"), _steps_inset, _("px"),
 202                           _("Inset and Outset commands displace the path by this distance (in px units)"), false);
 203     _steps_compass.init ( _("Compass-like display of angles"), "options.compassangledisplay", "value", true);
 204     _page_steps.add_line( false, "", _steps_compass, "",
 205                             _("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"));
 206     int const num_items = 17;
 207     Glib::ustring labels[num_items] = {"90", "60", "45", "36", "30", "22.5", "18", "15", "12", "10", "7.5", "6", "3", "2", "1", "0.5", _("None")};
 208     int values[num_items] = {2, 3, 4, 5, 6, 8, 10, 12, 15, 18, 24, 30, 60, 90, 180, 360, 0};
 209     _steps_rot_snap.set_size_request(_sb_width);
 210     _steps_rot_snap.init("options.rotationsnapsperpi", "value", labels, values, num_items, 12);
 211     _page_steps.add_line( false, _("Rotation snaps every:"), _steps_rot_snap, _("degrees"),
 212                            _("Rotating with Ctrl pressed snaps every that much degrees; also, pressing [ or ] rotates by this amount"), false);
 213     _steps_zoom.init ( "options.zoomincrement", "value", 101.0, 500.0, 1.0, 1.0, 1.414213562, true, true);
 214     _page_steps.add_line( false, _("Zoom in/out by:"), _steps_zoom, _("%"),
 215                           _("Zoom tool click, +/- keys, and middle click zoom in and out by this multiplier"), false);
 216 }
 217
 218 void InkscapePreferences::AddSelcueCheckbox(DialogPage& p, const std::string& prefs_path, bool def_value)
 219 {
 220     PrefCheckButton* cb = Gtk::manage( new PrefCheckButton);
 221     cb->init ( _("Show selection cue"), prefs_path, "selcue", def_value);
 222     p.add_line( false, "", *cb, "", _("Whether selected objects display a selection cue (the same as in selector)"));
 223 }
 224
 225 void InkscapePreferences::AddGradientCheckbox(DialogPage& p, const std::string& prefs_path, bool def_value)
 226 {
 227     PrefCheckButton* cb = Gtk::manage( new PrefCheckButton);
 228     cb->init ( _("Enable gradient editing"), prefs_path, "gradientdrag", def_value);
 229     p.add_line( false, "", *cb, "", _("Whether selected objects display gradient editing controls"));
 230 }
 231
 232 void InkscapePreferences::AddConvertGuidesCheckbox(DialogPage& p, const std::string& prefs_path, bool def_value) {
 233     PrefCheckButton* cb = Gtk::manage( new PrefCheckButton);
 234     cb->init ( _("Conversion to guides uses edges instead of bounding box"), prefs_path, "convertguides", def_value);
 235     p.add_line( false, "", *cb, "", _("Converting an object to guides places these along the object's true edges (imitating the object's shape), not along the bounding box."));
 236 }
 237
 238 void StyleFromSelectionToTool(gchar const *prefs_path, StyleSwatch *swatch)
 239 {
 240     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 241     if (desktop == NULL)
 242         return;
 243
 244     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 245
 246     if (selection->isEmpty()) {
 247         sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE,
 248                                        _("<b>No objects selected</b> to take the style from."));
 249         return;
 250     }
 251     SPItem *item = selection->singleItem();
 252     if (!item) {
 253         /* TODO: If each item in the selection has the same style then don't consider it an error.
 254          * Maybe we should try to handle multiple selections anyway, e.g. the intersection of the
 255          * style attributes for the selected items. */
 256         sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE,
 257                                        _("<b>More than one object selected.</b>  Cannot take style from multiple objects."));
 258         return;
 259     }
 260
 261     SPCSSAttr *css = take_style_from_item (item);
 262
 263     if (!css) return;
 264
 265     // only store text style for the text tool
 266     if (!g_strrstr ((const gchar *) prefs_path, "text")) {
 267         css = sp_css_attr_unset_text (css);
 268     }
 269
 270     // we cannot store properties with uris - they will be invalid in other documents
 271     css = sp_css_attr_unset_uris (css);
 272
 273     sp_repr_css_change (inkscape_get_repr (INKSCAPE, prefs_path), css, "style");
 274     sp_repr_css_attr_unref (css);
 275
 276     // update the swatch
 277     if (swatch) {
 278         Inkscape::XML::Node *tool_repr = inkscape_get_repr(INKSCAPE, prefs_path);
 279         if (tool_repr) {
 280             SPCSSAttr *css = sp_repr_css_attr_inherited(tool_repr, "style");
 281             swatch->setStyle (css);
 282             sp_repr_css_attr_unref(css);
 283         }
 284     }
 285 }
 286
 287 void InkscapePreferences::AddNewObjectsStyle(DialogPage& p, const std::string& prefs_path)
 288 {
 289
 290
 291     p.add_group_header( _("Create new objects with:"));
 292     PrefRadioButton* current = Gtk::manage( new PrefRadioButton);
 293     current->init ( _("Last used style"), prefs_path, "usecurrent", 1, true, 0);
 294     p.add_line( true, "", *current, "",
 295                 _("Apply the style you last set on an object"));
 296
 297     PrefRadioButton* own = Gtk::manage( new PrefRadioButton);
 298     Gtk::HBox* hb = Gtk::manage( new Gtk::HBox);
 299     Gtk::Alignment* align = Gtk::manage( new Gtk::Alignment);
 300     own->init ( _("This tool's own style:"), prefs_path, "usecurrent", 0, false, current);
 301     align->set(0,0,0,0);
 302     align->add(*own);
 303     hb->add(*align);
 304     p.set_tip( *own, _("Each tool may store its own style to apply to the newly created objects. Use the button below to set it."));
 305     p.add_line( true, "", *hb, "", "");
 306
 307     // style swatch
 308     Inkscape::XML::Node *tool_repr = inkscape_get_repr(INKSCAPE, prefs_path.c_str());
 309     Gtk::Button* button = Gtk::manage( new Gtk::Button(_("Take from selection"),true));
 310     StyleSwatch *swatch = 0;
 311     if (tool_repr) {
 312         SPCSSAttr *css = sp_repr_css_attr_inherited(tool_repr, "style");
 313         swatch = new StyleSwatch(css, _("This tool's style of new objects"));
 314         hb->add(*swatch);
 315         sp_repr_css_attr_unref(css);
 316     }
 317
 318     button->signal_clicked().connect( sigc::bind( sigc::ptr_fun(StyleFromSelectionToTool), prefs_path.c_str(), swatch)  );
 319     own->changed_signal.connect( sigc::mem_fun(*button, &Gtk::Button::set_sensitive) );
 320     p.add_line( true, "", *button, "",
 321                 _("Remember the style of the (first) selected object as this tool's style"));
 322 }
 323
 324 void InkscapePreferences::initPageTools()
 325 {
 326     Gtk::TreeModel::iterator iter_tools = this->AddPage(_page_tools, _("Tools"), PREFS_PAGE_TOOLS);
 327     _path_tools = _page_list.get_model()->get_path(iter_tools);
 328
 329     _page_tools.add_group_header( _("Bounding box to use:"));
 330     _t_bbox_visual.init ( _("Visual bounding box"), "tools", "bounding_box", "visual", false, 0);
 331     _page_tools.add_line( true, "", _t_bbox_visual, "",
 332                             _("This bounding box includes stroke width, markers, filter margins, etc."));
 333     _t_bbox_geometric.init ( _("Geometric bounding box"), "tools", "bounding_box", "geometric", true, &_t_bbox_visual);
 334     _page_tools.add_line( true, "", _t_bbox_geometric, "",
 335                             _("This bounding box includes only the bare path"));
 336
 337     _page_tools.add_group_header( _("Conversion to guides:"));
 338     _t_cvg_keep_objects.init ( _("Keep objects after conversion to guides"), "tools", "cvg_keep_objects", false);
 339     _page_tools.add_line( true, "", _t_cvg_keep_objects, "",
 340                             _("When converting an object to guides, don't delete the object after the conversion."));
 341
 342     _calligrapy_use_abs_size.init ( _("Width is in absolute units"), "tools.calligraphic", "abs_width", false);
 343     _calligrapy_keep_selected.init ( _("Select new path"), "tools.calligraphic", "keep_selected", true);
 344     _connector_ignore_text.init( _("Don't attach connectors to text objects"), "tools.connector", "ignoretext", true);
 345
 346     //Selector
 347     this->AddPage(_page_selector, _("Selector"), iter_tools, PREFS_PAGE_TOOLS_SELECTOR);
 348
 349     AddSelcueCheckbox(_page_selector, "tools.select", false);
 350     _page_selector.add_group_header( _("When transforming, show:"));
 351     _t_sel_trans_obj.init ( _("Objects"), "tools.select", "show", "content", true, 0);
 352     _page_selector.add_line( true, "", _t_sel_trans_obj, "",
 353                             _("Show the actual objects when moving or transforming"));
 354     _t_sel_trans_outl.init ( _("Box outline"), "tools.select", "show", "outline", false, &_t_sel_trans_obj);
 355     _page_selector.add_line( true, "", _t_sel_trans_outl, "",
 356                             _("Show only a box outline of the objects when moving or transforming"));
 357     _page_selector.add_group_header( _("Per-object selection cue:"));
 358     _t_sel_cue_none.init ( _("None"), "options.selcue", "value", Inkscape::SelCue::NONE, false, 0);
 359     _page_selector.add_line( true, "", _t_sel_cue_none, "",
 360                             _("No per-object selection indication"));
 361     _t_sel_cue_mark.init ( _("Mark"), "options.selcue", "value", Inkscape::SelCue::MARK, true, &_t_sel_cue_none);
 362     _page_selector.add_line( true, "", _t_sel_cue_mark, "",
 363                             _("Each selected object has a diamond mark in the top left corner"));
 364     _t_sel_cue_box.init ( _("Box"), "options.selcue", "value", Inkscape::SelCue::BBOX, false, &_t_sel_cue_none);
 365     _page_selector.add_line( true, "", _t_sel_cue_box, "",
 366                             _("Each selected object displays its bounding box"));
 367
 368     //Node
 369     this->AddPage(_page_node, _("Node"), iter_tools, PREFS_PAGE_TOOLS_NODE);
 370     AddSelcueCheckbox(_page_node, "tools.nodes", true);
 371     AddGradientCheckbox(_page_node, "tools.nodes", true);
 372     //Tweak
 373     this->AddPage(_page_tweak, _("Tweak"), iter_tools, PREFS_PAGE_TOOLS_NODE);
 374     AddSelcueCheckbox(_page_tweak, "tools.tweak", true);
 375     AddGradientCheckbox(_page_tweak, "tools.tweak", false);
 376     //Zoom
 377     this->AddPage(_page_zoom, _("Zoom"), iter_tools, PREFS_PAGE_TOOLS_ZOOM);
 378     AddSelcueCheckbox(_page_zoom, "tools.zoom", true);
 379     AddGradientCheckbox(_page_zoom, "tools.zoom", false);
 380     //Shapes
 381     Gtk::TreeModel::iterator iter_shapes = this->AddPage(_page_shapes, _("Shapes"), iter_tools, PREFS_PAGE_TOOLS_SHAPES);
 382     _path_shapes = _page_list.get_model()->get_path(iter_shapes);
 383     this->AddSelcueCheckbox(_page_shapes, "tools.shapes", true);
 384     this->AddGradientCheckbox(_page_shapes, "tools.shapes", true);
 385     //Rectangle
 386     this->AddPage(_page_rectangle, _("Rectangle"), iter_shapes, PREFS_PAGE_TOOLS_SHAPES_RECT);
 387     this->AddNewObjectsStyle(_page_rectangle, "tools.shapes.rect");
 388     this->AddConvertGuidesCheckbox(_page_rectangle, "tools.shapes.rect", true);
 389     //3D box
 390     this->AddPage(_page_3dbox, _("3D Box"), iter_shapes, PREFS_PAGE_TOOLS_SHAPES_3DBOX);
 391     this->AddNewObjectsStyle(_page_3dbox, "tools.shapes.3dbox");
 392     this->AddConvertGuidesCheckbox(_page_3dbox, "tools.shapes.3dbox", true);
 393     //ellipse
 394     this->AddPage(_page_ellipse, _("Ellipse"), iter_shapes, PREFS_PAGE_TOOLS_SHAPES_ELLIPSE);
 395     this->AddNewObjectsStyle(_page_ellipse, "tools.shapes.arc");
 396     //star
 397     this->AddPage(_page_star, _("Star"), iter_shapes, PREFS_PAGE_TOOLS_SHAPES_STAR);
 398     this->AddNewObjectsStyle(_page_star, "tools.shapes.star");
 399     //spiral
 400     this->AddPage(_page_spiral, _("Spiral"), iter_shapes, PREFS_PAGE_TOOLS_SHAPES_SPIRAL);
 401     this->AddNewObjectsStyle(_page_spiral, "tools.shapes.spiral");
 402     //Pencil
 403     this->AddPage(_page_pencil, _("Pencil"), iter_tools, PREFS_PAGE_TOOLS_PENCIL);
 404     this->AddSelcueCheckbox(_page_pencil, "tools.freehand.pencil", true);
 405     _t_pencil_tolerance.init ( "tools.freehand.pencil", "tolerance", 0.0, 100.0, 0.5, 1.0, 10.0, false, false);
 406     _page_pencil.add_line( false, _("Tolerance:"), _t_pencil_tolerance, "",
 407                            _("This value affects the amount of smoothing applied to freehand lines; lower values produce more uneven paths with more nodes"),
 408                            false );
 409     this->AddNewObjectsStyle(_page_pencil, "tools.freehand.pencil");
 410     //Pen
 411     this->AddPage(_page_pen, _("Pen"), iter_tools, PREFS_PAGE_TOOLS_PEN);
 412     this->AddSelcueCheckbox(_page_pen, "tools.freehand.pen", true);
 413     this->AddNewObjectsStyle(_page_pen, "tools.freehand.pen");
 414     //Calligraphy
 415     this->AddPage(_page_calligraphy, _("Calligraphy"), iter_tools, PREFS_PAGE_TOOLS_CALLIGRAPHY);
 416     this->AddSelcueCheckbox(_page_calligraphy, "tools.calligraphic", false);
 417     this->AddNewObjectsStyle(_page_calligraphy, "tools.calligraphic");
 418     _page_calligraphy.add_line( false, "", _calligrapy_use_abs_size, "",
 419                             _("If on, pen width is in absolute units (px) independent of zoom; otherwise pen width depends on zoom so that it looks the same at any zoom"));
 420     _page_calligraphy.add_line( false, "", _calligrapy_keep_selected, "",
 421                             _("If on, each newly created object will be selected (deselecting previous selection)"));
 422     //Paint Bucket
 423     this->AddPage(_page_paintbucket, _("Paint Bucket"), iter_tools, PREFS_PAGE_TOOLS_PAINTBUCKET);
 424     this->AddSelcueCheckbox(_page_paintbucket, "tools.paintbucket", false);
 425     this->AddNewObjectsStyle(_page_paintbucket, "tools.paintbucket");
 426     //Text
 427     this->AddPage(_page_text, _("Text"), iter_tools, PREFS_PAGE_TOOLS_TEXT);
 428     this->AddSelcueCheckbox(_page_text, "tools.text", true);
 429     this->AddGradientCheckbox(_page_text, "tools.text", true);
 430     this->AddNewObjectsStyle(_page_text, "tools.text");
 431     //Gradient
 432     this->AddPage(_page_gradient, _("Gradient"), iter_tools, PREFS_PAGE_TOOLS_GRADIENT);
 433     this->AddSelcueCheckbox(_page_gradient, "tools.gradient", true);
 434     //Connector
 435     this->AddPage(_page_connector, _("Connector"), iter_tools, PREFS_PAGE_TOOLS_CONNECTOR);
 436     this->AddSelcueCheckbox(_page_connector, "tools.connector", true);
 437     _page_connector.add_line(false, "", _connector_ignore_text, "",
 438             _("If on, connector attachment points will not be shown for text objects"));
 439     //Dropper
 440     this->AddPage(_page_dropper, _("Dropper"), iter_tools, PREFS_PAGE_TOOLS_DROPPER);
 441     this->AddSelcueCheckbox(_page_dropper, "tools.dropper", true);
 442     this->AddGradientCheckbox(_page_dropper, "tools.dropper", true);
 443 }
 444
 445 void InkscapePreferences::initPageWindows()
 446 {
 447     _win_save_geom.init ( _("Save and restore window geometry for each document"), "options.savewindowgeometry", "value", 1, true, 0);
 448     _win_save_geom_prefs.init ( _("Remember and use last window's geometry"), "options.savewindowgeometry", "value", 2, false, &_win_save_geom);
 449     _win_save_geom_off.init ( _("Don't save window geometry"), "options.savewindowgeometry", "value", 0, false, &_win_save_geom);
 450
 451     _win_dockable.init ( _("Dockable"), "options.dialogtype", "value", 1, true, 0);
 452     _win_floating.init ( _("Floating"), "options.dialogtype", "value", 0, false, &_win_dockable);
 453
 454     _win_hide_task.init ( _("Dialogs are hidden in taskbar"), "options.dialogsskiptaskbar", "value", true);
 455     _win_zoom_resize.init ( _("Zoom when window is resized"), "options.stickyzoom", "value", false);
 456     _win_show_close.init ( _("Show close button on dialogs"), "dialogs", "showclose", false);
 457     _win_ontop_none.init ( _("None"), "options.transientpolicy", "value", 0, false, 0);
 458     _win_ontop_normal.init ( _("Normal"), "options.transientpolicy", "value", 1, true, &_win_ontop_none);
 459     _win_ontop_agressive.init ( _("Aggressive"), "options.transientpolicy", "value", 2, false, &_win_ontop_none);
 460
 461 // FIXME: Temporary Win32 special code to enable transient dialogs
 462 #ifdef WIN32
 463     _win_ontop_win32.init ( _("Dialogs stay on top (experimental!)"), "options.dialogsontopwin32", "value", false);
 464 #endif
 465
 466     _page_windows.add_group_header( _("Saving window geometry (size and position):"));
 467     _page_windows.add_line( false, "", _win_save_geom_off, "",
 468                             _("Let the window manager determine placement of all windows"));
 469     _page_windows.add_line( false, "", _win_save_geom_prefs, "",
 470                             _("Remember and use the last window's geometry (saves geometry to user preferences)"));
 471     _page_windows.add_line( false, "", _win_save_geom, "",
 472                             _("Save and restore window geometry for each document (saves geometry in the document)"));
 473
 474     _page_windows.add_group_header( _("Dialog behavior (requires restart):"));
 475     _page_windows.add_line( true, "", _win_dockable, "",
 476                             _("Dockable"));
 477     _page_windows.add_line( true, "", _win_floating, "",
 478                             _("Floating"));
 479
 480     _page_windows.add_group_header( _("Dialogs on top:"));
 481 #ifndef WIN32 // FIXME: Temporary Win32 special code to enable transient dialogs
 482     _page_windows.add_line( true, "", _win_ontop_none, "",
 483                             _("Dialogs are treated as regular windows"));
 484     _page_windows.add_line( true, "", _win_ontop_normal, "",
 485                             _("Dialogs stay on top of document windows"));
 486     _page_windows.add_line( true, "", _win_ontop_agressive, "",
 487                             _("Same as Normal but may work better with some window managers"));
 488 #else
 489     _page_windows.add_line( false, "", _win_ontop_win32, "",
 490                             _("Whether dialogs should stay on top of document windows. Read the ReleaseNotes on this issue! (Rightclick the taskbar button and press 'Restore' to bring back a minimized document window)"));
 491 #endif
 492
 493     _page_windows.add_group_header( _("Miscellaneous:"));
 494 #ifndef WIN32 // FIXME: Temporary Win32 special code to enable transient dialogs
 495     _page_windows.add_line( false, "", _win_hide_task, "",
 496                             _("Whether dialog windows are to be hidden in the window manager taskbar"));
 497 #endif
 498     _page_windows.add_line( false, "", _win_zoom_resize, "",
 499                             _("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)"));
 500     _page_windows.add_line( false, "", _win_show_close, "",
 501                             _("Whether dialog windows have a close button (requires restart)"));
 502     this->AddPage(_page_windows, _("Windows"), PREFS_PAGE_WINDOWS);
 503 }
 504
 505 void InkscapePreferences::initPageClones()
 506 {
 507     _clone_option_parallel.init ( _("Move in parallel"), "options.clonecompensation", "value",
 508                                   SP_CLONE_COMPENSATION_PARALLEL, true, 0);
 509     _clone_option_stay.init ( _("Stay unmoved"), "options.clonecompensation", "value",
 510                                   SP_CLONE_COMPENSATION_UNMOVED, false, &_clone_option_parallel);
 511     _clone_option_transform.init ( _("Move according to transform"), "options.clonecompensation", "value",
 512                                   SP_CLONE_COMPENSATION_NONE, false, &_clone_option_parallel);
 513     _clone_option_unlink.init ( _("Are unlinked"), "options.cloneorphans", "value",
 514                                   SP_CLONE_ORPHANS_UNLINK, true, 0);
 515     _clone_option_delete.init ( _("Are deleted"), "options.cloneorphans", "value",
 516                                   SP_CLONE_ORPHANS_DELETE, false, &_clone_option_unlink);
 517
 518     _page_clones.add_group_header( _("When the original moves, its clones and linked offsets:"));
 519     _page_clones.add_line( true, "", _clone_option_parallel, "",
 520                            _("Clones are translated by the same vector as their original."));
 521     _page_clones.add_line( true, "", _clone_option_stay, "",
 522                            _("Clones preserve their positions when their original is moved."));
 523     _page_clones.add_line( true, "", _clone_option_transform, "",
 524                            _("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."));
 525     _page_clones.add_group_header( _("When the original is deleted, its clones:"));
 526     _page_clones.add_line( true, "", _clone_option_unlink, "",
 527                            _("Orphaned clones are converted to regular objects."));
 528     _page_clones.add_line( true, "", _clone_option_delete, "",
 529                            _("Orphaned clones are deleted along with their original."));
 530
 531     this->AddPage(_page_clones, _("Clones"), PREFS_PAGE_CLONES);
 532 }
 533
 534 void InkscapePreferences::initPageMasks()
 535 {
 536     _mask_mask_on_top.init ( _("When applying, use the topmost selected object as clippath/mask"), "options.maskobject", "topmost", true);
 537     _page_mask.add_line(true, "", _mask_mask_on_top, "",
 538                         _("Uncheck this to use the bottom selected object as the clipping path or mask"));
 539     _mask_mask_remove.init ( _("Remove clippath/mask object after applying"), "options.maskobject", "remove", true);
 540     _page_mask.add_line(true, "", _mask_mask_remove, "",
 541                         _("After applying, remove the object used as the clipping path or mask from the drawing"));
 542     this->AddPage(_page_mask, _("Clippaths and masks"), PREFS_PAGE_MASKS);
 543 }
 544
 545 void InkscapePreferences::initPageTransforms()
 546 {
 547     _trans_scale_stroke.init ( _("Scale stroke width"), "options.transform", "stroke", true);
 548     _trans_scale_corner.init ( _("Scale rounded corners in rectangles"), "options.transform", "rectcorners", false);
 549     _trans_gradient.init ( _("Transform gradients"), "options.transform", "gradient", true);
 550     _trans_pattern.init ( _("Transform patterns"), "options.transform", "pattern", false);
 551     _trans_optimized.init ( _("Optimized"), "options.preservetransform", "value", 0, true, 0);
 552     _trans_preserved.init ( _("Preserved"), "options.preservetransform", "value", 1, false, &_trans_optimized);
 553
 554     _page_transforms.add_line( false, "", _trans_scale_stroke, "",
 555                                _("When scaling objects, scale the stroke width by the same proportion"));
 556     _page_transforms.add_line( false, "", _trans_scale_corner, "",
 557                                _("When scaling rectangles, scale the radii of rounded corners"));
 558     _page_transforms.add_line( false, "", _trans_gradient, "",
 559                                _("Move gradients (in fill or stroke) along with the objects"));
 560     _page_transforms.add_line( false, "", _trans_pattern, "",
 561                                _("Move patterns (in fill or stroke) along with the objects"));
 562     _page_transforms.add_group_header( _("Store transformation:"));
 563     _page_transforms.add_line( true, "", _trans_optimized, "",
 564                                _("If possible, apply transformation to objects without adding a transform= attribute"));
 565     _page_transforms.add_line( true, "", _trans_preserved, "",
 566                                _("Always store transformation as a transform= attribute on objects"));
 567
 568     this->AddPage(_page_transforms, _("Transforms"), PREFS_PAGE_TRANSFORMS);
 569 }
 570
 571 void InkscapePreferences::initPageFilters()
 572 {
 573     _blur_quality_best.init ( _("Best quality (slowest)"), "options.blurquality", "value",
 574                                   BLUR_QUALITY_BEST, false, 0);
 575     _blur_quality_better.init ( _("Better quality (slower)"), "options.blurquality", "value",
 576                                   BLUR_QUALITY_BETTER, false, &_blur_quality_best);
 577     _blur_quality_normal.init ( _("Average quality"), "options.blurquality", "value",
 578                                   BLUR_QUALITY_NORMAL, true, &_blur_quality_best);
 579     _blur_quality_worse.init ( _("Lower quality (faster)"), "options.blurquality", "value",
 580                                   BLUR_QUALITY_WORSE, false, &_blur_quality_best);
 581     _blur_quality_worst.init ( _("Lowest quality (fastest)"), "options.blurquality", "value",
 582                                   BLUR_QUALITY_WORST, false, &_blur_quality_best);
 583
 584     _page_filters.add_group_header( _("Gaussian blur quality for display:"));
 585     _page_filters.add_line( true, "", _blur_quality_best, "",
 586                            _("Best quality, but display may be very slow at high zooms (bitmap export always uses best quality)"));
 587     _page_filters.add_line( true, "", _blur_quality_better, "",
 588                            _("Better quality, but slower display"));
 589     _page_filters.add_line( true, "", _blur_quality_normal, "",
 590                            _("Average quality, acceptable display speed"));
 591     _page_filters.add_line( true, "", _blur_quality_worse, "",
 592                            _("Lower quality (some artifacts), but display is faster"));
 593     _page_filters.add_line( true, "", _blur_quality_worst, "",
 594                            _("Lowest quality (considerable artifacts), but display is fastest"));
 595
 596     this->AddPage(_page_filters, _("Filters"), PREFS_PAGE_FILTERS);
 597 }
 598
 599
 600 void InkscapePreferences::initPageSelecting()
 601 {
 602     _sel_all.init ( _("Select in all layers"), "options.kbselection", "inlayer", PREFS_SELECTION_ALL, false, 0);
 603     _sel_current.init ( _("Select only within current layer"), "options.kbselection", "inlayer", PREFS_SELECTION_LAYER, true, &_sel_all);
 604     _sel_recursive.init ( _("Select in current layer and sublayers"), "options.kbselection", "inlayer", PREFS_SELECTION_LAYER_RECURSIVE, false, &_sel_all);
 605     _sel_hidden.init ( _("Ignore hidden objects and layers"), "options.kbselection", "onlyvisible", true);
 606     _sel_locked.init ( _("Ignore locked objects and layers"), "options.kbselection", "onlysensitive", true);
 607     _sel_layer_deselects.init ( _("Deselect upon layer change"), "options.selection", "layerdeselect", true);
 608
 609     _page_select.add_group_header( _("Ctrl+A, Tab, Shift+Tab:"));
 610     _page_select.add_line( true, "", _sel_all, "",
 611                            _("Make keyboard selection commands work on objects in all layers"));
 612     _page_select.add_line( true, "", _sel_current, "",
 613                            _("Make keyboard selection commands work on objects in current layer only"));
 614     _page_select.add_line( true, "", _sel_recursive, "",
 615                            _("Make keyboard selection commands work on objects in current layer and all its sublayers"));
 616     _page_select.add_line( true, "", _sel_hidden, "",
 617                            _("Uncheck this to be able to select objects that are hidden (either by themselves or by being in a hidden layer)"));
 618     _page_select.add_line( true, "", _sel_locked, "",
 619                            _("Uncheck this to be able to select objects that are locked (either by themselves or by being in a locked layer)"));
 620
 621     _page_select.add_line( false, "", _sel_layer_deselects, "",
 622                            _("Uncheck this to be able to keep the current objects selected when the current layer changes"));
 623
 624     this->AddPage(_page_select, _("Selecting"), PREFS_PAGE_SELECTING);
 625 }
 626
 627
 628 void InkscapePreferences::initPageImportExport()
 629 {
 630     _importexport_export.init("dialogs.export.defaultxdpi", "value", 0.0, 6000.0, 1.0, 1.0, PX_PER_IN, true, false);
 631     _page_importexport.add_line( false, _("Default export resolution:"), _importexport_export, _("dpi"),
 632                             _("Default bitmap resolution (in dots per inch) in the Export dialog"), false);
 633     _importexport_ocal_url.init("options.ocalurl", "str", true, g_strdup_printf("openclipart.org"));
 634     _page_importexport.add_line( false, _("Open Clip Art Library Server Name:"), _importexport_ocal_url, "",
 635         _("The server name of the Open Clip Art Library webdav server. It's used by the Import and Export to OCAL function."), true);
 636     _importexport_ocal_username.init("options.ocalusername", "str", true);
 637     _page_importexport.add_line( false, _("Open Clip Art Library Username:"), _importexport_ocal_username, "",
 638             _("The username used to log into Open Clip Art Library."), true);
 639     _importexport_ocal_password.init("options.ocalpassword", "str", false);
 640     _page_importexport.add_line( false, _("Open Clip Art Library Password:"), _importexport_ocal_password, "",
 641             _("The password used to log into Open Clip Art Library."), true);
 642
 643     this->AddPage(_page_importexport, _("Import/Export"), PREFS_PAGE_IMPORTEXPORT);
 644 }
 645
 646 #if ENABLE_LCMS
 647 static void profileComboChanged( Gtk::ComboBoxText* combo )
 648 {
 649     int rowNum = combo->get_active_row_number();
 650     if ( rowNum < 1 ) {
 651         prefs_set_string_attribute( "options.displayprofile", "uri", "" );
 652     } else {
 653         Glib::ustring active = combo->get_active_text();
 654
 655         Glib::ustring path = get_path_for_profile(active);
 656         if ( !path.empty() ) {
 657             prefs_set_string_attribute( "options.displayprofile", "uri", path.c_str() );
 658         }
 659     }
 660 }
 661
 662 static void proofComboChanged( Gtk::ComboBoxText* combo )
 663 {
 664     Glib::ustring active = combo->get_active_text();
 665
 666     Glib::ustring path = get_path_for_profile(active);
 667     if ( !path.empty() ) {
 668         prefs_set_string_attribute( "options.softproof", "uri", path.c_str() );
 669     }
 670 }
 671
 672 static void gamutColorChanged( Gtk::ColorButton* btn ) {
 673     Gdk::Color color = btn->get_color();
 674     gushort r = color.get_red();
 675     gushort g = color.get_green();
 676     gushort b = color.get_blue();
 677
 678     gchar* tmp = g_strdup_printf("#%02x%02x%02x", (r >> 8), (g >> 8), (b >> 8) );
 679
 680     prefs_set_string_attribute( "options.softproof", "gamutcolor", tmp );
 681     g_free(tmp);
 682 }
 683 #endif // ENABLE_LCMS
 684
 685 void InkscapePreferences::initPageCMS()
 686 {
 687     int const numIntents = 4;
 688     /* TRANSLATORS: see http://www.newsandtech.com/issues/2004/03-04/pt/03-04_rendering.htm */
 689     Glib::ustring intentLabels[numIntents] = {_("Perceptual"), _("Relative Colorimetric"), _("Saturation"), _("Absolute Colorimetric")};
 690     int intentValues[numIntents] = {0, 1, 2, 3};
 691
 692 #if !ENABLE_LCMS
 693     Gtk::Label* lbl = new Gtk::Label(_("(Note: Color management has been disabled in this build)"));
 694     _page_cms.add_line( false, "", *lbl, "", "", true);
 695 #endif // !ENABLE_LCMS
 696
 697     _page_cms.add_group_header( _("Display adjustment"));
 698
 699     _page_cms.add_line( false, _("Display profile:"), _cms_display_profile, "",
 700                         _("The ICC profile to use to calibrate display output."), false);
 701
 702     _cms_from_display.init( _("Retrieve profile from display"), "options.displayprofile", "from_display", false);
 703     _page_cms.add_line( false, "", _cms_from_display, "",
 704 #ifdef GDK_WINDOWING_X11
 705                         _("Retrieve profiles from those attached to displays via XICC."), false);
 706 #else
 707                         _("Retrieve profiles from those attached to displays."), false);
 708 #endif // GDK_WINDOWING_X11
 709
 710
 711     _cms_intent.init("options.displayprofile", "intent", intentLabels, intentValues, numIntents, 0);
 712     _page_cms.add_line( false, _("Display rendering intent:"), _cms_intent, "",
 713                         _("The rendering intent to use to calibrate display output."), false);
 714
 715     _page_cms.add_group_header( _("Proofing"));
 716
 717     _cms_softproof.init( _("Simulate output on screen"), "options.softproof", "enable", false);
 718     _page_cms.add_line( false, "", _cms_softproof, "",
 719                         _("Simulates output of target device."), false);
 720
 721     _cms_gamutwarn.init( _("Mark out of gamut colors"), "options.softproof", "gamutwarn", false);
 722     _page_cms.add_line( false, "", _cms_gamutwarn, "",
 723                         _("Highlights colors that are out of gamut for the target device."), false);
 724
 725     gchar const* colorStr = prefs_get_string_attribute("options.softproof", "gamutcolor");
 726     Gdk::Color tmpColor( (colorStr && colorStr[0]) ? colorStr : "#00ff00");
 727     _cms_gamutcolor.set_color( tmpColor );
 728     _page_cms.add_line( true, _("Out of gamut warning color:"), _cms_gamutcolor, "",
 729                         _("Selects the color used for out of gamut warning."), false);
 730
 731     _page_cms.add_line( false, _("Device profile:"), _cms_proof_profile, "",
 732                         _("The ICC profile to use to simulate device output."), false);
 733
 734     _cms_proof_intent.init("options.softproof", "intent", intentLabels, intentValues, numIntents, 0);
 735     _page_cms.add_line( false, _("Device rendering intent:"), _cms_proof_intent, "",
 736                         _("The rendering intent to use to calibrate display output."), false);
 737
 738     _cms_proof_blackpoint.init( _("Black point compensation"), "options.softproof", "bpc", false);
 739     _page_cms.add_line( false, "", _cms_proof_blackpoint, "",
 740                         _("Enables black point compensation."), false);
 741
 742     _cms_proof_preserveblack.init( _("Preserve black"), "options.softproof", "preserveblack", false);
 743     _page_cms.add_line( false, "", _cms_proof_preserveblack,
 744 #if defined(cmsFLAGS_PRESERVEBLACK)
 745                         "",
 746 #else
 747                         _("(LittleCMS 1.15 or later required)"),
 748 #endif // defined(cmsFLAGS_PRESERVEBLACK)
 749                         _("Preserve K channel in CMYK -> CMYK transforms"), false);
 750
 751 #if !defined(cmsFLAGS_PRESERVEBLACK)
 752     _cms_proof_preserveblack.set_sensitive( false );
 753 #endif // !defined(cmsFLAGS_PRESERVEBLACK)
 754
 755
 756 #if ENABLE_LCMS
 757     {
 758         std::vector<Glib::ustring> names = ::Inkscape::colorprofile_get_display_names();
 759         Glib::ustring current = prefs_get_string_attribute( "options.displayprofile", "uri" );
 760
 761         gint index = 0;
 762         _cms_display_profile.append_text(_("<none>"));
 763         index++;
 764         for ( std::vector<Glib::ustring>::iterator it = names.begin(); it != names.end(); ++it ) {
 765             _cms_display_profile.append_text( *it );
 766             Glib::ustring path = get_path_for_profile(*it);
 767             if ( !path.empty() && path == current ) {
 768                 _cms_display_profile.set_active(index);
 769             }
 770             index++;
 771         }
 772         if ( current.empty() ) {
 773             _cms_display_profile.set_active(0);
 774         }
 775
 776         names = ::Inkscape::colorprofile_get_softproof_names();
 777         const gchar * tmp = prefs_get_string_attribute( "options.softproof", "uri" );
 778         current = tmp ? tmp : "";
 779         index = 0;
 780         for ( std::vector<Glib::ustring>::iterator it = names.begin(); it != names.end(); ++it ) {
 781             _cms_proof_profile.append_text( *it );
 782             Glib::ustring path = get_path_for_profile(*it);
 783             if ( !path.empty() && path == current ) {
 784                 _cms_proof_profile.set_active(index);
 785             }
 786             index++;
 787         }
 788     }
 789
 790     _cms_gamutcolor.signal_color_set().connect( sigc::bind( sigc::ptr_fun(gamutColorChanged), &_cms_gamutcolor) );
 791
 792     _cms_display_profile.signal_changed().connect( sigc::bind( sigc::ptr_fun(profileComboChanged), &_cms_display_profile) );
 793     _cms_proof_profile.signal_changed().connect( sigc::bind( sigc::ptr_fun(proofComboChanged), &_cms_proof_profile) );
 794 #else
 795     // disable it, but leave it visible
 796     _cms_intent.set_sensitive( false );
 797     _cms_display_profile.set_sensitive( false );
 798     _cms_from_display.set_sensitive( false );
 799     _cms_softproof.set_sensitive( false );
 800     _cms_gamutwarn.set_sensitive( false );
 801     _cms_gamutcolor.set_sensitive( false );
 802     _cms_proof_intent.set_sensitive( false );
 803     _cms_proof_profile.set_sensitive( false );
 804     _cms_proof_blackpoint.set_sensitive( false );
 805     _cms_proof_preserveblack.set_sensitive( false );
 806 #endif // ENABLE_LCMS
 807
 808     this->AddPage(_page_cms, _("Color management"), PREFS_PAGE_CMS);
 809 }
 810
 811 void InkscapePreferences::initPageGrids()
 812 {
 813     _page_grids.add_group_header( _("Default grid settings"));
 814
 815     _grids_no_emphasize_on_zoom.init( _("Don't emphasize gridlines when zoomed out"), "options.grids", "no_emphasize_when_zoomedout", false);
 816     _page_grids.add_line( false, "", _grids_no_emphasize_on_zoom, "", _("If set and zoomed out, the gridlines will be shown in normal color instead of major grid line color."), false);
 817     _page_grids.add_line( false, "", _grids_notebook, "", "", false);
 818     _grids_notebook.append_page(_grids_xy,     CanvasGrid::getName( GRID_RECTANGULAR ));
 819     _grids_notebook.append_page(_grids_axonom, CanvasGrid::getName( GRID_AXONOMETRIC ));
 820         _grids_xy_units.init("options.grids.xy", "units");
 821         _grids_xy.add_line( false, _("Grid units"), _grids_xy_units, "", "", false);
 822         _grids_xy_origin_x.init("options.grids.xy", "origin_x", -10000.0, 10000.0, 0.1, 1.0, 0.0, false, false);
 823         _grids_xy_origin_y.init("options.grids.xy", "origin_y", -10000.0, 10000.0, 0.1, 1.0, 0.0, false, false);
 824         _grids_xy.add_line( false, _("Origin X"), _grids_xy_origin_x, "", _("X coordinate of grid origin"), false);
 825         _grids_xy.add_line( false, _("Origin Y"), _grids_xy_origin_y, "", _("Y coordinate of grid origin"), false);
 826         _grids_xy_spacing_x.init("options.grids.xy", "spacing_x", -10000.0, 10000.0, 0.1, 1.0, 1.0, false, false);
 827         _grids_xy_spacing_y.init("options.grids.xy", "spacing_y", -10000.0, 10000.0, 0.1, 1.0, 1.0, false, false);
 828         _grids_xy.add_line( false, _("Spacing X"), _grids_xy_spacing_x, "", _("Distance between vertical grid lines"), false);
 829         _grids_xy.add_line( false, _("Spacing Y"), _grids_xy_spacing_y, "", _("Distance between horizontal grid lines"), false);
 830
 831         _grids_xy_color.init(_("Grid line color"), "options.grids.xy", "color", 0x0000ff20);
 832         _grids_xy.add_line( false, _("Grid line color"), _grids_xy_color, "", _("Selects the color used for normal grid lines."), false);
 833         _grids_xy_empcolor.init(_("Major grid line color"), "options.grids.xy", "empcolor", 0x0000ff40);
 834         _grids_xy.add_line( false, _("Major grid line color"), _grids_xy_empcolor, "", _("Selects the color used for major (highlighted) grid lines."), false);
 835         _grids_xy_empspacing.init("options.grids.xy", "empspacing", 1.0, 1000.0, 1.0, 5.0, 5.0, true, false);
 836         _grids_xy.add_line( false, _("Major grid line every"), _grids_xy_empspacing, "", "", false);
 837         _grids_xy_dotted.init( _("Show dots instead of lines"), "options.grids.xy", "dotted", false);
 838         _grids_xy.add_line( false, "", _grids_xy_dotted, "", _("If set, displays dots at gridpoints instead of gridlines"), false);
 839
 840     // CanvasAxonomGrid properties:
 841         _grids_axonom_units.init("options.grids.axonom", "units");
 842         _grids_axonom.add_line( false, _("Grid units"), _grids_axonom_units, "", "", false);
 843         _grids_axonom_origin_x.init("options.grids.axonom", "origin_x", -10000.0, 10000.0, 0.1, 1.0, 0.0, false, false);
 844         _grids_axonom_origin_y.init("options.grids.axonom", "origin_y", -10000.0, 10000.0, 0.1, 1.0, 0.0, false, false);
 845         _grids_axonom.add_line( false, _("Origin X"), _grids_axonom_origin_x, "", _("X coordinate of grid origin"), false);
 846         _grids_axonom.add_line( false, _("Origin Y"), _grids_axonom_origin_y, "", _("Y coordinate of grid origin"), false);
 847         _grids_axonom_spacing_y.init("options.grids.axonom", "spacing_y", -10000.0, 10000.0, 0.1, 1.0, 1.0, false, false);
 848         _grids_axonom.add_line( false, _("Spacing Y"), _grids_axonom_spacing_y, "", _("Base length of z-axis"), false);
 849         _grids_axonom_angle_x.init("options.grids.axonom", "angle_x", -360.0, 360.0, 1.0, 10.0, 30.0, false, false);
 850         _grids_axonom_angle_z.init("options.grids.axonom", "angle_z", -360.0, 360.0, 1.0, 10.0, 30.0, false, false);
 851         _grids_axonom.add_line( false, _("Angle X"), _grids_axonom_angle_x, "", _("Angle of x-axis"), false);
 852         _grids_axonom.add_line( false, _("Angle Z"), _grids_axonom_angle_z, "", _("Angle of z-axis"), false);
 853         _grids_axonom_color.init(_("Grid line color"), "options.grids.axonom", "color", 0x0000ff20);
 854         _grids_axonom.add_line( false, _("Grid line color"), _grids_axonom_color, "", _("Selects the color used for normal grid lines."), false);
 855         _grids_axonom_empcolor.init(_("Major grid line color"), "options.grids.axonom", "empcolor", 0x0000ff40);
 856         _grids_axonom.add_line( false, _("Major grid line color"), _grids_axonom_empcolor, "", _("Selects the color used for major (highlighted) grid lines."), false);
 857         _grids_axonom_empspacing.init("options.grids.axonom", "empspacing", 1.0, 1000.0, 1.0, 5.0, 5.0, true, false);
 858         _grids_axonom.add_line( false, _("Major grid line every"), _grids_axonom_empspacing, "", "", false);
 859
 860     this->AddPage(_page_grids, _("Grids"), PREFS_PAGE_GRIDS);
 861 }
 862
 863 void InkscapePreferences::initPageMisc()
 864 {
 865     _misc_comment.init( _("Add label comments to printing output"), "printing.debug", "show-label-comments", false);
 866     _page_misc.add_line( false, "", _misc_comment, "",
 867                            _("When on, a comment will be added to the raw print output, marking the rendered output for an object with its label"), true);
 868
 869     _misc_forkvectors.init( _("Prevent sharing of gradient definitions"), "options.forkgradientvectors", "value", true);
 870     _page_misc.add_line( false, "", _misc_forkvectors, "",
 871                            _("When on, shared gradient definitions are automatically forked on change; uncheck to allow sharing of gradient definitions so that editing one object may affect other objects using the same gradient"), true);
 872
 873     _page_misc.add_line( false, _("Simplification threshold:"), _misc_simpl, "",
 874                            _("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);
 875     int const num_items = 5;
 876     Glib::ustring labels[num_items] = {_("None"), _("2x2"), _("4x4"), _("8x8"), _("16x16")};
 877     int values[num_items] = {0, 1, 2, 3, 4};
 878     _misc_overs_bitmap.set_size_request(_sb_width);
 879     _misc_overs_bitmap.init("options.bitmapoversample", "value", labels, values, num_items, 1);
 880     _page_misc.add_line( false, _("Oversample bitmaps:"), _misc_overs_bitmap, "", "", false);
 881
 882
 883     // consider moving this to an UI tab:
 884     _misc_small_toolbar.init( _("Make the commands toolbar icons smaller"), "toolbox", "small", true);
 885     _page_misc.add_line( false, "", _misc_small_toolbar, "",
 886                            _("Make the commands toolbar use the 'secondary' toolbar size (requires restart)"), true);
 887
 888     _misc_small_tools.init( _("Make the main toolbar icons smaller"), "toolbox.tools", "small", true);
 889     _page_misc.add_line( false, "", _misc_small_tools, "",
 890                            _("Make the main tools use the 'secondary' toolbar size (requires restart)"), true);
 891
 892     _misc_recent.init("options.maxrecentdocuments", "value", 0.0, 1000.0, 1.0, 1.0, 1.0, true, false);
 893     _page_misc.add_line( false, _("Maximum number of recent documents:"), _misc_recent, "",
 894                            _("The maximum length of the Open Recent list in the File menu"), false);
 895     _misc_simpl.init("options.simplifythreshold", "value", 0.0001, 1.0, 0.0001, 0.0010, 0.0010, false, false);
 896
 897     this->AddPage(_page_misc, _("Misc"), PREFS_PAGE_MISC);
 898 }
 899
 900 bool InkscapePreferences::SetMaxDialogSize(const Gtk::TreeModel::iterator& iter)
 901 {
 902     Gtk::TreeModel::Row row = *iter;
 903     DialogPage* page = row[_page_list_columns._col_page];
 904     _page_frame.add(*page);
 905     this->show_all_children();
 906     Gtk:: Requisition sreq;
 907     this->size_request(sreq);
 908     _max_dialog_width=std::max(_max_dialog_width, sreq.width);
 909     _max_dialog_height=std::max(_max_dialog_height, sreq.height);
 910     _page_frame.remove();
 911     return false;
 912 }
 913
 914 bool InkscapePreferences::PresentPage(const Gtk::TreeModel::iterator& iter)
 915 {
 916     Gtk::TreeModel::Row row = *iter;
 917     int desired_page = prefs_get_int_attribute("dialogs.preferences", "page", 0);
 918     if (desired_page == row[_page_list_columns._col_id])
 919     {
 920         if (desired_page >= PREFS_PAGE_TOOLS && desired_page <= PREFS_PAGE_TOOLS_DROPPER)
 921             _page_list.expand_row(_path_tools, false);
 922         if (desired_page >= PREFS_PAGE_TOOLS_SHAPES && desired_page <= PREFS_PAGE_TOOLS_SHAPES_SPIRAL)
 923             _page_list.expand_row(_path_shapes, false);
 924         _page_list.get_selection()->select(iter);
 925         return true;
 926     }
 927     return false;
 928 }
 929
 930 void InkscapePreferences::on_pagelist_selection_changed()
 931 {
 932     // show new selection
 933     Glib::RefPtr<Gtk::TreeSelection> selection = _page_list.get_selection();
 934     Gtk::TreeModel::iterator iter = selection->get_selected();
 935     if(iter)
 936     {
 937         if (_current_page)
 938             _page_frame.remove();
 939         Gtk::TreeModel::Row row = *iter;
 940         _current_page = row[_page_list_columns._col_page];
 941         prefs_set_int_attribute("dialogs.preferences", "page", row[_page_list_columns._col_id]);
 942         _page_title.set_markup("<span size='large'><b>" + row[_page_list_columns._col_name] + "</b></span>");
 943         _page_frame.add(*_current_page);
 944         _current_page->show();
 945         while (Gtk::Main::events_pending())
 946         {
 947             Gtk::Main::iteration();
 948         }
 949         this->show_all_children();
 950     }
 951 }
 952
 953 void InkscapePreferences::_presentPages()
 954 {
 955     _page_list_model->foreach_iter(sigc::mem_fun(*this, &InkscapePreferences::PresentPage));
 956 }
 957
 958 } // namespace Dialog
 959 } // namespace UI
 960 } // namespace Inkscape
 961
 962 /*
 963   Local Variables:
 964   mode:c++
 965   c-file-style:"stroustrup"
 966   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 967   indent-tabs-mode:nil
 968   fill-column:99
 969   End:
 970 */
 971 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :