plugins/tools/editor.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     editor.c
   4     Copyright (C) 2003 Biswapesh Chattopadhyay
   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  * Tool editor dialog
  23  * This is used to set all tool informations.
  24  *
  25  *---------------------------------------------------------------------------*/
  26
  27 #include <config.h>
  28 #include <errno.h>
  29 #include <sys/stat.h>
  30 #include "editor.h"
  31
  32 #include "dialog.h"
  33 #include "tool.h"
  34 #include "variable.h"
  35
  36 #include <libanjuta/anjuta-utils.h>
  37 #include <libanjuta/interfaces/ianjuta-document-manager.h>
  38 #include <libanjuta/interfaces/ianjuta-editor.h>
  39 #include <libanjuta/interfaces/ianjuta-file-loader.h>
  40 #include <glib.h>
  41 #include <gdk/gdk.h>
  42 #include <gtk/gtk.h>
  43 #include <sys/types.h>
  44 #include <fcntl.h>
  45 #include <unistd.h>
  46 #include <string.h>
  47
  48 /*---------------------------------------------------------------------------*/
  49
  50 /* Variable dialog */
  51
  52 typedef enum {
  53         ATP_VARIABLE_DEFAULT = 0,
  54         ATP_VARIABLE_REPLACE = 1 << 1
  55 } ATPVariableType;
  56
  57 typedef struct _ATPVariableDialog
  58 {
  59         GtkDialog* dialog;
  60         GtkTreeView* view;
  61         ATPToolEditor* editor;
  62         GtkEditable* entry;
  63         ATPVariableType type;
  64 } ATPVariableDialog;
  65
  66 enum {
  67         ATP_VARIABLE_NAME_COLUMN,
  68         ATP_VARIABLE_MEAN_COLUMN,
  69         ATP_VARIABLE_VALUE_COLUMN,
  70         ATP_N_VARIABLE_COLUMNS,
  71 };
  72
  73 /* Structure containing the required properties of the tool editor GUI */
  74 struct _ATPToolEditor
  75 {
  76         GtkWidget *dialog;
  77         GtkEditable *name_en;
  78         GtkEditable *command_en;
  79         GtkEditable *param_en;
  80         ATPVariableDialog param_var;
  81         GtkEditable *dir_en;
  82         ATPVariableDialog dir_var;
  83         GtkToggleButton *enabled_tb;
  84         GtkToggleButton *terminal_tb;
  85         GtkToggleButton *autosave_tb;
  86         GtkToggleButton *script_tb;
  87         GtkComboBox *output_com;
  88         GtkComboBox *error_com;
  89         GtkComboBox *input_com;
  90         GtkEditable *input_en;
  91         GtkButton *input_var_bt;
  92         ATPVariableDialog input_file_var;
  93         ATPVariableDialog input_string_var;
  94         GtkToggleButton *shortcut_bt;
  95         GtkButton *icon_en;
  96         gchar* shortcut;
  97         ATPUserTool *tool;
  98         ATPToolDialog* parent;
  99         ATPToolEditorList* owner;
 100         ATPToolEditor* next;
 101 };
 102
 103 /*---------------------------------------------------------------------------*/
 104
 105 /* Widget and signal name found in glade file
 106  *---------------------------------------------------------------------------*/
 107
 108 #define TOOL_EDITOR "editor_dialog"
 109 #define TOOL_NAME "name_entry"
 110 #define TOOL_COMMAND "command_entry"
 111 #define TOOL_PARAM "parameter_entry"
 112 #define TOOL_WORKING_DIR "directory_entry"
 113 #define TOOL_ENABLED "enable_checkbox"
 114 #define TOOL_AUTOSAVE "save_checkbox"
 115 #define TOOL_TERMINAL "terminal_checkbox"
 116 #define TOOL_SCRIPT "script_checkbox"
 117 #define TOOL_OUTPUT "output_combo"
 118 #define TOOL_ERROR "error_combo"
 119 #define TOOL_INPUT "input_combo"
 120 #define TOOL_INPUT_VALUE "input_entry"
 121 #define TOOL_INPUT_VARIABLE "input_button"
 122 #define TOOL_SHORTCUT "shortcut_bt"
 123 #define TOOL_ICON "icon_entry"
 124 #define TOOL_BROWSE_WORKING_DIR "browse_button_directory_entry"
 125 #define TOOL_BROWSE_COMMAND "browse_button_command_entry"
 126 #define TOOL_VARIABLE "variable_dialog"
 127 #define VARIABLE_TREEVIEW "variable_treeview"
 128
 129 void atp_on_variable_activate_row (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data);
 130 void atp_on_variable_dialog_response (GtkDialog *dialog, gint response, gpointer user_data);
 131 void atp_on_editor_icon_entry_clicked (GtkButton *button, gpointer user_data);
 132 void atp_on_editor_terminal_toggle (GtkToggleButton *tb, gpointer user_data);
 133 void atp_on_editor_script_toggle (GtkToggleButton *tb, gpointer user_data);
 134 void atp_on_editor_input_changed (GtkComboBox *combo, gpointer user_data);
 135 void atp_on_editor_dialog_response (GtkDialog *dialog, gint response, gpointer user_data);
 136 void atp_on_editor_param_variable_show (GtkButton *button, gpointer user_data);
 137 void atp_on_editor_dir_variable_show (GtkButton *button, gpointer user_data);
 138 void atp_on_editor_input_variable_show (GtkButton *button, gpointer user_data);
 139 void atp_on_editor_shortcut_toggle (GtkToggleButton *tb, gpointer user_data);
 140 void atp_on_editor_browse_button_clicked (GtkButton *button, GtkEntry *entry);
 141 void atp_on_editor_browse_button_dir_clicked (GtkButton *button, GtkEntry *entry);
 142
 143
 144 /* Add helper function
 145  *---------------------------------------------------------------------------*/
 146
 147 static gboolean
 148 make_directory (gchar* path)
 149 {
 150         gchar c;
 151         gchar* ptr;
 152
 153         for (ptr = path; *ptr;)
 154         {
 155                 /* Get next directory */
 156                 for (c = '\0'; *ptr; ++ptr)
 157                 {
 158                         if (*ptr == G_DIR_SEPARATOR)
 159                         {
 160                                 /* Strip leading directory separator */
 161                                 do
 162                                 {
 163                                         ++ptr;
 164                                 } while (*ptr == G_DIR_SEPARATOR);
 165                                 c = *ptr;
 166                                 *ptr = '\0';
 167                                 break;
 168                         }
 169                 }
 170
 171                 /* Create it */
 172                 if (mkdir (path, 0755) < 0)
 173                 {
 174                         /* Error creating directory */
 175                         *ptr = c;
 176                         if (errno != EEXIST)
 177                         {
 178                                 /* An already existing directory is not an error */
 179                                 return FALSE;
 180                         }
 181                 }
 182                 else
 183                 {
 184                         /* New directory created */
 185                         *ptr = c;
 186                 }
 187         }
 188
 189         return TRUE;
 190 }
 191
 192 static void
 193 set_combo_box_enum_model (GtkComboBox* combo_box, const ATPEnumType* list)
 194 {
 195         GtkTreeModel *model;
 196         GtkCellRenderer * renderer;
 197
 198         model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT));
 199
 200         for (; list->id != -1;++list)
 201         {
 202                 GtkTreeIter iter;
 203
 204                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 205                 gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, _(list->name), 1, list->id, -1);
 206         }
 207         gtk_combo_box_set_model (combo_box, model);
 208         renderer = gtk_cell_renderer_text_new();
 209         gtk_cell_layout_clear (GTK_CELL_LAYOUT(combo_box));
 210     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
 211     gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combo_box), renderer, "text", 0 );
 212 }
 213
 214 static gint
 215 get_combo_box_value (GtkComboBox* combo_box)
 216 {
 217         GtkTreeIter iter;
 218         GtkTreeModel *model;
 219         gint value = -1;
 220
 221         if (gtk_combo_box_get_active_iter (combo_box, &iter))
 222         {
 223                 model = gtk_combo_box_get_model (combo_box);
 224                 gtk_tree_model_get (model, &iter, 1, &value, -1);
 225         }
 226
 227         return value;
 228 }
 229
 230 static gboolean
 231 set_combo_box_value (GtkComboBox* combo_box, gint value)
 232 {
 233         GtkTreeIter iter;
 234         GtkTreeModel *model;
 235         gint current;
 236
 237         if (value != -1)
 238         {
 239                 model = gtk_combo_box_get_model (combo_box);
 240                 if (gtk_tree_model_get_iter_first (model, &iter))
 241                 {
 242                         do
 243                         {
 244                                 gtk_tree_model_get (model, &iter, 1, &current, -1);
 245                                 if (value == current)
 246                                 {
 247                                         gtk_combo_box_set_active_iter (combo_box, &iter);
 248
 249                                         return TRUE;
 250                                 }
 251                         }
 252                         while (gtk_tree_model_iter_next (model, &iter));
 253                 }
 254         }
 255
 256         gtk_combo_box_set_active (combo_box, 0);
 257
 258         return FALSE;
 259 }
 260
 261 /* Tool variable dialog
 262  * Display a list of variables useable as command line parameters or working
 263  * directory with their values. Clicking on a variable add it in the current
 264  * entry widget.
 265  *---------------------------------------------------------------------------*/
 266
 267 static ATPVariableDialog*
 268 atp_variable_dialog_construct (ATPVariableDialog* this, ATPToolEditor* editor, ATPVariableType type)
 269 {
 270         this->dialog = NULL;
 271         this->editor = editor;
 272         this->type = type;
 273
 274         return this;
 275 }
 276
 277 static void
 278 atp_variable_dialog_destroy (ATPVariableDialog* this)
 279 {
 280         if (this->dialog)
 281         {
 282                 gtk_widget_destroy (GTK_WIDGET (this->dialog));
 283                 this->dialog = NULL;
 284         }
 285 }
 286
 287 static void
 288 atp_variable_dialog_set_entry (ATPVariableDialog *this, GtkEditable* entry)
 289 {
 290         this->entry = entry;
 291 }
 292
 293 static void
 294 atp_variable_dialog_populate (ATPVariableDialog* this, ATPFlags flag)
 295 {
 296         GtkTreeModel *model;
 297         ATPVariable* variable;
 298         guint i;
 299
 300         variable = atp_tool_dialog_get_variable (this->editor->parent);
 301         model = gtk_tree_view_get_model (this->view);
 302         gtk_list_store_clear (GTK_LIST_STORE(model));
 303
 304         for (i = atp_variable_get_count(variable); i > 0;)
 305         {
 306                 GtkTreeIter iter;
 307                 gchar* value;
 308                 const gchar* value_col;
 309                 ATPFlags var_flags;
 310
 311                 --i;
 312                 var_flags = atp_variable_get_flag (variable, i);
 313                 if (!(var_flags & ATP_NO_VARIABLE) && ((flag == ATP_DEFAULT_VARIABLE) || (var_flags & flag)))
 314                 {
 315                         if (var_flags & ATP_INTERACTIVE_VARIABLE)
 316                         {
 317                                 value = NULL;
 318                                 value_col = _("ask at runtime");
 319                         }
 320                         else
 321                         {
 322                                 value = atp_variable_get_value_from_id (variable, i);
 323                                 value_col = (value == NULL) ? _("undefined") : value;
 324                         }
 325                         gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 326                         gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 327                                 ATP_VARIABLE_NAME_COLUMN,
 328                                 atp_variable_get_name(variable, i),
 329                                 ATP_VARIABLE_MEAN_COLUMN,
 330                                 _(atp_variable_get_help(variable, i)),
 331                                 ATP_VARIABLE_VALUE_COLUMN,
 332                                 value_col,
 333                                 -1);
 334                         if (value) g_free (value);
 335                 }
 336         }
 337 }
 338
 339 static void
 340 atp_variable_dialog_add_variable(ATPVariableDialog *this, const gchar* text)
 341 {
 342         gint pos;
 343
 344         g_return_if_fail (this->entry);
 345
 346         if (text != NULL)
 347         {
 348                 gchar* next;
 349
 350                 if (this->type == ATP_VARIABLE_REPLACE)
 351                 {
 352                         gtk_editable_delete_text (this->entry, 0, -1);
 353                 }
 354
 355                 pos = gtk_editable_get_position(this->entry);
 356                 /* Add space before if useful */
 357                 if (pos != 0)
 358                 {
 359                         next = gtk_editable_get_chars (this->entry, pos - 1, pos);
 360
 361                         if (!g_ascii_isspace (*next))
 362                         {
 363                                 gtk_editable_insert_text (this->entry, " ", 1, &pos);
 364                         }
 365                         g_free (next);
 366                 }
 367                 gtk_editable_insert_text (this->entry, "$(", 2, &pos);
 368                 gtk_editable_insert_text (this->entry, text, strlen(text), &pos);
 369                 gtk_editable_insert_text (this->entry, ")", 1, &pos);
 370                 /* Add space after if useful */
 371                 next = gtk_editable_get_chars (this->entry, pos, pos + 1);
 372                 if (next != NULL)
 373                 {
 374                         if ((*next != '\0') && (!g_ascii_isspace (*next)))
 375                         {
 376                                 gtk_editable_insert_text (this->entry, " ",1, &pos);
 377                         }
 378                         g_free (next);
 379                 }
 380         }
 381 }
 382
 383 static gchar*
 384 get_current_name (GtkTreeView *view)
 385 {
 386         GtkTreeModel *model;
 387         GtkTreeSelection *sel;
 388         GtkTreeIter iter;
 389         gchar* name;
 390
 391         model = gtk_tree_view_get_model (view);
 392         sel = gtk_tree_view_get_selection (view);
 393         if (gtk_tree_selection_get_selected (sel, &model, &iter))
 394         {
 395                 gtk_tree_model_get (model, &iter, ATP_VARIABLE_NAME_COLUMN, &name, -1);
 396
 397                 return name;
 398         }
 399
 400         return NULL;
 401 }
 402
 403 void
 404 atp_on_variable_activate_row (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
 405 {
 406         ATPVariableDialog *this = (ATPVariableDialog*)user_data;
 407         GtkTreeIter iter;
 408         GtkTreeModel *model;
 409         gchar* name;
 410
 411         /* Get Selected variable name */
 412         model = gtk_tree_view_get_model (treeview);
 413         gtk_tree_model_get_iter (model, &iter, path);
 414         gtk_tree_model_get (model, &iter, ATP_VARIABLE_NAME_COLUMN, &name, -1);
 415
 416         atp_variable_dialog_add_variable (this, name);
 417
 418         gtk_widget_hide (GTK_WIDGET (this->dialog));
 419 }
 420
 421 void
 422 atp_on_variable_dialog_response (GtkDialog *dialog, gint response, gpointer user_data)
 423 {
 424         ATPVariableDialog *this = (ATPVariableDialog *)user_data;
 425         gchar* name;
 426
 427         switch (response)
 428         {
 429         case GTK_RESPONSE_OK:
 430                 name = get_current_name (this->view);
 431                 atp_variable_dialog_add_variable (this, name);
 432                 break;
 433         default:
 434                 break;
 435         }
 436
 437         gtk_widget_hide (GTK_WIDGET (this->dialog));
 438 }
 439
 440 static gboolean
 441 atp_variable_dialog_show (ATPVariableDialog* this, ATPFlags flag)
 442 {
 443         GtkBuilder *bxml;
 444         GtkTreeModel *model;
 445         GtkCellRenderer *renderer;
 446         GtkTreeViewColumn *column;
 447
 448         if (this->dialog != NULL)
 449         {
 450                 /* Display dialog box */
 451                 if (this->dialog) gtk_window_present (GTK_WINDOW (this->dialog));
 452                 return TRUE;
 453         }
 454
 455         bxml = anjuta_util_builder_new (GLADE_FILE, NULL);
 456         if (!bxml) return FALSE;
 457         anjuta_util_builder_get_objects (bxml,
 458             TOOL_VARIABLE, &this->dialog,
 459             VARIABLE_TREEVIEW, &this->view,
 460             NULL);
 461
 462         gtk_widget_show (GTK_WIDGET (this->dialog));
 463         gtk_window_set_transient_for (GTK_WINDOW (this->dialog), GTK_WINDOW (this->editor->dialog));
 464
 465         /* Create variable list */
 466         model = GTK_TREE_MODEL (gtk_list_store_new (ATP_N_VARIABLE_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING));
 467         gtk_tree_view_set_model (this->view, model);
 468
 469         renderer = gtk_cell_renderer_text_new ();
 470         column = gtk_tree_view_column_new_with_attributes (_("Variable"), renderer, "text", ATP_VARIABLE_NAME_COLUMN, NULL);
 471         gtk_tree_view_append_column (this->view, column);
 472         renderer = gtk_cell_renderer_text_new ();
 473         column = gtk_tree_view_column_new_with_attributes (_("Meaning"), renderer, "text", ATP_VARIABLE_MEAN_COLUMN, NULL);
 474         gtk_tree_view_append_column (this->view, column);
 475         renderer = gtk_cell_renderer_text_new ();
 476         column = gtk_tree_view_column_new_with_attributes (_("Value"), renderer, "text", ATP_VARIABLE_VALUE_COLUMN, NULL);
 477         gtk_tree_view_append_column (this->view, column);
 478         g_object_unref (model);
 479         atp_variable_dialog_populate (this, flag);
 480
 481         /* Connect all signals */
 482         gtk_builder_connect_signals (bxml, this);
 483         g_signal_connect (G_OBJECT (this->dialog), "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
 484
 485         g_object_unref (bxml);
 486
 487         return TRUE;
 488 }
 489
 490 /* Tool editor dialog
 491  *---------------------------------------------------------------------------*/
 492
 493 static void
 494 cb_preview_update (GtkFileChooser *fc,
 495                    GtkImage *preview)
 496 {
 497         char *filename;
 498         GdkPixbuf *pixbuf;
 499
 500         filename = gtk_file_chooser_get_preview_filename (fc);
 501         if (filename) {
 502                 pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
 503
 504                 gtk_file_chooser_set_preview_widget_active (fc, pixbuf != NULL);
 505
 506                 if (pixbuf) {
 507                         gtk_image_set_from_pixbuf (preview, pixbuf);
 508                         g_object_unref (pixbuf);
 509                 }
 510
 511                 g_free (filename);
 512         }
 513 }
 514
 515 void
 516 atp_on_editor_icon_entry_clicked (GtkButton *button, gpointer user_data)
 517 {
 518         ATPToolEditor *this = (ATPToolEditor *)user_data;
 519         GtkWidget *dialog;
 520         GtkFileFilter *filter;
 521         GtkWidget *preview;
 522         int res;
 523
 524         dialog = gtk_file_chooser_dialog_new (_("Select an Image File"),
 525                                                                                         NULL,
 526                                                                                 GTK_FILE_CHOOSER_ACTION_OPEN,
 527                                                                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 528                                                                                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 529                                                                                 NULL);
 530         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 531                                                                                 PACKAGE_PIXMAPS_DIR);
 532         filter = gtk_file_filter_new ();
 533         gtk_file_filter_add_pixbuf_formats (filter);
 534         gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
 535
 536         preview = gtk_image_new ();
 537         gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog),
 538                                                                             preview);
 539         g_signal_connect (dialog, "update-preview",
 540                                                                                         G_CALLBACK (cb_preview_update), preview);
 541
 542         res = gtk_dialog_run (GTK_DIALOG (dialog));
 543
 544         if (res == GTK_RESPONSE_ACCEPT) {
 545         gchar *filename;
 546
 547         filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 548                 if (filename != NULL)
 549                 {
 550                         GtkWidget* image;
 551                         image = gtk_image_new_from_file (filename);
 552                         gtk_button_set_image (button, image);
 553                         gtk_button_set_label (button, NULL);
 554                 }
 555                 else
 556                 {
 557                         gtk_button_set_image (button, NULL);
 558                         gtk_button_set_label (button, _("Choose Icon"));
 559                 }
 560                 atp_user_tool_set_icon (this->tool, filename);
 561                 g_free (filename);
 562         }
 563
 564         gtk_widget_destroy (dialog);
 565 }
 566
 567 static void
 568 atp_clear_tool_editor(ATPToolEditor* this)
 569 {
 570         g_return_if_fail (this != NULL);
 571
 572         gtk_editable_delete_text(this->name_en, 0, -1);
 573         gtk_editable_delete_text(this->command_en, 0, -1);
 574         gtk_editable_delete_text(this->param_en, 0, -1);
 575         gtk_editable_delete_text(this->dir_en, 0, -1);
 576 }
 577
 578 static void
 579 atp_update_sensitivity(ATPToolEditor *this)
 580 {
 581         gboolean en;
 582
 583         /* Deactivate output and input setting if a terminal is used */
 584         en = gtk_toggle_button_get_active (this->terminal_tb);
 585         gtk_widget_set_sensitive(GTK_WIDGET (this->output_com), !en);
 586         gtk_widget_set_sensitive(GTK_WIDGET (this->error_com), !en);
 587         gtk_widget_set_sensitive(GTK_WIDGET (this->input_com), !en);
 588
 589         /* input value is available for a few input type only */
 590         if (!en)
 591         {
 592                 switch (get_combo_box_value (this->input_com))
 593                 {
 594                 case ATP_TIN_FILE:
 595                 case ATP_TIN_STRING:
 596                         en = TRUE;
 597                         break;
 598                 default:
 599                         en = FALSE;
 600                         break;
 601                 }
 602                 gtk_widget_set_sensitive(GTK_WIDGET (this->input_en), en);
 603                 gtk_widget_set_sensitive(GTK_WIDGET (this->input_var_bt), en);
 604         }
 605         else
 606         {
 607                 gtk_widget_set_sensitive(GTK_WIDGET (this->input_en), FALSE);
 608                 gtk_widget_set_sensitive(GTK_WIDGET (this->input_var_bt), FALSE);
 609         }
 610 }
 611
 612 static void
 613 atp_editor_update_shortcut (ATPToolEditor* this)
 614 {
 615         if (this->shortcut != NULL)
 616         {
 617                 gtk_button_set_label (GTK_BUTTON (this->shortcut_bt), this->shortcut);
 618         }
 619         else
 620         {
 621                 gtk_button_set_label (GTK_BUTTON (this->shortcut_bt), _("Disabled"));
 622         }
 623 }
 624
 625 static void
 626 atp_populate_tool_editor(ATPToolEditor* this)
 627 {
 628         gint pos;
 629         const gchar* value;
 630         guint accel_key;
 631         GdkModifierType accel_mods;
 632
 633         g_return_if_fail (this != NULL);
 634
 635         /* Nothing to fill */
 636         if (this->tool == NULL) return;
 637
 638         value = atp_user_tool_get_name (this->tool);
 639         if (value)
 640         {
 641                 gtk_editable_insert_text(this->name_en, value
 642                           , strlen(value), &pos);
 643         }
 644         value = atp_user_tool_get_command (this->tool);
 645         if (value)
 646         {
 647                 gtk_editable_insert_text(this->command_en, value
 648                   , strlen(value), &pos);
 649         }
 650         value = atp_user_tool_get_param (this->tool);
 651         if (value)
 652         {
 653                 gtk_editable_insert_text(this->param_en, value
 654                   , strlen(value), &pos);
 655         }
 656         value = atp_user_tool_get_working_dir (this->tool);
 657         if (value)
 658         {
 659                 gtk_editable_insert_text(this->dir_en, value
 660                   , strlen(value), &pos);
 661         }
 662         gtk_toggle_button_set_active (this->enabled_tb, atp_user_tool_get_flag (this->tool, ATP_TOOL_ENABLE));
 663         gtk_toggle_button_set_active (this->autosave_tb, atp_user_tool_get_flag (this->tool, ATP_TOOL_AUTOSAVE));
 664         gtk_toggle_button_set_active (this->terminal_tb, atp_user_tool_get_flag (this->tool, ATP_TOOL_TERMINAL));
 665
 666         set_combo_box_value (this->output_com, atp_user_tool_get_output (this->tool));
 667         set_combo_box_value (this->error_com, atp_user_tool_get_error (this->tool));
 668         set_combo_box_value (this->input_com, atp_user_tool_get_input (this->tool));
 669         switch (atp_user_tool_get_input (this->tool))
 670         {
 671         case ATP_TIN_FILE:
 672         case ATP_TIN_STRING:
 673                 value = atp_user_tool_get_input_string (this->tool);
 674                 if (value)
 675                 {
 676                         gtk_editable_insert_text(this->input_en, value, strlen(value), &pos);
 677                 }
 678                 break;
 679         default:
 680                 break;
 681         }
 682         atp_update_sensitivity (this);
 683
 684         if (this->shortcut != NULL) g_free (this->shortcut);
 685         if (atp_user_tool_get_accelerator (this->tool, &accel_key, &accel_mods))
 686         {
 687                 this->shortcut = gtk_accelerator_name (accel_key, accel_mods);
 688         }
 689         else
 690         {
 691                 this->shortcut = NULL;
 692         }
 693         atp_editor_update_shortcut (this);
 694
 695         if (atp_user_tool_get_icon (this->tool))
 696         {
 697                 GtkWidget* image;
 698                 image = gtk_image_new_from_file (atp_user_tool_get_icon (this->tool));
 699                 gtk_button_set_image (this->icon_en, image);
 700                 gtk_button_set_label (this->icon_en, NULL);
 701         }
 702         else
 703         {
 704                 gtk_button_set_image (this->icon_en, NULL);
 705                 gtk_button_set_label (this->icon_en, _("Choose Icon"));
 706         }
 707 }
 708
 709 void
 710 atp_on_editor_terminal_toggle (GtkToggleButton *tb, gpointer user_data)
 711 {
 712         ATPToolEditor *this = (ATPToolEditor *)user_data;
 713
 714         atp_update_sensitivity (this);
 715 }
 716
 717 void
 718 atp_on_editor_script_toggle (GtkToggleButton *tb, gpointer user_data)
 719 {
 720         ATPToolEditor *this = (ATPToolEditor *)user_data;
 721         gchar* command;
 722
 723         if (gtk_toggle_button_get_active(tb))
 724         {
 725                 /* Get current command */
 726                 command = gtk_editable_get_chars(this->command_en, 0, -1);
 727
 728                 if ((command == NULL) || (*command == '\0'))
 729                 {
 730                         gchar* name;
 731                         gint pos;
 732
 733                         if (command) g_free (command);
 734                         /* Generate a new script file name */
 735                         command = gtk_editable_get_chars(this->name_en, 0, -1);
 736                         if ((command == NULL) || (*command == '\0'))
 737                         {
 738                                 command = g_strdup("script");
 739                         }
 740                         name = atp_remove_mnemonic (command);
 741                         g_free (command);
 742
 743                         command = anjuta_util_get_user_data_file_path ("scripts/", name, NULL);
 744                         g_free (name);
 745
 746                         /* Find a new file name */
 747                         name = command;
 748                         pos = 0;
 749                         while (g_file_test (command, G_FILE_TEST_EXISTS))
 750                         {
 751                                 if (command != name) g_free (command);
 752                                 command = g_strdup_printf("%s%d", name, pos);
 753                                 pos++;
 754                         }
 755                         if (command != name) g_free (name);
 756
 757                         /* Fill command line */
 758                         gtk_editable_delete_text(this->command_en, 0, -1);
 759                         gtk_editable_insert_text(this->command_en, command,
 760                                                                          strlen(command), &pos);
 761                 }
 762                 if (command) g_free (command);
 763         }
 764 }
 765
 766 void
 767 atp_on_editor_input_changed (GtkComboBox *combo, gpointer user_data)
 768 {
 769         ATPToolEditor *this = (ATPToolEditor *)user_data;
 770
 771         atp_update_sensitivity (this);
 772 }
 773
 774 void
 775 atp_on_editor_dialog_response (GtkDialog *dialog, gint response, gpointer user_data)
 776 {
 777         ATPToolEditor* this = (ATPToolEditor*)user_data;
 778         gchar* name;
 779         gchar* data;
 780         ATPInputType in_type;
 781         guint accel_key;
 782         GdkModifierType accel_mods;
 783         GtkAccelGroup* group;
 784         AnjutaUI* ui;
 785
 786         if (response == GTK_RESPONSE_OK)
 787         {
 788                 /* Check for all mandatory fields */
 789                 name = gtk_editable_get_chars(this->name_en, 0, -1);
 790                 if (!name || '\0' == name[0])
 791                 {
 792                         if (name) g_free (name);
 793                         anjuta_util_dialog_error(GTK_WINDOW (this->dialog), _("You must provide a tool name!"));
 794                         return;
 795                 }
 796                 data = gtk_editable_get_chars(this->command_en, 0, -1);
 797                 if (!data || '\0' == data[0])
 798                 {
 799                         if (name) g_free (name);
 800                         if (data) g_free (data);
 801                         anjuta_util_dialog_error(GTK_WINDOW (this->dialog), _("You must provide a tool command!"));
 802                         return;
 803                 }
 804
 805                 if (!atp_user_tool_set_name (this->tool, name))
 806                 {
 807                         if (name) g_free (name);
 808                         if (data) g_free (data);
 809                         anjuta_util_dialog_error(GTK_WINDOW (this->dialog), _("A tool with the same name already exists!"));
 810                         return;
 811                 }
 812                 g_free (name);
 813
 814                 if (this->shortcut == NULL)
 815                 {
 816                         accel_key = 0;
 817                         accel_mods = 0;
 818                 }
 819                 else
 820                 {
 821                         gtk_accelerator_parse (this->shortcut, &accel_key, &accel_mods);
 822                         ui = anjuta_shell_get_ui (ANJUTA_PLUGIN(this->parent->plugin)->shell, NULL);
 823                         group = anjuta_ui_get_accel_group(ui);
 824                         if (gtk_accel_group_query (group, accel_key, accel_mods, NULL) != NULL)
 825                         {
 826                                 if (!anjuta_util_dialog_boolean_question (GTK_WINDOW (this->dialog), FALSE,
 827                                     _("The shortcut is already used by another component in Anjuta. Do you want to keep it anyway?")))
 828                                 {
 829                                         return;
 830                                 }
 831                         }
 832                 }
 833
 834                 /* Set new tool data */
 835                 atp_user_tool_set_command (this->tool, data);
 836                 g_free (data);
 837
 838                 data = gtk_editable_get_chars(this->param_en, 0, -1);
 839                 atp_user_tool_set_param (this->tool, data);
 840                 g_free (data);
 841
 842                 data = gtk_editable_get_chars(this->dir_en, 0, -1);
 843                 atp_user_tool_set_working_dir (this->tool, data);
 844                 g_free (data);
 845
 846                 atp_user_tool_set_flag (this->tool, ATP_TOOL_ENABLE | (gtk_toggle_button_get_active(this->enabled_tb) ? ATP_SET : ATP_CLEAR));
 847
 848                 atp_user_tool_set_flag (this->tool, ATP_TOOL_AUTOSAVE | (gtk_toggle_button_get_active(this->autosave_tb) ? ATP_SET : ATP_CLEAR));
 849
 850                 atp_user_tool_set_flag (this->tool, ATP_TOOL_TERMINAL | (gtk_toggle_button_get_active(this->terminal_tb) ? ATP_SET : ATP_CLEAR));
 851
 852
 853                 atp_user_tool_set_output (this->tool, get_combo_box_value (this->output_com));
 854                 atp_user_tool_set_error (this->tool, get_combo_box_value (this->error_com));
 855                 in_type = get_combo_box_value (this->input_com);
 856                 switch (in_type)
 857                 {
 858                 case ATP_TIN_FILE:
 859                 case ATP_TIN_STRING:
 860                         data = gtk_editable_get_chars(this->input_en, 0, -1);
 861                         atp_user_tool_set_input (this->tool, in_type, data);
 862                         g_free (data);
 863                         break;
 864                 default:
 865                         atp_user_tool_set_input (this->tool, in_type, NULL);
 866                         break;
 867                 }
 868
 869                 atp_user_tool_set_accelerator (this->tool, accel_key, accel_mods);
 870
 871                 /* Open script in editor if requested */
 872                 if (gtk_toggle_button_get_active (this->script_tb))
 873                 {
 874                         IAnjutaDocumentManager *docman;
 875                         IAnjutaDocument *doc;
 876                         GFile* file;
 877
 878                         /* Check that default script directory exist */
 879                         data = anjuta_util_get_user_data_file_path ("scripts/", NULL);
 880
 881                         // TODO: Replace with g_mkdir_with_parents
 882                         make_directory (data);
 883                         g_free (data);
 884
 885                         data = gtk_editable_get_chars(this->command_en, 0, -1);
 886
 887                         if (!g_file_test (data, G_FILE_TEST_EXISTS))
 888                         {
 889                                 FILE* sh;
 890
 891                                 /* Create default script */
 892                                 sh = fopen (data, "wt");
 893                                 if (sh != NULL)
 894                                 {
 895                                         gint previous;
 896
 897                                         fprintf(sh, "#!\n#\tScript template generated by Anjuta.\n#\tYou can pass argument using command line parameters\n#\n\n");
 898                                         fclose (sh);
 899
 900                                         /* Make this file executable */
 901                                         previous = umask (0666);
 902                                         chmod (data, 0777 & ~previous);
 903                                         umask (previous);
 904                                 }
 905                         }
 906
 907                         /* Load the script in an editor window */
 908                         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (this->parent->plugin)->shell, IAnjutaDocumentManager, NULL);
 909                         if (docman == NULL)
 910                         {
 911                                 anjuta_util_dialog_error(GTK_WINDOW (this->dialog), _("Unable to edit script"));
 912                                 return;
 913                         }
 914
 915                         file = g_file_new_for_path (data);
 916                         g_free (data);
 917                         doc =
 918                                 ianjuta_document_manager_find_document_with_file
 919                                                            (docman, file, NULL);
 920                         if (doc == NULL)
 921                         {
 922                                 IAnjutaFileLoader* loader;
 923
 924                                 /* Not found, load file */
 925                                 loader = IANJUTA_FILE_LOADER (anjuta_shell_get_interface (ANJUTA_PLUGIN (this->parent->plugin)->shell, IAnjutaFileLoader, NULL));
 926                                 ianjuta_file_loader_load (loader, file, FALSE, NULL);
 927                         }
 928                         else
 929                         {
 930                                 /* Set as current */
 931                                 ianjuta_document_manager_set_current_document (docman, doc, NULL);
 932                         }
 933                         g_object_unref (file);
 934                 }
 935         }
 936
 937         atp_tool_dialog_refresh (this->parent, atp_user_tool_get_name (this->tool));
 938
 939         atp_tool_editor_free (this);
 940 }
 941
 942 void
 943 atp_on_editor_param_variable_show (GtkButton *button, gpointer user_data)
 944 {
 945         ATPToolEditor* this = (ATPToolEditor*)user_data;
 946
 947         atp_variable_dialog_show (&this->param_var, ATP_DEFAULT_VARIABLE);
 948 }
 949
 950 void
 951 atp_on_editor_dir_variable_show (GtkButton *button, gpointer user_data)
 952 {
 953         ATPToolEditor* this = (ATPToolEditor*)user_data;
 954
 955         atp_variable_dialog_show (&this->dir_var, ATP_DIRECTORY_VARIABLE);
 956 }
 957
 958 void
 959 atp_on_editor_input_variable_show (GtkButton *button, gpointer user_data)
 960 {
 961         ATPToolEditor* this = (ATPToolEditor*)user_data;
 962
 963         switch (get_combo_box_value (this->input_com))
 964         {
 965         case ATP_TIN_FILE:
 966                 atp_variable_dialog_show (&this->input_file_var, ATP_FILE_VARIABLE);
 967                 break;
 968         case ATP_TIN_STRING:
 969                 atp_variable_dialog_show (&this->input_string_var, ATP_DEFAULT_VARIABLE);
 970                 break;
 971         }
 972 }
 973
 974 static gboolean
 975 on_editor_get_keys(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 976 {
 977         ATPToolEditor *this = (ATPToolEditor*)user_data;
 978         GdkDisplay *display;
 979         guint accel_key = 0;
 980         GdkModifierType accel_mods = 0;
 981         GdkModifierType consumed_mods = 0;
 982         gboolean delete = FALSE;
 983         gboolean edited = FALSE;
 984
 985         switch (event->keyval)
 986         {
 987         case GDK_KEY_Shift_L:
 988         case GDK_KEY_Shift_R:
 989         case GDK_KEY_Control_L:
 990         case GDK_KEY_Control_R:
 991         case GDK_KEY_Alt_L:
 992         case GDK_KEY_Alt_R:
 993                 return TRUE;
 994         case GDK_KEY_Escape:
 995                 break;
 996         case GDK_KEY_Delete:
 997         case GDK_KEY_KP_Delete:
 998         case GDK_KEY_BackSpace:
 999                 delete = TRUE;
1000                 break;
1001         default:
1002                 display = gtk_widget_get_display (widget);
1003                 gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
1004                                        event->hardware_keycode,
1005                                        event->state,
1006                                        event->group,
1007                                        NULL, NULL, NULL, &consumed_mods);
1008
1009                 accel_key = gdk_keyval_to_lower (event->keyval);
1010                 accel_mods = (event->state & gtk_accelerator_get_default_mod_mask () & ~consumed_mods);
1011
1012                 /* If lowercasing affects the keysym, then we need to include SHIFT
1013                 * in the modifiers, We re-upper case when we match against the
1014                 * keyval, but display and save in caseless form.
1015                 */
1016                 if (accel_key != event->keyval)
1017                         accel_mods |= GDK_SHIFT_MASK;
1018
1019                 edited = gtk_accelerator_valid (accel_key, accel_mods);
1020                 break;
1021         }
1022
1023         if (delete || edited)
1024         {
1025                 /* Remove previous shortcut */
1026                 if (this->shortcut != NULL) g_free (this->shortcut);
1027
1028                 /* Set new one */
1029                 this->shortcut = delete ? NULL : gtk_accelerator_name (accel_key, accel_mods);
1030         }
1031
1032         gtk_toggle_button_set_active (this->shortcut_bt, FALSE);
1033
1034         return TRUE;
1035 }
1036
1037 void
1038 atp_on_editor_shortcut_toggle (GtkToggleButton *tb, gpointer user_data)
1039 {
1040         ATPToolEditor *this = (ATPToolEditor *)user_data;
1041
1042         if (gtk_toggle_button_get_active (tb))
1043         {
1044                 gtk_grab_add(GTK_WIDGET(tb));
1045
1046                 g_signal_connect (G_OBJECT (tb), "key_press_event", G_CALLBACK (on_editor_get_keys), this);
1047                 gtk_button_set_label (GTK_BUTTON (tb), _("New accelerator…"));
1048         }
1049         else
1050         {
1051                 g_signal_handlers_disconnect_by_func (G_OBJECT (this->shortcut_bt), G_CALLBACK (on_editor_get_keys), this);
1052                 gtk_grab_remove (GTK_WIDGET(this->shortcut_bt));
1053
1054                 atp_editor_update_shortcut (this);
1055         }
1056 }
1057
1058 void
1059 atp_on_editor_browse_button_clicked (GtkButton *button, GtkEntry *entry)
1060 {
1061         GtkWidget *dialog;
1062         dialog = gtk_file_chooser_dialog_new ("Open File",
1063                                               NULL,
1064                                               GTK_FILE_CHOOSER_ACTION_OPEN,
1065                                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1066                                               GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1067                                               NULL);
1068         if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
1069         {
1070                 char *filename;
1071                 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1072
1073                 gtk_entry_set_text (entry, filename);
1074
1075                 g_free (filename);
1076         }
1077         gtk_widget_destroy(dialog);
1078 }
1079
1080 void
1081 atp_on_editor_browse_button_dir_clicked (GtkButton *button, GtkEntry *entry)
1082 {
1083         GtkWidget *dialog;
1084         dialog = gtk_file_chooser_dialog_new ("Open",
1085                                               NULL,
1086                                               GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1087                                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1088                                               GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1089                                               NULL);
1090         if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
1091         {
1092                 char *filename;
1093                 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1094
1095                 gtk_entry_set_text (entry, filename);
1096
1097                 g_free (filename);
1098         }
1099         gtk_widget_destroy(dialog);
1100 }
1101
1102 gboolean
1103 atp_tool_editor_show (ATPToolEditor* this)
1104 {
1105         GtkBuilder *bxml;
1106
1107         if (this->dialog != NULL)
1108         {
1109                 /* dialog is already displayed */
1110                 gtk_window_present (GTK_WINDOW (this->dialog));
1111                 return TRUE;
1112         }
1113
1114         bxml = anjuta_util_builder_new (GLADE_FILE, NULL);
1115         if (!bxml) return FALSE;
1116
1117         /* Get all objects */
1118         anjuta_util_builder_get_objects (bxml,
1119             TOOL_EDITOR, &this->dialog,
1120                 TOOL_NAME, &this->name_en ,
1121                 TOOL_COMMAND, &this->command_en,
1122                 TOOL_PARAM, &this->param_en,
1123                 TOOL_WORKING_DIR, &this->dir_en,
1124                 TOOL_ENABLED, &this->enabled_tb,
1125                 TOOL_TERMINAL, &this->terminal_tb,
1126                 TOOL_AUTOSAVE, &this->autosave_tb,
1127                 TOOL_SCRIPT, &this->script_tb,
1128                 TOOL_OUTPUT, &this->output_com,
1129                 TOOL_ERROR, &this->error_com,
1130                 TOOL_INPUT, &this->input_com,
1131                 TOOL_INPUT_VALUE, &this->input_en,
1132                 TOOL_INPUT_VARIABLE, &this->input_var_bt,
1133                 TOOL_SHORTCUT, &this->shortcut_bt,
1134                 TOOL_ICON, &this->icon_en,
1135             NULL);
1136
1137         gtk_widget_show (this->dialog);
1138         gtk_window_set_transient_for (GTK_WINDOW (this->dialog), atp_plugin_get_app_window (this->parent->plugin));
1139
1140         /* Initialize entries */
1141         atp_variable_dialog_set_entry (&this->param_var, this->param_en);
1142         atp_variable_dialog_set_entry (&this->dir_var, this->dir_en);
1143         atp_variable_dialog_set_entry (&this->input_file_var, this->input_en);
1144         atp_variable_dialog_set_entry (&this->input_string_var, this->input_en);
1145
1146         /* Add combox box value */
1147         set_combo_box_enum_model (this->error_com, atp_get_error_type_list());
1148         set_combo_box_enum_model (this->output_com, atp_get_output_type_list());
1149         set_combo_box_enum_model (this->input_com, atp_get_input_type_list());
1150
1151         atp_clear_tool_editor (this);
1152         atp_populate_tool_editor (this);
1153         atp_update_sensitivity (this);
1154
1155         /* Connect all signals */
1156         gtk_builder_connect_signals (bxml, this);
1157
1158         g_object_unref (bxml);
1159
1160         return TRUE;
1161 }
1162
1163 ATPToolEditor*
1164 atp_tool_editor_new (ATPUserTool *tool, ATPToolEditorList *list, struct _ATPToolDialog *dialog)
1165 {
1166         ATPToolEditor *this;
1167
1168         /* Search a already existing tool editor with same name */
1169         for (this = list->first; this != NULL; this = this->next)
1170         {
1171                 /* Name use the same string, so a string comparaison is not necessary */
1172                 if (atp_user_tool_get_name (this->tool) == atp_user_tool_get_name (tool))
1173                 {
1174                         return this;
1175                 }
1176         }
1177
1178         /* Not found, create a new object */
1179         this = g_new0(ATPToolEditor, 1);
1180         this->parent = dialog;
1181         this->owner = list;
1182         this->tool = tool;
1183         atp_variable_dialog_construct (&this->param_var, this, ATP_VARIABLE_DEFAULT);
1184         atp_variable_dialog_construct (&this->dir_var, this, ATP_VARIABLE_REPLACE);
1185         atp_variable_dialog_construct (&this->input_file_var, this, ATP_VARIABLE_REPLACE);
1186         atp_variable_dialog_construct (&this->input_string_var, this, ATP_VARIABLE_REPLACE);
1187
1188         /* Add it in the list */
1189         if (list != NULL)
1190         {
1191                 this->next = list->first;
1192                 list->first = this;
1193         }
1194
1195         return this;
1196 }
1197
1198 gboolean
1199 atp_tool_editor_free (ATPToolEditor *this)
1200 {
1201         ATPToolEditor **prev;
1202
1203         atp_variable_dialog_destroy (&this->input_string_var);
1204         atp_variable_dialog_destroy (&this->input_file_var);
1205         atp_variable_dialog_destroy (&this->dir_var);
1206         atp_variable_dialog_destroy (&this->param_var);
1207
1208         if (this->shortcut != NULL) g_free (this->shortcut);
1209
1210         if (atp_user_tool_get_name (this->tool) == NULL) atp_user_tool_free(this->tool);
1211
1212         if (this->owner == NULL)
1213         {
1214                 /* tool editor is not in a list */
1215                 gtk_widget_destroy (GTK_WIDGET (this->dialog));
1216                 g_free (this);
1217
1218                 return TRUE;
1219         }
1220
1221         /* Search tool editor in list */
1222         for (prev = &this->owner->first; *prev != NULL; prev = &((*prev)->next))
1223         {
1224                 if (*prev == this)
1225                 {
1226                         /* remove tool editor from list */
1227                         *prev = this->next;
1228                         /* delete tool editor object */
1229                         gtk_widget_destroy (GTK_WIDGET (this->dialog));
1230                         g_free (this);
1231
1232                         return TRUE;
1233                 }
1234         }
1235
1236         /* tool editor not found in list */
1237         return FALSE;
1238 }
1239
1240 /* Tool editor list
1241  * This list all the current active tool editors, it is mainly useful for
1242  * avoiding to have two dialogs editing the same tool. It could be possible
1243  * because the tool editing dialog is not modal.
1244  *---------------------------------------------------------------------------*/
1245
1246 ATPToolEditorList*
1247 atp_tool_editor_list_construct (ATPToolEditorList* this)
1248 {
1249         this->first = NULL;
1250
1251         return this;
1252 }
1253
1254 void
1255 atp_tool_editor_list_destroy (ATPToolEditorList* this)
1256 {
1257         ATPToolEditor *ted;
1258
1259         for ( ; (ted = this->first) != NULL;)
1260         {
1261                 atp_tool_editor_free (ted);
1262
1263         }
1264 }
1265