src/verbs.cpp

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