src/verbs.cpp

   1 #define __SP_VERBS_C__
   2 /**
   3  * \file verbs.cpp
   4  *
   5  * \brief Actions for inkscape
   6  *
   7  * This file implements routines necessary to deal with verbs.  A verb
   8  * is a numeric identifier used to retrieve standard SPActions for particular
   9  * views.
  10  */
  11
  12 /*
  13  * Authors:
  14  *   Lauris Kaplinski <lauris@kaplinski.com>
  15  *   Ted Gould <ted@gould.cx>
  16  *   MenTaLguY <mental@rydia.net>
  17  *   David Turner <novalis@gnu.org>
  18  *   bulia byak <buliabyak@users.sf.net>
  19  *
  20  * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
  21  * Copyright (C) (date unspecified) Authors
  22  * This code is in public domain.
  23  */
  24
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <cstring>
  31 #include <gtk/gtkstock.h>
  32 #include <gtkmm/filechooserdialog.h>
  33 #include <gtkmm/messagedialog.h>
  34 #include <gtkmm/stock.h>
  35 #include <string>
  36
  37 #include "bind/javabind.h"
  38 #include "desktop.h"
  39 #include "desktop-handles.h"
  40 #include "dialogs/clonetiler.h"
  41 #include "dialogs/find.h"
  42 #include "dialogs/input.h"
  43 #include "dialogs/item-properties.h"
  44 #include "dialogs/spellcheck.h"
  45 #include "dialogs/text-edit.h"
  46 #include "dialogs/xml-tree.h"
  47 #include "display/curve.h"
  48 #include "document.h"
  49 #include "draw-context.h"
  50 #include "extension/effect.h"
  51 #include "file.h"
  52 #include "gradient-context.h"
  53 #include "gradient-drag.h"
  54 #include "helper/action.h"
  55 #include "help.h"
  56 #include "inkscape-private.h"
  57 #include "interface.h"
  58 #include "layer-fns.h"
  59 #include "layer-manager.h"
  60 #include "message-stack.h"
  61 #include "path-chemistry.h"
  62 #include "preferences.h"
  63 #include "select-context.h"
  64 #include "selection-chemistry.h"
  65 #include "seltrans.h"
  66 #include "shape-editor.h"
  67 #include "sp-flowtext.h"
  68 #include "sp-guide.h"
  69 #include "splivarot.h"
  70 #include "sp-namedview.h"
  71 #include "text-chemistry.h"
  72 #include "tools-switch.h"
  73 #include "ui/dialog/dialog-manager.h"
  74 #include "ui/dialog/document-properties.h"
  75 #include "ui/dialog/extensions.h"
  76 #include "ui/dialog/icon-preview.h"
  77 #include "ui/dialog/inkscape-preferences.h"
  78 #include "ui/dialog/layer-properties.h"
  79 #include "ui/dialog/layers.h"
  80 #include "ui/dialog/swatches.h"
  81 #include "ui/icon-names.h"
  82 #include "ui/tool/multi-path-manipulator.h"
  83 #include "ui/tool/node-tool.h"
  84
  85 //#ifdef WITH_INKBOARD
  86 //#include "jabber_whiteboard/session-manager.h"
  87 //#endif
  88
  89 /**
  90  * \brief Return the name without underscores and ellipsis, for use in dialog
  91  * titles, etc. Allocated memory must be freed by caller.
  92  */
  93 gchar *
  94 sp_action_get_title(SPAction const *action)
  95 {
  96     char const *src = action->name;
  97     gchar *ret = g_new(gchar, strlen(src) + 1);
  98     unsigned ri = 0;
  99
 100     for (unsigned si = 0 ; ; si++)  {
 101         int const c = src[si];
 102         if ( c != '_' && c != '.' ) {
 103             ret[ri] = c;
 104             ri++;
 105             if (c == '\0') {
 106                 return ret;
 107             }
 108         }
 109     }
 110
 111 } // end of sp_action_get_title()
 112
 113 namespace Inkscape {
 114
 115 /** \brief A class to encompass all of the verbs which deal with
 116            file operations. */
 117 class FileVerb : public Verb {
 118 private:
 119     static void perform(SPAction *action, void *mydata, void *otherdata);
 120     static SPActionEventVector vector;
 121 protected:
 122     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 123 public:
 124     /** \brief Use the Verb initializer with the same parameters. */
 125     FileVerb(unsigned int const code,
 126              gchar const *id,
 127              gchar const *name,
 128              gchar const *tip,
 129              gchar const *image) :
 130         Verb(code, id, name, tip, image)
 131     { }
 132 }; /* FileVerb class */
 133
 134 /** \brief A class to encompass all of the verbs which deal with
 135            edit operations. */
 136 class EditVerb : public Verb {
 137 private:
 138     static void perform(SPAction *action, void *mydata, void *otherdata);
 139     static SPActionEventVector vector;
 140 protected:
 141     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 142 public:
 143     /** \brief Use the Verb initializer with the same parameters. */
 144     EditVerb(unsigned int const code,
 145              gchar const *id,
 146              gchar const *name,
 147              gchar const *tip,
 148              gchar const *image) :
 149         Verb(code, id, name, tip, image)
 150     { }
 151 }; /* EditVerb class */
 152
 153 /** \brief A class to encompass all of the verbs which deal with
 154            selection operations. */
 155 class SelectionVerb : public Verb {
 156 private:
 157     static void perform(SPAction *action, void *mydata, void *otherdata);
 158     static SPActionEventVector vector;
 159 protected:
 160     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 161 public:
 162     /** \brief Use the Verb initializer with the same parameters. */
 163     SelectionVerb(unsigned int const code,
 164                   gchar const *id,
 165                   gchar const *name,
 166                   gchar const *tip,
 167                   gchar const *image) :
 168         Verb(code, id, name, tip, image)
 169     { }
 170 }; /* SelectionVerb class */
 171
 172 /** \brief A class to encompass all of the verbs which deal with
 173            layer operations. */
 174 class LayerVerb : public Verb {
 175 private:
 176     static void perform(SPAction *action, void *mydata, void *otherdata);
 177     static SPActionEventVector vector;
 178 protected:
 179     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 180 public:
 181     /** \brief Use the Verb initializer with the same parameters. */
 182     LayerVerb(unsigned int const code,
 183               gchar const *id,
 184               gchar const *name,
 185               gchar const *tip,
 186               gchar const *image) :
 187         Verb(code, id, name, tip, image)
 188     { }
 189 }; /* LayerVerb class */
 190
 191 /** \brief A class to encompass all of the verbs which deal with
 192            operations related to objects. */
 193 class ObjectVerb : public Verb {
 194 private:
 195     static void perform(SPAction *action, void *mydata, void *otherdata);
 196     static SPActionEventVector vector;
 197 protected:
 198     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 199 public:
 200     /** \brief Use the Verb initializer with the same parameters. */
 201     ObjectVerb(unsigned int const code,
 202                gchar const *id,
 203                gchar const *name,
 204                gchar const *tip,
 205                gchar const *image) :
 206         Verb(code, id, name, tip, image)
 207     { }
 208 }; /* ObjectVerb class */
 209
 210 /** \brief A class to encompass all of the verbs which deal with
 211            operations relative to context. */
 212 class ContextVerb : public Verb {
 213 private:
 214     static void perform(SPAction *action, void *mydata, void *otherdata);
 215     static SPActionEventVector vector;
 216 protected:
 217     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 218 public:
 219     /** \brief Use the Verb initializer with the same parameters. */
 220     ContextVerb(unsigned int const code,
 221                 gchar const *id,
 222                 gchar const *name,
 223                 gchar const *tip,
 224                 gchar const *image) :
 225         Verb(code, id, name, tip, image)
 226     { }
 227 }; /* ContextVerb class */
 228
 229 /** \brief A class to encompass all of the verbs which deal with
 230            zoom operations. */
 231 class ZoomVerb : public Verb {
 232 private:
 233     static void perform(SPAction *action, void *mydata, void *otherdata);
 234     static SPActionEventVector vector;
 235 protected:
 236     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 237 public:
 238     /** \brief Use the Verb initializer with the same parameters. */
 239     ZoomVerb(unsigned int const code,
 240              gchar const *id,
 241              gchar const *name,
 242              gchar const *tip,
 243              gchar const *image) :
 244         Verb(code, id, name, tip, image)
 245     { }
 246 }; /* ZoomVerb class */
 247
 248
 249 /** \brief A class to encompass all of the verbs which deal with
 250            dialog operations. */
 251 class DialogVerb : public Verb {
 252 private:
 253     static void perform(SPAction *action, void *mydata, void *otherdata);
 254     static SPActionEventVector vector;
 255 protected:
 256     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 257 public:
 258     /** \brief Use the Verb initializer with the same parameters. */
 259     DialogVerb(unsigned int const code,
 260                gchar const *id,
 261                gchar const *name,
 262                gchar const *tip,
 263                gchar const *image) :
 264         Verb(code, id, name, tip, image)
 265     { }
 266 }; /* DialogVerb class */
 267
 268 /** \brief A class to encompass all of the verbs which deal with
 269            help operations. */
 270 class HelpVerb : public Verb {
 271 private:
 272     static void perform(SPAction *action, void *mydata, void *otherdata);
 273     static SPActionEventVector vector;
 274 protected:
 275     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 276 public:
 277     /** \brief Use the Verb initializer with the same parameters. */
 278     HelpVerb(unsigned int const code,
 279              gchar const *id,
 280              gchar const *name,
 281              gchar const *tip,
 282              gchar const *image) :
 283         Verb(code, id, name, tip, image)
 284     { }
 285 }; /* HelpVerb class */
 286
 287 /** \brief A class to encompass all of the verbs which deal with
 288            tutorial operations. */
 289 class TutorialVerb : public Verb {
 290 private:
 291     static void perform(SPAction *action, void *mydata, void *otherdata);
 292     static SPActionEventVector vector;
 293 protected:
 294     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 295 public:
 296     /** \brief Use the Verb initializer with the same parameters. */
 297     TutorialVerb(unsigned int const code,
 298                  gchar const *id,
 299                  gchar const *name,
 300                  gchar const *tip,
 301                  gchar const *image) :
 302         Verb(code, id, name, tip, image)
 303     { }
 304 }; /* TutorialVerb class */
 305
 306 /** \brief A class to encompass all of the verbs which deal with
 307            text operations. */
 308 class TextVerb : public Verb {
 309 private:
 310     static void perform(SPAction *action, void *mydata, void *otherdata);
 311     static SPActionEventVector vector;
 312 protected:
 313     virtual SPAction *make_action(Inkscape::UI::View::View *view);
 314 public:
 315     /** \brief Use the Verb initializer with the same parameters. */
 316     TextVerb(unsigned int const code,
 317               gchar const *id,
 318               gchar const *name,
 319               gchar const *tip,
 320               gchar const *image) :
 321         Verb(code, id, name, tip, image)
 322     { }
 323 }; //TextVerb : public Verb
 324
 325 Verb::VerbTable Verb::_verbs;
 326 Verb::VerbIDTable Verb::_verb_ids;
 327
 328 /** \brief  Create a verb without a code.
 329
 330     This function calls the other constructor for all of the parameters,
 331     but generates the code.  It is important to READ THE OTHER DOCUMENTATION
 332     it has important details in it.  To generate the code a static is
 333     used which starts at the last static value: \c SP_VERB_LAST.  For
 334     each call it is incremented.  The list of allocated verbs is kept
 335     in the \c _verbs hashtable which is indexed by the \c code.
 336 */
 337 Verb::Verb(gchar const *id, gchar const *name, gchar const *tip, gchar const *image) :
 338     _actions(NULL), _id(id), _name(name), _tip(tip), _image(image)
 339 {
 340     static int count = SP_VERB_LAST;
 341
 342     count++;
 343     _code = count;
 344     _verbs.insert(VerbTable::value_type(count, this));
 345     _verb_ids.insert(VerbIDTable::value_type(_id, this));
 346
 347     return;
 348 }
 349
 350 /** \brief  Destroy a verb.
 351
 352       The only allocated variable is the _actions variable.  If it has
 353     been allocated it is deleted.
 354 */
 355 Verb::~Verb(void)
 356 {
 357     /// \todo all the actions need to be cleaned up first.
 358     if (_actions != NULL) {
 359         delete _actions;
 360     }
 361
 362     return;
 363 }
 364
 365 /** \brief  Verbs are no good without actions.  This is a place holder
 366             for a function that every subclass should write.  Most
 367             can be written using \c make_action_helper.
 368     \param  view  Which view the action should be created for.
 369     \return NULL to represent error (this function shouldn't ever be called)
 370 */
 371 SPAction *
 372 Verb::make_action(Inkscape::UI::View::View */*view*/)
 373 {
 374     //std::cout << "make_action" << std::endl;
 375     return NULL;
 376 }
 377
 378 /** \brief  Create an action for a \c FileVerb
 379     \param  view  Which view the action should be created for
 380     \return The built action.
 381
 382     Calls \c make_action_helper with the \c vector.
 383 */
 384 SPAction *
 385 FileVerb::make_action(Inkscape::UI::View::View *view)
 386 {
 387     //std::cout << "fileverb: make_action: " << &vector << std::endl;
 388     return make_action_helper(view, &vector);
 389 }
 390
 391 /** \brief  Create an action for a \c EditVerb
 392     \param  view  Which view the action should be created for
 393     \return The built action.
 394
 395     Calls \c make_action_helper with the \c vector.
 396 */
 397 SPAction *
 398 EditVerb::make_action(Inkscape::UI::View::View *view)
 399 {
 400     //std::cout << "editverb: make_action: " << &vector << std::endl;
 401     return make_action_helper(view, &vector);
 402 }
 403
 404 /** \brief  Create an action for a \c SelectionVerb
 405     \param  view  Which view the action should be created for
 406     \return The built action.
 407
 408     Calls \c make_action_helper with the \c vector.
 409 */
 410 SPAction *
 411 SelectionVerb::make_action(Inkscape::UI::View::View *view)
 412 {
 413     return make_action_helper(view, &vector);
 414 }
 415
 416 /** \brief  Create an action for a \c LayerVerb
 417     \param  view  Which view the action should be created for
 418     \return The built action.
 419
 420     Calls \c make_action_helper with the \c vector.
 421 */
 422 SPAction *
 423 LayerVerb::make_action(Inkscape::UI::View::View *view)
 424 {
 425     return make_action_helper(view, &vector);
 426 }
 427
 428 /** \brief  Create an action for a \c ObjectVerb
 429     \param  view  Which view the action should be created for
 430     \return The built action.
 431
 432     Calls \c make_action_helper with the \c vector.
 433 */
 434 SPAction *
 435 ObjectVerb::make_action(Inkscape::UI::View::View *view)
 436 {
 437     return make_action_helper(view, &vector);
 438 }
 439
 440 /** \brief  Create an action for a \c ContextVerb
 441     \param  view  Which view the action should be created for
 442     \return The built action.
 443
 444     Calls \c make_action_helper with the \c vector.
 445 */
 446 SPAction *
 447 ContextVerb::make_action(Inkscape::UI::View::View *view)
 448 {
 449     return make_action_helper(view, &vector);
 450 }
 451
 452 /** \brief  Create an action for a \c ZoomVerb
 453     \param  view  Which view the action should be created for
 454     \return The built action.
 455
 456     Calls \c make_action_helper with the \c vector.
 457 */
 458 SPAction *
 459 ZoomVerb::make_action(Inkscape::UI::View::View *view)
 460 {
 461     return make_action_helper(view, &vector);
 462 }
 463
 464 /** \brief  Create an action for a \c DialogVerb
 465     \param  view  Which view the action should be created for
 466     \return The built action.
 467
 468     Calls \c make_action_helper with the \c vector.
 469 */
 470 SPAction *
 471 DialogVerb::make_action(Inkscape::UI::View::View *view)
 472 {
 473     return make_action_helper(view, &vector);
 474 }
 475
 476 /** \brief  Create an action for a \c HelpVerb
 477     \param  view  Which view the action should be created for
 478     \return The built action.
 479
 480     Calls \c make_action_helper with the \c vector.
 481 */
 482 SPAction *
 483 HelpVerb::make_action(Inkscape::UI::View::View *view)
 484 {
 485     return make_action_helper(view, &vector);
 486 }
 487
 488 /** \brief  Create an action for a \c TutorialVerb
 489     \param  view  Which view the action should be created for
 490     \return The built action.
 491
 492     Calls \c make_action_helper with the \c vector.
 493 */
 494 SPAction *
 495 TutorialVerb::make_action(Inkscape::UI::View::View *view)
 496 {
 497     return make_action_helper(view, &vector);
 498 }
 499
 500 /** \brief  Create an action for a \c TextVerb
 501     \param  view  Which view the action should be created for
 502     \return The built action.
 503
 504     Calls \c make_action_helper with the \c vector.
 505 */
 506 SPAction *
 507 TextVerb::make_action(Inkscape::UI::View::View *view)
 508 {
 509     return make_action_helper(view, &vector);
 510 }
 511
 512 /** \brief A quick little convience function to make building actions
 513            a little bit easier.
 514     \param  view    Which view the action should be created for.
 515     \param  vector  The function vector for the verb.
 516     \return The created action.
 517
 518     This function does a couple of things.  The most obvious is that
 519     it allocates and creates the action.  When it does this it
 520     translates the \c _name and \c _tip variables.  This allows them
 521     to be staticly allocated easily, and get translated in the end.  Then,
 522     if the action gets crated, a listener is added to the action with
 523     the vector that is passed in.
 524 */
 525 SPAction *
 526 Verb::make_action_helper(Inkscape::UI::View::View *view, SPActionEventVector *vector, void *in_pntr)
 527 {
 528     SPAction *action;
 529
 530     //std::cout << "Adding action: " << _code << std::endl;
 531     action = sp_action_new(view, _id, _(_name),
 532                            _(_tip), _image, this);
 533
 534     if (action != NULL) {
 535         if (in_pntr == NULL) {
 536             nr_active_object_add_listener(
 537                 (NRActiveObject *) action,
 538                 (NRObjectEventVector *) vector,
 539                 sizeof(SPActionEventVector),
 540                 reinterpret_cast<void *>(_code)
 541             );
 542         } else {
 543             nr_active_object_add_listener(
 544                 (NRActiveObject *) action,
 545                 (NRObjectEventVector *) vector,
 546                 sizeof(SPActionEventVector),
 547                 in_pntr
 548             );
 549         }
 550     }
 551
 552     return action;
 553 }
 554
 555 /** \brief  A function to get an action if it exists, or otherwise to
 556             build it.
 557     \param  view  The view which this action would relate to
 558     \return The action, or NULL if there is an error.
 559
 560     This function will get the action for a given view for this verb.  It
 561     will create the verb if it can't be found in the ActionTable.  Also,
 562     if the \c ActionTable has not been created, it gets created by this
 563     function.
 564
 565     If the action is created, it's sensitivity must be determined.  The
 566     default for a new action is that it is sensitive.  If the value in
 567     \c _default_sensitive is \c false, then the sensitivity must be
 568     removed.  Also, if the view being created is based on the same
 569     document as a view already created, the sensitivity should be the
 570     same as views on that document.  A view with the same document is
 571     looked for, and the sensitivity is matched.  Unfortunately, this is
 572     currently a linear search.
 573 */
 574 SPAction *
 575 Verb::get_action(Inkscape::UI::View::View *view)
 576 {
 577     SPAction *action = NULL;
 578
 579     if ( _actions == NULL ) {
 580         _actions = new ActionTable;
 581     }
 582     ActionTable::iterator action_found = _actions->find(view);
 583
 584     if (action_found != _actions->end()) {
 585         action = action_found->second;
 586     } else {
 587         action = this->make_action(view);
 588
 589         // if (action == NULL) printf("Hmm, NULL in %s\n", _name);
 590         if (action == NULL) printf("Hmm, NULL in %s\n", _name);
 591         if (!_default_sensitive) {
 592             sp_action_set_sensitive(action, 0);
 593         } else {
 594             for (ActionTable::iterator cur_action = _actions->begin();
 595                  cur_action != _actions->end() && view != NULL;
 596                  cur_action++) {
 597                 if (cur_action->first != NULL && cur_action->first->doc() == view->doc()) {
 598                     sp_action_set_sensitive(action, cur_action->second->sensitive);
 599                     break;
 600                 }
 601             }
 602         }
 603
 604         _actions->insert(ActionTable::value_type(view, action));
 605     }
 606
 607     return action;
 608 }
 609
 610 void
 611 Verb::sensitive(SPDocument *in_doc, bool in_sensitive)
 612 {
 613     // printf("Setting sensitivity of \"%s\" to %d\n", _name, in_sensitive);
 614     if (_actions != NULL) {
 615         for (ActionTable::iterator cur_action = _actions->begin();
 616              cur_action != _actions->end();
 617              cur_action++) {
 618             if (in_doc == NULL || (cur_action->first != NULL && cur_action->first->doc() == in_doc)) {
 619                 sp_action_set_sensitive(cur_action->second, in_sensitive ? 1 : 0);
 620             }
 621         }
 622     }
 623
 624     if (in_doc == NULL) {
 625         _default_sensitive = in_sensitive;
 626     }
 627
 628     return;
 629 }
 630
 631 /** \brief Accessor to get the tooltip for verb as localised string */
 632 gchar const *
 633 Verb::get_tip (void)
 634 {
 635         return _(_tip);
 636 }
 637
 638 void
 639 Verb::name(SPDocument *in_doc, Glib::ustring in_name)
 640 {
 641     if (_actions != NULL) {
 642         for (ActionTable::iterator cur_action = _actions->begin();
 643              cur_action != _actions->end();
 644              cur_action++) {
 645             if (in_doc == NULL || (cur_action->first != NULL && cur_action->first->doc() == in_doc)) {
 646                 sp_action_set_name(cur_action->second, in_name);
 647             }
 648         }
 649     }
 650 }
 651
 652 /** \brief  A function to remove the action associated with a view.
 653     \param  view  Which view's actions should be removed.
 654     \return None
 655
 656     This function looks for the action in \c _actions.  If it is
 657     found then it is unreferenced and the entry in the action
 658     table is erased.
 659 */
 660 void
 661 Verb::delete_view(Inkscape::UI::View::View *view)
 662 {
 663     if (_actions == NULL) return;
 664     if (_actions->empty()) return;
 665
 666 #if 0
 667     static int count = 0;
 668     std::cout << count++ << std::endl;
 669 #endif
 670
 671     ActionTable::iterator action_found = _actions->find(view);
 672
 673     if (action_found != _actions->end()) {
 674         SPAction *action = action_found->second;
 675         nr_object_unref(NR_OBJECT(action));
 676         _actions->erase(action_found);
 677     }
 678
 679     return;
 680 }
 681
 682 /** \brief  A function to delete a view from all verbs
 683     \param  view  Which view's actions should be removed.
 684     \return None
 685
 686     This function first looks through _base_verbs and deteles
 687     the view from all of those views.  If \c _verbs is not empty
 688     then all of the entries in that table have all of the views
 689     deleted also.
 690 */
 691 void
 692 Verb::delete_all_view(Inkscape::UI::View::View *view)
 693 {
 694     for (int i = 0; i <= SP_VERB_LAST; i++) {
 695         if (_base_verbs[i])
 696           _base_verbs[i]->delete_view(view);
 697     }
 698
 699     if (!_verbs.empty()) {
 700         for (VerbTable::iterator thisverb = _verbs.begin();
 701              thisverb != _verbs.end(); thisverb++) {
 702             Inkscape::Verb *verbpntr = thisverb->second;
 703             // std::cout << "Delete In Verb: " << verbpntr->_name << std::endl;
 704             verbpntr->delete_view(view);
 705         }
 706     }
 707
 708     return;
 709 }
 710
 711 /** \brief  A function to turn a \c code into a Verb for dynamically
 712             created Verbs.
 713     \param  code  What code is being looked for
 714     \return The found Verb of NULL if none is found.
 715
 716     This function basically just looks through the \c _verbs hash
 717     table.  STL does all the work.
 718 */
 719 Verb *
 720 Verb::get_search(unsigned int code)
 721 {
 722     Verb *verb = NULL;
 723     VerbTable::iterator verb_found = _verbs.find(code);
 724
 725     if (verb_found != _verbs.end()) {
 726         verb = verb_found->second;
 727     }
 728
 729     return verb;
 730 }
 731
 732 /** \brief  Find a Verb using it's ID
 733     \param  id  Which id to search for
 734
 735     This function uses the \c _verb_ids has table to find the
 736     verb by it's id.  Should be much faster than previous
 737     implementations.
 738 */
 739 Verb *
 740 Verb::getbyid(gchar const *id)
 741 {
 742     Verb *verb = NULL;
 743     VerbIDTable::iterator verb_found = _verb_ids.find(id);
 744
 745     if (verb_found != _verb_ids.end()) {
 746         verb = verb_found->second;
 747     }
 748
 749     if (verb == NULL)
 750         printf("Unable to find: %s\n", id);
 751
 752     return verb;
 753 }
 754
 755 /** \brief  Decode the verb code and take appropriate action */
 756 void
 757 FileVerb::perform(SPAction *action, void *data, void */*pdata*/)
 758 {
 759 #if 0
 760     /* These aren't used, but are here to remind people not to use
 761        the CURRENT_DOCUMENT macros unless they really have to. */
 762     Inkscape::UI::View::View *current_view = sp_action_get_view(action);
 763     SPDocument *current_document = current_view->doc();
 764 #endif
 765
 766     SPDesktop *desktop = dynamic_cast<SPDesktop*>(sp_action_get_view(action));
 767     g_assert(desktop != NULL);
 768     Gtk::Window *parent = desktop->getToplevel();
 769     g_assert(parent != NULL);
 770
 771     switch ((long) data) {
 772         case SP_VERB_FILE_NEW:
 773             sp_file_new_default();
 774             break;
 775         case SP_VERB_FILE_OPEN:
 776             sp_file_open_dialog(*parent, NULL, NULL);
 777             break;
 778         case SP_VERB_FILE_REVERT:
 779             sp_file_revert_dialog();
 780             break;
 781         case SP_VERB_FILE_SAVE:
 782             sp_file_save(*parent, NULL, NULL);
 783             break;
 784         case SP_VERB_FILE_SAVE_AS:
 785             sp_file_save_as(*parent, NULL, NULL);
 786             break;
 787         case SP_VERB_FILE_SAVE_A_COPY:
 788             sp_file_save_a_copy(*parent, NULL, NULL);
 789             break;
 790         case SP_VERB_FILE_PRINT:
 791             sp_file_print(*parent);
 792             break;
 793         case SP_VERB_FILE_VACUUM:
 794             sp_file_vacuum();
 795             break;
 796         case SP_VERB_FILE_PRINT_PREVIEW:
 797             sp_file_print_preview(NULL, NULL);
 798             break;
 799         case SP_VERB_FILE_IMPORT:
 800             sp_file_import(*parent);
 801             break;
 802         case SP_VERB_FILE_EXPORT:
 803             sp_file_export_dialog(*parent);
 804             break;
 805         case SP_VERB_FILE_IMPORT_FROM_OCAL:
 806             sp_file_import_from_ocal(*parent);
 807             break;
 808 //        case SP_VERB_FILE_EXPORT_TO_OCAL:
 809 //            sp_file_export_to_ocal(*parent);
 810 //            break;
 811         case SP_VERB_FILE_NEXT_DESKTOP:
 812             inkscape_switch_desktops_next();
 813             break;
 814         case SP_VERB_FILE_PREV_DESKTOP:
 815             inkscape_switch_desktops_prev();
 816             break;
 817         case SP_VERB_FILE_CLOSE_VIEW:
 818             sp_ui_close_view(NULL);
 819             break;
 820         case SP_VERB_FILE_QUIT:
 821             sp_file_exit();
 822             break;
 823         default:
 824             break;
 825     }
 826
 827
 828 } // end of sp_verb_action_file_perform()
 829
 830 /** \brief  Decode the verb code and take appropriate action */
 831 void
 832 EditVerb::perform(SPAction *action, void *data, void */*pdata*/)
 833 {
 834     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
 835     if (!dt)
 836         return;
 837     SPEventContext *ec = dt->event_context;
 838
 839     switch (reinterpret_cast<std::size_t>(data)) {
 840         case SP_VERB_EDIT_UNDO:
 841             sp_undo(dt, sp_desktop_document(dt));
 842             break;
 843         case SP_VERB_EDIT_REDO:
 844             sp_redo(dt, sp_desktop_document(dt));
 845             break;
 846         case SP_VERB_EDIT_CUT:
 847             sp_selection_cut(dt);
 848             break;
 849         case SP_VERB_EDIT_COPY:
 850             sp_selection_copy();
 851             break;
 852         case SP_VERB_EDIT_PASTE:
 853             sp_selection_paste(dt, false);
 854             break;
 855         case SP_VERB_EDIT_PASTE_STYLE:
 856             sp_selection_paste_style(dt);
 857             break;
 858         case SP_VERB_EDIT_PASTE_SIZE:
 859             sp_selection_paste_size(dt, true, true);
 860             break;
 861         case SP_VERB_EDIT_PASTE_SIZE_X:
 862             sp_selection_paste_size(dt, true, false);
 863             break;
 864         case SP_VERB_EDIT_PASTE_SIZE_Y:
 865             sp_selection_paste_size(dt, false, true);
 866             break;
 867         case SP_VERB_EDIT_PASTE_SIZE_SEPARATELY:
 868             sp_selection_paste_size_separately(dt, true, true);
 869             break;
 870         case SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_X:
 871             sp_selection_paste_size_separately(dt, true, false);
 872             break;
 873         case SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_Y:
 874             sp_selection_paste_size_separately(dt, false, true);
 875             break;
 876         case SP_VERB_EDIT_PASTE_IN_PLACE:
 877             sp_selection_paste(dt, true);
 878             break;
 879         case SP_VERB_EDIT_PASTE_LIVEPATHEFFECT:
 880             sp_selection_paste_livepatheffect(dt);
 881             break;
 882         case SP_VERB_EDIT_REMOVE_LIVEPATHEFFECT:
 883             sp_selection_remove_livepatheffect(dt);
 884             break;
 885         case SP_VERB_EDIT_REMOVE_FILTER:
 886             sp_selection_remove_filter(dt);
 887             break;
 888         case SP_VERB_EDIT_DELETE:
 889             sp_selection_delete(dt);
 890             break;
 891         case SP_VERB_EDIT_DUPLICATE:
 892             sp_selection_duplicate(dt);
 893             break;
 894         case SP_VERB_EDIT_CLONE:
 895             sp_selection_clone(dt);
 896             break;
 897         case SP_VERB_EDIT_UNLINK_CLONE:
 898             sp_selection_unlink(dt);
 899             break;
 900         case SP_VERB_EDIT_RELINK_CLONE:
 901             sp_selection_relink(dt);
 902             break;
 903         case SP_VERB_EDIT_CLONE_SELECT_ORIGINAL:
 904             sp_select_clone_original(dt);
 905             break;
 906         case SP_VERB_EDIT_SELECTION_2_MARKER:
 907             sp_selection_to_marker(dt);
 908             break;
 909         case SP_VERB_EDIT_SELECTION_2_GUIDES:
 910             sp_selection_to_guides(dt);
 911             break;
 912         case SP_VERB_EDIT_TILE:
 913             sp_selection_tile(dt);
 914             break;
 915         case SP_VERB_EDIT_UNTILE:
 916             sp_selection_untile(dt);
 917             break;
 918         case SP_VERB_EDIT_CLEAR_ALL:
 919             sp_edit_clear_all(dt);
 920             break;
 921         case SP_VERB_EDIT_SELECT_ALL:
 922             if (tools_isactive(dt, TOOLS_NODES)) {
 923                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 924                 nt->_multipath->selectSubpaths();
 925             } else {
 926                 sp_edit_select_all(dt);
 927             }
 928             break;
 929         case SP_VERB_EDIT_INVERT:
 930             if (tools_isactive(dt, TOOLS_NODES)) {
 931                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 932                 nt->_multipath->invertSelectionInSubpaths();
 933             } else {
 934                 sp_edit_invert(dt);
 935             }
 936             break;
 937         case SP_VERB_EDIT_SELECT_ALL_IN_ALL_LAYERS:
 938             if (tools_isactive(dt, TOOLS_NODES)) {
 939                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 940                 nt->_multipath->selectAll();
 941             } else {
 942                 sp_edit_select_all_in_all_layers(dt);
 943             }
 944             break;
 945         case SP_VERB_EDIT_INVERT_IN_ALL_LAYERS:
 946             if (tools_isactive(dt, TOOLS_NODES)) {
 947                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 948                 nt->_multipath->invertSelection();
 949             } else {
 950                 sp_edit_invert_in_all_layers(dt);
 951             }
 952             break;
 953
 954         case SP_VERB_EDIT_SELECT_NEXT:
 955             if (tools_isactive(dt, TOOLS_NODES)) {
 956                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 957                 nt->_multipath->shiftSelection(1);
 958             } else if (tools_isactive(dt, TOOLS_GRADIENT)
 959                        && ec->_grdrag->isNonEmpty()) {
 960                 sp_gradient_context_select_next (ec);
 961             } else {
 962                 sp_selection_item_next(dt);
 963             }
 964             break;
 965         case SP_VERB_EDIT_SELECT_PREV:
 966             if (tools_isactive(dt, TOOLS_NODES)) {
 967                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 968                 nt->_multipath->shiftSelection(-1);
 969             } else if (tools_isactive(dt, TOOLS_GRADIENT)
 970                        && ec->_grdrag->isNonEmpty()) {
 971                 sp_gradient_context_select_prev (ec);
 972             } else {
 973                 sp_selection_item_prev(dt);
 974             }
 975             break;
 976
 977         case SP_VERB_EDIT_DESELECT:
 978             if (tools_isactive(dt, TOOLS_NODES)) {
 979                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
 980                 nt->_multipath->deselect();
 981             } else {
 982                 sp_desktop_selection(dt)->clear();
 983             }
 984             break;
 985
 986         case SP_VERB_EDIT_GUIDES_AROUND_PAGE:
 987             sp_guide_create_guides_around_page(dt);
 988             break;
 989
 990         case SP_VERB_EDIT_NEXT_PATHEFFECT_PARAMETER:
 991             sp_selection_next_patheffect_param(dt);
 992             break;
 993         case SP_VERB_EDIT_LINK_COLOR_PROFILE:
 994             break;
 995         case SP_VERB_EDIT_REMOVE_COLOR_PROFILE:
 996             break;
 997         default:
 998             break;
 999     }
1000
1001 } // end of sp_verb_action_edit_perform()
1002
1003 /** \brief  Decode the verb code and take appropriate action */
1004 void
1005 SelectionVerb::perform(SPAction *action, void *data, void */*pdata*/)
1006 {
1007     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1008
1009     if (!dt)
1010         return;
1011
1012     g_assert(dt->_dlg_mgr != NULL);
1013
1014     switch (reinterpret_cast<std::size_t>(data)) {
1015         case SP_VERB_SELECTION_TO_FRONT:
1016             sp_selection_raise_to_top(dt);
1017             break;
1018         case SP_VERB_SELECTION_TO_BACK:
1019             sp_selection_lower_to_bottom(dt);
1020             break;
1021         case SP_VERB_SELECTION_RAISE:
1022             sp_selection_raise(dt);
1023             break;
1024         case SP_VERB_SELECTION_LOWER:
1025             sp_selection_lower(dt);
1026             break;
1027         case SP_VERB_SELECTION_GROUP:
1028             sp_selection_group(dt);
1029             break;
1030         case SP_VERB_SELECTION_UNGROUP:
1031             sp_selection_ungroup(dt);
1032             break;
1033
1034         case SP_VERB_SELECTION_TEXTTOPATH:
1035             text_put_on_path();
1036             break;
1037         case SP_VERB_SELECTION_TEXTFROMPATH:
1038             text_remove_from_path();
1039             break;
1040         case SP_VERB_SELECTION_REMOVE_KERNS:
1041             text_remove_all_kerns();
1042             break;
1043
1044         case SP_VERB_SELECTION_UNION:
1045             sp_selected_path_union(dt);
1046             break;
1047         case SP_VERB_SELECTION_INTERSECT:
1048             sp_selected_path_intersect(dt);
1049             break;
1050         case SP_VERB_SELECTION_DIFF:
1051             sp_selected_path_diff(dt);
1052             break;
1053         case SP_VERB_SELECTION_SYMDIFF:
1054             sp_selected_path_symdiff(dt);
1055             break;
1056
1057         case SP_VERB_SELECTION_CUT:
1058             sp_selected_path_cut(dt);
1059             break;
1060         case SP_VERB_SELECTION_SLICE:
1061             sp_selected_path_slice(dt);
1062             break;
1063
1064         case SP_VERB_SELECTION_OFFSET:
1065             sp_selected_path_offset(dt);
1066             break;
1067         case SP_VERB_SELECTION_OFFSET_SCREEN:
1068             sp_selected_path_offset_screen(dt, 1);
1069             break;
1070         case SP_VERB_SELECTION_OFFSET_SCREEN_10:
1071             sp_selected_path_offset_screen(dt, 10);
1072             break;
1073         case SP_VERB_SELECTION_INSET:
1074             sp_selected_path_inset(dt);
1075             break;
1076         case SP_VERB_SELECTION_INSET_SCREEN:
1077             sp_selected_path_inset_screen(dt, 1);
1078             break;
1079         case SP_VERB_SELECTION_INSET_SCREEN_10:
1080             sp_selected_path_inset_screen(dt, 10);
1081             break;
1082         case SP_VERB_SELECTION_DYNAMIC_OFFSET:
1083             sp_selected_path_create_offset_object_zero(dt);
1084             tools_switch(dt, TOOLS_NODES);
1085             break;
1086         case SP_VERB_SELECTION_LINKED_OFFSET:
1087             sp_selected_path_create_updating_offset_object_zero(dt);
1088             tools_switch(dt, TOOLS_NODES);
1089             break;
1090         case SP_VERB_SELECTION_OUTLINE:
1091             sp_selected_path_outline(dt);
1092             break;
1093         case SP_VERB_SELECTION_SIMPLIFY:
1094             sp_selected_path_simplify(dt);
1095             break;
1096         case SP_VERB_SELECTION_REVERSE:
1097             // TODO make this a virtual method of event context!
1098             if (tools_isactive(dt, TOOLS_NODES)) {
1099                 InkNodeTool *nt = static_cast<InkNodeTool*>(dt->event_context);
1100                 nt->_multipath->reverseSubpaths();
1101             } else {
1102                 sp_selected_path_reverse(dt);
1103             }
1104             break;
1105         case SP_VERB_SELECTION_TRACE:
1106             inkscape_dialogs_unhide();
1107             dt->_dlg_mgr->showDialog("Trace");
1108             break;
1109         case SP_VERB_SELECTION_CREATE_BITMAP:
1110             sp_selection_create_bitmap_copy(dt);
1111             break;
1112
1113         case SP_VERB_SELECTION_COMBINE:
1114             sp_selected_path_combine(dt);
1115             break;
1116         case SP_VERB_SELECTION_BREAK_APART:
1117             sp_selected_path_break_apart(dt);
1118             break;
1119         case SP_VERB_SELECTION_GRIDTILE:
1120             inkscape_dialogs_unhide();
1121             dt->_dlg_mgr->showDialog("TileDialog");
1122             break;
1123         default:
1124             break;
1125     }
1126
1127 } // end of sp_verb_action_selection_perform()
1128
1129 /** \brief  Decode the verb code and take appropriate action */
1130 void
1131 LayerVerb::perform(SPAction *action, void *data, void */*pdata*/)
1132 {
1133     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1134     unsigned int verb = reinterpret_cast<std::size_t>(data);
1135
1136     if ( !dt || !dt->currentLayer() ) {
1137         return;
1138     }
1139
1140     switch (verb) {
1141         case SP_VERB_LAYER_NEW: {
1142             Inkscape::UI::Dialogs::LayerPropertiesDialog::showCreate(dt, dt->currentLayer());
1143             break;
1144         }
1145         case SP_VERB_LAYER_RENAME: {
1146             Inkscape::UI::Dialogs::LayerPropertiesDialog::showRename(dt, dt->currentLayer());
1147             break;
1148         }
1149         case SP_VERB_LAYER_NEXT: {
1150             SPObject *next=Inkscape::next_layer(dt->currentRoot(), dt->currentLayer());
1151             if (next) {
1152                 dt->setCurrentLayer(next);
1153                 sp_document_done(sp_desktop_document(dt), SP_VERB_LAYER_NEXT,
1154                                  _("Switch to next layer"));
1155                 dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Switched to next layer."));
1156             } else {
1157                 dt->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Cannot go past last layer."));
1158             }
1159             break;
1160         }
1161         case SP_VERB_LAYER_PREV: {
1162             SPObject *prev=Inkscape::previous_layer(dt->currentRoot(), dt->currentLayer());
1163             if (prev) {
1164                 dt->setCurrentLayer(prev);
1165                 sp_document_done(sp_desktop_document(dt), SP_VERB_LAYER_PREV,
1166                                  _("Switch to previous layer"));
1167                 dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Switched to previous layer."));
1168             } else {
1169                 dt->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Cannot go before first layer."));
1170             }
1171             break;
1172         }
1173         case SP_VERB_LAYER_MOVE_TO_NEXT: {
1174             sp_selection_to_next_layer(dt);
1175             break;
1176         }
1177         case SP_VERB_LAYER_MOVE_TO_PREV: {
1178             sp_selection_to_prev_layer(dt);
1179             break;
1180         }
1181         case SP_VERB_LAYER_TO_TOP:
1182         case SP_VERB_LAYER_TO_BOTTOM:
1183         case SP_VERB_LAYER_RAISE:
1184         case SP_VERB_LAYER_LOWER: {
1185             if ( dt->currentLayer() == dt->currentRoot() ) {
1186                 dt->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("No current layer."));
1187                 return;
1188             }
1189
1190             SPItem *layer=SP_ITEM(dt->currentLayer());
1191             g_return_if_fail(layer != NULL);
1192
1193             SPObject *old_pos=SP_OBJECT_NEXT(layer);
1194
1195             switch (verb) {
1196                 case SP_VERB_LAYER_TO_TOP:
1197                     layer->raiseToTop();
1198                     break;
1199                 case SP_VERB_LAYER_TO_BOTTOM:
1200                     layer->lowerToBottom();
1201                     break;
1202                 case SP_VERB_LAYER_RAISE:
1203                     layer->raiseOne();
1204                     break;
1205                 case SP_VERB_LAYER_LOWER:
1206                     layer->lowerOne();
1207                     break;
1208             }
1209
1210             if ( SP_OBJECT_NEXT(layer) != old_pos ) {
1211                 char const *message = NULL;
1212                 Glib::ustring description = "";
1213                 switch (verb) {
1214                     case SP_VERB_LAYER_TO_TOP:
1215                         message = g_strdup_printf(_("Raised layer <b>%s</b>."), layer->defaultLabel());
1216                         description = _("Layer to top");
1217                         break;
1218                     case SP_VERB_LAYER_RAISE:
1219                         message = g_strdup_printf(_("Raised layer <b>%s</b>."), layer->defaultLabel());
1220                         description = _("Raise layer");
1221                         break;
1222                     case SP_VERB_LAYER_TO_BOTTOM:
1223                         message = g_strdup_printf(_("Lowered layer <b>%s</b>."), layer->defaultLabel());
1224                         description = _("Layer to bottom");
1225                         break;
1226                     case SP_VERB_LAYER_LOWER:
1227                         message = g_strdup_printf(_("Lowered layer <b>%s</b>."), layer->defaultLabel());
1228                         description = _("Lower layer");
1229                         break;
1230                 };
1231                 sp_document_done(sp_desktop_document(dt), verb, description);
1232                 if (message) {
1233                     dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, message);
1234                     g_free((void *) message);
1235                 }
1236             } else {
1237                 dt->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("Cannot move layer any further."));
1238             }
1239
1240             break;
1241         }
1242         case SP_VERB_LAYER_DUPLICATE: {
1243             if ( dt->currentLayer() != dt->currentRoot() ) {
1244                 // Note with either approach:
1245                 // Any clone masters are duplicated, their clones use the *original*,
1246                 // but the duplicated master is not linked up as master nor clone of the original.
1247 #if 0
1248                 // Only copies selectable things, honoring locks, visibility, avoids sublayers.
1249                 SPObject *new_layer = Inkscape::create_layer(dt->currentRoot(), dt->currentLayer(), LPOS_BELOW);
1250                 if ( dt->currentLayer()->label() ) {
1251                     gchar* name = g_strdup_printf(_("%s copy"), dt->currentLayer()->label());
1252                     dt->layer_manager->renameLayer( new_layer, name, TRUE );
1253                     g_free(name);
1254                 }
1255                 sp_edit_select_all(dt);
1256                 sp_selection_duplicate(dt, true);
1257                 sp_selection_to_prev_layer(dt, true);
1258                 dt->setCurrentLayer(new_layer);
1259                 sp_edit_select_all(dt);
1260 #else
1261                 // Copies everything, regardless of locks, visibility, sublayers.
1262                 Inkscape::XML::Node *selected = dt->currentLayer()->repr;
1263                 Inkscape::XML::Node *parent = sp_repr_parent(selected);
1264                 Inkscape::XML::Node *dup = selected->duplicate(parent->document());
1265                 parent->addChild(dup, selected);
1266                 SPObject *new_layer = dt->currentLayer()->next;
1267                 if (new_layer) {
1268                     if (new_layer->label()) {
1269                         gchar* name = g_strdup_printf(_("%s copy"), new_layer->label());
1270                         dt->layer_manager->renameLayer( new_layer, name, TRUE );
1271                         g_free(name);
1272                     }
1273                     dt->setCurrentLayer(new_layer);
1274                 }
1275 #endif
1276                 sp_document_done(sp_desktop_document(dt), SP_VERB_LAYER_DUPLICATE,
1277                                  _("Duplicate layer"));
1278
1279                 // TRANSLATORS: this means "The layer has been duplicated."
1280                 dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Duplicated layer."));
1281             } else {
1282                 dt->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("No current layer."));
1283             }
1284             break;
1285         }
1286         case SP_VERB_LAYER_DELETE: {
1287             if ( dt->currentLayer() != dt->currentRoot() ) {
1288                 sp_desktop_selection(dt)->clear();
1289                 SPObject *old_layer=dt->currentLayer();
1290
1291                 sp_object_ref(old_layer, NULL);
1292                 SPObject *survivor=Inkscape::next_layer(dt->currentRoot(), old_layer);
1293                 if (!survivor) {
1294                     survivor = Inkscape::previous_layer(dt->currentRoot(), old_layer);
1295                 }
1296
1297                 /* Deleting the old layer before switching layers is a hack to trigger the
1298                  * listeners of the deletion event (as happens when old_layer is deleted using the
1299                  * xml editor).  See
1300                  * http://sourceforge.net/tracker/index.php?func=detail&aid=1339397&group_id=93438&atid=604306
1301                  */
1302                 old_layer->deleteObject();
1303                 sp_object_unref(old_layer, NULL);
1304                 if (survivor) {
1305                     dt->setCurrentLayer(survivor);
1306                 }
1307
1308                 sp_document_done(sp_desktop_document(dt), SP_VERB_LAYER_DELETE,
1309                                  _("Delete layer"));
1310
1311                 // TRANSLATORS: this means "The layer has been deleted."
1312                 dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Deleted layer."));
1313             } else {
1314                 dt->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("No current layer."));
1315             }
1316             break;
1317         }
1318         case SP_VERB_LAYER_SOLO: {
1319             if ( dt->currentLayer() == dt->currentRoot() ) {
1320                 dt->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("No current layer."));
1321             } else {
1322                 dt->toggleLayerSolo( dt->currentLayer() );
1323                 sp_document_maybe_done(sp_desktop_document(dt), "layer:solo", SP_VERB_LAYER_SOLO, _("Toggle layer solo"));
1324             }
1325             break;
1326         }
1327     }
1328
1329     return;
1330 } // end of sp_verb_action_layer_perform()
1331
1332 /** \brief  Decode the verb code and take appropriate action */
1333 void
1334 ObjectVerb::perform( SPAction *action, void *data, void */*pdata*/ )
1335 {
1336     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1337     if (!dt)
1338         return;
1339
1340     SPEventContext *ec = dt->event_context;
1341
1342     Inkscape::Selection *sel = sp_desktop_selection(dt);
1343
1344     if (sel->isEmpty())
1345         return;
1346
1347     Geom::OptRect bbox = sel->bounds();
1348     if (!bbox) {
1349         return;
1350     }
1351     // If the rotation center of the selection is visible, choose it as reference point
1352     // for horizontal and vertical flips. Otherwise, take the center of the bounding box.
1353     Geom::Point center;
1354     if (tools_isactive(dt, TOOLS_SELECT) && sel->center() && SP_SELECT_CONTEXT(ec)->_seltrans->centerIsVisible())
1355         center = *sel->center();
1356     else
1357         center = bbox->midpoint();
1358
1359     switch (reinterpret_cast<std::size_t>(data)) {
1360         case SP_VERB_OBJECT_ROTATE_90_CW:
1361             sp_selection_rotate_90(dt, false);
1362             break;
1363         case SP_VERB_OBJECT_ROTATE_90_CCW:
1364             sp_selection_rotate_90(dt, true);
1365             break;
1366         case SP_VERB_OBJECT_FLATTEN:
1367             sp_selection_remove_transform(dt);
1368             break;
1369         case SP_VERB_OBJECT_TO_CURVE:
1370             sp_selected_path_to_curves(dt);
1371             break;
1372         case SP_VERB_OBJECT_FLOW_TEXT:
1373             text_flow_into_shape();
1374             break;
1375         case SP_VERB_OBJECT_UNFLOW_TEXT:
1376             text_unflow();
1377             break;
1378         case SP_VERB_OBJECT_FLOWTEXT_TO_TEXT:
1379             flowtext_to_text();
1380             break;
1381         case SP_VERB_OBJECT_FLIP_HORIZONTAL:
1382             sp_selection_scale_relative(sel, center, Geom::Scale(-1.0, 1.0));
1383             sp_document_done(sp_desktop_document(dt), SP_VERB_OBJECT_FLIP_HORIZONTAL,
1384                              _("Flip horizontally"));
1385             break;
1386         case SP_VERB_OBJECT_FLIP_VERTICAL:
1387             sp_selection_scale_relative(sel, center, Geom::Scale(1.0, -1.0));
1388             sp_document_done(sp_desktop_document(dt), SP_VERB_OBJECT_FLIP_VERTICAL,
1389                              _("Flip vertically"));
1390             break;
1391         case SP_VERB_OBJECT_SET_MASK:
1392             sp_selection_set_mask(dt, false, false);
1393             break;
1394         case SP_VERB_OBJECT_EDIT_MASK:
1395             sp_selection_edit_clip_or_mask(dt, false);
1396             break;
1397         case SP_VERB_OBJECT_UNSET_MASK:
1398             sp_selection_unset_mask(dt, false);
1399             break;
1400         case SP_VERB_OBJECT_SET_CLIPPATH:
1401             sp_selection_set_mask(dt, true, false);
1402             break;
1403         case SP_VERB_OBJECT_EDIT_CLIPPATH:
1404             sp_selection_edit_clip_or_mask(dt, true);
1405             break;
1406         case SP_VERB_OBJECT_UNSET_CLIPPATH:
1407             sp_selection_unset_mask(dt, true);
1408             break;
1409         default:
1410             break;
1411     }
1412
1413 } // end of sp_verb_action_object_perform()
1414
1415 /** \brief  Decode the verb code and take appropriate action */
1416 void
1417 ContextVerb::perform(SPAction *action, void *data, void */*pdata*/)
1418 {
1419     SPDesktop *dt;
1420     sp_verb_t verb;
1421     int vidx;
1422
1423     dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1424
1425     if (!dt)
1426         return;
1427
1428     verb = (sp_verb_t)GPOINTER_TO_INT((gpointer)data);
1429
1430     /** \todo !!! hopefully this can go away soon and actions can look after
1431      * themselves
1432      */
1433     for (vidx = SP_VERB_CONTEXT_SELECT; vidx <= SP_VERB_CONTEXT_PAINTBUCKET_PREFS; vidx++)
1434     {
1435         SPAction *tool_action= get((sp_verb_t)vidx)->get_action(dt);
1436         if (tool_action) {
1437             sp_action_set_active(tool_action, vidx == (int)verb);
1438         }
1439     }
1440
1441     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1442     switch (verb) {
1443         case SP_VERB_CONTEXT_SELECT:
1444             tools_switch(dt, TOOLS_SELECT);
1445             break;
1446         case SP_VERB_CONTEXT_NODE:
1447             tools_switch(dt, TOOLS_NODES);
1448             break;
1449         case SP_VERB_CONTEXT_TWEAK:
1450             tools_switch(dt, TOOLS_TWEAK);
1451             break;
1452         case SP_VERB_CONTEXT_RECT:
1453             tools_switch(dt, TOOLS_SHAPES_RECT);
1454             break;
1455         case SP_VERB_CONTEXT_3DBOX:
1456             tools_switch(dt, TOOLS_SHAPES_3DBOX);
1457             break;
1458         case SP_VERB_CONTEXT_ARC:
1459             tools_switch(dt, TOOLS_SHAPES_ARC);
1460             break;
1461         case SP_VERB_CONTEXT_STAR:
1462             tools_switch(dt, TOOLS_SHAPES_STAR);
1463             break;
1464         case SP_VERB_CONTEXT_SPIRAL:
1465             tools_switch(dt, TOOLS_SHAPES_SPIRAL);
1466             break;
1467         case SP_VERB_CONTEXT_PENCIL:
1468             tools_switch(dt, TOOLS_FREEHAND_PENCIL);
1469             break;
1470         case SP_VERB_CONTEXT_PEN:
1471             tools_switch(dt, TOOLS_FREEHAND_PEN);
1472             break;
1473         case SP_VERB_CONTEXT_CALLIGRAPHIC:
1474             tools_switch(dt, TOOLS_CALLIGRAPHIC);
1475             break;
1476         case SP_VERB_CONTEXT_TEXT:
1477             tools_switch(dt, TOOLS_TEXT);
1478             break;
1479         case SP_VERB_CONTEXT_GRADIENT:
1480             tools_switch(dt, TOOLS_GRADIENT);
1481             break;
1482         case SP_VERB_CONTEXT_ZOOM:
1483             tools_switch(dt, TOOLS_ZOOM);
1484             break;
1485         case SP_VERB_CONTEXT_DROPPER:
1486             tools_switch(dt, TOOLS_DROPPER);
1487             break;
1488         case SP_VERB_CONTEXT_CONNECTOR:
1489             tools_switch(dt,  TOOLS_CONNECTOR);
1490             break;
1491         case SP_VERB_CONTEXT_PAINTBUCKET:
1492             tools_switch(dt, TOOLS_PAINTBUCKET);
1493             break;
1494         case SP_VERB_CONTEXT_ERASER:
1495             tools_switch(dt, TOOLS_ERASER);
1496             break;
1497         case SP_VERB_CONTEXT_LPETOOL:
1498             tools_switch(dt, TOOLS_LPETOOL);
1499             break;
1500
1501         case SP_VERB_CONTEXT_SELECT_PREFS:
1502             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_SELECTOR);
1503             dt->_dlg_mgr->showDialog("InkscapePreferences");
1504             break;
1505         case SP_VERB_CONTEXT_NODE_PREFS:
1506             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_NODE);
1507             dt->_dlg_mgr->showDialog("InkscapePreferences");
1508             break;
1509         case SP_VERB_CONTEXT_TWEAK_PREFS:
1510             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_TWEAK);
1511             dt->_dlg_mgr->showDialog("InkscapePreferences");
1512             break;
1513         case SP_VERB_CONTEXT_RECT_PREFS:
1514             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_SHAPES_RECT);
1515             dt->_dlg_mgr->showDialog("InkscapePreferences");
1516             break;
1517         case SP_VERB_CONTEXT_3DBOX_PREFS:
1518             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_SHAPES_3DBOX);
1519             dt->_dlg_mgr->showDialog("InkscapePreferences");
1520             break;
1521         case SP_VERB_CONTEXT_ARC_PREFS:
1522             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_SHAPES_ELLIPSE);
1523             dt->_dlg_mgr->showDialog("InkscapePreferences");
1524             break;
1525         case SP_VERB_CONTEXT_STAR_PREFS:
1526             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_SHAPES_STAR);
1527             dt->_dlg_mgr->showDialog("InkscapePreferences");
1528             break;
1529         case SP_VERB_CONTEXT_SPIRAL_PREFS:
1530             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_SHAPES_SPIRAL);
1531             dt->_dlg_mgr->showDialog("InkscapePreferences");
1532             break;
1533         case SP_VERB_CONTEXT_PENCIL_PREFS:
1534             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_PENCIL);
1535             dt->_dlg_mgr->showDialog("InkscapePreferences");
1536             break;
1537         case SP_VERB_CONTEXT_PEN_PREFS:
1538             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_PEN);
1539             dt->_dlg_mgr->showDialog("InkscapePreferences");
1540             break;
1541         case SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS:
1542             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_CALLIGRAPHY);
1543             dt->_dlg_mgr->showDialog("InkscapePreferences");
1544             break;
1545         case SP_VERB_CONTEXT_TEXT_PREFS:
1546             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_TEXT);
1547             dt->_dlg_mgr->showDialog("InkscapePreferences");
1548             break;
1549         case SP_VERB_CONTEXT_GRADIENT_PREFS:
1550             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_GRADIENT);
1551             dt->_dlg_mgr->showDialog("InkscapePreferences");
1552             break;
1553         case SP_VERB_CONTEXT_ZOOM_PREFS:
1554             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_ZOOM);
1555             dt->_dlg_mgr->showDialog("InkscapePreferences");
1556             break;
1557         case SP_VERB_CONTEXT_DROPPER_PREFS:
1558             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_DROPPER);
1559             dt->_dlg_mgr->showDialog("InkscapePreferences");
1560             break;
1561         case SP_VERB_CONTEXT_CONNECTOR_PREFS:
1562             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_CONNECTOR);
1563             dt->_dlg_mgr->showDialog("InkscapePreferences");
1564             break;
1565         case SP_VERB_CONTEXT_PAINTBUCKET_PREFS:
1566             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_PAINTBUCKET);
1567             dt->_dlg_mgr->showDialog("InkscapePreferences");
1568             break;
1569         case SP_VERB_CONTEXT_ERASER_PREFS:
1570             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_ERASER);
1571             dt->_dlg_mgr->showDialog("InkscapePreferences");
1572             break;
1573         case SP_VERB_CONTEXT_LPETOOL_PREFS:
1574             g_print ("TODO: Create preferences page for LPETool\n");
1575             prefs->setInt("/dialogs/preferences/page", PREFS_PAGE_TOOLS_LPETOOL);
1576             dt->_dlg_mgr->showDialog("InkscapePreferences");
1577             break;
1578
1579         default:
1580             break;
1581     }
1582
1583 } // end of sp_verb_action_ctx_perform()
1584
1585 /** \brief  Decode the verb code and take appropriate action */
1586 void
1587 TextVerb::perform(SPAction *action, void */*data*/, void */*pdata*/)
1588 {
1589     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1590     if (!dt)
1591         return;
1592
1593     SPDocument *doc = sp_desktop_document(dt);
1594     (void)doc;
1595     Inkscape::XML::Node *repr = SP_OBJECT_REPR(dt->namedview);
1596     (void)repr;
1597 }
1598
1599 /** \brief  Decode the verb code and take appropriate action */
1600 void
1601 ZoomVerb::perform(SPAction *action, void *data, void */*pdata*/)
1602 {
1603     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1604     if (!dt)
1605         return;
1606     SPEventContext *ec = dt->event_context;
1607
1608     SPDocument *doc = sp_desktop_document(dt);
1609
1610     Inkscape::XML::Node *repr = SP_OBJECT_REPR(dt->namedview);
1611
1612     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1613     gdouble zoom_inc =
1614         prefs->getDoubleLimited( "/options/zoomincrement/value", 1.414213562, 1.01, 10 );
1615
1616     switch (GPOINTER_TO_INT(data)) {
1617         case SP_VERB_ZOOM_IN:
1618         {
1619             gint mul = 1 + gobble_key_events(
1620                  GDK_KP_Add, 0); // with any mask
1621             // While drawing with the pen/pencil tool, zoom towards the end of the unfinished path
1622             if (tools_isactive(dt, TOOLS_FREEHAND_PENCIL) || tools_isactive(dt, TOOLS_FREEHAND_PEN)) {
1623                 SPCurve *rc = SP_DRAW_CONTEXT(ec)->red_curve;
1624                 if (!rc->is_empty()) {
1625                     Geom::Point const zoom_to (*rc->last_point());
1626                     dt->zoom_relative_keep_point(zoom_to, mul*zoom_inc);
1627                     break;
1628                 }
1629             }
1630
1631             Geom::Rect const d = dt->get_display_area();
1632             dt->zoom_relative( d.midpoint()[Geom::X], d.midpoint()[Geom::Y], mul*zoom_inc);
1633             break;
1634         }
1635         case SP_VERB_ZOOM_OUT:
1636         {
1637             gint mul = 1 + gobble_key_events(
1638                  GDK_KP_Subtract, 0); // with any mask
1639             // While drawing with the pen/pencil tool, zoom away from the end of the unfinished path
1640             if (tools_isactive(dt, TOOLS_FREEHAND_PENCIL) || tools_isactive(dt, TOOLS_FREEHAND_PEN)) {
1641                 SPCurve *rc = SP_DRAW_CONTEXT(ec)->red_curve;
1642                 if (!rc->is_empty()) {
1643                     Geom::Point const zoom_to (*rc->last_point());
1644                     dt->zoom_relative_keep_point(zoom_to, 1 / (mul*zoom_inc));
1645                     break;
1646                 }
1647             }
1648
1649             Geom::Rect const d = dt->get_display_area();
1650             dt->zoom_relative( d.midpoint()[Geom::X], d.midpoint()[Geom::Y], 1 / (mul*zoom_inc) );
1651             break;
1652         }
1653         case SP_VERB_ZOOM_1_1:
1654         {
1655             double zcorr = prefs->getDouble("/options/zoomcorrection/value", 1.0);
1656             Geom::Rect const d = dt->get_display_area();
1657             dt->zoom_absolute( d.midpoint()[Geom::X], d.midpoint()[Geom::Y], 1.0 * zcorr );
1658             break;
1659         }
1660         case SP_VERB_ZOOM_1_2:
1661         {
1662             double zcorr = prefs->getDouble("/options/zoomcorrection/value", 1.0);
1663             Geom::Rect const d = dt->get_display_area();
1664             dt->zoom_absolute( d.midpoint()[Geom::X], d.midpoint()[Geom::Y], 0.5 * zcorr );
1665             break;
1666         }
1667         case SP_VERB_ZOOM_2_1:
1668         {
1669             double zcorr = prefs->getDouble("/options/zoomcorrection/value", 1.0);
1670             Geom::Rect const d = dt->get_display_area();
1671             dt->zoom_absolute( d.midpoint()[Geom::X], d.midpoint()[Geom::Y], 2.0 * zcorr );
1672             break;
1673         }
1674         case SP_VERB_ZOOM_PAGE:
1675             dt->zoom_page();
1676             break;
1677         case SP_VERB_ZOOM_PAGE_WIDTH:
1678             dt->zoom_page_width();
1679             break;
1680         case SP_VERB_ZOOM_DRAWING:
1681             dt->zoom_drawing();
1682             break;
1683         case SP_VERB_ZOOM_SELECTION:
1684             dt->zoom_selection();
1685             break;
1686         case SP_VERB_ZOOM_NEXT:
1687             dt->next_zoom();
1688             break;
1689         case SP_VERB_ZOOM_PREV:
1690             dt->prev_zoom();
1691             break;
1692         case SP_VERB_TOGGLE_RULERS:
1693             dt->toggleRulers();
1694             break;
1695         case SP_VERB_TOGGLE_SCROLLBARS:
1696             dt->toggleScrollbars();
1697             break;
1698         case SP_VERB_TOGGLE_GUIDES:
1699             sp_namedview_toggle_guides(doc, repr);
1700             break;
1701         case SP_VERB_TOGGLE_SNAPPING:
1702             dt->toggleSnapGlobal();
1703             break;
1704         case SP_VERB_TOGGLE_GRID:
1705             dt->toggleGrids();
1706             break;
1707 #ifdef HAVE_GTK_WINDOW_FULLSCREEN
1708         case SP_VERB_FULLSCREEN:
1709             dt->fullscreen();
1710             break;
1711 #endif /* HAVE_GTK_WINDOW_FULLSCREEN */
1712         case SP_VERB_FOCUSTOGGLE:
1713             dt->focusMode(!dt->is_focusMode());
1714             break;
1715         case SP_VERB_VIEW_NEW:
1716             sp_ui_new_view();
1717             break;
1718         case SP_VERB_VIEW_NEW_PREVIEW:
1719             sp_ui_new_view_preview();
1720             break;
1721         case SP_VERB_VIEW_MODE_NORMAL:
1722             dt->setDisplayModeNormal();
1723             break;
1724         case SP_VERB_VIEW_MODE_NO_FILTERS:
1725             dt->setDisplayModeNoFilters();
1726             break;
1727         case SP_VERB_VIEW_MODE_OUTLINE:
1728             dt->setDisplayModeOutline();
1729             break;
1730         case SP_VERB_VIEW_MODE_TOGGLE:
1731             dt->displayModeToggle();
1732             break;
1733         case SP_VERB_VIEW_CMS_TOGGLE:
1734             dt->toggleColorProfAdjust();
1735             break;
1736         case SP_VERB_VIEW_ICON_PREVIEW:
1737             inkscape_dialogs_unhide();
1738             dt->_dlg_mgr->showDialog("IconPreviewPanel");
1739             break;
1740         default:
1741             break;
1742     }
1743
1744     dt->updateNow();
1745
1746 } // end of sp_verb_action_zoom_perform()
1747
1748 /** \brief  Decode the verb code and take appropriate action */
1749 void
1750 DialogVerb::perform(SPAction *action, void *data, void */*pdata*/)
1751 {
1752     if (reinterpret_cast<std::size_t>(data) != SP_VERB_DIALOG_TOGGLE) {
1753         // unhide all when opening a new dialog
1754         inkscape_dialogs_unhide();
1755     }
1756
1757     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1758     g_assert(dt->_dlg_mgr != NULL);
1759
1760     switch (reinterpret_cast<std::size_t>(data)) {
1761         case SP_VERB_DIALOG_DISPLAY:
1762             //sp_display_dialog();
1763             dt->_dlg_mgr->showDialog("InkscapePreferences");
1764             break;
1765         case SP_VERB_DIALOG_METADATA:
1766             // sp_desktop_dialog();
1767             dt->_dlg_mgr->showDialog("DocumentMetadata");
1768             break;
1769         case SP_VERB_DIALOG_NAMEDVIEW:
1770             // sp_desktop_dialog();
1771             dt->_dlg_mgr->showDialog("DocumentProperties");
1772             break;
1773         case SP_VERB_DIALOG_FILL_STROKE:
1774             dt->_dlg_mgr->showDialog("FillAndStroke");
1775             break;
1776         case SP_VERB_DIALOG_SWATCHES:
1777             dt->_dlg_mgr->showDialog("Swatches");
1778             break;
1779         case SP_VERB_DIALOG_TRANSFORM:
1780             dt->_dlg_mgr->showDialog("Transformation");
1781             break;
1782         case SP_VERB_DIALOG_ALIGN_DISTRIBUTE:
1783             dt->_dlg_mgr->showDialog("AlignAndDistribute");
1784             break;
1785         case SP_VERB_DIALOG_TEXT:
1786             sp_text_edit_dialog();
1787             break;
1788         case SP_VERB_DIALOG_XML_EDITOR:
1789             sp_xml_tree_dialog();
1790             break;
1791         case SP_VERB_DIALOG_FIND:
1792             sp_find_dialog();
1793 //              Please test the new find dialog if you have time:
1794 //            dt->_dlg_mgr->showDialog("Find");
1795             break;
1796         case SP_VERB_DIALOG_FINDREPLACE:
1797             // not implemented yet
1798             break;
1799         case SP_VERB_DIALOG_SPELLCHECK:
1800             sp_spellcheck_dialog();
1801             break;
1802         case SP_VERB_DIALOG_DEBUG:
1803             dt->_dlg_mgr->showDialog("Messages");
1804             break;
1805         case SP_VERB_DIALOG_SCRIPT:
1806             //dt->_dlg_mgr->showDialog("Script");
1807             Inkscape::Bind::JavaBindery::getInstance()->showConsole();
1808             break;
1809         case SP_VERB_DIALOG_UNDO_HISTORY:
1810             dt->_dlg_mgr->showDialog("UndoHistory");
1811             break;
1812         case SP_VERB_DIALOG_TOGGLE:
1813             inkscape_dialogs_toggle();
1814             break;
1815         case SP_VERB_DIALOG_CLONETILER:
1816             clonetiler_dialog();
1817             break;
1818         case SP_VERB_DIALOG_ITEM:
1819             sp_item_dialog();
1820             break;
1821 /*#ifdef WITH_INKBOARD
1822         case SP_VERB_XMPP_CLIENT:
1823         {
1824             Inkscape::Whiteboard::SessionManager::showClient();
1825             break;
1826         }
1827 #endif*/
1828         case SP_VERB_DIALOG_INPUT:
1829             sp_input_dialog();
1830             break;
1831         case SP_VERB_DIALOG_INPUT2:
1832             dt->_dlg_mgr->showDialog("InputDevices");
1833             break;
1834         case SP_VERB_DIALOG_EXTENSIONEDITOR:
1835             dt->_dlg_mgr->showDialog("ExtensionEditor");
1836             break;
1837         case SP_VERB_DIALOG_LAYERS:
1838             dt->_dlg_mgr->showDialog("LayersPanel");
1839             break;
1840         case SP_VERB_DIALOG_LIVE_PATH_EFFECT:
1841             dt->_dlg_mgr->showDialog("LivePathEffect");
1842             break;
1843         case SP_VERB_DIALOG_FILTER_EFFECTS:
1844             dt->_dlg_mgr->showDialog("FilterEffectsDialog");
1845             break;
1846         case SP_VERB_DIALOG_SVG_FONTS:
1847             dt->_dlg_mgr->showDialog("SvgFontsDialog");
1848             break;
1849         default:
1850             break;
1851     }
1852 } // end of sp_verb_action_dialog_perform()
1853
1854 /** \brief  Decode the verb code and take appropriate action */
1855 void
1856 HelpVerb::perform(SPAction *action, void *data, void */*pdata*/)
1857 {
1858     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1859     g_assert(dt->_dlg_mgr != NULL);
1860
1861     switch (reinterpret_cast<std::size_t>(data)) {
1862         case SP_VERB_HELP_ABOUT:
1863             sp_help_about();
1864             break;
1865         case SP_VERB_HELP_ABOUT_EXTENSIONS: {
1866             // Inkscape::UI::Dialogs::ExtensionsPanel *panel = new Inkscape::UI::Dialogs::ExtensionsPanel();
1867             // panel->set_full(true);
1868             // show_panel( *panel, "dialogs.aboutextensions", SP_VERB_HELP_ABOUT_EXTENSIONS );
1869             break;
1870         }
1871
1872         /*
1873         case SP_VERB_SHOW_LICENSE:
1874             // TRANSLATORS: See "tutorial-basic.svg" comment.
1875             sp_help_open_tutorial(NULL, (gpointer) _("gpl-2.svg"));
1876             break;
1877         */
1878
1879         case SP_VERB_HELP_MEMORY:
1880             inkscape_dialogs_unhide();
1881             dt->_dlg_mgr->showDialog("Memory");
1882             break;
1883         default:
1884             break;
1885     }
1886 } // end of sp_verb_action_help_perform()
1887
1888 /** \brief  Decode the verb code and take appropriate action */
1889 void
1890 TutorialVerb::perform(SPAction */*action*/, void *data, void */*pdata*/)
1891 {
1892     switch (reinterpret_cast<std::size_t>(data)) {
1893         case SP_VERB_TUTORIAL_BASIC:
1894             /* TRANSLATORS: If you have translated the tutorial-basic.svg file to your language,
1895                then translate this string as "tutorial-basic.LANG.svg" (where LANG is your language
1896                code); otherwise leave as "tutorial-basic.svg". */
1897             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-basic.svg"));
1898             break;
1899         case SP_VERB_TUTORIAL_SHAPES:
1900             // TRANSLATORS: See "tutorial-basic.svg" comment.
1901             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-shapes.svg"));
1902             break;
1903         case SP_VERB_TUTORIAL_ADVANCED:
1904             // TRANSLATORS: See "tutorial-basic.svg" comment.
1905             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-advanced.svg"));
1906             break;
1907         case SP_VERB_TUTORIAL_TRACING:
1908             // TRANSLATORS: See "tutorial-basic.svg" comment.
1909             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-tracing.svg"));
1910             break;
1911         case SP_VERB_TUTORIAL_CALLIGRAPHY:
1912             // TRANSLATORS: See "tutorial-basic.svg" comment.
1913             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-calligraphy.svg"));
1914             break;
1915         case SP_VERB_TUTORIAL_DESIGN:
1916             // TRANSLATORS: See "tutorial-basic.svg" comment.
1917             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-elements.svg"));
1918             break;
1919         case SP_VERB_TUTORIAL_TIPS:
1920             // TRANSLATORS: See "tutorial-basic.svg" comment.
1921             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-tips.svg"));
1922             break;
1923         default:
1924             break;
1925     }
1926 } // end of sp_verb_action_tutorial_perform()
1927
1928
1929 /**
1930  * Action vector to define functions called if a staticly defined file verb
1931  * is called.
1932  */
1933 SPActionEventVector FileVerb::vector =
1934             {{NULL},FileVerb::perform, NULL, NULL, NULL, NULL};
1935 /**
1936  * Action vector to define functions called if a staticly defined edit verb is
1937  * called.
1938  */
1939 SPActionEventVector EditVerb::vector =
1940             {{NULL},EditVerb::perform, NULL, NULL, NULL, NULL};
1941
1942 /**
1943  * Action vector to define functions called if a staticly defined selection
1944  * verb is called
1945  */
1946 SPActionEventVector SelectionVerb::vector =
1947             {{NULL},SelectionVerb::perform, NULL, NULL, NULL, NULL};
1948
1949 /**
1950  * Action vector to define functions called if a staticly defined layer
1951  * verb is called
1952  */
1953 SPActionEventVector LayerVerb::vector =
1954             {{NULL}, LayerVerb::perform, NULL, NULL, NULL, NULL};
1955
1956 /**
1957  * Action vector to define functions called if a staticly defined object
1958  * editing verb is called
1959  */
1960 SPActionEventVector ObjectVerb::vector =
1961             {{NULL},ObjectVerb::perform, NULL, NULL, NULL, NULL};
1962
1963 /**
1964  * Action vector to define functions called if a staticly defined context
1965  * verb is called
1966  */
1967 SPActionEventVector ContextVerb::vector =
1968             {{NULL},ContextVerb::perform, NULL, NULL, NULL, NULL};
1969
1970 /**
1971  * Action vector to define functions called if a staticly defined zoom verb
1972  * is called
1973  */
1974 SPActionEventVector ZoomVerb::vector =
1975             {{NULL},ZoomVerb::perform, NULL, NULL, NULL, NULL};
1976
1977
1978 /**
1979  * Action vector to define functions called if a staticly defined dialog verb
1980  * is called
1981  */
1982 SPActionEventVector DialogVerb::vector =
1983             {{NULL},DialogVerb::perform, NULL, NULL, NULL, NULL};
1984
1985 /**
1986  * Action vector to define functions called if a staticly defined help verb
1987  * is called
1988  */
1989 SPActionEventVector HelpVerb::vector =
1990             {{NULL},HelpVerb::perform, NULL, NULL, NULL, NULL};
1991
1992 /**
1993  * Action vector to define functions called if a staticly defined tutorial verb
1994  * is called
1995  */
1996 SPActionEventVector TutorialVerb::vector =
1997             {{NULL},TutorialVerb::perform, NULL, NULL, NULL, NULL};
1998
1999 /**
2000  * Action vector to define functions called if a staticly defined tutorial verb
2001  * is called
2002  */
2003 SPActionEventVector TextVerb::vector =
2004             {{NULL},TextVerb::perform, NULL, NULL, NULL, NULL};
2005
2006
2007 /* *********** Effect Last ********** */
2008
2009 /** \brief A class to represent the last effect issued */
2010 class EffectLastVerb : public Verb {
2011 private:
2012     static void perform(SPAction *action, void *mydata, void *otherdata);
2013     static SPActionEventVector vector;
2014 protected:
2015     virtual SPAction *make_action(Inkscape::UI::View::View *view);
2016 public:
2017     /** \brief Use the Verb initializer with the same parameters. */
2018     EffectLastVerb(unsigned int const code,
2019                    gchar const *id,
2020                    gchar const *name,
2021                    gchar const *tip,
2022                    gchar const *image) :
2023         Verb(code, id, name, tip, image)
2024     {
2025         set_default_sensitive(false);
2026     }
2027 }; /* EffectLastVerb class */
2028
2029 /**
2030  * The vector to attach in the last effect verb.
2031  */
2032 SPActionEventVector EffectLastVerb::vector =
2033             {{NULL},EffectLastVerb::perform, NULL, NULL, NULL, NULL};
2034
2035 /** \brief  Create an action for a \c EffectLastVerb
2036     \param  view  Which view the action should be created for
2037     \return The built action.
2038
2039     Calls \c make_action_helper with the \c vector.
2040 */
2041 SPAction *
2042 EffectLastVerb::make_action(Inkscape::UI::View::View *view)
2043 {
2044     return make_action_helper(view, &vector);
2045 }
2046
2047 /** \brief  Decode the verb code and take appropriate action */
2048 void
2049 EffectLastVerb::perform(SPAction *action, void *data, void */*pdata*/)
2050 {
2051     /* These aren't used, but are here to remind people not to use
2052        the CURRENT_DOCUMENT macros unless they really have to. */
2053     Inkscape::UI::View::View *current_view = sp_action_get_view(action);
2054     // SPDocument *current_document = SP_VIEW_DOCUMENT(current_view);
2055     Inkscape::Extension::Effect *effect = Inkscape::Extension::Effect::get_last_effect();
2056
2057     if (effect == NULL) return;
2058     if (current_view == NULL) return;
2059
2060     switch ((long) data) {
2061         case SP_VERB_EFFECT_LAST_PREF:
2062             effect->prefs(current_view);
2063             break;
2064         case SP_VERB_EFFECT_LAST:
2065             effect->effect(current_view);
2066             break;
2067         default:
2068             return;
2069     }
2070
2071     return;
2072 }
2073 /* *********** End Effect Last ********** */
2074
2075 /* *********** Fit Canvas ********** */
2076
2077 /** \brief A class to represent the canvas fitting verbs */
2078 class FitCanvasVerb : public Verb {
2079 private:
2080     static void perform(SPAction *action, void *mydata, void *otherdata);
2081     static SPActionEventVector vector;
2082 protected:
2083     virtual SPAction *make_action(Inkscape::UI::View::View *view);
2084 public:
2085     /** \brief Use the Verb initializer with the same parameters. */
2086     FitCanvasVerb(unsigned int const code,
2087                    gchar const *id,
2088                    gchar const *name,
2089                    gchar const *tip,
2090                    gchar const *image) :
2091         Verb(code, id, name, tip, image)
2092     {
2093         set_default_sensitive(false);
2094     }
2095 }; /* FitCanvasVerb class */
2096
2097 /**
2098  * The vector to attach in the fit canvas verb.
2099  */
2100 SPActionEventVector FitCanvasVerb::vector =
2101             {{NULL},FitCanvasVerb::perform, NULL, NULL, NULL, NULL};
2102
2103 /** \brief  Create an action for a \c FitCanvasVerb
2104     \param  view  Which view the action should be created for
2105     \return The built action.
2106
2107     Calls \c make_action_helper with the \c vector.
2108 */
2109 SPAction *
2110 FitCanvasVerb::make_action(Inkscape::UI::View::View *view)
2111 {
2112     SPAction *action = make_action_helper(view, &vector);
2113     return action;
2114 }
2115
2116 /** \brief  Decode the verb code and take appropriate action */
2117 void
2118 FitCanvasVerb::perform(SPAction *action, void *data, void */*pdata*/)
2119 {
2120     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
2121     if (!dt) return;
2122     SPDocument *doc = sp_desktop_document(dt);
2123     if (!doc) return;
2124
2125     switch ((long) data) {
2126         case SP_VERB_FIT_CANVAS_TO_SELECTION:
2127             verb_fit_canvas_to_selection(dt);
2128             break;
2129         case SP_VERB_FIT_CANVAS_TO_DRAWING:
2130             verb_fit_canvas_to_drawing(dt);
2131             break;
2132         case SP_VERB_FIT_CANVAS_TO_SELECTION_OR_DRAWING:
2133             fit_canvas_to_selection_or_drawing(dt);
2134             break;
2135         default:
2136             return;
2137     }
2138
2139     return;
2140 }
2141 /* *********** End Fit Canvas ********** */
2142
2143
2144 /* *********** Lock'N'Hide ********** */
2145
2146 /** \brief A class to represent the object unlocking and unhiding verbs */
2147 class LockAndHideVerb : public Verb {
2148 private:
2149     static void perform(SPAction *action, void *mydata, void *otherdata);
2150     static SPActionEventVector vector;
2151 protected:
2152     virtual SPAction *make_action(Inkscape::UI::View::View *view);
2153 public:
2154     /** \brief Use the Verb initializer with the same parameters. */
2155     LockAndHideVerb(unsigned int const code,
2156                    gchar const *id,
2157                    gchar const *name,
2158                    gchar const *tip,
2159                    gchar const *image) :
2160         Verb(code, id, name, tip, image)
2161     {
2162         set_default_sensitive(true);
2163     }
2164 }; /* LockAndHideVerb class */
2165
2166 /**
2167  * The vector to attach in the lock'n'hide verb.
2168  */
2169 SPActionEventVector LockAndHideVerb::vector =
2170             {{NULL},LockAndHideVerb::perform, NULL, NULL, NULL, NULL};
2171
2172 /** \brief  Create an action for a \c LockAndHideVerb
2173     \param  view  Which view the action should be created for
2174     \return The built action.
2175
2176     Calls \c make_action_helper with the \c vector.
2177 */
2178 SPAction *
2179 LockAndHideVerb::make_action(Inkscape::UI::View::View *view)
2180 {
2181     SPAction *action = make_action_helper(view, &vector);
2182     return action;
2183 }
2184
2185 /** \brief  Decode the verb code and take appropriate action */
2186 void
2187 LockAndHideVerb::perform(SPAction *action, void *data, void */*pdata*/)
2188 {
2189     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
2190     if (!dt) return;
2191     SPDocument *doc = sp_desktop_document(dt);
2192     if (!doc) return;
2193
2194     switch ((long) data) {
2195         case SP_VERB_UNLOCK_ALL:
2196             unlock_all(dt);
2197             sp_document_done(doc, SP_VERB_UNLOCK_ALL, _("Unlock all objects in the current layer"));
2198             break;
2199         case SP_VERB_UNLOCK_ALL_IN_ALL_LAYERS:
2200             unlock_all_in_all_layers(dt);
2201             sp_document_done(doc, SP_VERB_UNLOCK_ALL_IN_ALL_LAYERS, _("Unlock all objects in all layers"));
2202             break;
2203         case SP_VERB_UNHIDE_ALL:
2204             unhide_all(dt);
2205             sp_document_done(doc, SP_VERB_UNHIDE_ALL, _("Unhide all objects in the current layer"));
2206             break;
2207         case SP_VERB_UNHIDE_ALL_IN_ALL_LAYERS:
2208             unhide_all_in_all_layers(dt);
2209             sp_document_done(doc, SP_VERB_UNHIDE_ALL_IN_ALL_LAYERS, _("Unhide all objects in all layers"));
2210             break;
2211         default:
2212             return;
2213     }
2214
2215     return;
2216 }
2217 /* *********** End Lock'N'Hide ********** */
2218
2219
2220 /* these must be in the same order as the SP_VERB_* enum in "verbs.h" */
2221 Verb *Verb::_base_verbs[] = {
2222     /* Header */
2223     new Verb(SP_VERB_INVALID, NULL, NULL, NULL, NULL),
2224     new Verb(SP_VERB_NONE, "None", N_("None"), N_("Does nothing"), NULL),
2225
2226     /* File */
2227     new FileVerb(SP_VERB_FILE_NEW, "FileNew", N_("Default"), N_("Create new document from the default template"),
2228                  GTK_STOCK_NEW ),
2229     new FileVerb(SP_VERB_FILE_OPEN, "FileOpen", N_("_Open..."),
2230                  N_("Open an existing document"), GTK_STOCK_OPEN ),
2231     new FileVerb(SP_VERB_FILE_REVERT, "FileRevert", N_("Re_vert"),
2232                  N_("Revert to the last saved version of document (changes will be lost)"), GTK_STOCK_REVERT_TO_SAVED ),
2233     new FileVerb(SP_VERB_FILE_SAVE, "FileSave", N_("_Save"), N_("Save document"),
2234                  GTK_STOCK_SAVE ),
2235     new FileVerb(SP_VERB_FILE_SAVE_AS, "FileSaveAs", N_("Save _As..."),
2236                  N_("Save document under a new name"), GTK_STOCK_SAVE_AS ),
2237     new FileVerb(SP_VERB_FILE_SAVE_A_COPY, "FileSaveACopy", N_("Save a Cop_y..."),
2238                  N_("Save a copy of the document under a new name"), NULL ),
2239     new FileVerb(SP_VERB_FILE_PRINT, "FilePrint", N_("_Print..."), N_("Print document"),
2240                  GTK_STOCK_PRINT ),
2241     // TRANSLATORS: "Vacuum Defs" means "Clean up defs" (so as to remove unused definitions)
2242     new FileVerb(SP_VERB_FILE_VACUUM, "FileVacuum", N_("Vac_uum Defs"), N_("Remove unused definitions (such as gradients or clipping paths) from the &lt;defs&gt; of the document"),
2243                  INKSCAPE_ICON_DOCUMENT_CLEANUP ),
2244     new FileVerb(SP_VERB_FILE_PRINT_PREVIEW, "FilePrintPreview", N_("Print Previe_w"),
2245                  N_("Preview document printout"), GTK_STOCK_PRINT_PREVIEW ),
2246     new FileVerb(SP_VERB_FILE_IMPORT, "FileImport", N_("_Import..."),
2247                  N_("Import a bitmap or SVG image into this document"), INKSCAPE_ICON_DOCUMENT_IMPORT),
2248     new FileVerb(SP_VERB_FILE_EXPORT, "FileExport", N_("_Export Bitmap..."),
2249                  N_("Export this document or a selection as a bitmap image"), INKSCAPE_ICON_DOCUMENT_EXPORT),
2250     new FileVerb(SP_VERB_FILE_IMPORT_FROM_OCAL, "FileImportFromOCAL", N_("Import From Open Clip Art Library"), N_("Import a document from Open Clip Art Library"), INKSCAPE_ICON_DOCUMENT_IMPORT_OCAL),
2251 //    new FileVerb(SP_VERB_FILE_EXPORT_TO_OCAL, "FileExportToOCAL", N_("Export To Open Clip Art Library"), N_("Export this document to Open Clip Art Library"), INKSCAPE_ICON_DOCUMENT_EXPORT_OCAL),
2252     new FileVerb(SP_VERB_FILE_NEXT_DESKTOP, "NextWindow", N_("N_ext Window"),
2253                  N_("Switch to the next document window"), INKSCAPE_ICON_WINDOW_NEXT),
2254     new FileVerb(SP_VERB_FILE_PREV_DESKTOP, "PrevWindow", N_("P_revious Window"),
2255                  N_("Switch to the previous document window"), INKSCAPE_ICON_WINDOW_PREVIOUS),
2256     new FileVerb(SP_VERB_FILE_CLOSE_VIEW, "FileClose", N_("_Close"),
2257                  N_("Close this document window"), GTK_STOCK_CLOSE),
2258     new FileVerb(SP_VERB_FILE_QUIT, "FileQuit", N_("_Quit"), N_("Quit Inkscape"), GTK_STOCK_QUIT),
2259
2260     /* Edit */
2261     new EditVerb(SP_VERB_EDIT_UNDO, "EditUndo", N_("_Undo"), N_("Undo last action"),
2262                  GTK_STOCK_UNDO),
2263     new EditVerb(SP_VERB_EDIT_REDO, "EditRedo", N_("_Redo"),
2264                  N_("Do again the last undone action"), GTK_STOCK_REDO),
2265     new EditVerb(SP_VERB_EDIT_CUT, "EditCut", N_("Cu_t"),
2266                  N_("Cut selection to clipboard"), GTK_STOCK_CUT),
2267     new EditVerb(SP_VERB_EDIT_COPY, "EditCopy", N_("_Copy"),
2268                  N_("Copy selection to clipboard"), GTK_STOCK_COPY),
2269     new EditVerb(SP_VERB_EDIT_PASTE, "EditPaste", N_("_Paste"),
2270                  N_("Paste objects from clipboard to mouse point, or paste text"), GTK_STOCK_PASTE),
2271     new EditVerb(SP_VERB_EDIT_PASTE_STYLE, "EditPasteStyle", N_("Paste _Style"),
2272                  N_("Apply the style of the copied object to selection"), INKSCAPE_ICON_EDIT_PASTE_STYLE),
2273     new EditVerb(SP_VERB_EDIT_PASTE_SIZE, "EditPasteSize", N_("Paste Si_ze"),
2274                  N_("Scale selection to match the size of the copied object"), NULL),
2275     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_X, "EditPasteWidth", N_("Paste _Width"),
2276                  N_("Scale selection horizontally to match the width of the copied object"), NULL),
2277     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_Y, "EditPasteHeight", N_("Paste _Height"),
2278                  N_("Scale selection vertically to match the height of the copied object"), NULL),
2279     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY, "EditPasteSizeSeparately", N_("Paste Size Separately"),
2280                  N_("Scale each selected object to match the size of the copied object"), NULL),
2281     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_X, "EditPasteWidthSeparately", N_("Paste Width Separately"),
2282                  N_("Scale each selected object horizontally to match the width of the copied object"), NULL),
2283     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_Y, "EditPasteHeightSeparately", N_("Paste Height Separately"),
2284                  N_("Scale each selected object vertically to match the height of the copied object"), NULL),
2285     new EditVerb(SP_VERB_EDIT_PASTE_IN_PLACE, "EditPasteInPlace", N_("Paste _In Place"),
2286                  N_("Paste objects from clipboard to the original location"), INKSCAPE_ICON_EDIT_PASTE_IN_PLACE),
2287     new EditVerb(SP_VERB_EDIT_PASTE_LIVEPATHEFFECT, "PasteLivePathEffect", N_("Paste Path _Effect"),
2288                  N_("Apply the path effect of the copied object to selection"), NULL),
2289     new EditVerb(SP_VERB_EDIT_REMOVE_LIVEPATHEFFECT, "RemoveLivePathEffect", N_("Remove Path _Effect"),
2290                  N_("Remove any path effects from selected objects"), NULL),
2291     new EditVerb(SP_VERB_EDIT_REMOVE_FILTER, "RemoveFilter", N_("Remove Filters"),
2292                  N_("Remove any filters from selected objects"), NULL),
2293     new EditVerb(SP_VERB_EDIT_DELETE, "EditDelete", N_("_Delete"),
2294                  N_("Delete selection"), GTK_STOCK_DELETE),
2295     new EditVerb(SP_VERB_EDIT_DUPLICATE, "EditDuplicate", N_("Duplic_ate"),
2296                  N_("Duplicate selected objects"), INKSCAPE_ICON_EDIT_DUPLICATE),
2297     new EditVerb(SP_VERB_EDIT_CLONE, "EditClone", N_("Create Clo_ne"),
2298                  N_("Create a clone (a copy linked to the original) of selected object"), INKSCAPE_ICON_EDIT_CLONE),
2299     new EditVerb(SP_VERB_EDIT_UNLINK_CLONE, "EditUnlinkClone", N_("Unlin_k Clone"),
2300                  N_("Cut the selected clones' links to the originals, turning them into standalone objects"), INKSCAPE_ICON_EDIT_CLONE_UNLINK),
2301     new EditVerb(SP_VERB_EDIT_RELINK_CLONE, "EditRelinkClone", N_("Relink to Copied"),
2302                  N_("Relink the selected clones to the object currently on the clipboard"), NULL),
2303     new EditVerb(SP_VERB_EDIT_CLONE_SELECT_ORIGINAL, "EditCloneSelectOriginal", N_("Select _Original"),
2304                  N_("Select the object to which the selected clone is linked"), INKSCAPE_ICON_EDIT_SELECT_ORIGINAL),
2305     new EditVerb(SP_VERB_EDIT_SELECTION_2_MARKER, "ObjectsToMarker", N_("Objects to _Marker"),
2306                  N_("Convert selection to a line marker"), NULL),
2307     new EditVerb(SP_VERB_EDIT_SELECTION_2_GUIDES, "ObjectsToGuides", N_("Objects to Gu_ides"),
2308                  N_("Convert selected objects to a collection of guidelines aligned with their edges"), NULL),
2309     new EditVerb(SP_VERB_EDIT_TILE, "ObjectsToPattern", N_("Objects to Patter_n"),
2310                  N_("Convert selection to a rectangle with tiled pattern fill"), NULL),
2311     new EditVerb(SP_VERB_EDIT_UNTILE, "ObjectsFromPattern", N_("Pattern to _Objects"),
2312                  N_("Extract objects from a tiled pattern fill"), NULL),
2313     new EditVerb(SP_VERB_EDIT_CLEAR_ALL, "EditClearAll", N_("Clea_r All"),
2314                  N_("Delete all objects from document"), NULL),
2315     new EditVerb(SP_VERB_EDIT_SELECT_ALL, "EditSelectAll", N_("Select Al_l"),
2316                  N_("Select all objects or all nodes"), GTK_STOCK_SELECT_ALL),
2317     new EditVerb(SP_VERB_EDIT_SELECT_ALL_IN_ALL_LAYERS, "EditSelectAllInAllLayers", N_("Select All in All La_yers"),
2318                  N_("Select all objects in all visible and unlocked layers"), INKSCAPE_ICON_EDIT_SELECT_ALL_LAYERS),
2319     new EditVerb(SP_VERB_EDIT_INVERT, "EditInvert", N_("In_vert Selection"),
2320                  N_("Invert selection (unselect what is selected and select everything else)"), INKSCAPE_ICON_EDIT_SELECT_INVERT),
2321     new EditVerb(SP_VERB_EDIT_INVERT_IN_ALL_LAYERS, "EditInvertInAllLayers", N_("Invert in All Layers"),
2322                  N_("Invert selection in all visible and unlocked layers"), NULL),
2323     new EditVerb(SP_VERB_EDIT_SELECT_NEXT, "EditSelectNext", N_("Select Next"),
2324                  N_("Select next object or node"), NULL),
2325     new EditVerb(SP_VERB_EDIT_SELECT_PREV, "EditSelectPrev", N_("Select Previous"),
2326                  N_("Select previous object or node"), NULL),
2327     new EditVerb(SP_VERB_EDIT_DESELECT, "EditDeselect", N_("D_eselect"),
2328                  N_("Deselect any selected objects or nodes"), INKSCAPE_ICON_EDIT_SELECT_NONE),
2329     new EditVerb(SP_VERB_EDIT_GUIDES_AROUND_PAGE, "EditGuidesAroundPage", N_("_Guides Around Page"),
2330                  N_("Create four guides aligned with the page borders"), NULL),
2331     new EditVerb(SP_VERB_EDIT_NEXT_PATHEFFECT_PARAMETER, "EditNextPathEffectParameter", N_("Next Path Effect Parameter"),
2332                  N_("Show next Path Effect parameter for editing"), INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT),
2333
2334     /* Selection */
2335     new SelectionVerb(SP_VERB_SELECTION_TO_FRONT, "SelectionToFront", N_("Raise to _Top"),
2336                       N_("Raise selection to top"), INKSCAPE_ICON_SELECTION_TOP),
2337     new SelectionVerb(SP_VERB_SELECTION_TO_BACK, "SelectionToBack", N_("Lower to _Bottom"),
2338                       N_("Lower selection to bottom"), INKSCAPE_ICON_SELECTION_BOTTOM),
2339     new SelectionVerb(SP_VERB_SELECTION_RAISE, "SelectionRaise", N_("_Raise"),
2340                       N_("Raise selection one step"), INKSCAPE_ICON_SELECTION_RAISE),
2341     new SelectionVerb(SP_VERB_SELECTION_LOWER, "SelectionLower", N_("_Lower"),
2342                       N_("Lower selection one step"), INKSCAPE_ICON_SELECTION_LOWER),
2343     new SelectionVerb(SP_VERB_SELECTION_GROUP, "SelectionGroup", N_("_Group"),
2344                       N_("Group selected objects"), INKSCAPE_ICON_OBJECT_GROUP),
2345     new SelectionVerb(SP_VERB_SELECTION_UNGROUP, "SelectionUnGroup", N_("_Ungroup"),
2346                       N_("Ungroup selected groups"), INKSCAPE_ICON_OBJECT_UNGROUP),
2347
2348     new SelectionVerb(SP_VERB_SELECTION_TEXTTOPATH, "SelectionTextToPath", N_("_Put on Path"),
2349                       N_("Put text on path"), INKSCAPE_ICON_TEXT_PUT_ON_PATH),
2350     new SelectionVerb(SP_VERB_SELECTION_TEXTFROMPATH, "SelectionTextFromPath", N_("_Remove from Path"),
2351                       N_("Remove text from path"), INKSCAPE_ICON_TEXT_REMOVE_FROM_PATH),
2352     new SelectionVerb(SP_VERB_SELECTION_REMOVE_KERNS, "SelectionTextRemoveKerns", N_("Remove Manual _Kerns"),
2353                       // TRANSLATORS: "glyph": An image used in the visual representation of characters;
2354                       //  roughly speaking, how a character looks. A font is a set of glyphs.
2355                       N_("Remove all manual kerns and glyph rotations from a text object"), INKSCAPE_ICON_TEXT_UNKERN),
2356
2357     new SelectionVerb(SP_VERB_SELECTION_UNION, "SelectionUnion", N_("_Union"),
2358                       N_("Create union of selected paths"), INKSCAPE_ICON_PATH_UNION),
2359     new SelectionVerb(SP_VERB_SELECTION_INTERSECT, "SelectionIntersect", N_("_Intersection"),
2360                       N_("Create intersection of selected paths"), INKSCAPE_ICON_PATH_INTERSECTION),
2361     new SelectionVerb(SP_VERB_SELECTION_DIFF, "SelectionDiff", N_("_Difference"),
2362                       N_("Create difference of selected paths (bottom minus top)"), INKSCAPE_ICON_PATH_DIFFERENCE),
2363     new SelectionVerb(SP_VERB_SELECTION_SYMDIFF, "SelectionSymDiff", N_("E_xclusion"),
2364                       N_("Create exclusive OR of selected paths (those parts that belong to only one path)"), INKSCAPE_ICON_PATH_EXCLUSION),
2365     new SelectionVerb(SP_VERB_SELECTION_CUT, "SelectionDivide", N_("Di_vision"),
2366                       N_("Cut the bottom path into pieces"), INKSCAPE_ICON_PATH_DIVISION),
2367     // TRANSLATORS: "to cut a path" is not the same as "to break a path apart" - see the
2368     // Advanced tutorial for more info
2369     new SelectionVerb(SP_VERB_SELECTION_SLICE, "SelectionCutPath", N_("Cut _Path"),
2370                       N_("Cut the bottom path's stroke into pieces, removing fill"), INKSCAPE_ICON_PATH_CUT),
2371     // TRANSLATORS: "outset": expand a shape by offsetting the object's path,
2372     // i.e. by displacing it perpendicular to the path in each point.
2373     // See also the Advanced Tutorial for explanation.
2374     new SelectionVerb(SP_VERB_SELECTION_OFFSET, "SelectionOffset", N_("Outs_et"),
2375                       N_("Outset selected paths"), INKSCAPE_ICON_PATH_OUTSET),
2376     new SelectionVerb(SP_VERB_SELECTION_OFFSET_SCREEN, "SelectionOffsetScreen",
2377                       N_("O_utset Path by 1 px"),
2378                       N_("Outset selected paths by 1 px"), NULL),
2379     new SelectionVerb(SP_VERB_SELECTION_OFFSET_SCREEN_10, "SelectionOffsetScreen10",
2380                       N_("O_utset Path by 10 px"),
2381                       N_("Outset selected paths by 10 px"), NULL),
2382     // TRANSLATORS: "inset": contract a shape by offsetting the object's path,
2383     // i.e. by displacing it perpendicular to the path in each point.
2384     // See also the Advanced Tutorial for explanation.
2385     new SelectionVerb(SP_VERB_SELECTION_INSET, "SelectionInset", N_("I_nset"),
2386                       N_("Inset selected paths"), INKSCAPE_ICON_PATH_INSET),
2387     new SelectionVerb(SP_VERB_SELECTION_INSET_SCREEN, "SelectionInsetScreen",
2388                       N_("I_nset Path by 1 px"),
2389                       N_("Inset selected paths by 1 px"), NULL),
2390     new SelectionVerb(SP_VERB_SELECTION_INSET_SCREEN_10, "SelectionInsetScreen10",
2391                       N_("I_nset Path by 10 px"),
2392                       N_("Inset selected paths by 10 px"), NULL),
2393     new SelectionVerb(SP_VERB_SELECTION_DYNAMIC_OFFSET, "SelectionDynOffset",
2394                       N_("D_ynamic Offset"), N_("Create a dynamic offset object"), INKSCAPE_ICON_PATH_OFFSET_DYNAMIC),
2395     new SelectionVerb(SP_VERB_SELECTION_LINKED_OFFSET, "SelectionLinkedOffset",
2396                       N_("_Linked Offset"),
2397                       N_("Create a dynamic offset object linked to the original path"),
2398                       INKSCAPE_ICON_PATH_OFFSET_LINKED),
2399     new SelectionVerb(SP_VERB_SELECTION_OUTLINE, "StrokeToPath", N_("_Stroke to Path"),
2400                       N_("Convert selected object's stroke to paths"), INKSCAPE_ICON_STROKE_TO_PATH),
2401     new SelectionVerb(SP_VERB_SELECTION_SIMPLIFY, "SelectionSimplify", N_("Si_mplify"),
2402                       N_("Simplify selected paths (remove extra nodes)"), INKSCAPE_ICON_PATH_SIMPLIFY),
2403     new SelectionVerb(SP_VERB_SELECTION_REVERSE, "SelectionReverse", N_("_Reverse"),
2404                       N_("Reverse the direction of selected paths (useful for flipping markers)"), INKSCAPE_ICON_PATH_REVERSE),
2405     // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize)
2406     new SelectionVerb(SP_VERB_SELECTION_TRACE, "SelectionTrace", N_("_Trace Bitmap..."),
2407                       N_("Create one or more paths from a bitmap by tracing it"), INKSCAPE_ICON_BITMAP_TRACE),
2408     new SelectionVerb(SP_VERB_SELECTION_CREATE_BITMAP, "SelectionCreateBitmap", N_("_Make a Bitmap Copy"),
2409                       N_("Export selection to a bitmap and insert it into document"), INKSCAPE_ICON_SELECTION_MAKE_BITMAP_COPY ),
2410     new SelectionVerb(SP_VERB_SELECTION_COMBINE, "SelectionCombine", N_("_Combine"),
2411                       N_("Combine several paths into one"), INKSCAPE_ICON_PATH_COMBINE),
2412     // TRANSLATORS: "to cut a path" is not the same as "to break a path apart" - see the
2413     // Advanced tutorial for more info
2414     new SelectionVerb(SP_VERB_SELECTION_BREAK_APART, "SelectionBreakApart", N_("Break _Apart"),
2415                       N_("Break selected paths into subpaths"), INKSCAPE_ICON_PATH_BREAK_APART),
2416     new SelectionVerb(SP_VERB_SELECTION_GRIDTILE, "DialogGridArrange", N_("Rows and Columns..."),
2417                       N_("Arrange selected objects in a table"), INKSCAPE_ICON_DIALOG_ROWS_AND_COLUMNS),
2418     /* Layer */
2419     new LayerVerb(SP_VERB_LAYER_NEW, "LayerNew", N_("_Add Layer..."),
2420                   N_("Create a new layer"), INKSCAPE_ICON_LAYER_NEW),
2421     new LayerVerb(SP_VERB_LAYER_RENAME, "LayerRename", N_("Re_name Layer..."),
2422                   N_("Rename the current layer"), INKSCAPE_ICON_LAYER_RENAME),
2423     new LayerVerb(SP_VERB_LAYER_NEXT, "LayerNext", N_("Switch to Layer Abov_e"),
2424                   N_("Switch to the layer above the current"), INKSCAPE_ICON_LAYER_PREVIOUS),
2425     new LayerVerb(SP_VERB_LAYER_PREV, "LayerPrev", N_("Switch to Layer Belo_w"),
2426                   N_("Switch to the layer below the current"), INKSCAPE_ICON_LAYER_NEXT),
2427     new LayerVerb(SP_VERB_LAYER_MOVE_TO_NEXT, "LayerMoveToNext", N_("Move Selection to Layer Abo_ve"),
2428                   N_("Move selection to the layer above the current"), INKSCAPE_ICON_SELECTION_MOVE_TO_LAYER_ABOVE),
2429     new LayerVerb(SP_VERB_LAYER_MOVE_TO_PREV, "LayerMoveToPrev", N_("Move Selection to Layer Bel_ow"),
2430                   N_("Move selection to the layer below the current"), INKSCAPE_ICON_SELECTION_MOVE_TO_LAYER_BELOW),
2431     new LayerVerb(SP_VERB_LAYER_TO_TOP, "LayerToTop", N_("Layer to _Top"),
2432                   N_("Raise the current layer to the top"), INKSCAPE_ICON_LAYER_TOP),
2433     new LayerVerb(SP_VERB_LAYER_TO_BOTTOM, "LayerToBottom", N_("Layer to _Bottom"),
2434                   N_("Lower the current layer to the bottom"), INKSCAPE_ICON_LAYER_BOTTOM),
2435     new LayerVerb(SP_VERB_LAYER_RAISE, "LayerRaise", N_("_Raise Layer"),
2436                   N_("Raise the current layer"), INKSCAPE_ICON_LAYER_RAISE),
2437     new LayerVerb(SP_VERB_LAYER_LOWER, "LayerLower", N_("_Lower Layer"),
2438                   N_("Lower the current layer"), INKSCAPE_ICON_LAYER_LOWER),
2439     new LayerVerb(SP_VERB_LAYER_DUPLICATE, "LayerDuplicate", N_("Duplicate Current Layer"),
2440                   N_("Duplicate an existing layer"), NULL),
2441     new LayerVerb(SP_VERB_LAYER_DELETE, "LayerDelete", N_("_Delete Current Layer"),
2442                   N_("Delete the current layer"), INKSCAPE_ICON_LAYER_DELETE),
2443     new LayerVerb(SP_VERB_LAYER_SOLO, "LayerSolo", N_("_Show/hide other layers"),
2444                   N_("Solo the current layer"), NULL),
2445
2446     /* Object */
2447     new ObjectVerb(SP_VERB_OBJECT_ROTATE_90_CW, "ObjectRotate90", N_("Rotate _90&#176; CW"),
2448                    // This is shared between tooltips and statusbar, so they
2449                    // must use UTF-8, not HTML entities for special characters.
2450                    N_("Rotate selection 90\xc2\xb0 clockwise"), INKSCAPE_ICON_OBJECT_ROTATE_RIGHT),
2451     new ObjectVerb(SP_VERB_OBJECT_ROTATE_90_CCW, "ObjectRotate90CCW", N_("Rotate 9_0&#176; CCW"),
2452                    // This is shared between tooltips and statusbar, so they
2453                    // must use UTF-8, not HTML entities for special characters.
2454                    N_("Rotate selection 90\xc2\xb0 counter-clockwise"), INKSCAPE_ICON_OBJECT_ROTATE_LEFT),
2455     new ObjectVerb(SP_VERB_OBJECT_FLATTEN, "ObjectRemoveTransform", N_("Remove _Transformations"),
2456                    N_("Remove transformations from object"), NULL),
2457     new ObjectVerb(SP_VERB_OBJECT_TO_CURVE, "ObjectToPath", N_("_Object to Path"),
2458                    N_("Convert selected object to path"), INKSCAPE_ICON_OBJECT_TO_PATH),
2459     new ObjectVerb(SP_VERB_OBJECT_FLOW_TEXT, "ObjectFlowText", N_("_Flow into Frame"),
2460                    N_("Put text into a frame (path or shape), creating a flowed text linked to the frame object"), "text-flow-into-frame"),
2461     new ObjectVerb(SP_VERB_OBJECT_UNFLOW_TEXT, "ObjectUnFlowText", N_("_Unflow"),
2462                    N_("Remove text from frame (creates a single-line text object)"), INKSCAPE_ICON_TEXT_UNFLOW),
2463     new ObjectVerb(SP_VERB_OBJECT_FLOWTEXT_TO_TEXT, "ObjectFlowtextToText", N_("_Convert to Text"),
2464                    N_("Convert flowed text to regular text object (preserves appearance)"), INKSCAPE_ICON_TEXT_CONVERT_TO_REGULAR),
2465     new ObjectVerb(SP_VERB_OBJECT_FLIP_HORIZONTAL, "ObjectFlipHorizontally",
2466                    N_("Flip _Horizontal"), N_("Flip selected objects horizontally"),
2467                    INKSCAPE_ICON_OBJECT_FLIP_HORIZONTAL),
2468     new ObjectVerb(SP_VERB_OBJECT_FLIP_VERTICAL, "ObjectFlipVertically",
2469                    N_("Flip _Vertical"), N_("Flip selected objects vertically"),
2470                    INKSCAPE_ICON_OBJECT_FLIP_VERTICAL),
2471     new ObjectVerb(SP_VERB_OBJECT_SET_MASK, "ObjectSetMask", N_("_Set"),
2472                  N_("Apply mask to selection (using the topmost object as mask)"), NULL),
2473     new ObjectVerb(SP_VERB_OBJECT_EDIT_MASK, "ObjectEditMask", N_("_Edit"),
2474                  N_("Edit mask"), INKSCAPE_ICON_PATH_MASK_EDIT),
2475     new ObjectVerb(SP_VERB_OBJECT_UNSET_MASK, "ObjectUnSetMask", N_("_Release"),
2476                  N_("Remove mask from selection"), NULL),
2477     new ObjectVerb(SP_VERB_OBJECT_SET_CLIPPATH, "ObjectSetClipPath", N_("_Set"),
2478                  N_("Apply clipping path to selection (using the topmost object as clipping path)"), NULL),
2479     new ObjectVerb(SP_VERB_OBJECT_EDIT_CLIPPATH, "ObjectEditClipPath", N_("_Edit"),
2480                  N_("Edit clipping path"), INKSCAPE_ICON_PATH_CLIP_EDIT),
2481     new ObjectVerb(SP_VERB_OBJECT_UNSET_CLIPPATH, "ObjectUnSetClipPath", N_("_Release"),
2482                  N_("Remove clipping path from selection"), NULL),
2483
2484     /* Tools */
2485     new ContextVerb(SP_VERB_CONTEXT_SELECT, "ToolSelector", N_("Select"),
2486                     N_("Select and transform objects"), INKSCAPE_ICON_TOOL_POINTER),
2487     new ContextVerb(SP_VERB_CONTEXT_NODE, "ToolNode", N_("Node Edit"),
2488                     N_("Edit paths by nodes"), INKSCAPE_ICON_TOOL_NODE_EDITOR),
2489     new ContextVerb(SP_VERB_CONTEXT_TWEAK, "ToolTweak", N_("Tweak"),
2490                     N_("Tweak objects by sculpting or painting"), INKSCAPE_ICON_TOOL_TWEAK),
2491     new ContextVerb(SP_VERB_CONTEXT_RECT, "ToolRect", N_("Rectangle"),
2492                     N_("Create rectangles and squares"), INKSCAPE_ICON_DRAW_RECTANGLE),
2493     new ContextVerb(SP_VERB_CONTEXT_3DBOX, "Tool3DBox", N_("3D Box"),
2494                     N_("Create 3D boxes"), INKSCAPE_ICON_DRAW_CUBOID),
2495     new ContextVerb(SP_VERB_CONTEXT_ARC, "ToolArc", N_("Ellipse"),
2496                     N_("Create circles, ellipses, and arcs"), INKSCAPE_ICON_DRAW_ELLIPSE),
2497     new ContextVerb(SP_VERB_CONTEXT_STAR, "ToolStar", N_("Star"),
2498                     N_("Create stars and polygons"), INKSCAPE_ICON_DRAW_POLYGON_STAR),
2499     new ContextVerb(SP_VERB_CONTEXT_SPIRAL, "ToolSpiral", N_("Spiral"),
2500                     N_("Create spirals"), INKSCAPE_ICON_DRAW_SPIRAL),
2501     new ContextVerb(SP_VERB_CONTEXT_PENCIL, "ToolPencil", N_("Pencil"),
2502                     N_("Draw freehand lines"), INKSCAPE_ICON_DRAW_FREEHAND),
2503     new ContextVerb(SP_VERB_CONTEXT_PEN, "ToolPen", N_("Pen"),
2504                     N_("Draw Bezier curves and straight lines"), INKSCAPE_ICON_DRAW_PATH),
2505     new ContextVerb(SP_VERB_CONTEXT_CALLIGRAPHIC, "ToolCalligraphic", N_("Calligraphy"),
2506                     N_("Draw calligraphic or brush strokes"), INKSCAPE_ICON_DRAW_CALLIGRAPHIC),
2507     new ContextVerb(SP_VERB_CONTEXT_TEXT, "ToolText", N_("Text"),
2508                     N_("Create and edit text objects"), INKSCAPE_ICON_DRAW_TEXT),
2509     new ContextVerb(SP_VERB_CONTEXT_GRADIENT, "ToolGradient", N_("Gradient"),
2510                     N_("Create and edit gradients"), INKSCAPE_ICON_COLOR_GRADIENT),
2511     new ContextVerb(SP_VERB_CONTEXT_ZOOM, "ToolZoom", N_("Zoom"),
2512                     N_("Zoom in or out"), INKSCAPE_ICON_ZOOM),
2513     new ContextVerb(SP_VERB_CONTEXT_DROPPER, "ToolDropper", N_("Dropper"),
2514                     N_("Pick colors from image"), INKSCAPE_ICON_COLOR_PICKER),
2515     new ContextVerb(SP_VERB_CONTEXT_CONNECTOR, "ToolConnector", N_("Connector"),
2516                     N_("Create diagram connectors"), INKSCAPE_ICON_DRAW_CONNECTOR),
2517     new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET, "ToolPaintBucket", N_("Paint Bucket"),
2518                     N_("Fill bounded areas"), INKSCAPE_ICON_COLOR_FILL),
2519     new ContextVerb(SP_VERB_CONTEXT_LPE, "ToolLPE", N_("LPE Edit"),
2520                     N_("Edit Path Effect parameters"), NULL),
2521     new ContextVerb(SP_VERB_CONTEXT_ERASER, "ToolEraser", N_("Eraser"),
2522                     N_("Erase existing paths"), INKSCAPE_ICON_DRAW_ERASER),
2523     new ContextVerb(SP_VERB_CONTEXT_LPETOOL, "ToolLPETool", N_("LPE Tool"),
2524                     N_("Do geometric constructions"), "draw-geometry"),
2525     /* Tool prefs */
2526     new ContextVerb(SP_VERB_CONTEXT_SELECT_PREFS, "SelectPrefs", N_("Selector Preferences"),
2527                     N_("Open Preferences for the Selector tool"), NULL),
2528     new ContextVerb(SP_VERB_CONTEXT_NODE_PREFS, "NodePrefs", N_("Node Tool Preferences"),
2529                     N_("Open Preferences for the Node tool"), NULL),
2530     new ContextVerb(SP_VERB_CONTEXT_TWEAK_PREFS, "TweakPrefs", N_("Tweak Tool Preferences"),
2531                     N_("Open Preferences for the Tweak tool"), NULL),
2532     new ContextVerb(SP_VERB_CONTEXT_RECT_PREFS, "RectPrefs", N_("Rectangle Preferences"),
2533                     N_("Open Preferences for the Rectangle tool"), NULL),
2534     new ContextVerb(SP_VERB_CONTEXT_3DBOX_PREFS, "3DBoxPrefs", N_("3D Box Preferences"),
2535                     N_("Open Preferences for the 3D Box tool"), NULL),
2536     new ContextVerb(SP_VERB_CONTEXT_ARC_PREFS, "ArcPrefs", N_("Ellipse Preferences"),
2537                     N_("Open Preferences for the Ellipse tool"), NULL),
2538     new ContextVerb(SP_VERB_CONTEXT_STAR_PREFS, "StarPrefs", N_("Star Preferences"),
2539                     N_("Open Preferences for the Star tool"), NULL),
2540     new ContextVerb(SP_VERB_CONTEXT_SPIRAL_PREFS, "SpiralPrefs", N_("Spiral Preferences"),
2541                     N_("Open Preferences for the Spiral tool"), NULL),
2542     new ContextVerb(SP_VERB_CONTEXT_PENCIL_PREFS, "PencilPrefs", N_("Pencil Preferences"),
2543                     N_("Open Preferences for the Pencil tool"), NULL),
2544     new ContextVerb(SP_VERB_CONTEXT_PEN_PREFS, "PenPrefs", N_("Pen Preferences"),
2545                     N_("Open Preferences for the Pen tool"), NULL),
2546     new ContextVerb(SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "CalligraphicPrefs", N_("Calligraphic Preferences"),
2547                     N_("Open Preferences for the Calligraphy tool"), NULL),
2548     new ContextVerb(SP_VERB_CONTEXT_TEXT_PREFS, "TextPrefs", N_("Text Preferences"),
2549                     N_("Open Preferences for the Text tool"), NULL),
2550     new ContextVerb(SP_VERB_CONTEXT_GRADIENT_PREFS, "GradientPrefs", N_("Gradient Preferences"),
2551                     N_("Open Preferences for the Gradient tool"), NULL),
2552     new ContextVerb(SP_VERB_CONTEXT_ZOOM_PREFS, "ZoomPrefs", N_("Zoom Preferences"),
2553                     N_("Open Preferences for the Zoom tool"), NULL),
2554     new ContextVerb(SP_VERB_CONTEXT_DROPPER_PREFS, "DropperPrefs", N_("Dropper Preferences"),
2555                     N_("Open Preferences for the Dropper tool"), NULL),
2556     new ContextVerb(SP_VERB_CONTEXT_CONNECTOR_PREFS, "ConnectorPrefs", N_("Connector Preferences"),
2557                     N_("Open Preferences for the Connector tool"), NULL),
2558     new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "PaintBucketPrefs", N_("Paint Bucket Preferences"),
2559                     N_("Open Preferences for the Paint Bucket tool"), NULL),
2560     new ContextVerb(SP_VERB_CONTEXT_ERASER_PREFS, "EraserPrefs", N_("Eraser Preferences"),
2561                     N_("Open Preferences for the Eraser tool"), NULL),
2562     new ContextVerb(SP_VERB_CONTEXT_LPETOOL_PREFS, "LPEToolPrefs", N_("LPE Tool Preferences"),
2563                     N_("Open Preferences for the LPETool tool"), NULL),
2564
2565     /* Zoom/View */
2566     new ZoomVerb(SP_VERB_ZOOM_IN, "ZoomIn", N_("Zoom In"), N_("Zoom in"), INKSCAPE_ICON_ZOOM_IN),
2567     new ZoomVerb(SP_VERB_ZOOM_OUT, "ZoomOut", N_("Zoom Out"), N_("Zoom out"), INKSCAPE_ICON_ZOOM_OUT),
2568     new ZoomVerb(SP_VERB_TOGGLE_RULERS, "ToggleRulers", N_("_Rulers"), N_("Show or hide the canvas rulers"), NULL),
2569     new ZoomVerb(SP_VERB_TOGGLE_SCROLLBARS, "ToggleScrollbars", N_("Scroll_bars"), N_("Show or hide the canvas scrollbars"), NULL),
2570     new ZoomVerb(SP_VERB_TOGGLE_GRID, "ToggleGrid", N_("_Grid"), N_("Show or hide the grid"), INKSCAPE_ICON_SHOW_GRID),
2571     new ZoomVerb(SP_VERB_TOGGLE_GUIDES, "ToggleGuides", N_("G_uides"), N_("Show or hide guides (drag from a ruler to create a guide)"), INKSCAPE_ICON_SHOW_GUIDES),
2572     new ZoomVerb(SP_VERB_TOGGLE_SNAPPING, "ToggleSnapGlobal", N_("Snap"), N_("Toggle snapping on or off"), INKSCAPE_ICON_SNAP),
2573     new ZoomVerb(SP_VERB_ZOOM_NEXT, "ZoomNext", N_("Nex_t Zoom"), N_("Next zoom (from the history of zooms)"),
2574                  INKSCAPE_ICON_ZOOM_NEXT),
2575     new ZoomVerb(SP_VERB_ZOOM_PREV, "ZoomPrev", N_("Pre_vious Zoom"), N_("Previous zoom (from the history of zooms)"),
2576                  INKSCAPE_ICON_ZOOM_PREVIOUS),
2577     new ZoomVerb(SP_VERB_ZOOM_1_1, "Zoom1:0", N_("Zoom 1:_1"), N_("Zoom to 1:1"),
2578                  INKSCAPE_ICON_ZOOM_ORIGINAL),
2579     new ZoomVerb(SP_VERB_ZOOM_1_2, "Zoom1:2", N_("Zoom 1:_2"), N_("Zoom to 1:2"),
2580                  INKSCAPE_ICON_ZOOM_HALF_SIZE),
2581     new ZoomVerb(SP_VERB_ZOOM_2_1, "Zoom2:1", N_("_Zoom 2:1"), N_("Zoom to 2:1"),
2582                  INKSCAPE_ICON_ZOOM_DOUBLE_SIZE),
2583 #ifdef HAVE_GTK_WINDOW_FULLSCREEN
2584     new ZoomVerb(SP_VERB_FULLSCREEN, "FullScreen", N_("_Fullscreen"), N_("Stretch this document window to full screen"),
2585                  INKSCAPE_ICON_VIEW_FULLSCREEN),
2586 #endif /* HAVE_GTK_WINDOW_FULLSCREEN */
2587     new ZoomVerb(SP_VERB_FOCUSTOGGLE, "FocusToggle", N_("Toggle _Focus Mode"), N_("Remove excess toolbars to focus on drawing"),
2588                  NULL),
2589     new ZoomVerb(SP_VERB_VIEW_NEW, "ViewNew", N_("Duplic_ate Window"), N_("Open a new window with the same document"),
2590                  INKSCAPE_ICON_WINDOW_NEW),
2591     new ZoomVerb(SP_VERB_VIEW_NEW_PREVIEW, "ViewNewPreview", N_("_New View Preview"),
2592                  N_("New View Preview"), NULL/*"view_new_preview"*/),
2593
2594     new ZoomVerb(SP_VERB_VIEW_MODE_NORMAL, "ViewModeNormal", N_("_Normal"),
2595                  N_("Switch to normal display mode"), NULL),
2596     new ZoomVerb(SP_VERB_VIEW_MODE_NO_FILTERS, "ViewModeNoFilters", N_("No _Filters"),
2597                  N_("Switch to normal display without filters"), NULL),
2598     new ZoomVerb(SP_VERB_VIEW_MODE_OUTLINE, "ViewModeOutline", N_("_Outline"),
2599                  N_("Switch to outline (wireframe) display mode"), NULL),
2600     new ZoomVerb(SP_VERB_VIEW_MODE_TOGGLE, "ViewModeToggle", N_("_Toggle"),
2601                  N_("Toggle between normal and outline display modes"), NULL),
2602
2603     new ZoomVerb(SP_VERB_VIEW_CMS_TOGGLE, "ViewCmsToggle", N_("Color-managed view"),
2604                  N_("Toggle color-managed display for this document window"), INKSCAPE_ICON_COLOR_MANAGEMENT),
2605
2606     new ZoomVerb(SP_VERB_VIEW_ICON_PREVIEW, "ViewIconPreview", N_("Ico_n Preview..."),
2607                  N_("Open a window to preview objects at different icon resolutions"), INKSCAPE_ICON_DIALOG_ICON_PREVIEW),
2608     new ZoomVerb(SP_VERB_ZOOM_PAGE, "ZoomPage", N_("_Page"),
2609                  N_("Zoom to fit page in window"), INKSCAPE_ICON_ZOOM_FIT_PAGE),
2610     new ZoomVerb(SP_VERB_ZOOM_PAGE_WIDTH, "ZoomPageWidth", N_("Page _Width"),
2611                  N_("Zoom to fit page width in window"), INKSCAPE_ICON_ZOOM_FIT_WIDTH),
2612     new ZoomVerb(SP_VERB_ZOOM_DRAWING, "ZoomDrawing", N_("_Drawing"),
2613                  N_("Zoom to fit drawing in window"), INKSCAPE_ICON_ZOOM_FIT_DRAWING),
2614     new ZoomVerb(SP_VERB_ZOOM_SELECTION, "ZoomSelection", N_("_Selection"),
2615                  N_("Zoom to fit selection in window"), INKSCAPE_ICON_ZOOM_FIT_SELECTION),
2616
2617     /* Dialogs */
2618     new DialogVerb(SP_VERB_DIALOG_DISPLAY, "DialogPreferences", N_("In_kscape Preferences..."),
2619                    N_("Edit global Inkscape preferences"), GTK_STOCK_PREFERENCES ),
2620     new DialogVerb(SP_VERB_DIALOG_NAMEDVIEW, "DialogDocumentProperties", N_("_Document Properties..."),
2621                    N_("Edit properties of this document (to be saved with the document)"), GTK_STOCK_PROPERTIES ),
2622     new DialogVerb(SP_VERB_DIALOG_METADATA, "DialogMetadata", N_("Document _Metadata..."),
2623                    N_("Edit document metadata (to be saved with the document)"), INKSCAPE_ICON_DOCUMENT_METADATA ),
2624     new DialogVerb(SP_VERB_DIALOG_FILL_STROKE, "DialogFillStroke", N_("_Fill and Stroke..."),
2625                    N_("Edit objects' colors, gradients, stroke width, arrowheads, dash patterns..."), INKSCAPE_ICON_DIALOG_FILL_AND_STROKE),
2626     // TRANSLATORS: "Swatches" means: color samples
2627     new DialogVerb(SP_VERB_DIALOG_SWATCHES, "DialogSwatches", N_("S_watches..."),
2628                    N_("Select colors from a swatches palette"), GTK_STOCK_SELECT_COLOR),
2629     new DialogVerb(SP_VERB_DIALOG_TRANSFORM, "DialogTransform", N_("Transfor_m..."),
2630                    N_("Precisely control objects' transformations"), INKSCAPE_ICON_DIALOG_TRANSFORM),
2631     new DialogVerb(SP_VERB_DIALOG_ALIGN_DISTRIBUTE, "DialogAlignDistribute", N_("_Align and Distribute..."),
2632                    N_("Align and distribute objects"), INKSCAPE_ICON_DIALOG_ALIGN_AND_DISTRIBUTE),
2633     new DialogVerb(SP_VERB_DIALOG_UNDO_HISTORY, "DialogUndoHistory", N_("Undo _History..."),
2634                    N_("Undo History"), INKSCAPE_ICON_EDIT_UNDO_HISTORY),
2635     new DialogVerb(SP_VERB_DIALOG_TEXT, "DialogText", N_("_Text and Font..."),
2636                    N_("View and select font family, font size and other text properties"), INKSCAPE_ICON_DIALOG_TEXT_AND_FONT),
2637     new DialogVerb(SP_VERB_DIALOG_XML_EDITOR, "DialogXMLEditor", N_("_XML Editor..."),
2638                    N_("View and edit the XML tree of the document"), INKSCAPE_ICON_DIALOG_XML_EDITOR),
2639     new DialogVerb(SP_VERB_DIALOG_FIND, "DialogFind", N_("_Find..."),
2640                    N_("Find objects in document"), GTK_STOCK_FIND ),
2641     new DialogVerb(SP_VERB_DIALOG_FINDREPLACE, "DialogFindReplace", N_("Find and _Replace Text..."),
2642                    N_("Find and replace text in document"), GTK_STOCK_FIND_AND_REPLACE ),
2643     new DialogVerb(SP_VERB_DIALOG_SPELLCHECK, "DialogSpellcheck", N_("Check Spellin_g..."),
2644                    N_("Check spelling of text in document"), GTK_STOCK_SPELL_CHECK ),
2645     new DialogVerb(SP_VERB_DIALOG_DEBUG, "DialogDebug", N_("_Messages..."),
2646                    N_("View debug messages"), INKSCAPE_ICON_DIALOG_MESSAGES),
2647     new DialogVerb(SP_VERB_DIALOG_SCRIPT, "DialogScript", N_("S_cripts..."),
2648                    N_("Run scripts"), INKSCAPE_ICON_DIALOG_SCRIPTS),
2649     new DialogVerb(SP_VERB_DIALOG_TOGGLE, "DialogsToggle", N_("Show/Hide D_ialogs"),
2650                    N_("Show or hide all open dialogs"), INKSCAPE_ICON_SHOW_DIALOGS),
2651     new DialogVerb(SP_VERB_DIALOG_CLONETILER, "DialogClonetiler", N_("Create Tiled Clones..."),
2652                    N_("Create multiple clones of selected object, arranging them into a pattern or scattering"), INKSCAPE_ICON_DIALOG_TILE_CLONES),
2653     new DialogVerb(SP_VERB_DIALOG_ITEM, "DialogObjectProperties", N_("_Object Properties..."),
2654                    N_("Edit the ID, locked and visible status, and other object properties"), INKSCAPE_ICON_DIALOG_OBJECT_PROPERTIES),
2655 /*#ifdef WITH_INKBOARD
2656     new DialogVerb(SP_VERB_XMPP_CLIENT, "DialogXmppClient",
2657                    N_("_Instant Messaging..."), N_("Jabber Instant Messaging Client"), NULL),
2658 #endif*/
2659     new DialogVerb(SP_VERB_DIALOG_INPUT, "DialogInput", N_("_Input Devices..."),
2660                    N_("Configure extended input devices, such as a graphics tablet"), INKSCAPE_ICON_DIALOG_INPUT_DEVICES),
2661     new DialogVerb(SP_VERB_DIALOG_INPUT2, "DialogInput2", N_("_Input Devices (new)..."),
2662                    N_("Configure extended input devices, such as a graphics tablet"), INKSCAPE_ICON_DIALOG_INPUT_DEVICES),
2663     new DialogVerb(SP_VERB_DIALOG_EXTENSIONEDITOR, "org.inkscape.dialogs.extensioneditor", N_("_Extensions..."),
2664                    N_("Query information about extensions"), NULL),
2665     new DialogVerb(SP_VERB_DIALOG_LAYERS, "DialogLayers", N_("Layer_s..."),
2666                    N_("View Layers"), INKSCAPE_ICON_DIALOG_LAYERS),
2667     new DialogVerb(SP_VERB_DIALOG_LIVE_PATH_EFFECT, "DialogLivePathEffect", N_("Path Effect Editor..."),
2668                    N_("Manage, edit, and apply path effects"), NULL),
2669     new DialogVerb(SP_VERB_DIALOG_FILTER_EFFECTS, "DialogFilterEffects", N_("Filter Editor..."),
2670                    N_("Manage, edit, and apply SVG filters"), NULL),
2671     new DialogVerb(SP_VERB_DIALOG_SVG_FONTS, "DialogSVGFonts", N_("SVG Font Editor..."),
2672                    N_("Edit SVG fonts"), NULL),
2673
2674     /* Help */
2675     new HelpVerb(SP_VERB_HELP_ABOUT_EXTENSIONS, "HelpAboutExtensions", N_("About E_xtensions"),
2676                  N_("Information on Inkscape extensions"), NULL),
2677     new HelpVerb(SP_VERB_HELP_MEMORY, "HelpAboutMemory", N_("About _Memory"),
2678                  N_("Memory usage information"), INKSCAPE_ICON_DIALOG_MEMORY),
2679     new HelpVerb(SP_VERB_HELP_ABOUT, "HelpAbout", N_("_About Inkscape"),
2680                  N_("Inkscape version, authors, license"), INKSCAPE_ICON_INKSCAPE),
2681     //new HelpVerb(SP_VERB_SHOW_LICENSE, "ShowLicense", N_("_License"),
2682     //           N_("Distribution terms"), /*"show_license"*/"inkscape_options"),
2683
2684     /* Tutorials */
2685     new TutorialVerb(SP_VERB_TUTORIAL_BASIC, "TutorialsBasic", N_("Inkscape: _Basic"),
2686                      N_("Getting started with Inkscape"), NULL/*"tutorial_basic"*/),
2687     new TutorialVerb(SP_VERB_TUTORIAL_SHAPES, "TutorialsShapes", N_("Inkscape: _Shapes"),
2688                      N_("Using shape tools to create and edit shapes"), NULL),
2689     new TutorialVerb(SP_VERB_TUTORIAL_ADVANCED, "TutorialsAdvanced", N_("Inkscape: _Advanced"),
2690                      N_("Advanced Inkscape topics"), NULL/*"tutorial_advanced"*/),
2691     // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize)
2692     new TutorialVerb(SP_VERB_TUTORIAL_TRACING, "TutorialsTracing", N_("Inkscape: T_racing"),
2693                      N_("Using bitmap tracing"), NULL/*"tutorial_tracing"*/),
2694     new TutorialVerb(SP_VERB_TUTORIAL_CALLIGRAPHY, "TutorialsCalligraphy", N_("Inkscape: _Calligraphy"),
2695                      N_("Using the Calligraphy pen tool"), NULL),
2696     new TutorialVerb(SP_VERB_TUTORIAL_DESIGN, "TutorialsDesign", N_("_Elements of Design"),
2697                      N_("Principles of design in the tutorial form"), NULL/*"tutorial_design"*/),
2698     new TutorialVerb(SP_VERB_TUTORIAL_TIPS, "TutorialsTips", N_("_Tips and Tricks"),
2699                      N_("Miscellaneous tips and tricks"), NULL/*"tutorial_tips"*/),
2700
2701     /* Effect -- renamed Extension */
2702     new EffectLastVerb(SP_VERB_EFFECT_LAST, "EffectLast", N_("Previous Extension"),
2703                        N_("Repeat the last extension with the same settings"), NULL),
2704     new EffectLastVerb(SP_VERB_EFFECT_LAST_PREF, "EffectLastPref", N_("Previous Extension Settings..."),
2705                        N_("Repeat the last extension with new settings"), NULL),
2706
2707     /* Fit Page */
2708     new FitCanvasVerb(SP_VERB_FIT_CANVAS_TO_SELECTION, "FitCanvasToSelection", N_("Fit Page to Selection"),
2709                        N_("Fit the page to the current selection"), NULL),
2710     new FitCanvasVerb(SP_VERB_FIT_CANVAS_TO_DRAWING, "FitCanvasToDrawing", N_("Fit Page to Drawing"),
2711                        N_("Fit the page to the drawing"), NULL),
2712     new FitCanvasVerb(SP_VERB_FIT_CANVAS_TO_SELECTION_OR_DRAWING, "FitCanvasToSelectionOrDrawing", N_("Fit Page to Selection or Drawing"),
2713                        N_("Fit the page to the current selection or the drawing if there is no selection"), NULL),
2714     /* LockAndHide */
2715     new LockAndHideVerb(SP_VERB_UNLOCK_ALL, "UnlockAll", N_("Unlock All"),
2716                        N_("Unlock all objects in the current layer"), NULL),
2717     new LockAndHideVerb(SP_VERB_UNLOCK_ALL_IN_ALL_LAYERS, "UnlockAllInAllLayers", N_("Unlock All in All Layers"),
2718                        N_("Unlock all objects in all layers"), NULL),
2719     new LockAndHideVerb(SP_VERB_UNHIDE_ALL, "UnhideAll", N_("Unhide All"),
2720                        N_("Unhide all objects in the current layer"), NULL),
2721     new LockAndHideVerb(SP_VERB_UNHIDE_ALL_IN_ALL_LAYERS, "UnhideAllInAllLayers", N_("Unhide All in All Layers"),
2722                        N_("Unhide all objects in all layers"), NULL),
2723     /*Color Management*/
2724     new EditVerb(SP_VERB_EDIT_LINK_COLOR_PROFILE, "LinkColorProfile", N_("Link Color Profile"),
2725                  N_("Link an ICC color profile"), NULL),
2726     new EditVerb(SP_VERB_EDIT_REMOVE_COLOR_PROFILE, "RemoveColorProfile", N_("Remove Color Profile"),
2727                  N_("Remove a linked ICC color profile"), NULL),
2728     /* Footer */
2729     new Verb(SP_VERB_LAST, " '\"invalid id", NULL, NULL, NULL)
2730 };
2731
2732
2733 void
2734 Verb::list (void) {
2735     // Go through the dynamic verb table
2736     for (VerbTable::iterator iter = _verbs.begin(); iter != _verbs.end(); iter++) {
2737         Verb * verb = iter->second;
2738         if (verb->get_code() == SP_VERB_INVALID ||
2739                 verb->get_code() == SP_VERB_NONE ||
2740                 verb->get_code() == SP_VERB_LAST) {
2741             continue;
2742         }
2743
2744         printf("%s: %s\n", verb->get_id(), verb->get_tip()? verb->get_tip() : verb->get_name());
2745     }
2746
2747     return;
2748 };
2749
2750 }  /* namespace Inkscape */
2751
2752 /*
2753   Local Variables:
2754   mode:c++
2755   c-file-style:"stroustrup"
2756   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
2757   indent-tabs-mode:nil
2758   fill-column:99
2759   End:
2760 */
2761 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :