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