src/verbs.cpp

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