plugins/tools/tool.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     tool.c
   4     Copyright (C) 2005 Sebastien Granjoux
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19 */
  20
  21 /*
  22  * Keep all external tool data (ATPUserTool)
  23  * All tools belong to a list (ATPToolList) which take care of allocating
  24  * memory for them. This tool list is implemented with a linked list of all
  25  * tools and a hash table to allow a fast access to a tool from its name.
  26  *
  27  * It is possible to read tools configuration from differents files (typically
  28  * a file in a system directory and another one in an user directory) and to
  29  * have the same tools (= same name) defined in both files. In this case
  30  * both are in the list and each tool have a different storage number and are
  31  * linked with a pointer named over.
  32  *
  33  * It is not possible to ordered tool with different storage order. But to
  34  * emulate this function, it is possible to create new tools with the same
  35  * data in the right storage location.
  36  *---------------------------------------------------------------------------*/
  37
  38 #include <config.h>
  39
  40 #include "tool.h"
  41
  42 #include "execute.h"
  43
  44 #include <libanjuta/anjuta-ui.h>
  45
  46 /*---------------------------------------------------------------------------*/
  47
  48 #define STRING_CHUNK_SIZE       256
  49
  50 /*---------------------------------------------------------------------------*/
  51
  52 struct _ATPUserTool
  53 {
  54         gchar *name;
  55         gchar *command;         /* Command and parameters are in two variables */
  56         gchar *param;
  57         gchar *working_dir;
  58         ATPToolFlag flags;
  59         ATPOutputType output;
  60         ATPOutputType error;
  61         ATPInputType input;
  62         gchar *input_string;
  63         ATPToolStore storage;
  64         GtkWidget* menu_item;
  65         guint accel_key;
  66         GdkModifierType accel_mods;
  67         gchar *icon;
  68         ATPToolList *owner;
  69         ATPUserTool *over;      /* Same tool in another storage */
  70         ATPUserTool *next;      /* Next tool in the list */
  71         ATPUserTool *prev;      /* Previous tool in the list */
  72 };
  73
  74 /* Tools helper functions (map enum to string)
  75  *---------------------------------------------------------------------------*/
  76
  77 ATPEnumType output_type_list[] = {
  78  {ATP_TOUT_SAME, "Same than output"},
  79  {ATP_TOUT_COMMON_PANE, "Existing message pane"},
  80  {ATP_TOUT_NEW_PANE, "New message pane"},
  81  {ATP_TOUT_NEW_BUFFER, "New buffer"},
  82  {ATP_TOUT_REPLACE_BUFFER, "Replace buffer"},
  83  {ATP_TOUT_INSERT_BUFFER, "Insert in buffer"},
  84  {ATP_TOUT_APPEND_BUFFER, "Append to buffer"},
  85  {ATP_TOUT_REPLACE_SELECTION, "Replace selection"},
  86  {ATP_TOUT_POPUP_DIALOG, "Popup dialog"},
  87  {ATP_TOUT_NULL, "Discard output"},
  88  {-1, NULL}
  89 };
  90
  91 ATPEnumType input_type_list[] = {
  92  {ATP_TIN_NONE, "None"},
  93  {ATP_TIN_BUFFER, "Current buffer"},
  94  {ATP_TIN_SELECTION, "Current selection"},
  95  {ATP_TIN_STRING, "String"},
  96  {ATP_TIN_FILE, "File"},
  97  {-1, NULL}
  98 };
  99
 100 /*---------------------------------------------------------------------------*/
 101
 102 const ATPEnumType* atp_get_output_type_list (void)
 103 {
 104         return &output_type_list[1];
 105 }
 106
 107 const ATPEnumType* atp_get_error_type_list (void)
 108 {
 109         return &output_type_list[0];
 110 }
 111
 112 const ATPEnumType* atp_get_input_type_list (void)
 113 {
 114         return &input_type_list[0];
 115 }
 116
 117 /* Return a copy of the name without mnemonic (underscore) */
 118 gchar*
 119 atp_remove_mnemonic (const gchar* label)
 120 {
 121         const char *src;
 122         char *dst;
 123         char *without;
 124
 125         without = g_new (char, strlen(label) + 1);
 126         dst = without;
 127         for (src = label; *src != '\0'; ++src)
 128         {
 129                 if (*src == '_')
 130                 {
 131                         /* Remove single underscore */
 132                         ++src;
 133                 }
 134                 *dst++ = *src;
 135         }
 136         *dst = *src;
 137
 138         return without;
 139 }
 140
 141 /* Tool object
 142  *
 143  *---------------------------------------------------------------------------*/
 144
 145 /* Private functions
 146  *---------------------------------------------------------------------------*/
 147
 148 /* Remove tool from list but doesn't remove from hash table */
 149
 150 static gboolean
 151 atp_user_tool_remove_list (ATPUserTool* this)
 152 {
 153         g_return_val_if_fail (this, FALSE);
 154         g_return_val_if_fail (this->owner, FALSE);
 155
 156         /* Remove from storage list */
 157         if (this->owner->list == this)
 158         {
 159                 /* First tool in the list */
 160                 this->owner->list = this->next;
 161                 if (this->next != NULL)
 162                 {
 163                         this->next->prev = NULL;
 164                 }
 165         }
 166         else
 167         {
 168                 if (this->next != NULL)
 169                 {
 170                         this->next->prev = this->prev;
 171                 }
 172                 if (this->prev != NULL)
 173                 {
 174                         this->prev->next = this->next;
 175                 }
 176         }
 177         this->next = NULL;
 178         this->prev = NULL;
 179
 180         return TRUE;
 181 }
 182
 183 /* Add tool in list but doesn't add in hash table */
 184
 185 static gboolean
 186 atp_user_tool_append_list (ATPUserTool *this, ATPUserTool *tool)
 187 {
 188         g_return_val_if_fail (tool, FALSE);
 189
 190         /* Keep storage type ordered */
 191         if (this == NULL)
 192         {
 193                 ATPUserTool* first;
 194                 /* Insert at the beginning of list (with right storage) */
 195                 for (first = tool->owner->list; first != NULL; first = first->next)
 196                 {
 197                         if (first->storage >= tool->storage) break;
 198                         this = first;
 199                 }
 200         }
 201
 202         /* If this is NULL insert at the beginning of the list */
 203         if (this == NULL)
 204         {
 205                 tool->next = tool->owner->list;
 206                 if (tool->next != NULL)
 207                         tool->next->prev = tool;
 208                 tool->owner->list = tool;
 209                 tool->prev = NULL;
 210         }
 211         else if ((this->storage == tool->storage) || (this->next == NULL) || (this->next->storage >= tool->storage))
 212         {
 213                 /* Insert tool in list */
 214                 tool->prev = this;
 215                 tool->next = this->next;
 216                 this->next = tool;
 217                 if (tool->next)
 218                 {
 219                         tool->next->prev = tool;
 220                 }
 221         }
 222         else if (this->storage < tool->storage)
 223         {
 224                 ATPUserTool *prev;
 225                 /* Insert tool at the beginning of storage list */
 226                 atp_user_tool_append_list (NULL, tool);
 227
 228                 /* Create new tool with the right storage and reorder them */
 229                 for (prev = tool;(prev = atp_user_tool_previous (prev)) != this;)
 230                 {
 231                         ATPUserTool *clone;
 232
 233                         clone = atp_user_tool_new (this->owner, prev->name, tool->storage);
 234                         atp_user_tool_append_list (tool, clone);
 235                 }
 236         }
 237         else
 238         {
 239                 /* Unable to handle this case */
 240                 g_return_val_if_reached (FALSE);
 241                 return FALSE;
 242         }
 243
 244         return TRUE;
 245 }
 246
 247 /* Remove from hash table and list */
 248
 249 static gboolean
 250 atp_user_tool_remove (ATPUserTool *this)
 251 {
 252         if (this->name != NULL)
 253         {
 254                 /* Remove from hash table */
 255                 ATPUserTool *first;
 256
 257                 first = (ATPUserTool *)g_hash_table_lookup (this->owner->hash, this->name);
 258                 if (first == NULL)
 259                 {
 260                         /* Unable to find tool */
 261                         g_return_val_if_reached (FALSE);
 262                 }
 263                 if (first == this)
 264                 {
 265                         if (this->over == NULL)
 266                         {
 267                                 g_hash_table_remove (this->owner->hash, this->name);
 268                         }
 269                         else
 270                         {
 271                                 g_hash_table_replace (this->owner->hash, this->name, this->over);
 272                         }
 273                 }
 274                 else
 275                 {
 276                         for (; first->over != this; first = first->over)
 277                         {
 278                                 if (first == NULL)
 279                                 {
 280                                         /* Unable to find tool */
 281                                         return FALSE;
 282                                 }
 283                         }
 284                         first->over = this->over;
 285                 }
 286         }
 287
 288         /* Remove from list */
 289         return atp_user_tool_remove_list (this);
 290 }
 291
 292 /* Replace tool name */
 293
 294 static gboolean
 295 atp_user_tool_replace_name (ATPUserTool *this, const gchar *name)
 296 {
 297         if ((name != NULL) && (g_hash_table_lookup (this->owner->hash, name) != NULL))
 298         {
 299                 /* Name already exist */
 300                 return FALSE;
 301         }
 302
 303         if (this->name != NULL)
 304         {
 305                 ATPUserTool *first;
 306
 307                 first = (ATPUserTool *) g_hash_table_lookup (this->owner->hash, this->name);
 308
 309                 if (first->over == NULL)
 310                 {
 311                         g_return_val_if_fail (first == this, FALSE);
 312
 313                         g_hash_table_remove (this->owner->hash, this->name);
 314                 }
 315                 else
 316                 {
 317                         /* Remove tool from override list */
 318                         if (first == this)
 319                         {
 320                                 g_hash_table_replace (this->owner->hash, this->name, this->over);
 321                                 this->over = NULL;
 322                         }
 323                         else
 324                         {
 325                                 ATPUserTool *tool;
 326
 327                                 for (tool = first; tool->over != this; tool = tool->over)
 328                                 {
 329                                         /* Tool not in list */
 330                                         g_return_val_if_fail (tool->over != NULL, FALSE);
 331                                 }
 332                                 tool->over = this->over;
 333                         }
 334                 }
 335         }
 336
 337         /* Add in list */
 338         this->name = name == NULL ? NULL : g_string_chunk_insert_const (this->owner->string_pool, name);
 339         if (name != NULL)
 340         {
 341                 /* Add name in hash table */
 342                 g_hash_table_insert (this->owner->hash, this->name, this);
 343         }
 344
 345         return TRUE;
 346 }
 347
 348 /* Creation and Destruction
 349  *---------------------------------------------------------------------------*/
 350
 351 /* Create a tool with corresponding name and storage
 352  *  but does NOT add it in the list */
 353
 354 ATPUserTool *
 355 atp_user_tool_new (ATPToolList *list, const gchar *name, ATPToolStore storage)
 356 {
 357         ATPUserTool *first;
 358         ATPUserTool *tool;
 359
 360         g_return_val_if_fail (list, NULL);
 361
 362         if (name)
 363         {
 364                 /* Search tool in hash table */
 365                 first = (ATPUserTool *) g_hash_table_lookup (list->hash, name);
 366                 if (first != NULL)
 367                 {
 368                         /* Search tool in the list */
 369                         for(tool = first;;  tool = tool->over)
 370                         {
 371                                 if (tool->storage == storage)
 372                                 {
 373                                         /* Tool already exist */
 374
 375                                         return NULL;
 376                                 }
 377                                 else if (tool->storage > storage)
 378                                 {
 379                                         /* Add tool before */
 380                                         g_return_val_if_fail (tool == first, NULL);
 381
 382                                         tool = g_chunk_new0(ATPUserTool, list->data_pool);
 383                                         tool->over = first;
 384                                         tool->flags = ATP_TOOL_ENABLE;
 385                                         tool->name = first->name;
 386                                         g_hash_table_replace (list->hash, tool->name, tool);
 387                                         break;
 388                                 }
 389                                 else if ((tool->over == NULL) || (tool->over->storage > storage))
 390                                 {
 391                                         /* Add tool after, using previous values as default */
 392                                         first = g_chunk_new(ATPUserTool, list->data_pool);
 393                                         memcpy(first, tool, sizeof (ATPUserTool));
 394                                         first->over = tool->over;
 395                                         tool->over = first;
 396                                         tool->menu_item = NULL;
 397                                         tool = tool->over;
 398                                         break;
 399                                 }
 400                         }
 401                 }
 402                 else
 403                 {
 404                         /* Create new tool */
 405                         tool = g_chunk_new0(ATPUserTool, list->data_pool);
 406                         tool->flags = ATP_TOOL_ENABLE;
 407                         tool->name = g_string_chunk_insert_const (list->string_pool, name);
 408                         g_hash_table_insert (list->hash, tool->name, tool);
 409                 }
 410         }
 411         else
 412         {
 413                 /* Create stand alone tool */
 414                 tool = g_chunk_new0(ATPUserTool, list->data_pool);
 415                 tool->flags = ATP_TOOL_ENABLE;
 416         }
 417
 418         /* Set default values */
 419         tool->storage = storage;
 420         tool->owner = list;
 421
 422         return tool;
 423 }
 424
 425 void
 426 atp_user_tool_free (ATPUserTool *this)
 427 {
 428         g_return_if_fail (this->owner);
 429
 430         atp_user_tool_remove (this);
 431         atp_user_tool_deactivate (this);
 432
 433         g_chunk_free (this, this->owner->data_pool);
 434 }
 435
 436
 437 /* Access tool data
 438  *---------------------------------------------------------------------------*/
 439
 440 gboolean
 441 atp_user_tool_set_name (ATPUserTool *this, const gchar *value)
 442 {
 443         if ((value != this->name) && ((value == NULL) || (this->name == NULL) || (strcmp (value, this->name) != 0)))
 444         {
 445                 return atp_user_tool_replace_name (this, value);
 446         }
 447
 448         return TRUE;
 449 }
 450
 451 const gchar*
 452 atp_user_tool_get_name (const ATPUserTool* this)
 453 {
 454         return this->name;
 455 }
 456
 457 void
 458 atp_user_tool_set_command (ATPUserTool* this, const gchar* value)
 459 {
 460         this->command = value == NULL ? NULL : g_string_chunk_insert_const (this->owner->string_pool, value);
 461 }
 462
 463 const gchar*
 464 atp_user_tool_get_command (const ATPUserTool* this)
 465 {
 466         return this->command;
 467 }
 468
 469 void
 470 atp_user_tool_set_param (ATPUserTool* this, const gchar* value)
 471 {
 472         this->param = value == NULL ? NULL : g_string_chunk_insert_const (this->owner->string_pool, value);
 473 }
 474
 475 const gchar*
 476 atp_user_tool_get_param (const ATPUserTool* this)
 477 {
 478         return this->param;
 479 }
 480
 481 void
 482 atp_user_tool_set_working_dir (ATPUserTool* this, const gchar* value)
 483 {
 484         this->working_dir = value == NULL ? NULL : g_string_chunk_insert_const (this->owner->string_pool, value);
 485 }
 486
 487 const gchar*
 488 atp_user_tool_get_working_dir (const ATPUserTool* this)
 489 {
 490         return this->working_dir;
 491 }
 492
 493 void
 494 atp_user_tool_set_flag (ATPUserTool* this, ATPToolFlag flag)
 495 {
 496         switch (flag & ATP_OPERATION)
 497         {
 498         case ATP_SET:
 499                 this->flags |= flag;
 500                 break;
 501         case ATP_CLEAR:
 502                 this->flags &= ~flag;
 503                 break;
 504         case ATP_TOGGLE:
 505                 this->flags ^= flag;
 506                 break;
 507         default:
 508                 g_return_if_reached();
 509         }
 510
 511         if ((flag & ATP_TOOL_ENABLE) && (this->menu_item != NULL))
 512         {
 513                 /* Enable or disable menu item */
 514                 gtk_widget_set_sensitive (this->menu_item, this->flags & ATP_TOOL_ENABLE);
 515         }
 516 }
 517
 518 gboolean
 519 atp_user_tool_get_flag (const ATPUserTool* this, ATPToolFlag flag)
 520 {
 521         return this->flags & flag ? TRUE : FALSE;
 522 }
 523
 524 void
 525 atp_user_tool_set_output (ATPUserTool *this, ATPOutputType output)
 526 {
 527         this->output = output;
 528 }
 529
 530 ATPOutputType
 531 atp_user_tool_get_output (const ATPUserTool *this)
 532 {
 533         return this->output;
 534 }
 535
 536 void
 537 atp_user_tool_set_error (ATPUserTool *this, ATPOutputType error)
 538 {
 539         this->error = error;
 540 }
 541
 542 ATPOutputType
 543 atp_user_tool_get_error (const ATPUserTool *this )
 544 {
 545         return this->error;
 546 }
 547
 548 void
 549 atp_user_tool_set_input (ATPUserTool *this, ATPInputType type, const gchar* value)
 550 {
 551         this->input = type;
 552         this->input_string = value == NULL ? NULL : g_string_chunk_insert_const (this->owner->string_pool, value);
 553 }
 554
 555 ATPInputType
 556 atp_user_tool_get_input (const ATPUserTool *this )
 557 {
 558         return this->input;
 559 }
 560
 561 const gchar*
 562 atp_user_tool_get_input_string (const ATPUserTool *this )
 563 {
 564         return this->input_string;
 565 }
 566
 567 void
 568 atp_user_tool_set_accelerator (ATPUserTool *this, guint key, GdkModifierType mods)
 569 {
 570         this->accel_key = key;
 571         this->accel_mods = mods;
 572 }
 573
 574 gboolean
 575 atp_user_tool_get_accelerator (const ATPUserTool *this, guint *key, GdkModifierType *mods)
 576 {
 577         *key = this->accel_key;
 578         *mods = this->accel_mods;
 579
 580         return this->accel_key != 0;
 581 }
 582
 583 void atp_user_tool_set_icon (ATPUserTool *this, const gchar* value)
 584 {
 585         this->icon = value == NULL ? NULL : g_string_chunk_insert_const (this->owner->string_pool, value);
 586 }
 587
 588 const gchar* atp_user_tool_get_icon (const ATPUserTool *this)
 589 {
 590         return this->icon;
 591 }
 592
 593 ATPToolStore atp_user_tool_get_storage (const ATPUserTool *this)
 594 {
 595         return this->storage;
 596 }
 597
 598 ATPPlugin*
 599 atp_user_tool_get_plugin (ATPUserTool* this)
 600 {
 601         return this->owner->plugin;
 602 }
 603
 604 gboolean
 605 atp_user_tool_is_valid (const ATPUserTool* this)
 606 {
 607         return (this->command != NULL);
 608 }
 609
 610 /* Additional tool functions
 611  *---------------------------------------------------------------------------*/
 612
 613 ATPUserTool*
 614 atp_user_tool_next (ATPUserTool *this)
 615 {
 616         while ((this = this->next))
 617         {
 618                 /* Skip unnamed and overridden tool */
 619                 if ((this->name != NULL) && (this->over == NULL)) break;
 620         }
 621
 622         return this;
 623 }
 624
 625 ATPUserTool*
 626 atp_user_tool_next_in_same_storage (ATPUserTool *this)
 627 {
 628         ATPToolStore storage;
 629
 630         storage = this->storage;
 631         while ((this = this->next))
 632         {
 633                 /* Skip unnamed */
 634                 if (this->storage != storage) return NULL;
 635                 if (this->name != NULL) break;
 636         }
 637
 638         return this;
 639 }
 640
 641 ATPUserTool*
 642 atp_user_tool_previous (ATPUserTool *this)
 643 {
 644         while ((this = this->prev))
 645         {
 646                 /* Skip unnamed and overridden tool */
 647                 if ((this->name != NULL) && (this->over == NULL)) break;
 648         }
 649
 650         return this;
 651 }
 652
 653 ATPUserTool*
 654 atp_user_tool_override (const ATPUserTool *this)
 655 {
 656         ATPUserTool* tool;
 657
 658         for (tool = g_hash_table_lookup (this->owner->hash, this->name);
 659                  tool != NULL; tool = tool->over)
 660         {
 661                 if (tool->over == this) return tool;
 662         }
 663
 664         return NULL;
 665 }
 666
 667 ATPUserTool*
 668 atp_user_tool_append_new (ATPUserTool *this, const gchar *name, ATPToolStore storage)
 669 {
 670         ATPUserTool *tool;
 671
 672         g_return_val_if_fail (this, NULL);
 673
 674         /* Create tool */
 675         tool = atp_user_tool_new (this->owner, name, storage);
 676         if (tool)
 677         {
 678                 atp_user_tool_append_list (this, tool);
 679         }
 680
 681         return tool;
 682 }
 683
 684 ATPUserTool*
 685 atp_user_tool_clone_new (ATPUserTool *this, ATPToolStore storage)
 686 {
 687         ATPUserTool *tool;
 688
 689         g_return_val_if_fail (this, NULL);
 690
 691         /* Create tool */
 692         tool = atp_user_tool_new (this->owner, this->name, storage);
 693         if (tool)
 694         {
 695                 ATPUserTool *prev;
 696
 697                 prev = atp_user_tool_previous (this);
 698                 atp_user_tool_append_list (prev, tool);
 699         }
 700
 701         return tool;
 702 }
 703
 704 gboolean
 705 atp_user_tool_move_after (ATPUserTool *this, ATPUserTool *position)
 706 {
 707         g_return_val_if_fail (this, FALSE);
 708
 709         if (!atp_user_tool_remove_list (this)) return FALSE;
 710         return atp_user_tool_append_list (position, this);
 711 }
 712
 713 void
 714 atp_user_tool_deactivate (ATPUserTool* this)
 715 {
 716         /* accelerator is destroyed with the widget */
 717         if (this->menu_item)
 718         {
 719                 gtk_widget_destroy (this->menu_item);
 720                 this->menu_item = NULL;
 721         }
 722 }
 723
 724 gboolean
 725 atp_user_tool_activate (ATPUserTool *this, GtkMenu *submenu, GtkAccelGroup *group)
 726 {
 727         /* Remove previous menu */
 728         atp_user_tool_deactivate (this);
 729
 730         /* Create new menu item */
 731         this->menu_item = gtk_image_menu_item_new_with_mnemonic (this->name);
 732         gtk_widget_set_sensitive (this->menu_item, this->flags & ATP_TOOL_ENABLE);
 733
 734         /* Add icon */
 735         if ((this->menu_item != NULL) && (this->icon != NULL))
 736         {
 737                 GdkPixbuf *pixbuf;
 738                 GdkPixbuf *scaled_pixbuf;
 739                 gint height, width;
 740
 741                 gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (this->menu_item), GTK_ICON_SIZE_MENU, &width, &height);
 742
 743                 pixbuf = gdk_pixbuf_new_from_file (this->icon, NULL);
 744                 if (pixbuf)
 745                 {
 746                         GtkWidget* icon;
 747
 748                         scaled_pixbuf = gdk_pixbuf_scale_simple (pixbuf, width, height, GDK_INTERP_BILINEAR);
 749                         icon = gtk_image_new_from_pixbuf (scaled_pixbuf);
 750                         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (this->menu_item), icon);
 751                         g_object_unref (pixbuf);
 752                         g_object_unref (scaled_pixbuf);
 753                 }
 754         }
 755
 756         g_signal_connect (G_OBJECT (this->menu_item), "activate", G_CALLBACK (atp_user_tool_execute), this);
 757
 758         if (this->accel_key != 0)
 759         {
 760                 gtk_widget_add_accelerator(this->menu_item, "activate", group, this->accel_key, this->accel_mods, GTK_ACCEL_VISIBLE);
 761         }
 762
 763         gtk_menu_shell_append (GTK_MENU_SHELL (submenu), this->menu_item);
 764         gtk_widget_show(this->menu_item);
 765
 766         return TRUE;
 767 }
 768
 769 /* Tool list object containing all tools
 770  *---------------------------------------------------------------------------*/
 771
 772 ATPToolList *
 773 atp_tool_list_construct (ATPToolList* this, ATPPlugin* plugin)
 774 {
 775         this->plugin = plugin;
 776         this->ui = anjuta_shell_get_ui (ANJUTA_PLUGIN(plugin)->shell, NULL);
 777         this->list = NULL;
 778         this->hash = g_hash_table_new (g_str_hash, g_str_equal);
 779         this->string_pool = g_string_chunk_new (STRING_CHUNK_SIZE);
 780         this->data_pool = g_mem_chunk_new ("tool pool", sizeof (ATPUserTool), STRING_CHUNK_SIZE * sizeof (ATPUserTool) / 4, G_ALLOC_AND_FREE);
 781
 782         return this;
 783 }
 784
 785 void atp_tool_list_destroy (ATPToolList* this)
 786 {
 787         g_hash_table_destroy (this->hash);
 788         g_string_chunk_free (this->string_pool);
 789         g_mem_chunk_destroy (this->data_pool);
 790 }
 791
 792 /*---------------------------------------------------------------------------*/
 793
 794 ATPUserTool *
 795 atp_tool_list_last (ATPToolList *this)
 796 {
 797         ATPUserTool *tool;
 798         ATPUserTool *last;
 799
 800         last = NULL;
 801         for (tool = this->list; tool != NULL; tool = tool->next)
 802         {
 803                 /* Skip tool not registered */
 804                 if (tool->name != NULL)
 805                 {
 806                         last = tool;
 807                 }
 808         }
 809
 810         return last;
 811 }
 812
 813 static ATPUserTool *
 814 atp_tool_list_last_in_storage (const ATPToolList *this, ATPToolStore storage)
 815 {
 816         ATPUserTool *tool;
 817         ATPUserTool *last;
 818
 819         last = NULL;
 820         for (tool = this->list; tool != NULL; tool = tool->next)
 821         {
 822                 if (tool->storage > storage) break;
 823                 /* Skip tool not registered */
 824                 if (tool->name != NULL)
 825                 {
 826                         last = tool;
 827                 }
 828         }
 829
 830         return last;
 831 }
 832
 833 ATPUserTool*
 834 atp_tool_list_first (ATPToolList *this)
 835 {
 836         ATPUserTool *tool;
 837
 838         for (tool = this->list; tool != NULL; tool = tool->next)
 839         {
 840                 /* Skip unnamed and overridden tool*/
 841                 if ((tool->name != NULL) && (tool->over == NULL))
 842                 {
 843                         return tool;
 844                 }
 845         }
 846
 847         return NULL;
 848 }
 849
 850 ATPUserTool*
 851 atp_tool_list_first_in_storage (ATPToolList *this, ATPToolStore storage)
 852 {
 853         ATPUserTool *tool;
 854
 855         for (tool = this->list; tool != NULL; tool = tool->next)
 856         {
 857                 /* Skip unamed tool */
 858                 if ((tool->name != NULL) && (tool->storage == storage))
 859                 {
 860                         return tool;
 861                 }
 862         }
 863
 864         return NULL;
 865 }
 866
 867 ATPUserTool *
 868 atp_tool_list_append_new (ATPToolList *this, const gchar *name, ATPToolStore storage)
 869 {
 870         ATPUserTool *tool;
 871
 872         g_return_val_if_fail (this, NULL);
 873
 874         /* Create tool */
 875         tool = atp_user_tool_new (this, name, storage);
 876
 877         /* Add it in one of the storage list if necessary */
 878         if (tool)
 879         {
 880                 atp_user_tool_append_list (atp_tool_list_last_in_storage (this, storage), tool);
 881         }
 882
 883         return tool;
 884 }
 885
 886 gboolean atp_tool_list_activate (ATPToolList *this)
 887 {
 888         ATPUserTool *next;
 889         GtkMenu* menu;
 890         GtkAccelGroup* group;
 891
 892         menu = GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (gtk_ui_manager_get_widget (GTK_UI_MANAGER(this->ui), MENU_PLACEHOLDER))));
 893         group = anjuta_ui_get_accel_group(this->ui);
 894
 895         for (next = atp_tool_list_first (this); next != NULL; next = atp_user_tool_next (next))
 896         {
 897                 atp_user_tool_activate (next, menu, group);
 898         }
 899
 900         return TRUE;
 901 }
 902
 903