src/extension/extension.cpp

   1 #define __SP_MODULE_C__
   2 /** \file
   3  *
   4  * Inkscape::Extension::Extension:
   5  * the ability to have features that are more modular so that they
   6  * can be added and removed easily.  This is the basis for defining
   7  * those actions.
   8  */
   9
  10 /*
  11  * Authors:
  12  *   Ted Gould <ted@gould.cx>
  13  *
  14  * Copyright (C) 2002-2005 Authors
  15  *
  16  * Released under GNU GPL, read the file 'COPYING' for more information
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23
  24 #include <glibmm/i18n.h>
  25 #include <gtkmm/box.h>
  26 #include <gtkmm/label.h>
  27 #include <gtkmm/frame.h>
  28 #include <gtkmm/table.h>
  29 #include <gtkmm/tooltips.h>
  30
  31 #include "inkscape.h"
  32 #include "extension/implementation/implementation.h"
  33
  34 #include "db.h"
  35 #include "dependency.h"
  36 #include "timer.h"
  37 #include "parameter.h"
  38
  39 namespace Inkscape {
  40 namespace Extension {
  41
  42 /* Inkscape::Extension::Extension */
  43
  44 std::vector<const gchar *> Extension::search_path;
  45 std::ofstream Extension::error_file;
  46
  47 Parameter * param_shared (const gchar * name, GSList * list);
  48
  49 /**
  50     \return  none
  51     \brief   Constructs an Extension from a Inkscape::XML::Node
  52     \param   in_repr    The repr that should be used to build it
  53
  54     This function is the basis of building an extension for Inkscape.  It
  55     currently extracts the fields from the Repr that are used in the
  56     extension.  The Repr will likely include other children that are
  57     not related to the module directly.  If the Repr does not include
  58     a name and an ID the module will be left in an errored state.
  59 */
  60 Extension::Extension (Inkscape::XML::Node * in_repr, Implementation::Implementation * in_imp) : _help(NULL)
  61 {
  62     repr = in_repr;
  63     Inkscape::GC::anchor(in_repr);
  64
  65     id = NULL;
  66     name = NULL;
  67     _state = STATE_UNLOADED;
  68     parameters = NULL;
  69
  70     if (in_imp == NULL) {
  71         imp = new Implementation::Implementation();
  72     } else {
  73         imp = in_imp;
  74     }
  75
  76     // printf("Extension Constructor: ");
  77     if (repr != NULL) {
  78         Inkscape::XML::Node *child_repr = sp_repr_children(repr);
  79         /* TODO: Handle what happens if we don't have these two */
  80         while (child_repr != NULL) {
  81             char const * chname = child_repr->name();
  82             if (chname[0] == '_') /* Allow _ for translation of tags */
  83                 chname++;
  84             if (!strcmp(chname, "id")) {
  85                 gchar const *val = sp_repr_children(child_repr)->content();
  86                 id = g_strdup (val);
  87             } /* id */
  88             if (!strcmp(chname, "name")) {
  89                 name = g_strdup (sp_repr_children(child_repr)->content());
  90             } /* name */
  91             if (!strcmp(chname, "help")) {
  92                 _help = g_strdup (sp_repr_children(child_repr)->content());
  93             } /* name */
  94             if (!strcmp(chname, "param") || !strcmp(chname, "_param")) {
  95                 Parameter * param;
  96                 param = Parameter::make(child_repr, this);
  97                 if (param != NULL)
  98                     parameters = g_slist_append(parameters, param);
  99             } /* param || _param */
 100             if (!strcmp(chname, "dependency")) {
 101                 _deps.push_back(new Dependency(child_repr));
 102             } /* dependency */
 103             child_repr = sp_repr_next(child_repr);
 104         }
 105
 106         db.register_ext (this);
 107     }
 108     // printf("%s\n", name);
 109     timer = NULL;
 110
 111     return;
 112 }
 113
 114 /**
 115     \return   none
 116     \brief    Destroys the Extension
 117
 118     This function frees all of the strings that could be attached
 119     to the extension and also unreferences the repr.  This is better
 120     than freeing it because it may (I wouldn't know why) be referenced
 121     in another place.
 122 */
 123 Extension::~Extension (void)
 124 {
 125 //    printf("Extension Destructor: %s\n", name);
 126     set_state(STATE_UNLOADED);
 127     db.unregister_ext(this);
 128     Inkscape::GC::release(repr);
 129     g_free(id);
 130     g_free(name);
 131     delete timer;
 132     timer = NULL;
 133     /** \todo Need to do parameters here */
 134
 135     // delete parameters:
 136     for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) {
 137         Parameter * param = reinterpret_cast<Parameter *>(list->data);
 138         delete param;
 139     }
 140     g_slist_free(parameters);
 141
 142
 143     for (unsigned int i = 0 ; i < _deps.size(); i++) {
 144         delete _deps[i];
 145     }
 146     _deps.clear();
 147
 148     return;
 149 }
 150
 151 /**
 152     \return   none
 153     \brief    A function to set whether the extension should be loaded
 154               or unloaded
 155     \param    in_state  Which state should the extension be in?
 156
 157     It checks to see if this is a state change or not.  If we're changing
 158     states it will call the appropriate function in the implementation,
 159     load or unload.  Currently, there is no error checking in this
 160     function.  There should be.
 161 */
 162 void
 163 Extension::set_state (state_t in_state)
 164 {
 165     if (_state == STATE_DEACTIVATED) return;
 166     if (in_state != _state) {
 167         /** \todo Need some more error checking here! */
 168         switch (in_state) {
 169             case STATE_LOADED:
 170                 if (imp->load(this))
 171                     _state = STATE_LOADED;
 172
 173                 if (timer != NULL) {
 174                     delete timer;
 175                 }
 176                 timer = new ExpirationTimer(this);
 177
 178                 break;
 179             case STATE_UNLOADED:
 180                 // std::cout << "Unloading: " << name << std::endl;
 181                 imp->unload(this);
 182                 _state = STATE_UNLOADED;
 183
 184                 if (timer != NULL) {
 185                     delete timer;
 186                     timer = NULL;
 187                 }
 188                 break;
 189             case STATE_DEACTIVATED:
 190                 _state = STATE_DEACTIVATED;
 191
 192                 if (timer != NULL) {
 193                     delete timer;
 194                     timer = NULL;
 195                 }
 196                 break;
 197             default:
 198                 break;
 199         }
 200     }
 201
 202     return;
 203 }
 204
 205 /**
 206     \return   The state the extension is in
 207     \brief    A getter for the state variable.
 208 */
 209 Extension::state_t
 210 Extension::get_state (void)
 211 {
 212     return _state;
 213 }
 214
 215 /**
 216     \return  Whether the extension is loaded or not
 217     \brief   A quick function to test the state of the extension
 218 */
 219 bool
 220 Extension::loaded (void)
 221 {
 222     return get_state() == STATE_LOADED;
 223 }
 224
 225 /**
 226     \return  A boolean saying whether the extension passed the checks
 227     \brief   A function to check the validity of the extension
 228
 229     This function chekcs to make sure that there is an id, a name, a
 230     repr and an implemenation for this extension.  Then it checks all
 231     of the dependencies to see if they pass.  Finally, it asks the
 232     implmentation to do a check of itself.
 233
 234     On each check, if there is a failure, it will print a message to the
 235     error log for that failure.  It is important to note that the function
 236     keeps executing if it finds an error, to try and get as many of them
 237     into the error log as possible.  This should help people debug
 238     installations, and figure out what they need to get for the full
 239     functionality of Inkscape to be available.
 240 */
 241 bool
 242 Extension::check (void)
 243 {
 244     bool retval = true;
 245
 246     // static int i = 0;
 247     // std::cout << "Checking module[" << i++ << "]: " << name << std::endl;
 248
 249     const char * inx_failure = _("  This is caused by an improper .inx file for this extension."
 250                                  "  An improper .inx file could have been caused by a faulty installation of Inkscape.");
 251     if (id == NULL) {
 252         printFailure(Glib::ustring(_("an ID was not defined for it.")) + inx_failure);
 253         retval = false;
 254     }
 255     if (name == NULL) {
 256         printFailure(Glib::ustring(_("there was no name defined for it.")) + inx_failure);
 257         retval = false;
 258     }
 259     if (repr == NULL) {
 260         printFailure(Glib::ustring(_("the XML description of it got lost.")) + inx_failure);
 261         retval = false;
 262     }
 263     if (imp == NULL) {
 264         printFailure(Glib::ustring(_("no implementation was defined for the extension.")) + inx_failure);
 265         retval = false;
 266     }
 267
 268     for (unsigned int i = 0 ; i < _deps.size(); i++) {
 269         if (_deps[i]->check() == FALSE) {
 270             // std::cout << "Failed: " << *(_deps[i]) << std::endl;
 271             printFailure(Glib::ustring(_("a dependency was not met.")));
 272             error_file << *_deps[i] << std::endl;
 273             retval = false;
 274         }
 275     }
 276
 277     if (retval)
 278         return imp->check(this);
 279     return retval;
 280 }
 281
 282 /** \brief A quick function to print out a standard start of extension
 283            errors in the log.
 284     \param reason  A string explaining why this failed
 285
 286     Real simple, just put everything into \c error_file.
 287 */
 288 void
 289 Extension::printFailure (Glib::ustring reason)
 290 {
 291         error_file << _("Extension \"") << name << _("\" failed to load because ");
 292         error_file << reason.raw();
 293         error_file << std::endl;
 294         return;
 295 }
 296
 297 /**
 298     \return  The XML tree that is used to define the extension
 299     \brief   A getter for the internal Repr, does not add a reference.
 300 */
 301 Inkscape::XML::Node *
 302 Extension::get_repr (void)
 303 {
 304     return repr;
 305 }
 306
 307 /**
 308     \return  The textual id of this extension
 309     \brief   Get the ID of this extension - not a copy don't delete!
 310 */
 311 gchar *
 312 Extension::get_id (void)
 313 {
 314     return id;
 315 }
 316
 317 /**
 318     \return  The textual name of this extension
 319     \brief   Get the name of this extension - not a copy don't delete!
 320 */
 321 gchar *
 322 Extension::get_name (void)
 323 {
 324     return name;
 325 }
 326
 327 /**
 328     \return  None
 329     \brief   This function diactivates the extension (which makes it
 330              unusable, but not deleted)
 331
 332     This function is used to removed an extension from functioning, but
 333     not delete it completely.  It sets the state to \c STATE_DEACTIVATED to
 334     mark to the world that it has been deactivated.  It also removes
 335     the current implementation and replaces it with a standard one.  This
 336     makes it so that we don't have to continually check if there is an
 337     implementation, but we are gauranteed to have a benign one.
 338
 339     \warning It is important to note that there is no 'activate' function.
 340     Running this function is irreversable.
 341 */
 342 void
 343 Extension::deactivate (void)
 344 {
 345     set_state(STATE_DEACTIVATED);
 346
 347     /* Removing the old implementation, and making this use the default. */
 348     /* This should save some memory */
 349     delete imp;
 350     imp = new Implementation::Implementation();
 351
 352     return;
 353 }
 354
 355 /**
 356     \return  Whether the extension has been deactivated
 357     \brief   Find out the status of the extension
 358 */
 359 bool
 360 Extension::deactivated (void)
 361 {
 362     return get_state() == STATE_DEACTIVATED;
 363 }
 364
 365 /**
 366     \return    Parameter structure with a name of 'name'
 367     \brief     This function looks through the linked list for a parameter
 368                structure with the name of the passed in name
 369     \param     name   The name to search for
 370     \param     list   The list to look for
 371
 372     This is an inline function that is used by all the get_param and
 373     set_param functions to find a param_t in the linked list with
 374     the passed in name.  It is done as an inline so that it will be
 375     optimized into a 'jump' by the compiler.
 376
 377     This function can throw a 'param_not_exist' exception if the
 378     name is not found.
 379
 380     The first thing that this function checks is if the list is NULL.
 381     It could be NULL because there are no parameters for this extension
 382     or because all of them have been checked (I'll spoil the ending and
 383     tell you that this function is called recursively).  If the list
 384     is NULL then the 'param_not_exist' exception is thrown.
 385
 386     Otherwise, the function looks at the current param_t that the element
 387     list points to.  If the name of that param_t matches the passed in
 388     name then that param_t is returned.  Otherwise, this function is
 389     called again with g_slist_next as a parameter.
 390 */
 391 Parameter *
 392 param_shared (const gchar * name, GSList * list)
 393 {
 394     Parameter * output;
 395
 396     if (name == NULL) {
 397         throw Extension::param_not_exist();
 398     }
 399     if (list == NULL) {
 400         throw Extension::param_not_exist();
 401     }
 402
 403     output = static_cast<Parameter *>(list->data);
 404     if (!strcmp(output->name(), name)) {
 405         return output;
 406     }
 407
 408     return param_shared(name, g_slist_next(list));
 409 }
 410
 411 /**
 412     \return   A constant pointer to the string held by the parameters.
 413     \brief    Gets a parameter identified by name with the string placed
 414               in value.  It isn't duplicated into the value string.
 415     \param    name    The name of the parameter to get
 416     \param    doc    The document to look in for document specific parameters
 417     \param    node   The node to look in for a specific parameter
 418
 419     Look up in the parameters list, then execute the function on that
 420     found parameter.
 421 */
 422 const gchar *
 423 Extension::get_param_string (const gchar * name, const SPDocument * doc, const Inkscape::XML::Node * node)
 424 {
 425     Parameter * param;
 426
 427     param = param_shared(name, parameters);
 428     return param->get_string(doc, node);
 429 }
 430
 431 const gchar *
 432 Extension::get_param_enum (const gchar * name, const SPDocument * doc, const Inkscape::XML::Node * node)
 433 {
 434     Parameter* param = param_shared(name, parameters);
 435     return param->get_enum(doc, node);
 436 }
 437
 438 /**
 439     \return   The value of the parameter identified by the name
 440     \brief    Gets a parameter identified by name with the bool placed
 441               in value.
 442     \param    name    The name of the parameter to get
 443     \param    doc    The document to look in for document specific parameters
 444     \param    node   The node to look in for a specific parameter
 445
 446     Look up in the parameters list, then execute the function on that
 447     found parameter.
 448 */
 449 bool
 450 Extension::get_param_bool (const gchar * name, const SPDocument * doc, const Inkscape::XML::Node * node)
 451 {
 452     Parameter * param;
 453
 454     param = param_shared(name, parameters);
 455     return param->get_bool(doc, node);
 456 }
 457
 458 /**
 459     \return   The integer value for the parameter specified
 460     \brief    Gets a parameter identified by name with the integer placed
 461               in value.
 462     \param    name    The name of the parameter to get
 463     \param    doc    The document to look in for document specific parameters
 464     \param    node   The node to look in for a specific parameter
 465
 466     Look up in the parameters list, then execute the function on that
 467     found parameter.
 468 */
 469 int
 470 Extension::get_param_int (const gchar * name, const SPDocument * doc, const Inkscape::XML::Node * node)
 471 {
 472     Parameter * param;
 473
 474     param = param_shared(name, parameters);
 475     return param->get_int(doc, node);
 476 }
 477
 478 /**
 479     \return   The float value for the parameter specified
 480     \brief    Gets a parameter identified by name with the float placed
 481               in value.
 482     \param    name    The name of the parameter to get
 483     \param    doc    The document to look in for document specific parameters
 484     \param    node   The node to look in for a specific parameter
 485
 486     Look up in the parameters list, then execute the function on that
 487     found parameter.
 488 */
 489 float
 490 Extension::get_param_float (const gchar * name, const SPDocument * doc, const Inkscape::XML::Node * node)
 491 {
 492     Parameter * param;
 493     param = param_shared(name, parameters);
 494     return param->get_float(doc, node);
 495 }
 496
 497 /**
 498     \return   The string value for the parameter specified
 499     \brief    Gets a parameter identified by name with the float placed
 500               in value.
 501     \param    name    The name of the parameter to get
 502     \param    doc    The document to look in for document specific parameters
 503     \param    node   The node to look in for a specific parameter
 504
 505     Look up in the parameters list, then execute the function on that
 506     found parameter.
 507 */
 508 SPColor*
 509 Extension::get_param_color (const gchar * name, const SPDocument * doc, const Inkscape::XML::Node * node)
 510 {
 511     Parameter* param = param_shared(name, parameters);
 512     return param->get_color(doc, node);
 513 }
 514
 515 /**
 516     \return   The passed in value
 517     \brief    Sets a parameter identified by name with the boolean
 518               in the parameter value.
 519     \param    name    The name of the parameter to set
 520     \param    value   The value to set the parameter to
 521     \param    doc    The document to look in for document specific parameters
 522     \param    node   The node to look in for a specific parameter
 523
 524     Look up in the parameters list, then execute the function on that
 525     found parameter.
 526 */
 527 bool
 528 Extension::set_param_bool (const gchar * name, bool value, SPDocument * doc, Inkscape::XML::Node * node)
 529 {
 530     Parameter * param;
 531     param = param_shared(name, parameters);
 532     return param->set_bool(value, doc, node);
 533 }
 534
 535 /**
 536     \return   The passed in value
 537     \brief    Sets a parameter identified by name with the integer
 538               in the parameter value.
 539     \param    name    The name of the parameter to set
 540     \param    value   The value to set the parameter to
 541     \param    doc    The document to look in for document specific parameters
 542     \param    node   The node to look in for a specific parameter
 543
 544     Look up in the parameters list, then execute the function on that
 545     found parameter.
 546 */
 547 int
 548 Extension::set_param_int (const gchar * name, int value, SPDocument * doc, Inkscape::XML::Node * node)
 549 {
 550     Parameter * param;
 551     param = param_shared(name, parameters);
 552     return param->set_int(value, doc, node);
 553 }
 554
 555 /**
 556     \return   The passed in value
 557     \brief    Sets a parameter identified by name with the integer
 558               in the parameter value.
 559     \param    name    The name of the parameter to set
 560     \param    value   The value to set the parameter to
 561     \param    doc    The document to look in for document specific parameters
 562     \param    node   The node to look in for a specific parameter
 563
 564     Look up in the parameters list, then execute the function on that
 565     found parameter.
 566 */
 567 float
 568 Extension::set_param_float (const gchar * name, float value, SPDocument * doc, Inkscape::XML::Node * node)
 569 {
 570     Parameter * param;
 571     param = param_shared(name, parameters);
 572     return param->set_float(value, doc, node);
 573 }
 574
 575 /**
 576     \return   The passed in value
 577     \brief    Sets a parameter identified by name with the string
 578               in the parameter value.
 579     \param    name    The name of the parameter to set
 580     \param    value   The value to set the parameter to
 581     \param    doc    The document to look in for document specific parameters
 582     \param    node   The node to look in for a specific parameter
 583
 584     Look up in the parameters list, then execute the function on that
 585     found parameter.
 586 */
 587 const gchar *
 588 Extension::set_param_string (const gchar * name, const gchar * value, SPDocument * doc, Inkscape::XML::Node * node)
 589 {
 590     Parameter * param;
 591     param = param_shared(name, parameters);
 592     return param->set_string(value, doc, node);
 593 }
 594
 595 /**
 596     \return   The passed in value
 597     \brief    Sets a parameter identified by name with the string
 598               in the parameter value.
 599     \param    name    The name of the parameter to set
 600     \param    value   The value to set the parameter to
 601     \param    doc    The document to look in for document specific parameters
 602     \param    node   The node to look in for a specific parameter
 603
 604     Look up in the parameters list, then execute the function on that
 605     found parameter.
 606 */
 607 SPColor*
 608 Extension::set_param_color (const gchar * name, SPColor* color, SPDocument * doc, Inkscape::XML::Node * node)
 609 {
 610     Parameter* param = param_shared(name, parameters);
 611     return param->set_color(color, doc, node);
 612 }
 613
 614 /** \brief A function to open the error log file. */
 615 void
 616 Extension::error_file_open (void)
 617 {
 618     gchar * ext_error_file = profile_path(EXTENSION_ERROR_LOG_FILENAME);
 619     gchar * filename = g_filename_from_utf8( ext_error_file, -1, NULL, NULL, NULL );
 620     error_file.open(filename);
 621     if (!error_file.is_open()) {
 622         g_warning(_("Could not create extension error log file '%s'"),
 623                   filename);
 624     }
 625     g_free(filename);
 626     g_free(ext_error_file);
 627 };
 628
 629 /** \brief A function to close the error log file. */
 630 void
 631 Extension::error_file_close (void)
 632 {
 633     error_file.close();
 634 };
 635
 636 /** \brief  A widget to represent the inside of an AutoGUI widget */
 637 class AutoGUI : public Gtk::VBox {
 638     Gtk::Tooltips _tooltips;
 639 public:
 640     /** \brief  Create an AutoGUI object */
 641     AutoGUI (void) : Gtk::VBox() {};
 642     /** \brief  Adds a widget with a tool tip into the autogui
 643         \param  widg  Widget to add
 644         \param  tooltip   Tooltip for the widget
 645
 646         If there is no widget, nothing happens.  Otherwise it is just
 647         added into the VBox.  If there is a tooltip (non-NULL) then it
 648         is placed on the widget.
 649     */
 650     void addWidget (Gtk::Widget * widg, gchar const * tooltip) {
 651         if (widg == NULL) return;
 652         this->pack_start(*widg, true, true, 2);
 653         if (tooltip != NULL) {
 654             _tooltips.set_tip(*widg, Glib::ustring(tooltip));
 655         }
 656         return;
 657     };
 658 };
 659
 660 /** \brief  A function to automatically generate a GUI using the parameters
 661     \return Generated widget
 662
 663     This function just goes through each parameter, and calls it's 'get_widget'
 664     function to get each widget.  Then, each of those is placed into
 665     a Gtk::VBox, which is then returned to the calling function.
 666
 667     If there are no parameters, this function just returns NULL.
 668 */
 669 Gtk::Widget *
 670 Extension::autogui (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal<void> * changeSignal)
 671 {
 672     if (g_slist_length(parameters) == 0) return NULL;
 673
 674     AutoGUI * agui = Gtk::manage(new AutoGUI());
 675
 676     for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) {
 677         Parameter * param = reinterpret_cast<Parameter *>(list->data);
 678         Gtk::Widget * widg = param->get_widget(doc, node, changeSignal);
 679         gchar const * tip = param->get_tooltip();
 680         agui->addWidget(widg, tip);
 681     }
 682
 683     agui->show();
 684     return agui;
 685 };
 686
 687 /**
 688     \brief  A function to get the parameters in a string form
 689     \return An array with all the parameters in it.
 690
 691 */
 692 void
 693 Extension::paramListString (std::list <std::string> &retlist)
 694 {
 695     //std::list <std::string> retarray;
 696
 697     for (GSList * list = parameters; list != NULL; list = g_slist_next(list)) {
 698         Parameter * param = reinterpret_cast<Parameter *>(list->data);
 699
 700         std::string param_string;
 701         param_string += "--";
 702         param_string += param->name();
 703         param_string += "=";
 704         Glib::ustring * out = param->string();
 705         param_string += *out;
 706         delete out;
 707
 708         retlist.insert(retlist.end(), param_string);
 709     }
 710     //g_message("paramstring=%s", param_string->c_str());
 711
 712     return;
 713 }
 714
 715 /* Extension editor dialog stuff */
 716
 717 Gtk::VBox *
 718 Extension::get_info_widget(void)
 719 {
 720     Gtk::VBox * retval = Gtk::manage(new Gtk::VBox());
 721
 722     Gtk::Frame * info = Gtk::manage(new Gtk::Frame("General Extension Information"));
 723     retval->pack_start(*info, true, true, 5);
 724
 725     Gtk::Table * table = Gtk::manage(new Gtk::Table());
 726     info->add(*table);
 727
 728     int row = 0;
 729     add_val(_("Name:"), _(name), table, &row);
 730     add_val(_("ID:"), id, table, &row);
 731     add_val(_("State:"), _state == STATE_LOADED ? _("Loaded") : _state == STATE_UNLOADED ? _("Unloaded") : _("Deactivated"), table, &row);
 732
 733
 734     retval->show_all();
 735     return retval;
 736 }
 737
 738 void
 739 Extension::add_val(Glib::ustring labelstr, Glib::ustring valuestr, Gtk::Table * table, int * row)
 740 {
 741     Gtk::Label * label;
 742     Gtk::Label * value;
 743
 744     (*row)++;
 745     label = Gtk::manage(new Gtk::Label(labelstr));
 746     value = Gtk::manage(new Gtk::Label(valuestr));
 747     table->attach(*label, 0, 1, (*row) - 1, *row);
 748     table->attach(*value, 1, 2, (*row) - 1, *row);
 749
 750     label->show();
 751     value->show();
 752
 753     return;
 754 }
 755
 756 Gtk::VBox *
 757 Extension::get_help_widget(void)
 758 {
 759     Gtk::VBox * retval = Gtk::manage(new Gtk::VBox());
 760
 761     if (_help == NULL) {
 762         Gtk::Label * content = Gtk::manage(new Gtk::Label("Currently there is no help available for this Extension.  Please look on the Inkscape website or ask on the mailing lists if you have questions regarding this extension."));
 763         retval->pack_start(*content, true, true, 5);
 764         content->set_line_wrap(true);
 765         content->show();
 766     } else {
 767
 768
 769
 770     }
 771
 772     retval->show();
 773     return retval;
 774 }
 775
 776 Gtk::VBox *
 777 Extension::get_params_widget(void)
 778 {
 779     Gtk::VBox * retval = Gtk::manage(new Gtk::VBox());
 780     Gtk::Widget * content = Gtk::manage(new Gtk::Label("Params"));
 781     retval->pack_start(*content, true, true, 5);
 782     content->show();
 783     retval->show();
 784     return retval;
 785 }
 786
 787 }  /* namespace Extension */
 788 }  /* namespace Inkscape */
 789
 790
 791 /*
 792   Local Variables:
 793   mode:c++
 794   c-file-style:"stroustrup"
 795   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 796   indent-tabs-mode:nil
 797   fill-column:99
 798   End:
 799 */
 800 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :