plugins/tools/dialog.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     dialog.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  * First tool configuratin dialog, presenting all tools in a list.
  23  * In this dialog, you can enable, disable, add, remove and order tools.
  24  *
  25  *---------------------------------------------------------------------------*/
  26
  27 #include <config.h>
  28
  29 #include "dialog.h"
  30
  31 #include "editor.h"
  32 #include "fileop.h"
  33
  34 /*---------------------------------------------------------------------------*/
  35
  36 /* Widget and signal name found in glade file
  37  *---------------------------------------------------------------------------*/
  38
  39 #define TOOL_LIST "list_dialog"
  40 #define TOOL_TREEVIEW "tools_treeview"
  41 #define TOOL_EDIT_BUTTON "edit_bt"
  42 #define TOOL_DELETE_BUTTON "delete_bt"
  43 #define TOOL_UP_BUTTON "up_bt"
  44 #define TOOL_DOWN_BUTTON "down_bt"
  45
  46 #define LIST_RESPONSE_SIGNAL "on_list_dialog_response"
  47 #define TOOL_ADD_SIGNAL "on_tool_add"
  48 #define TOOL_ACTIVATED_SIGNAL "on_tool_activated"
  49 #define TOOL_EDIT_SIGNAL "on_tool_edit"
  50 #define TOOL_DELETE_SIGNAL "on_tool_delete"
  51 #define TOOL_UP_SIGNAL "on_tool_up"
  52 #define TOOL_DOWN_SIGNAL "on_tool_down"
  53
  54 /* column of the list view */
  55 enum {
  56         ATP_TOOLS_ENABLED_COLUMN,
  57         ATP_TOOLS_NAME_COLUMN,
  58         ATP_TOOLS_DATA_COLUMN,
  59         ATP_N_TOOLS_COLUMNS
  60 };
  61
  62 /* Useful function used by GUI code
  63  *---------------------------------------------------------------------------*/
  64
  65 static ATPUserTool*
  66 get_current_tool (const ATPToolDialog *this)
  67 {
  68         GtkTreeModel *model;
  69         GtkTreeSelection *sel;
  70         GtkTreeIter iter;
  71         ATPUserTool *tool;
  72
  73         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (this->view));
  74         if (gtk_tree_selection_get_selected (sel, &model, &iter))
  75         {
  76                 gtk_tree_model_get (model, &iter, ATP_TOOLS_DATA_COLUMN, &tool, -1);
  77
  78                 return tool;
  79         }
  80
  81         return NULL;
  82 }
  83
  84 static void
  85 update_sensitivity (const ATPToolDialog *this)
  86 {
  87         ATPUserTool *tool;
  88         gboolean tool_selected;
  89         gboolean tool_up;
  90         gboolean tool_down;
  91         gboolean tool_deletable;
  92
  93         /* Get current selected tool */
  94         tool = get_current_tool (this);
  95         tool_selected = tool != NULL;
  96         tool_up = tool_selected && (atp_user_tool_previous (tool) != NULL);
  97         tool_down = tool_selected && (atp_user_tool_next (tool) != NULL);
  98         tool_deletable = tool_selected && (atp_user_tool_get_storage (tool) > ATP_TSTORE_GLOBAL);
  99
 100         gtk_widget_set_sensitive(this->edit_bt, tool_selected);
 101         gtk_widget_set_sensitive(this->delete_bt, tool_deletable);
 102         gtk_widget_set_sensitive(this->up_bt, tool_up);
 103         gtk_widget_set_sensitive(this->down_bt, tool_down);
 104 }
 105
 106 static ATPUserTool*
 107 get_current_writable_tool (ATPToolDialog *this)
 108 {
 109         ATPUserTool *tool;
 110
 111         tool = get_current_tool(this);
 112         if (tool)
 113         {
 114                 if (atp_user_tool_get_storage (tool) <= ATP_TSTORE_GLOBAL)
 115                 {
 116                         /* global tool are read only so create a writeable one */
 117                         tool = atp_user_tool_clone_new (tool, ATP_TSTORE_LOCAL);
 118                 }
 119         }
 120
 121         return tool;
 122 }
 123
 124 /* Call backs
 125  *---------------------------------------------------------------------------*/
 126
 127 static void
 128 on_tool_add (GtkButton *button, gpointer user_data)
 129 {
 130         ATPToolDialog *this = (ATPToolDialog *)user_data;
 131         ATPUserTool *tool;
 132         ATPToolEditor *ted;
 133
 134         tool = get_current_tool (this);
 135
 136         if (tool == NULL)
 137         {
 138                 /* Add the new tool at the end of the list */
 139                 tool = atp_tool_list_append_new (atp_plugin_get_tool_list (this->plugin), NULL, ATP_TSTORE_LOCAL);
 140         }
 141         else
 142         {
 143                 /* Add tool after the current one */
 144                 tool = atp_user_tool_append_new (tool, NULL, ATP_TSTORE_LOCAL);
 145         }
 146
 147         ted = atp_tool_editor_new (tool, &this->tedl, this);
 148         atp_tool_editor_show (ted);
 149 }
 150
 151 static void
 152 on_tool_edit (GtkButton *button, gpointer user_data)
 153 {
 154         ATPToolDialog *this = (ATPToolDialog *)user_data;
 155         ATPUserTool *tool;
 156         ATPToolEditor *ted;
 157
 158         /* Warning button could be NULL (called from on_row_activated) */
 159
 160         tool = get_current_writable_tool (this);
 161         if (tool != NULL)
 162         {
 163                 ted = atp_tool_editor_new (tool, &this->tedl, this);
 164                 atp_tool_editor_show (ted);
 165         }
 166 }
 167
 168 static void
 169 on_tool_delete (GtkButton *button, gpointer user_data)
 170 {
 171         ATPToolDialog *this = (ATPToolDialog *)user_data;
 172         ATPUserTool *tool;
 173
 174         tool = get_current_tool (this);
 175         if ((tool != NULL) && (atp_user_tool_get_storage (tool) > ATP_TSTORE_GLOBAL))
 176         {
 177                 if (anjuta_util_dialog_boolean_question (GTK_WINDOW (this->dialog), _("Are you sure you want to delete the '%s' tool?"), atp_user_tool_get_name(tool)))
 178                 {
 179                         atp_user_tool_free (tool);
 180                         atp_tool_dialog_refresh (this, NULL);
 181                 }
 182         }
 183 }
 184
 185 static void
 186 on_tool_up (GtkButton *button, gpointer user_data)
 187 {
 188         ATPToolDialog *this = (ATPToolDialog *)user_data;
 189         ATPUserTool *tool;
 190         ATPUserTool *prev;
 191
 192         tool = get_current_writable_tool (this);
 193         if (tool != NULL)
 194         {
 195                 prev = atp_user_tool_previous (tool);
 196                 if (prev != NULL)
 197                 {
 198                         if (atp_user_tool_get_storage (prev) <= ATP_TSTORE_GLOBAL)
 199                         {
 200                                 /* global tool are read only so create a writeable one */
 201                                 prev = atp_user_tool_clone_new (prev, ATP_TSTORE_LOCAL);
 202                         }
 203                         atp_user_tool_move_after (prev, tool);
 204                         atp_tool_dialog_refresh (this, atp_user_tool_get_name (tool));
 205                 }
 206         }
 207 }
 208
 209 static void
 210 on_tool_down (GtkButton *button, gpointer user_data)
 211 {
 212         ATPToolDialog *this = (ATPToolDialog *)user_data;
 213         ATPUserTool *tool;
 214         ATPUserTool *next;
 215
 216         tool = get_current_writable_tool (this);
 217         if (tool != NULL)
 218         {
 219                 next = atp_user_tool_next (tool);
 220                 if (next != NULL)
 221                 {
 222                         atp_user_tool_move_after (tool, next);
 223                         atp_tool_dialog_refresh (this, atp_user_tool_get_name (tool));
 224                 }
 225         }
 226 }
 227
 228 static void
 229 on_tool_enable (GtkCellRendererToggle *cell_renderer, const gchar *path, gpointer user_data)
 230 {
 231         ATPToolDialog *this = (ATPToolDialog *)user_data;
 232         GtkTreeModel *model;
 233         GtkTreeIter iter;
 234         ATPUserTool *tool;
 235
 236         model = gtk_tree_view_get_model (this->view);
 237         if (gtk_tree_model_get_iter_from_string (model, &iter, path))
 238         {
 239                 gtk_tree_model_get (model, &iter, ATP_TOOLS_DATA_COLUMN, &tool, -1);
 240                 atp_user_tool_set_flag (tool, ATP_TOOL_ENABLE | ATP_TOGGLE);
 241
 242                 gtk_list_store_set (GTK_LIST_STORE(model), &iter, ATP_TOOLS_ENABLED_COLUMN,
 243                                 atp_user_tool_get_flag (tool, ATP_TOOL_ENABLE), -1);
 244         }
 245 }
 246
 247 static void
 248 on_tool_activated (GtkTreeView  *treeview, GtkTreePath *path, GtkTreeViewColumn *col, gpointer user_data)
 249 {
 250         on_tool_edit (NULL, user_data);
 251 }
 252
 253 static void
 254 on_tool_selection_changed (GtkTreeSelection *selection, gpointer user_data)
 255 {
 256         ATPToolDialog *this = (ATPToolDialog *)user_data;
 257
 258         update_sensitivity (this);
 259 }
 260
 261 static void
 262 on_list_response (GtkDialog *dialog, gint res, gpointer user_data)
 263 {
 264         ATPToolDialog *this = (ATPToolDialog *)user_data;
 265
 266         /* Just save tool list */
 267         atp_anjuta_tools_save(this->plugin);
 268
 269         /* Close widget */
 270         atp_tool_dialog_close (this);
 271 }
 272
 273 /* Public functions
 274  *---------------------------------------------------------------------------*/
 275
 276 void
 277 atp_tool_dialog_refresh (const ATPToolDialog *this, const gchar* select)
 278 {
 279         ATPUserTool *tool;
 280         GtkTreeModel *model;
 281         GtkTreeSelection *selection;
 282
 283         /* Disable changed signal to avoid changing buttons sensitivity */
 284         selection = gtk_tree_view_get_selection (this->view);
 285         g_signal_handler_block (selection, this->changed_sig);
 286
 287         /* Regenerate the tool list */
 288         model = gtk_tree_view_get_model (this->view);
 289         gtk_list_store_clear (GTK_LIST_STORE(model));
 290         tool = atp_tool_list_first (atp_plugin_get_tool_list (this->plugin));
 291         while (tool)
 292         {
 293                 GtkTreeIter iter;
 294
 295                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 296                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 297                                 ATP_TOOLS_ENABLED_COLUMN,
 298                                 atp_user_tool_get_flag (tool, ATP_TOOL_ENABLE),
 299                                 ATP_TOOLS_NAME_COLUMN,
 300                                 atp_user_tool_get_name (tool),
 301                                 ATP_TOOLS_DATA_COLUMN, tool,
 302                                 -1);
 303                 if ((select != NULL) && (strcmp(select, atp_user_tool_get_name (tool)) == 0))
 304                 {
 305                         gtk_tree_selection_select_iter (selection, &iter);
 306                 }
 307                 tool = atp_user_tool_next (tool);
 308
 309         }
 310
 311         /* Regenerate the tool menu */
 312         atp_tool_list_activate (atp_plugin_get_tool_list (this->plugin));
 313
 314         /* Restore changed signal */
 315         g_signal_handler_unblock (selection, this->changed_sig);
 316         update_sensitivity(this);
 317 }
 318
 319 /* Start the tool lister and editor */
 320
 321 gboolean
 322 atp_tool_dialog_show (ATPToolDialog* this)
 323 {
 324         GladeXML *xml;
 325         GtkTreeModel *model;
 326         GtkCellRenderer *renderer;
 327         GtkTreeViewColumn *column;
 328         GtkTreeSelection *selection;
 329
 330         if (this->dialog != NULL)
 331         {
 332                 /* dialog is already displayed */
 333                 gtk_window_present (GTK_WINDOW (this->dialog));
 334                 return FALSE;
 335         }
 336
 337         /* Load glade file */
 338         if (NULL == (xml = glade_xml_new(GLADE_FILE, TOOL_LIST, NULL)))
 339         {
 340                 anjuta_util_dialog_error(atp_plugin_get_app_window (this->plugin), _("Unable to build user interface for tool list"));
 341                 return FALSE;
 342         }
 343         this->dialog = GTK_DIALOG(glade_xml_get_widget(xml, TOOL_LIST));
 344         gtk_widget_show (GTK_WIDGET(this->dialog));
 345         gtk_window_set_transient_for (GTK_WINDOW (this->dialog), atp_plugin_get_app_window (this->plugin));
 346
 347         /* Create tree view */
 348         this->view = GTK_TREE_VIEW (glade_xml_get_widget(xml, TOOL_TREEVIEW));
 349         model = GTK_TREE_MODEL (gtk_list_store_new (ATP_N_TOOLS_COLUMNS,
 350                 G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER));
 351         gtk_tree_view_set_model (this->view, model);
 352
 353         renderer = gtk_cell_renderer_toggle_new ();
 354         g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (on_tool_enable), this);
 355         column = gtk_tree_view_column_new_with_attributes ("", renderer,
 356            "active", ATP_TOOLS_ENABLED_COLUMN, NULL);
 357         gtk_tree_view_append_column (this->view, column);
 358
 359         renderer = gtk_cell_renderer_text_new ();
 360         column = gtk_tree_view_column_new_with_attributes (_("Tool"), renderer,
 361            "text", ATP_TOOLS_NAME_COLUMN, NULL);
 362         gtk_tree_view_append_column (this->view, column);
 363         g_object_unref (model);
 364
 365         /* Get all buttons */
 366         this->edit_bt = glade_xml_get_widget(xml, TOOL_EDIT_BUTTON);
 367         this->delete_bt = glade_xml_get_widget(xml, TOOL_DELETE_BUTTON);
 368         this->up_bt = glade_xml_get_widget(xml, TOOL_UP_BUTTON);
 369         this->down_bt = glade_xml_get_widget(xml, TOOL_DOWN_BUTTON);
 370
 371         /* Connect all signals */
 372         glade_xml_signal_connect_data (xml, LIST_RESPONSE_SIGNAL, GTK_SIGNAL_FUNC (on_list_response), this);
 373         glade_xml_signal_connect_data (xml, TOOL_ADD_SIGNAL, GTK_SIGNAL_FUNC (on_tool_add), this);
 374         glade_xml_signal_connect_data (xml, TOOL_ACTIVATED_SIGNAL, GTK_SIGNAL_FUNC (on_tool_activated), this);
 375         glade_xml_signal_connect_data (xml, TOOL_EDIT_SIGNAL, GTK_SIGNAL_FUNC (on_tool_edit), this);
 376         glade_xml_signal_connect_data (xml, TOOL_DELETE_SIGNAL, GTK_SIGNAL_FUNC (on_tool_delete), this);
 377         glade_xml_signal_connect_data (xml, TOOL_UP_SIGNAL, GTK_SIGNAL_FUNC (on_tool_up), this);
 378         glade_xml_signal_connect_data (xml, TOOL_DOWN_SIGNAL, GTK_SIGNAL_FUNC (on_tool_down), this);
 379         selection = gtk_tree_view_get_selection (this->view);
 380         this->changed_sig = g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_tool_selection_changed), this);
 381
 382         g_object_unref (xml);
 383
 384         atp_tool_dialog_refresh (this, NULL);
 385
 386         return TRUE;
 387 }
 388
 389 void
 390 atp_tool_dialog_close (ATPToolDialog *this)
 391 {
 392         atp_tool_editor_list_destroy (&this->tedl);
 393
 394         if (this->dialog)
 395         {
 396                 gtk_widget_destroy (GTK_WIDGET(this->dialog));
 397                 this->dialog = NULL;
 398         }
 399 }
 400
 401 /* Access functions
 402  *---------------------------------------------------------------------------*/
 403
 404 GtkWindow*
 405 atp_tool_dialog_get_window (const ATPToolDialog *this)
 406 {
 407         return GTK_WINDOW (this->dialog);
 408 }
 409
 410 ATPVariable*
 411 atp_tool_dialog_get_variable (const ATPToolDialog *this)
 412 {
 413         return atp_plugin_get_variable (this->plugin);
 414 }
 415
 416 /* Creation and Destruction
 417  *---------------------------------------------------------------------------*/
 418
 419 void
 420 atp_tool_dialog_construct (ATPToolDialog *this, ATPPlugin *plugin)
 421 {
 422         this->plugin = plugin;
 423         this->dialog = NULL;
 424         atp_tool_editor_list_construct (&this->tedl);
 425 }
 426
 427 void
 428 atp_tool_dialog_destroy (ATPToolDialog *this)
 429 {
 430         atp_tool_dialog_close (this);
 431 }