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_CMS_TOGGLE:
1634             dt->toggleColorProfAdjust();
1635             break;
1636         case SP_VERB_VIEW_ICON_PREVIEW:
1637             inkscape_dialogs_unhide();
1638             dt->_dlg_mgr->showDialog("IconPreviewPanel");
1639             break;
1640         default:
1641             break;
1642     }
1643
1644     dt->updateNow();
1645
1646 } // end of sp_verb_action_zoom_perform()
1647
1648 /** \brief  Decode the verb code and take appropriate action */
1649 void
1650 DialogVerb::perform(SPAction *action, void *data, void */*pdata*/)
1651 {
1652     if (reinterpret_cast<std::size_t>(data) != SP_VERB_DIALOG_TOGGLE) {
1653         // unhide all when opening a new dialog
1654         inkscape_dialogs_unhide();
1655     }
1656
1657     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1658     g_assert(dt->_dlg_mgr != NULL);
1659
1660     switch (reinterpret_cast<std::size_t>(data)) {
1661         case SP_VERB_DIALOG_DISPLAY:
1662             //sp_display_dialog();
1663             dt->_dlg_mgr->showDialog("InkscapePreferences");
1664             break;
1665         case SP_VERB_DIALOG_METADATA:
1666             // sp_desktop_dialog();
1667             dt->_dlg_mgr->showDialog("DocumentMetadata");
1668             break;
1669         case SP_VERB_DIALOG_NAMEDVIEW:
1670             // sp_desktop_dialog();
1671             dt->_dlg_mgr->showDialog("DocumentProperties");
1672             break;
1673         case SP_VERB_DIALOG_FILL_STROKE:
1674             dt->_dlg_mgr->showDialog("FillAndStroke");
1675             break;
1676         case SP_VERB_DIALOG_SWATCHES:
1677             dt->_dlg_mgr->showDialog("Swatches");
1678             break;
1679         case SP_VERB_DIALOG_TRANSFORM:
1680             dt->_dlg_mgr->showDialog("Transformation");
1681             break;
1682         case SP_VERB_DIALOG_ALIGN_DISTRIBUTE:
1683             dt->_dlg_mgr->showDialog("AlignAndDistribute");
1684             break;
1685         case SP_VERB_DIALOG_TEXT:
1686             sp_text_edit_dialog();
1687             break;
1688         case SP_VERB_DIALOG_XML_EDITOR:
1689             sp_xml_tree_dialog();
1690             break;
1691         case SP_VERB_DIALOG_FIND:
1692             sp_find_dialog();
1693 //              Please test the new find dialog if you have time:
1694 //            dt->_dlg_mgr->showDialog("Find");
1695             break;
1696         case SP_VERB_DIALOG_DEBUG:
1697             dt->_dlg_mgr->showDialog("Messages");
1698             break;
1699         case SP_VERB_DIALOG_SCRIPT:
1700             dt->_dlg_mgr->showDialog("Script");
1701             break;
1702         case SP_VERB_DIALOG_UNDO_HISTORY:
1703             dt->_dlg_mgr->showDialog("UndoHistory");
1704             break;
1705         case SP_VERB_DIALOG_TOGGLE:
1706             inkscape_dialogs_toggle();
1707             break;
1708         case SP_VERB_DIALOG_CLONETILER:
1709             clonetiler_dialog();
1710             break;
1711         case SP_VERB_DIALOG_ITEM:
1712             sp_item_dialog();
1713             break;
1714 #ifdef WITH_INKBOARD
1715         case SP_VERB_XMPP_CLIENT:
1716         {
1717             Inkscape::Whiteboard::SessionManager::showClient();
1718             break;
1719         }
1720 #endif
1721         case SP_VERB_DIALOG_INPUT:
1722             sp_input_dialog();
1723             break;
1724         case SP_VERB_DIALOG_EXTENSIONEDITOR:
1725             dt->_dlg_mgr->showDialog("ExtensionEditor");
1726             break;
1727         case SP_VERB_DIALOG_LAYERS:
1728             dt->_dlg_mgr->showDialog("LayersPanel");
1729             break;
1730         case SP_VERB_DIALOG_LIVE_PATH_EFFECT:
1731             dt->_dlg_mgr->showDialog("LivePathEffect");
1732             break;
1733         case SP_VERB_DIALOG_FILTER_EFFECTS:
1734             dt->_dlg_mgr->showDialog("FilterEffectsDialog");
1735             break;
1736         default:
1737             break;
1738     }
1739 } // end of sp_verb_action_dialog_perform()
1740
1741 /** \brief  Decode the verb code and take appropriate action */
1742 void
1743 HelpVerb::perform(SPAction *action, void *data, void */*pdata*/)
1744 {
1745     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
1746     g_assert(dt->_dlg_mgr != NULL);
1747
1748     switch (reinterpret_cast<std::size_t>(data)) {
1749         case SP_VERB_HELP_ABOUT:
1750             sp_help_about();
1751             break;
1752         case SP_VERB_HELP_ABOUT_EXTENSIONS: {
1753             // Inkscape::UI::Dialogs::ExtensionsPanel *panel = new Inkscape::UI::Dialogs::ExtensionsPanel();
1754             // panel->set_full(true);
1755             // show_panel( *panel, "dialogs.aboutextensions", SP_VERB_HELP_ABOUT_EXTENSIONS );
1756             break;
1757         }
1758
1759         /*
1760         case SP_VERB_SHOW_LICENSE:
1761             // TRANSLATORS: See "tutorial-basic.svg" comment.
1762             sp_help_open_tutorial(NULL, (gpointer) _("gpl-2.svg"));
1763             break;
1764         */
1765
1766         case SP_VERB_HELP_MEMORY:
1767             inkscape_dialogs_unhide();
1768             dt->_dlg_mgr->showDialog("Memory");
1769             break;
1770         default:
1771             break;
1772     }
1773 } // end of sp_verb_action_help_perform()
1774
1775 /** \brief  Decode the verb code and take appropriate action */
1776 void
1777 TutorialVerb::perform(SPAction */*action*/, void *data, void */*pdata*/)
1778 {
1779     switch (reinterpret_cast<std::size_t>(data)) {
1780         case SP_VERB_TUTORIAL_BASIC:
1781             /* TRANSLATORS: If you have translated the tutorial-basic.svg file to your language,
1782                then translate this string as "tutorial-basic.LANG.svg" (where LANG is your language
1783                code); otherwise leave as "tutorial-basic.svg". */
1784             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-basic.svg"));
1785             break;
1786         case SP_VERB_TUTORIAL_SHAPES:
1787             // TRANSLATORS: See "tutorial-basic.svg" comment.
1788             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-shapes.svg"));
1789             break;
1790         case SP_VERB_TUTORIAL_ADVANCED:
1791             // TRANSLATORS: See "tutorial-basic.svg" comment.
1792             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-advanced.svg"));
1793             break;
1794         case SP_VERB_TUTORIAL_TRACING:
1795             // TRANSLATORS: See "tutorial-basic.svg" comment.
1796             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-tracing.svg"));
1797             break;
1798         case SP_VERB_TUTORIAL_CALLIGRAPHY:
1799             // TRANSLATORS: See "tutorial-basic.svg" comment.
1800             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-calligraphy.svg"));
1801             break;
1802         case SP_VERB_TUTORIAL_DESIGN:
1803             // TRANSLATORS: See "tutorial-basic.svg" comment.
1804             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-elements.svg"));
1805             break;
1806         case SP_VERB_TUTORIAL_TIPS:
1807             // TRANSLATORS: See "tutorial-basic.svg" comment.
1808             sp_help_open_tutorial(NULL, (gpointer)_("tutorial-tips.svg"));
1809             break;
1810         default:
1811             break;
1812     }
1813 } // end of sp_verb_action_tutorial_perform()
1814
1815
1816 /**
1817  * Action vector to define functions called if a staticly defined file verb
1818  * is called.
1819  */
1820 SPActionEventVector FileVerb::vector =
1821             {{NULL},FileVerb::perform, NULL, NULL, NULL, NULL};
1822 /**
1823  * Action vector to define functions called if a staticly defined edit verb is
1824  * called.
1825  */
1826 SPActionEventVector EditVerb::vector =
1827             {{NULL},EditVerb::perform, NULL, NULL, NULL, NULL};
1828
1829 /**
1830  * Action vector to define functions called if a staticly defined selection
1831  * verb is called
1832  */
1833 SPActionEventVector SelectionVerb::vector =
1834             {{NULL},SelectionVerb::perform, NULL, NULL, NULL, NULL};
1835
1836 /**
1837  * Action vector to define functions called if a staticly defined layer
1838  * verb is called
1839  */
1840 SPActionEventVector LayerVerb::vector =
1841             {{NULL}, LayerVerb::perform, NULL, NULL, NULL, NULL};
1842
1843 /**
1844  * Action vector to define functions called if a staticly defined object
1845  * editing verb is called
1846  */
1847 SPActionEventVector ObjectVerb::vector =
1848             {{NULL},ObjectVerb::perform, NULL, NULL, NULL, NULL};
1849
1850 /**
1851  * Action vector to define functions called if a staticly defined context
1852  * verb is called
1853  */
1854 SPActionEventVector ContextVerb::vector =
1855             {{NULL},ContextVerb::perform, NULL, NULL, NULL, NULL};
1856
1857 /**
1858  * Action vector to define functions called if a staticly defined zoom verb
1859  * is called
1860  */
1861 SPActionEventVector ZoomVerb::vector =
1862             {{NULL},ZoomVerb::perform, NULL, NULL, NULL, NULL};
1863
1864
1865 /**
1866  * Action vector to define functions called if a staticly defined dialog verb
1867  * is called
1868  */
1869 SPActionEventVector DialogVerb::vector =
1870             {{NULL},DialogVerb::perform, NULL, NULL, NULL, NULL};
1871
1872 /**
1873  * Action vector to define functions called if a staticly defined help verb
1874  * is called
1875  */
1876 SPActionEventVector HelpVerb::vector =
1877             {{NULL},HelpVerb::perform, NULL, NULL, NULL, NULL};
1878
1879 /**
1880  * Action vector to define functions called if a staticly defined tutorial verb
1881  * is called
1882  */
1883 SPActionEventVector TutorialVerb::vector =
1884             {{NULL},TutorialVerb::perform, NULL, NULL, NULL, NULL};
1885
1886 /**
1887  * Action vector to define functions called if a staticly defined tutorial verb
1888  * is called
1889  */
1890 SPActionEventVector TextVerb::vector =
1891             {{NULL},TextVerb::perform, NULL, NULL, NULL, NULL};
1892
1893
1894 /* *********** Effect Last ********** */
1895
1896 /** \brief A class to represent the last effect issued */
1897 class EffectLastVerb : public Verb {
1898 private:
1899     static void perform(SPAction *action, void *mydata, void *otherdata);
1900     static SPActionEventVector vector;
1901 protected:
1902     virtual SPAction *make_action(Inkscape::UI::View::View *view);
1903 public:
1904     /** \brief Use the Verb initializer with the same parameters. */
1905     EffectLastVerb(unsigned int const code,
1906                    gchar const *id,
1907                    gchar const *name,
1908                    gchar const *tip,
1909                    gchar const *image) :
1910         Verb(code, id, name, tip, image)
1911     {
1912         set_default_sensitive(false);
1913     }
1914 }; /* EffectLastVerb class */
1915
1916 /**
1917  * The vector to attach in the last effect verb.
1918  */
1919 SPActionEventVector EffectLastVerb::vector =
1920             {{NULL},EffectLastVerb::perform, NULL, NULL, NULL, NULL};
1921
1922 /** \brief  Create an action for a \c EffectLastVerb
1923     \param  view  Which view the action should be created for
1924     \return The built action.
1925
1926     Calls \c make_action_helper with the \c vector.
1927 */
1928 SPAction *
1929 EffectLastVerb::make_action(Inkscape::UI::View::View *view)
1930 {
1931     return make_action_helper(view, &vector);
1932 }
1933
1934 /** \brief  Decode the verb code and take appropriate action */
1935 void
1936 EffectLastVerb::perform(SPAction *action, void *data, void */*pdata*/)
1937 {
1938     /* These aren't used, but are here to remind people not to use
1939        the CURRENT_DOCUMENT macros unless they really have to. */
1940     Inkscape::UI::View::View *current_view = sp_action_get_view(action);
1941     // SPDocument *current_document = SP_VIEW_DOCUMENT(current_view);
1942     Inkscape::Extension::Effect *effect = Inkscape::Extension::Effect::get_last_effect();
1943
1944     if (effect == NULL) return;
1945     if (current_view == NULL) return;
1946
1947     switch ((long) data) {
1948         case SP_VERB_EFFECT_LAST_PREF:
1949             if (!effect->prefs(current_view))
1950                 return;
1951             /* Note: fall through */
1952         case SP_VERB_EFFECT_LAST:
1953             effect->effect(current_view);
1954             break;
1955         default:
1956             return;
1957     }
1958
1959     return;
1960 }
1961 /* *********** End Effect Last ********** */
1962
1963 /* *********** Fit Canvas ********** */
1964
1965 /** \brief A class to represent the canvas fitting verbs */
1966 class FitCanvasVerb : public Verb {
1967 private:
1968     static void perform(SPAction *action, void *mydata, void *otherdata);
1969     static SPActionEventVector vector;
1970 protected:
1971     virtual SPAction *make_action(Inkscape::UI::View::View *view);
1972 public:
1973     /** \brief Use the Verb initializer with the same parameters. */
1974     FitCanvasVerb(unsigned int const code,
1975                    gchar const *id,
1976                    gchar const *name,
1977                    gchar const *tip,
1978                    gchar const *image) :
1979         Verb(code, id, name, tip, image)
1980     {
1981         set_default_sensitive(false);
1982     }
1983 }; /* FitCanvasVerb class */
1984
1985 /**
1986  * The vector to attach in the fit canvas verb.
1987  */
1988 SPActionEventVector FitCanvasVerb::vector =
1989             {{NULL},FitCanvasVerb::perform, NULL, NULL, NULL, NULL};
1990
1991 /** \brief  Create an action for a \c FitCanvasVerb
1992     \param  view  Which view the action should be created for
1993     \return The built action.
1994
1995     Calls \c make_action_helper with the \c vector.
1996 */
1997 SPAction *
1998 FitCanvasVerb::make_action(Inkscape::UI::View::View *view)
1999 {
2000     SPAction *action = make_action_helper(view, &vector);
2001     return action;
2002 }
2003
2004 /** \brief  Decode the verb code and take appropriate action */
2005 void
2006 FitCanvasVerb::perform(SPAction *action, void *data, void */*pdata*/)
2007 {
2008     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
2009     if (!dt) return;
2010     SPDocument *doc = sp_desktop_document(dt);
2011     if (!doc) return;
2012
2013     switch ((long) data) {
2014         case SP_VERB_FIT_CANVAS_TO_SELECTION:
2015             fit_canvas_to_selection(dt);
2016             break;
2017         case SP_VERB_FIT_CANVAS_TO_DRAWING:
2018             fit_canvas_to_drawing(doc);
2019             break;
2020         case SP_VERB_FIT_CANVAS_TO_SELECTION_OR_DRAWING:
2021             fit_canvas_to_selection_or_drawing(dt);
2022             break;
2023         default:
2024             return;
2025     }
2026
2027     return;
2028 }
2029 /* *********** End Fit Canvas ********** */
2030
2031
2032 /* *********** Lock'N'Hide ********** */
2033
2034 /** \brief A class to represent the object unlocking and unhiding verbs */
2035 class LockAndHideVerb : public Verb {
2036 private:
2037     static void perform(SPAction *action, void *mydata, void *otherdata);
2038     static SPActionEventVector vector;
2039 protected:
2040     virtual SPAction *make_action(Inkscape::UI::View::View *view);
2041 public:
2042     /** \brief Use the Verb initializer with the same parameters. */
2043     LockAndHideVerb(unsigned int const code,
2044                    gchar const *id,
2045                    gchar const *name,
2046                    gchar const *tip,
2047                    gchar const *image) :
2048         Verb(code, id, name, tip, image)
2049     {
2050         set_default_sensitive(true);
2051     }
2052 }; /* LockAndHideVerb class */
2053
2054 /**
2055  * The vector to attach in the lock'n'hide verb.
2056  */
2057 SPActionEventVector LockAndHideVerb::vector =
2058             {{NULL},LockAndHideVerb::perform, NULL, NULL, NULL, NULL};
2059
2060 /** \brief  Create an action for a \c LockAndHideVerb
2061     \param  view  Which view the action should be created for
2062     \return The built action.
2063
2064     Calls \c make_action_helper with the \c vector.
2065 */
2066 SPAction *
2067 LockAndHideVerb::make_action(Inkscape::UI::View::View *view)
2068 {
2069     SPAction *action = make_action_helper(view, &vector);
2070     return action;
2071 }
2072
2073 /** \brief  Decode the verb code and take appropriate action */
2074 void
2075 LockAndHideVerb::perform(SPAction *action, void *data, void */*pdata*/)
2076 {
2077     SPDesktop *dt = static_cast<SPDesktop*>(sp_action_get_view(action));
2078     if (!dt) return;
2079     SPDocument *doc = sp_desktop_document(dt);
2080     if (!doc) return;
2081
2082     switch ((long) data) {
2083         case SP_VERB_UNLOCK_ALL:
2084             unlock_all(dt);
2085             sp_document_done(doc, SP_VERB_UNLOCK_ALL, _("Unlock all objects in the current layer"));
2086             break;
2087         case SP_VERB_UNLOCK_ALL_IN_ALL_LAYERS:
2088             unlock_all_in_all_layers(dt);
2089             sp_document_done(doc, SP_VERB_UNLOCK_ALL_IN_ALL_LAYERS, _("Unlock all objects in all layers"));
2090             break;
2091         case SP_VERB_UNHIDE_ALL:
2092             unhide_all(dt);
2093             sp_document_done(doc, SP_VERB_UNHIDE_ALL, _("Unhide all objects in the current layer"));
2094             break;
2095         case SP_VERB_UNHIDE_ALL_IN_ALL_LAYERS:
2096             unhide_all_in_all_layers(dt);
2097             sp_document_done(doc, SP_VERB_UNHIDE_ALL_IN_ALL_LAYERS, _("Unhide all objects in all layers"));
2098             break;
2099         default:
2100             return;
2101     }
2102
2103     return;
2104 }
2105 /* *********** End Lock'N'Hide ********** */
2106
2107
2108 /* these must be in the same order as the SP_VERB_* enum in "verbs.h" */
2109 Verb *Verb::_base_verbs[] = {
2110     /* Header */
2111     new Verb(SP_VERB_INVALID, NULL, NULL, NULL, NULL),
2112     new Verb(SP_VERB_NONE, "None", N_("None"), N_("Does nothing"), NULL),
2113
2114     /* File */
2115     new FileVerb(SP_VERB_FILE_NEW, "FileNew", N_("Default"), N_("Create new document from the default template"),
2116                  GTK_STOCK_NEW ),
2117     new FileVerb(SP_VERB_FILE_OPEN, "FileOpen", N_("_Open..."),
2118                  N_("Open an existing document"), GTK_STOCK_OPEN ),
2119     new FileVerb(SP_VERB_FILE_REVERT, "FileRevert", N_("Re_vert"),
2120                  N_("Revert to the last saved version of document (changes will be lost)"), GTK_STOCK_REVERT_TO_SAVED ),
2121     new FileVerb(SP_VERB_FILE_SAVE, "FileSave", N_("_Save"), N_("Save document"),
2122                  GTK_STOCK_SAVE ),
2123     new FileVerb(SP_VERB_FILE_SAVE_AS, "FileSaveAs", N_("Save _As..."),
2124                  N_("Save document under a new name"), GTK_STOCK_SAVE_AS ),
2125     new FileVerb(SP_VERB_FILE_SAVE_A_COPY, "FileSaveACopy", N_("Save a Cop_y..."),
2126                  N_("Save a copy of the document under a new name"), NULL ),
2127     new FileVerb(SP_VERB_FILE_PRINT, "FilePrint", N_("_Print..."), N_("Print document"),
2128                  GTK_STOCK_PRINT ),
2129     // TRANSLATORS: "Vacuum Defs" means "Clean up defs" (so as to remove unused definitions)
2130     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"),
2131                  "file_vacuum" ),
2132     new FileVerb(SP_VERB_FILE_PRINT_DIRECT, "FilePrintDirect", N_("Print _Direct"),
2133                  N_("Print directly without prompting to a file or pipe"), NULL ),
2134     new FileVerb(SP_VERB_FILE_PRINT_PREVIEW, "FilePrintPreview", N_("Print Previe_w"),
2135                  N_("Preview document printout"), GTK_STOCK_PRINT_PREVIEW ),
2136     new FileVerb(SP_VERB_FILE_IMPORT, "FileImport", N_("_Import..."),
2137                  N_("Import a bitmap or SVG image into this document"), "file_import"),
2138     new FileVerb(SP_VERB_FILE_EXPORT, "FileExport", N_("_Export Bitmap..."),
2139                  N_("Export this document or a selection as a bitmap image"), "file_export"),
2140     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"),
2141     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"),
2142     new FileVerb(SP_VERB_FILE_NEXT_DESKTOP, "NextWindow", N_("N_ext Window"),
2143                  N_("Switch to the next document window"), "window_next"),
2144     new FileVerb(SP_VERB_FILE_PREV_DESKTOP, "PrevWindow", N_("P_revious Window"),
2145                  N_("Switch to the previous document window"), "window_previous"),
2146     new FileVerb(SP_VERB_FILE_CLOSE_VIEW, "FileClose", N_("_Close"),
2147                  N_("Close this document window"), GTK_STOCK_CLOSE),
2148     new FileVerb(SP_VERB_FILE_QUIT, "FileQuit", N_("_Quit"), N_("Quit Inkscape"), GTK_STOCK_QUIT),
2149
2150     /* Edit */
2151     new EditVerb(SP_VERB_EDIT_UNDO, "EditUndo", N_("_Undo"), N_("Undo last action"),
2152                  GTK_STOCK_UNDO),
2153     new EditVerb(SP_VERB_EDIT_REDO, "EditRedo", N_("_Redo"),
2154                  N_("Do again the last undone action"), GTK_STOCK_REDO),
2155     new EditVerb(SP_VERB_EDIT_CUT, "EditCut", N_("Cu_t"),
2156                  N_("Cut selection to clipboard"), GTK_STOCK_CUT),
2157     new EditVerb(SP_VERB_EDIT_COPY, "EditCopy", N_("_Copy"),
2158                  N_("Copy selection to clipboard"), GTK_STOCK_COPY),
2159     new EditVerb(SP_VERB_EDIT_PASTE, "EditPaste", N_("_Paste"),
2160                  N_("Paste objects from clipboard to mouse point, or paste text"), GTK_STOCK_PASTE),
2161     new EditVerb(SP_VERB_EDIT_PASTE_STYLE, "EditPasteStyle", N_("Paste _Style"),
2162                  N_("Apply the style of the copied object to selection"), "selection_paste_style"),
2163     new EditVerb(SP_VERB_EDIT_PASTE_SIZE, "EditPasteSize", N_("Paste Si_ze"),
2164                  N_("Scale selection to match the size of the copied object"), NULL),
2165     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_X, "EditPasteWidth", N_("Paste _Width"),
2166                  N_("Scale selection horizontally to match the width of the copied object"), NULL),
2167     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_Y, "EditPasteHeight", N_("Paste _Height"),
2168                  N_("Scale selection vertically to match the height of the copied object"), NULL),
2169     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY, "EditPasteSizeSeparately", N_("Paste Size Separately"),
2170                  N_("Scale each selected object to match the size of the copied object"), NULL),
2171     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_X, "EditPasteWidthSeparately", N_("Paste Width Separately"),
2172                  N_("Scale each selected object horizontally to match the width of the copied object"), NULL),
2173     new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_Y, "EditPasteHeightSeparately", N_("Paste Height Separately"),
2174                  N_("Scale each selected object vertically to match the height of the copied object"), NULL),
2175     new EditVerb(SP_VERB_EDIT_PASTE_IN_PLACE, "EditPasteInPlace", N_("Paste _In Place"),
2176                  N_("Paste objects from clipboard to the original location"), "selection_paste_in_place"),
2177     new EditVerb(SP_VERB_EDIT_PASTE_LIVEPATHEFFECT, "EditPasteLivePathEffect", N_("Paste Path _Effect"),
2178                  N_("Apply the path effect of the copied object to selection"), NULL),
2179     new EditVerb(SP_VERB_EDIT_DELETE, "EditDelete", N_("_Delete"),
2180                  N_("Delete selection"), GTK_STOCK_DELETE),
2181     new EditVerb(SP_VERB_EDIT_DUPLICATE, "EditDuplicate", N_("Duplic_ate"),
2182                  N_("Duplicate selected objects"), "edit_duplicate"),
2183     new EditVerb(SP_VERB_EDIT_CLONE, "EditClone", N_("Create Clo_ne"),
2184                  N_("Create a clone (a copy linked to the original) of selected object"), "edit_clone"),
2185     new EditVerb(SP_VERB_EDIT_UNLINK_CLONE, "EditUnlinkClone", N_("Unlin_k Clone"),
2186                  N_("Cut the selected clone's link to its original, turning it into a standalone object"), "edit_unlink_clone"),
2187     new EditVerb(SP_VERB_EDIT_CLONE_SELECT_ORIGINAL, "EditCloneSelectOriginal", N_("Select _Original"),
2188                  N_("Select the object to which the selected clone is linked"), "edit_select_original"),
2189     // TRANSLATORS: Convert selection to a line marker
2190     new EditVerb(SP_VERB_EDIT_SELECTION_2_MARKER, "ObjectsToMarker", N_("Objects to _Marker"),
2191                  N_("Convert selection to a line marker"), NULL),
2192     // TRANSLATORS: Convert selection to a rectangle with tiled pattern fill
2193     new EditVerb(SP_VERB_EDIT_TILE, "ObjectsToPattern", N_("Objects to Patter_n"),
2194                  N_("Convert selection to a rectangle with tiled pattern fill"), NULL),
2195     // TRANSLATORS: Extract objects from a tiled pattern fill
2196     new EditVerb(SP_VERB_EDIT_UNTILE, "ObjectsFromPattern", N_("Pattern to _Objects"),
2197                  N_("Extract objects from a tiled pattern fill"), NULL),
2198     new EditVerb(SP_VERB_EDIT_CLEAR_ALL, "EditClearAll", N_("Clea_r All"),
2199                  N_("Delete all objects from document"), NULL),
2200     new EditVerb(SP_VERB_EDIT_SELECT_ALL, "EditSelectAll", N_("Select Al_l"),
2201                  N_("Select all objects or all nodes"), "selection_select_all"),
2202     new EditVerb(SP_VERB_EDIT_SELECT_ALL_IN_ALL_LAYERS, "EditSelectAllInAllLayers", N_("Select All in All La_yers"),
2203                  N_("Select all objects in all visible and unlocked layers"), "selection_select_all_in_all_layers"),
2204     new EditVerb(SP_VERB_EDIT_INVERT, "EditInvert", N_("In_vert Selection"),
2205                  N_("Invert selection (unselect what is selected and select everything else)"), "selection_invert"),
2206     new EditVerb(SP_VERB_EDIT_INVERT_IN_ALL_LAYERS, "EditInvertInAllLayers", N_("Invert in All Layers"),
2207                  N_("Invert selection in all visible and unlocked layers"), NULL),
2208     new EditVerb(SP_VERB_EDIT_SELECT_NEXT, "EditSelectNext", N_("Select Next"),
2209                  N_("Select next object or node"), NULL),
2210     new EditVerb(SP_VERB_EDIT_SELECT_PREV, "EditSelectPrev", N_("Select Previous"),
2211                  N_("Select previous object or node"), NULL),
2212     new EditVerb(SP_VERB_EDIT_DESELECT, "EditDeselect", N_("D_eselect"),
2213                  N_("Deselect any selected objects or nodes"), "selection_deselect"),
2214     new EditVerb(SP_VERB_EDIT_NEXT_PATHEFFECT_PARAMETER, "EditNextPathEffectParameter", N_("Next Path Effect Parameter"),
2215                  N_("Show next Path Effect parameter for editing"), NULL),
2216
2217     /* Selection */
2218     new SelectionVerb(SP_VERB_SELECTION_TO_FRONT, "SelectionToFront", N_("Raise to _Top"),
2219                       N_("Raise selection to top"), "selection_top"),
2220     new SelectionVerb(SP_VERB_SELECTION_TO_BACK, "SelectionToBack", N_("Lower to _Bottom"),
2221                       N_("Lower selection to bottom"), "selection_bot"),
2222     new SelectionVerb(SP_VERB_SELECTION_RAISE, "SelectionRaise", N_("_Raise"),
2223                       N_("Raise selection one step"), "selection_up"),
2224     new SelectionVerb(SP_VERB_SELECTION_LOWER, "SelectionLower", N_("_Lower"),
2225                       N_("Lower selection one step"), "selection_down"),
2226     new SelectionVerb(SP_VERB_SELECTION_GROUP, "SelectionGroup", N_("_Group"),
2227                       N_("Group selected objects"), "selection_group"),
2228     new SelectionVerb(SP_VERB_SELECTION_UNGROUP, "SelectionUnGroup", N_("_Ungroup"),
2229                       N_("Ungroup selected groups"), "selection_ungroup"),
2230
2231     new SelectionVerb(SP_VERB_SELECTION_TEXTTOPATH, "SelectionTextToPath", N_("_Put on Path"),
2232                       N_("Put text on path"), "put_on_path"),
2233     new SelectionVerb(SP_VERB_SELECTION_TEXTFROMPATH, "SelectionTextFromPath", N_("_Remove from Path"),
2234                       N_("Remove text from path"), "remove_from_path"),
2235     new SelectionVerb(SP_VERB_SELECTION_REMOVE_KERNS, "SelectionTextRemoveKerns", N_("Remove Manual _Kerns"),
2236                       // TRANSLATORS: "glyph": An image used in the visual representation of characters;
2237                       //  roughly speaking, how a character looks. A font is a set of glyphs.
2238                       N_("Remove all manual kerns and glyph rotations from a text object"), "remove_manual_kerns"),
2239
2240     new SelectionVerb(SP_VERB_SELECTION_UNION, "SelectionUnion", N_("_Union"),
2241                       N_("Create union of selected paths"), "union"),
2242     new SelectionVerb(SP_VERB_SELECTION_INTERSECT, "SelectionIntersect", N_("_Intersection"),
2243                       N_("Create intersection of selected paths"), "intersection"),
2244     new SelectionVerb(SP_VERB_SELECTION_DIFF, "SelectionDiff", N_("_Difference"),
2245                       N_("Create difference of selected paths (bottom minus top)"), "difference"),
2246     new SelectionVerb(SP_VERB_SELECTION_SYMDIFF, "SelectionSymDiff", N_("E_xclusion"),
2247                       N_("Create exclusive OR of selected paths (those parts that belong to only one path)"), "exclusion"),
2248     new SelectionVerb(SP_VERB_SELECTION_CUT, "SelectionDivide", N_("Di_vision"),
2249                       N_("Cut the bottom path into pieces"), "division"),
2250     // TRANSLATORS: "to cut a path" is not the same as "to break a path apart" - see the
2251     // Advanced tutorial for more info
2252     new SelectionVerb(SP_VERB_SELECTION_SLICE, "SelectionCutPath", N_("Cut _Path"),
2253                       N_("Cut the bottom path's stroke into pieces, removing fill"), "cut_path"),
2254     // TRANSLATORS: "outset": expand a shape by offsetting the object's path,
2255     // i.e. by displacing it perpendicular to the path in each point.
2256     // See also the Advanced Tutorial for explanation.
2257     new SelectionVerb(SP_VERB_SELECTION_OFFSET, "SelectionOffset", N_("Outs_et"),
2258                       N_("Outset selected paths"), "outset_path"),
2259     new SelectionVerb(SP_VERB_SELECTION_OFFSET_SCREEN, "SelectionOffsetScreen",
2260                       N_("O_utset Path by 1 px"),
2261                       N_("Outset selected paths by 1 px"), NULL),
2262     new SelectionVerb(SP_VERB_SELECTION_OFFSET_SCREEN_10, "SelectionOffsetScreen10",
2263                       N_("O_utset Path by 10 px"),
2264                       N_("Outset selected paths by 10 px"), NULL),
2265     // TRANSLATORS: "inset": contract a shape by offsetting the object's path,
2266     // i.e. by displacing it perpendicular to the path in each point.
2267     // See also the Advanced Tutorial for explanation.
2268     new SelectionVerb(SP_VERB_SELECTION_INSET, "SelectionInset", N_("I_nset"),
2269                       N_("Inset selected paths"), "inset_path"),
2270     new SelectionVerb(SP_VERB_SELECTION_INSET_SCREEN, "SelectionInsetScreen",
2271                       N_("I_nset Path by 1 px"),
2272                       N_("Inset selected paths by 1 px"), NULL),
2273     new SelectionVerb(SP_VERB_SELECTION_INSET_SCREEN_10, "SelectionInsetScreen10",
2274                       N_("I_nset Path by 10 px"),
2275                       N_("Inset selected paths by 10 px"), NULL),
2276     new SelectionVerb(SP_VERB_SELECTION_DYNAMIC_OFFSET, "SelectionDynOffset",
2277                       N_("D_ynamic Offset"), N_("Create a dynamic offset object"), "dynamic_offset"),
2278     new SelectionVerb(SP_VERB_SELECTION_LINKED_OFFSET, "SelectionLinkedOffset",
2279                       N_("_Linked Offset"),
2280                       N_("Create a dynamic offset object linked to the original path"),
2281                       "linked_offset"),
2282     new SelectionVerb(SP_VERB_SELECTION_OUTLINE, "StrokeToPath", N_("_Stroke to Path"),
2283                       N_("Convert selected object's stroke to paths"), "stroke_tocurve"),
2284     new SelectionVerb(SP_VERB_SELECTION_SIMPLIFY, "SelectionSimplify", N_("Si_mplify"),
2285                       N_("Simplify selected paths (remove extra nodes)"), "simplify"),
2286     new SelectionVerb(SP_VERB_SELECTION_REVERSE, "SelectionReverse", N_("_Reverse"),
2287                       N_("Reverse the direction of selected paths (useful for flipping markers)"), "selection_reverse"),
2288     // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize)
2289     new SelectionVerb(SP_VERB_SELECTION_TRACE, "SelectionTrace", N_("_Trace Bitmap..."),
2290                       N_("Create one or more paths from a bitmap by tracing it"), "selection_trace"),
2291     new SelectionVerb(SP_VERB_SELECTION_CREATE_BITMAP, "SelectionCreateBitmap", N_("_Make a Bitmap Copy"),
2292                       N_("Export selection to a bitmap and insert it into document"), "selection_bitmap" ),
2293     new SelectionVerb(SP_VERB_SELECTION_COMBINE, "SelectionCombine", N_("_Combine"),
2294                       N_("Combine several paths into one"), "selection_combine"),
2295     // TRANSLATORS: "to cut a path" is not the same as "to break a path apart" - see the
2296     // Advanced tutorial for more info
2297     new SelectionVerb(SP_VERB_SELECTION_BREAK_APART, "SelectionBreakApart", N_("Break _Apart"),
2298                       N_("Break selected paths into subpaths"), "selection_break"),
2299     new SelectionVerb(SP_VERB_SELECTION_GRIDTILE, "DialogGridArrange", N_("Gri_d Arrange..."),
2300                       N_("Arrange selected objects in a grid pattern"), "grid_arrange"),
2301     /* Layer */
2302     new LayerVerb(SP_VERB_LAYER_NEW, "LayerNew", N_("_Add Layer..."),
2303                   N_("Create a new layer"), "new_layer"),
2304     new LayerVerb(SP_VERB_LAYER_RENAME, "LayerRename", N_("Re_name Layer..."),
2305                   N_("Rename the current layer"), "rename_layer"),
2306     new LayerVerb(SP_VERB_LAYER_NEXT, "LayerNext", N_("Switch to Layer Abov_e"),
2307                   N_("Switch to the layer above the current"), "switch_to_layer_above"),
2308     new LayerVerb(SP_VERB_LAYER_PREV, "LayerPrev", N_("Switch to Layer Belo_w"),
2309                   N_("Switch to the layer below the current"), "switch_to_layer_below"),
2310     new LayerVerb(SP_VERB_LAYER_MOVE_TO_NEXT, "LayerMoveToNext", N_("Move Selection to Layer Abo_ve"),
2311                   N_("Move selection to the layer above the current"), "move_selection_above"),
2312     new LayerVerb(SP_VERB_LAYER_MOVE_TO_PREV, "LayerMoveToPrev", N_("Move Selection to Layer Bel_ow"),
2313                   N_("Move selection to the layer below the current"), "move_selection_below"),
2314     new LayerVerb(SP_VERB_LAYER_TO_TOP, "LayerToTop", N_("Layer to _Top"),
2315                   N_("Raise the current layer to the top"), "layer_to_top"),
2316     new LayerVerb(SP_VERB_LAYER_TO_BOTTOM, "LayerToBottom", N_("Layer to _Bottom"),
2317                   N_("Lower the current layer to the bottom"), "layer_to_bottom"),
2318     new LayerVerb(SP_VERB_LAYER_RAISE, "LayerRaise", N_("_Raise Layer"),
2319                   N_("Raise the current layer"), "raise_layer"),
2320     new LayerVerb(SP_VERB_LAYER_LOWER, "LayerLower", N_("_Lower Layer"),
2321                   N_("Lower the current layer"), "lower_layer"),
2322     new LayerVerb(SP_VERB_LAYER_DELETE, "LayerDelete", N_("_Delete Current Layer"),
2323                   N_("Delete the current layer"), "delete_layer"),
2324
2325     /* Object */
2326     new ObjectVerb(SP_VERB_OBJECT_ROTATE_90_CW, "ObjectRotate90", N_("Rotate _90&#176; CW"),
2327                    // This is shared between tooltips and statusbar, so they
2328                    // must use UTF-8, not HTML entities for special characters.
2329                    N_("Rotate selection 90\xc2\xb0 clockwise"), "object_rotate_90_CW"),
2330     new ObjectVerb(SP_VERB_OBJECT_ROTATE_90_CCW, "ObjectRotate90CCW", N_("Rotate 9_0&#176; CCW"),
2331                    // This is shared between tooltips and statusbar, so they
2332                    // must use UTF-8, not HTML entities for special characters.
2333                    N_("Rotate selection 90\xc2\xb0 counter-clockwise"), "object_rotate_90_CCW"),
2334     new ObjectVerb(SP_VERB_OBJECT_FLATTEN, "ObjectRemoveTransform", N_("Remove _Transformations"),
2335                    N_("Remove transformations from object"), "object_reset"),
2336     new ObjectVerb(SP_VERB_OBJECT_TO_CURVE, "ObjectToPath", N_("_Object to Path"),
2337                    N_("Convert selected object to path"), "object_tocurve"),
2338     new ObjectVerb(SP_VERB_OBJECT_FLOW_TEXT, "ObjectFlowText", N_("_Flow into Frame"),
2339                    N_("Put text into a frame (path or shape), creating a flowed text linked to the frame object"), "flow_into_frame"),
2340     new ObjectVerb(SP_VERB_OBJECT_UNFLOW_TEXT, "ObjectUnFlowText", N_("_Unflow"),
2341                    N_("Remove text from frame (creates a single-line text object)"), "unflow"),
2342     new ObjectVerb(SP_VERB_OBJECT_FLOWTEXT_TO_TEXT, "ObjectFlowtextToText", N_("_Convert to Text"),
2343                    N_("Convert flowed text to regular text object (preserves appearance)"), "convert_to_text"),
2344     new ObjectVerb(SP_VERB_OBJECT_FLIP_HORIZONTAL, "ObjectFlipHorizontally",
2345                    N_("Flip _Horizontal"), N_("Flip selected objects horizontally"),
2346                    "object_flip_hor"),
2347     new ObjectVerb(SP_VERB_OBJECT_FLIP_VERTICAL, "ObjectFlipVertically",
2348                    N_("Flip _Vertical"), N_("Flip selected objects vertically"),
2349                    "object_flip_ver"),
2350     new ObjectVerb(SP_VERB_OBJECT_SET_MASK, "ObjectSetMask", N_("_Set"),
2351                  N_("Apply mask to selection (using the topmost object as mask)"), NULL),
2352     new ObjectVerb(SP_VERB_OBJECT_UNSET_MASK, "ObjectUnSetMask", N_("_Release"),
2353                  N_("Remove mask from selection"), NULL),
2354     new ObjectVerb(SP_VERB_OBJECT_SET_CLIPPATH, "ObjectSetClipPath", N_("_Set"),
2355                  N_("Apply clipping path to selection (using the topmost object as clipping path)"), NULL),
2356     new ObjectVerb(SP_VERB_OBJECT_UNSET_CLIPPATH, "ObjectUnSetClipPath", N_("_Release"),
2357                  N_("Remove clipping path from selection"), NULL),
2358
2359     /* Tools */
2360     new ContextVerb(SP_VERB_CONTEXT_SELECT, "ToolSelector", N_("Select"),
2361                     N_("Select and transform objects"), "draw_select"),
2362     new ContextVerb(SP_VERB_CONTEXT_NODE, "ToolNode", N_("Node Edit"),
2363                     N_("Edit paths by nodes"), "draw_node"),
2364     new ContextVerb(SP_VERB_CONTEXT_TWEAK, "ToolTweak", N_("Tweak"),
2365                     N_("Tweak objects by sculpting or painting"), "draw_tweak"),
2366     new ContextVerb(SP_VERB_CONTEXT_RECT, "ToolRect", N_("Rectangle"),
2367                     N_("Create rectangles and squares"), "draw_rect"),
2368     new ContextVerb(SP_VERB_CONTEXT_3DBOX, "Tool3DBox", N_("3D Box"),
2369                     N_("Create 3D boxes"), "draw_3dbox"),
2370     new ContextVerb(SP_VERB_CONTEXT_ARC, "ToolArc", N_("Ellipse"),
2371                     N_("Create circles, ellipses, and arcs"), "draw_arc"),
2372     new ContextVerb(SP_VERB_CONTEXT_STAR, "ToolStar", N_("Star"),
2373                     N_("Create stars and polygons"), "draw_star"),
2374     new ContextVerb(SP_VERB_CONTEXT_SPIRAL, "ToolSpiral", N_("Spiral"),
2375                     N_("Create spirals"), "draw_spiral"),
2376     new ContextVerb(SP_VERB_CONTEXT_PENCIL, "ToolPencil", N_("Pencil"),
2377                     N_("Draw freehand lines"), "draw_freehand"),
2378     new ContextVerb(SP_VERB_CONTEXT_PEN, "ToolPen", N_("Pen"),
2379                     N_("Draw Bezier curves and straight lines"), "draw_pen"),
2380     new ContextVerb(SP_VERB_CONTEXT_CALLIGRAPHIC, "ToolCalligraphic", N_("Calligraphy"),
2381                     N_("Draw calligraphic or brush strokes"), "draw_calligraphic"),
2382     new ContextVerb(SP_VERB_CONTEXT_TEXT, "ToolText", N_("Text"),
2383                     N_("Create and edit text objects"), "draw_text"),
2384     new ContextVerb(SP_VERB_CONTEXT_GRADIENT, "ToolGradient", N_("Gradient"),
2385                     N_("Create and edit gradients"), "draw_gradient"),
2386     new ContextVerb(SP_VERB_CONTEXT_ZOOM, "ToolZoom", N_("Zoom"),
2387                     N_("Zoom in or out"), "draw_zoom"),
2388     new ContextVerb(SP_VERB_CONTEXT_DROPPER, "ToolDropper", N_("Dropper"),
2389                     N_("Pick colors from image"), "draw_dropper"),
2390     new ContextVerb(SP_VERB_CONTEXT_CONNECTOR, "ToolConnector", N_("Connector"),
2391                     N_("Create diagram connectors"), "draw_connector"),
2392     new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET, "ToolPaintBucket", N_("Paint Bucket"),
2393                     N_("Fill bounded areas"), "draw_paintbucket"),
2394
2395     /* Tool prefs */
2396     new ContextVerb(SP_VERB_CONTEXT_SELECT_PREFS, "SelectPrefs", N_("Selector Preferences"),
2397                     N_("Open Preferences for the Selector tool"), NULL),
2398     new ContextVerb(SP_VERB_CONTEXT_NODE_PREFS, "NodePrefs", N_("Node Tool Preferences"),
2399                     N_("Open Preferences for the Node tool"), NULL),
2400     new ContextVerb(SP_VERB_CONTEXT_TWEAK_PREFS, "TweakPrefs", N_("Tweak Tool Preferences"),
2401                     N_("Open Preferences for the Tweak tool"), NULL),
2402     new ContextVerb(SP_VERB_CONTEXT_RECT_PREFS, "RectPrefs", N_("Rectangle Preferences"),
2403                     N_("Open Preferences for the Rectangle tool"), NULL),
2404     new ContextVerb(SP_VERB_CONTEXT_3DBOX_PREFS, "3DBoxPrefs", N_("3D Box Preferences"),
2405                     N_("Open Preferences for the 3D Box tool"), NULL),
2406     new ContextVerb(SP_VERB_CONTEXT_ARC_PREFS, "ArcPrefs", N_("Ellipse Preferences"),
2407                     N_("Open Preferences for the Ellipse tool"), NULL),
2408     new ContextVerb(SP_VERB_CONTEXT_STAR_PREFS, "StarPrefs", N_("Star Preferences"),
2409                     N_("Open Preferences for the Star tool"), NULL),
2410     new ContextVerb(SP_VERB_CONTEXT_SPIRAL_PREFS, "SpiralPrefs", N_("Spiral Preferences"),
2411                     N_("Open Preferences for the Spiral tool"), NULL),
2412     new ContextVerb(SP_VERB_CONTEXT_PENCIL_PREFS, "PencilPrefs", N_("Pencil Preferences"),
2413                     N_("Open Preferences for the Pencil tool"), NULL),
2414     new ContextVerb(SP_VERB_CONTEXT_PEN_PREFS, "PenPrefs", N_("Pen Preferences"),
2415                     N_("Open Preferences for the Pen tool"), NULL),
2416     new ContextVerb(SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "CalligraphicPrefs", N_("Calligraphic Preferences"),
2417                     N_("Open Preferences for the Calligraphy tool"), NULL),
2418     new ContextVerb(SP_VERB_CONTEXT_TEXT_PREFS, "TextPrefs", N_("Text Preferences"),
2419                     N_("Open Preferences for the Text tool"), NULL),
2420     new ContextVerb(SP_VERB_CONTEXT_GRADIENT_PREFS, "GradientPrefs", N_("Gradient Preferences"),
2421                     N_("Open Preferences for the Gradient tool"), NULL),
2422     new ContextVerb(SP_VERB_CONTEXT_ZOOM_PREFS, "ZoomPrefs", N_("Zoom Preferences"),
2423                     N_("Open Preferences for the Zoom tool"), NULL),
2424     new ContextVerb(SP_VERB_CONTEXT_DROPPER_PREFS, "DropperPrefs", N_("Dropper Preferences"),
2425                     N_("Open Preferences for the Dropper tool"), NULL),
2426     new ContextVerb(SP_VERB_CONTEXT_CONNECTOR_PREFS, "ConnectorPrefs", N_("Connector Preferences"),
2427                     N_("Open Preferences for the Connector tool"), NULL),
2428     new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "PaintBucketPrefs", N_("Paint Bucket Preferences"),
2429                     N_("Open Preferences for the Paint Bucket tool"), NULL),
2430
2431     /* Zoom/View */
2432     new ZoomVerb(SP_VERB_ZOOM_IN, "ZoomIn", N_("Zoom In"), N_("Zoom in"), "zoom_in"),
2433     new ZoomVerb(SP_VERB_ZOOM_OUT, "ZoomOut", N_("Zoom Out"), N_("Zoom out"), "zoom_out"),
2434     new ZoomVerb(SP_VERB_TOGGLE_RULERS, "ToggleRulers", N_("_Rulers"), N_("Show or hide the canvas rulers"), "rulers"),
2435     new ZoomVerb(SP_VERB_TOGGLE_SCROLLBARS, "ToggleScrollbars", N_("Scroll_bars"), N_("Show or hide the canvas scrollbars"), "scrollbars"),
2436     new ZoomVerb(SP_VERB_TOGGLE_GRID, "ToggleGrid", N_("_Grid"), N_("Show or hide the grid"), "grid"),
2437     new ZoomVerb(SP_VERB_TOGGLE_GUIDES, "ToggleGuides", N_("G_uides"), N_("Show or hide guides (drag from a ruler to create a guide)"), "guides"),
2438     new ZoomVerb(SP_VERB_ZOOM_NEXT, "ZoomNext", N_("Nex_t Zoom"), N_("Next zoom (from the history of zooms)"),
2439                  "zoom_next"),
2440     new ZoomVerb(SP_VERB_ZOOM_PREV, "ZoomPrev", N_("Pre_vious Zoom"), N_("Previous zoom (from the history of zooms)"),
2441                  "zoom_previous"),
2442     new ZoomVerb(SP_VERB_ZOOM_1_1, "Zoom1:0", N_("Zoom 1:_1"), N_("Zoom to 1:1"),
2443                  "zoom_1_to_1"),
2444     new ZoomVerb(SP_VERB_ZOOM_1_2, "Zoom1:2", N_("Zoom 1:_2"), N_("Zoom to 1:2"),
2445                  "zoom_1_to_2"),
2446     new ZoomVerb(SP_VERB_ZOOM_2_1, "Zoom2:1", N_("_Zoom 2:1"), N_("Zoom to 2:1"),
2447                  "zoom_2_to_1"),
2448 #ifdef HAVE_GTK_WINDOW_FULLSCREEN
2449     new ZoomVerb(SP_VERB_FULLSCREEN, "FullScreen", N_("_Fullscreen"), N_("Stretch this document window to full screen"),
2450                  "fullscreen"),
2451 #endif /* HAVE_GTK_WINDOW_FULLSCREEN */
2452     new ZoomVerb(SP_VERB_VIEW_NEW, "ViewNew", N_("Duplic_ate Window"), N_("Open a new window with the same document"),
2453                  "view_new"),
2454     new ZoomVerb(SP_VERB_VIEW_NEW_PREVIEW, "ViewNewPreview", N_("_New View Preview"),
2455                  N_("New View Preview"), NULL/*"view_new_preview"*/),
2456
2457     new ZoomVerb(SP_VERB_VIEW_MODE_NORMAL, "ViewModeNormal", N_("_Normal"),
2458                  N_("Switch to normal display mode"), NULL),
2459     new ZoomVerb(SP_VERB_VIEW_MODE_OUTLINE, "ViewModeOutline", N_("_Outline"),
2460                  N_("Switch to outline (wireframe) display mode"), NULL),
2461     new ZoomVerb(SP_VERB_VIEW_MODE_TOGGLE, "ViewModeToggle", N_("_Toggle"),
2462                  N_("Toggle between normal and outline display modes"), NULL),
2463
2464     new ZoomVerb(SP_VERB_VIEW_CMS_TOGGLE, "ViewCmsToggle", N_("Display Adjustment"),
2465                  N_("Toggle CMS display adjustment on and off"), "swatches"),
2466
2467     new ZoomVerb(SP_VERB_VIEW_ICON_PREVIEW, "ViewIconPreview", N_("Ico_n Preview..."),
2468                  N_("Open a window to preview objects at different icon resolutions"), "view_icon_preview"),
2469     new ZoomVerb(SP_VERB_ZOOM_PAGE, "ZoomPage", N_("_Page"),
2470                  N_("Zoom to fit page in window"), "zoom_page"),
2471     new ZoomVerb(SP_VERB_ZOOM_PAGE_WIDTH, "ZoomPageWidth", N_("Page _Width"),
2472                  N_("Zoom to fit page width in window"), "zoom_pagewidth"),
2473     new ZoomVerb(SP_VERB_ZOOM_DRAWING, "ZoomDrawing", N_("_Drawing"),
2474                  N_("Zoom to fit drawing in window"), "zoom_draw"),
2475     new ZoomVerb(SP_VERB_ZOOM_SELECTION, "ZoomSelection", N_("_Selection"),
2476                  N_("Zoom to fit selection in window"), "zoom_select"),
2477
2478     /* Dialogs */
2479     new DialogVerb(SP_VERB_DIALOG_DISPLAY, "DialogPreferences", N_("In_kscape Preferences..."),
2480                    N_("Edit global Inkscape preferences"), GTK_STOCK_PREFERENCES ),
2481     new DialogVerb(SP_VERB_DIALOG_NAMEDVIEW, "DialogDocumentProperties", N_("_Document Properties..."),
2482                    N_("Edit properties of this document (to be saved with the document)"), GTK_STOCK_PROPERTIES ),
2483     new DialogVerb(SP_VERB_DIALOG_METADATA, "DialogMetadata", N_("Document _Metadata..."),
2484                    N_("Edit document metadata (to be saved with the document)"), "document_metadata" ),
2485     new DialogVerb(SP_VERB_DIALOG_FILL_STROKE, "DialogFillStroke", N_("_Fill and Stroke..."),
2486                    N_("Edit objects' colors, gradients, stroke width, arrowheads, dash patterns..."), "fill_and_stroke"),
2487     // TRANSLATORS: "Swatches" means: color samples
2488     new DialogVerb(SP_VERB_DIALOG_SWATCHES, "DialogSwatches", N_("S_watches..."),
2489                    N_("Select colors from a swatches palette"), GTK_STOCK_SELECT_COLOR),
2490     new DialogVerb(SP_VERB_DIALOG_TRANSFORM, "DialogTransform", N_("Transfor_m..."),
2491                    N_("Precisely control objects' transformations"), "object_trans"),
2492     new DialogVerb(SP_VERB_DIALOG_ALIGN_DISTRIBUTE, "DialogAlignDistribute", N_("_Align and Distribute..."),
2493                    N_("Align and distribute objects"), "object_align"),
2494     new DialogVerb(SP_VERB_DIALOG_UNDO_HISTORY, "DialogUndoHistory", N_("Undo _History..."),
2495                    N_("Undo History"), "edit_undo_history"),
2496     new DialogVerb(SP_VERB_DIALOG_TEXT, "DialogText", N_("_Text and Font..."),
2497                    N_("View and select font family, font size and other text properties"), "object_font"),
2498     new DialogVerb(SP_VERB_DIALOG_XML_EDITOR, "DialogXMLEditor", N_("_XML Editor..."),
2499                    N_("View and edit the XML tree of the document"), "xml_editor"),
2500     new DialogVerb(SP_VERB_DIALOG_FIND, "DialogFind", N_("_Find..."),
2501                    N_("Find objects in document"), GTK_STOCK_FIND ),
2502     new DialogVerb(SP_VERB_DIALOG_DEBUG, "DialogDebug", N_("_Messages..."),
2503                    N_("View debug messages"), "messages"),
2504     new DialogVerb(SP_VERB_DIALOG_SCRIPT, "DialogScript", N_("S_cripts..."),
2505                    N_("Run scripts"), "scripts"),
2506     new DialogVerb(SP_VERB_DIALOG_TOGGLE, "DialogsToggle", N_("Show/Hide D_ialogs"),
2507                    N_("Show or hide all open dialogs"), "dialog_toggle"),
2508     new DialogVerb(SP_VERB_DIALOG_CLONETILER, "DialogClonetiler", N_("Create Tiled Clones..."),
2509                    N_("Create multiple clones of selected object, arranging them into a pattern or scattering"), "edit_create_tiled_clones"),
2510     new DialogVerb(SP_VERB_DIALOG_ITEM, "DialogObjectProperties", N_("_Object Properties..."),
2511                    N_("Edit the ID, locked and visible status, and other object properties"), "dialog_item_properties"),
2512 #ifdef WITH_INKBOARD
2513     new DialogVerb(SP_VERB_XMPP_CLIENT, "DialogXmppClient",
2514                    N_("_Instant Messaging..."), N_("Jabber Instant Messaging Client"), NULL),
2515 #endif
2516     new DialogVerb(SP_VERB_DIALOG_INPUT, "DialogInput", N_("_Input Devices..."),
2517                    N_("Configure extended input devices, such as a graphics tablet"), "input_devices"),
2518     new DialogVerb(SP_VERB_DIALOG_EXTENSIONEDITOR, "org.inkscape.dialogs.extensioneditor", N_("_Extensions..."),
2519                    N_("Query information about extensions"), NULL),
2520     new DialogVerb(SP_VERB_DIALOG_LAYERS, "DialogLayers", N_("Layer_s..."),
2521                    N_("View Layers"), "layers"),
2522     new DialogVerb(SP_VERB_DIALOG_LIVE_PATH_EFFECT, "DialogLivePathEffect", N_("Path Effects..."),
2523                    N_("Manage path effects"), NULL),
2524     new DialogVerb(SP_VERB_DIALOG_FILTER_EFFECTS, "DialogFilterEffects", N_("Filter Effects..."),
2525                    N_("Manage SVG filter effects"), NULL),
2526
2527     /* Help */
2528     new HelpVerb(SP_VERB_HELP_ABOUT_EXTENSIONS, "HelpAboutExtensions", N_("About E_xtensions"),
2529                  N_("Information on Inkscape extensions"), NULL),
2530     new HelpVerb(SP_VERB_HELP_MEMORY, "HelpAboutMemory", N_("About _Memory"),
2531                  N_("Memory usage information"), "about_memory"),
2532     new HelpVerb(SP_VERB_HELP_ABOUT, "HelpAbout", N_("_About Inkscape"),
2533                  N_("Inkscape version, authors, license"), /*"help_about"*/"inkscape_options"),
2534     //new HelpVerb(SP_VERB_SHOW_LICENSE, "ShowLicense", N_("_License"),
2535     //           N_("Distribution terms"), /*"show_license"*/"inkscape_options"),
2536
2537     /* Tutorials */
2538     new TutorialVerb(SP_VERB_TUTORIAL_BASIC, "TutorialsBasic", N_("Inkscape: _Basic"),
2539                      N_("Getting started with Inkscape"), NULL/*"tutorial_basic"*/),
2540     new TutorialVerb(SP_VERB_TUTORIAL_SHAPES, "TutorialsShapes", N_("Inkscape: _Shapes"),
2541                      N_("Using shape tools to create and edit shapes"), NULL),
2542     new TutorialVerb(SP_VERB_TUTORIAL_ADVANCED, "TutorialsAdvanced", N_("Inkscape: _Advanced"),
2543                      N_("Advanced Inkscape topics"), NULL/*"tutorial_advanced"*/),
2544     // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize)
2545     new TutorialVerb(SP_VERB_TUTORIAL_TRACING, "TutorialsTracing", N_("Inkscape: T_racing"),
2546                      N_("Using bitmap tracing"), NULL/*"tutorial_tracing"*/),
2547     new TutorialVerb(SP_VERB_TUTORIAL_CALLIGRAPHY, "TutorialsCalligraphy", N_("Inkscape: _Calligraphy"),
2548                      N_("Using the Calligraphy pen tool"), NULL),
2549     new TutorialVerb(SP_VERB_TUTORIAL_DESIGN, "TutorialsDesign", N_("_Elements of Design"),
2550                      N_("Principles of design in the tutorial form"), NULL/*"tutorial_design"*/),
2551     new TutorialVerb(SP_VERB_TUTORIAL_TIPS, "TutorialsTips", N_("_Tips and Tricks"),
2552                      N_("Miscellaneous tips and tricks"), NULL/*"tutorial_tips"*/),
2553
2554     /* Effect */
2555     new EffectLastVerb(SP_VERB_EFFECT_LAST, "EffectLast", N_("Previous Effect"),
2556                        N_("Repeat the last effect with the same settings"), NULL),
2557     new EffectLastVerb(SP_VERB_EFFECT_LAST_PREF, "EffectLastPref", N_("Previous Effect Settings..."),
2558                        N_("Repeat the last effect with new settings"), NULL),
2559
2560     /* Fit Page */
2561     new FitCanvasVerb(SP_VERB_FIT_CANVAS_TO_SELECTION, "FitCanvasToSelection", N_("Fit Page to Selection"),
2562                        N_("Fit the page to the current selection"), NULL),
2563     new FitCanvasVerb(SP_VERB_FIT_CANVAS_TO_DRAWING, "FitCanvasToDrawing", N_("Fit Page to Drawing"),
2564                        N_("Fit the page to the drawing"), NULL),
2565     new FitCanvasVerb(SP_VERB_FIT_CANVAS_TO_SELECTION_OR_DRAWING, "FitCanvasToSelectionOrDrawing", N_("Fit Page to Selection or Drawing"),
2566                        N_("Fit the page to the current selection or the drawing if there is no selection"), NULL),
2567     /* LockAndHide */
2568     new LockAndHideVerb(SP_VERB_UNLOCK_ALL, "UnlockAll", N_("Unlock All"),
2569                        N_("Unlock all objects in the current layer"), NULL),
2570     new LockAndHideVerb(SP_VERB_UNLOCK_ALL_IN_ALL_LAYERS, "UnlockAllInAllLayers", N_("Unlock All in All Layers"),
2571                        N_("Unlock all objects in all layers"), NULL),
2572     new LockAndHideVerb(SP_VERB_UNHIDE_ALL, "UnhideAll", N_("Unhide All"),
2573                        N_("Unhide all objects in the current layer"), NULL),
2574     new LockAndHideVerb(SP_VERB_UNHIDE_ALL_IN_ALL_LAYERS, "UnhideAllInAllLayers", N_("Unhide All in All Layers"),
2575                        N_("Unhide all objects in all layers"), NULL),
2576     /* Footer */
2577     new Verb(SP_VERB_LAST, " '\"invalid id", NULL, NULL, NULL)
2578 };
2579
2580
2581 void
2582 Verb::list (void) {
2583     // Go through the dynamic verb table
2584     for (VerbTable::iterator iter = _verbs.begin(); iter != _verbs.end(); iter++) {
2585         Verb * verb = iter->second;
2586         if (verb->get_code() == SP_VERB_INVALID ||
2587                 verb->get_code() == SP_VERB_NONE ||
2588                 verb->get_code() == SP_VERB_LAST) {
2589             continue;
2590         }
2591
2592         printf("%s: %s\n", verb->get_id(), verb->get_tip()? verb->get_tip() : verb->get_name());
2593     }
2594
2595     return;
2596 };
2597
2598 }  /* namespace Inkscape */
2599
2600 /*
2601   Local Variables:
2602   mode:c++
2603   c-file-style:"stroustrup"
2604   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
2605   indent-tabs-mode:nil
2606   fill-column:99
2607   End:
2608 */
2609 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :