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