plugins/git/git-ui-utils.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta
   4  * Copyright (C) James Liggett 2007 <jrliggett@cox.net>
   5  *
   6  * anjuta is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * anjuta is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16  * See the GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with anjuta.  If not, write to:
  20  *      The Free Software Foundation, Inc.,
  21  *      51 Franklin Street, Fifth Floor
  22  *      Boston, MA  02110-1301, USA.
  23  */
  24
  25 #include "git-ui-utils.h"
  26
  27 /* Private structure for pulse progress */
  28 typedef struct
  29 {
  30         AnjutaStatus *status;
  31         gchar *text;
  32 } PulseProgressData;
  33
  34 GitUIData*
  35 git_ui_data_new (Git* plugin, GladeXML* gxml)
  36 {
  37         GitUIData* data = g_new0 (GitUIData, 1);
  38         data->plugin = plugin;
  39         data->gxml = gxml;
  40
  41         return data;
  42 }
  43
  44 void
  45 git_ui_data_free (GitUIData* data)
  46 {
  47         g_object_unref (data->gxml);
  48         g_free (data);
  49 }
  50
  51 static void
  52 on_message_view_destroy (Git* plugin, gpointer destroyed_view)
  53 {
  54         plugin->message_view = NULL;
  55 }
  56
  57 void
  58 create_message_view (Git* plugin)
  59 {
  60         IAnjutaMessageManager* message_manager;
  61
  62
  63         message_manager = anjuta_shell_get_interface  (ANJUTA_PLUGIN (plugin)->shell,
  64                                                                                                    IAnjutaMessageManager, NULL);
  65         plugin->message_view =  ianjuta_message_manager_get_view_by_name (message_manager,
  66                                                                                                                                           _("Git"),
  67                                                                                                                                           NULL);
  68         if (!plugin->message_view)
  69         {
  70                 plugin->message_view = ianjuta_message_manager_add_view (message_manager,
  71                                                                                                                                  _("Git"),
  72                                                                                                                                  ICON_FILE,
  73                                                                                                                                  NULL);
  74                 g_object_weak_ref (G_OBJECT (plugin->message_view),
  75                                                    (GWeakNotify) on_message_view_destroy, plugin);
  76         }
  77
  78         ianjuta_message_view_clear(plugin->message_view, NULL);
  79         ianjuta_message_manager_set_current_view (message_manager, plugin->message_view,
  80                                                                                           NULL);
  81 }
  82
  83 gboolean
  84 check_input (GtkWidget *parent, GtkWidget *entry, const gchar *error_message)
  85 {
  86         gchar *input;
  87         gboolean ret;
  88         GtkWidget *dialog;
  89
  90         input = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
  91
  92         if (strlen (input) > 0)
  93                 ret = TRUE;
  94         else
  95         {
  96                 dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
  97                                                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
  98                                                                                  GTK_MESSAGE_WARNING,
  99                                                                                  GTK_BUTTONS_OK,
 100                                                                                  error_message);
 101
 102                 gtk_dialog_run (GTK_DIALOG (dialog));
 103                 gtk_widget_destroy (dialog);
 104
 105                 gtk_window_set_focus (GTK_WINDOW (parent), entry);
 106
 107                 ret = FALSE;
 108         }
 109
 110         g_free (input);
 111
 112         return ret;
 113 }
 114
 115 gchar *
 116 get_log_from_textview (GtkWidget* textview)
 117 {
 118         gchar* log;
 119         GtkTextBuffer* textbuf;
 120         GtkTextIter iterbegin, iterend;
 121         gchar* escaped_log;
 122
 123         textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
 124         gtk_text_buffer_get_start_iter(textbuf, &iterbegin);
 125         gtk_text_buffer_get_end_iter(textbuf, &iterend) ;
 126         log = gtk_text_buffer_get_text(textbuf, &iterbegin, &iterend, FALSE);
 127         escaped_log = anjuta_util_escape_quotes (log);
 128         return escaped_log;
 129 }
 130
 131 static gboolean
 132 status_pulse_timer (PulseProgressData *data)
 133 {
 134         anjuta_status_progress_pulse (data->status, data->text);
 135         return TRUE;
 136 }
 137
 138 static gboolean
 139 pulse_timer (GtkProgressBar *progress_bar)
 140 {
 141         gtk_progress_bar_pulse (progress_bar);
 142         return TRUE;
 143 }
 144
 145 static void
 146 on_pulse_timer_destroyed (PulseProgressData *data)
 147 {
 148         anjuta_status_progress_reset (data->status);
 149
 150         g_free (data->text);
 151         g_free (data);
 152 }
 153
 154 guint
 155 status_bar_progress_pulse (Git *plugin, gchar *text)
 156 {
 157         PulseProgressData *data;
 158
 159         data = g_new0 (PulseProgressData, 1);
 160         data->status = anjuta_shell_get_status (ANJUTA_PLUGIN (plugin)->shell,
 161                                                                                         NULL);
 162         data->text = g_strdup (text);
 163
 164         return g_timeout_add_full (G_PRIORITY_DEFAULT, 100,
 165                                                            (GSourceFunc) status_pulse_timer, data,
 166                                                            (GDestroyNotify) on_pulse_timer_destroyed);
 167 }
 168
 169 void
 170 clear_status_bar_progress_pulse (guint timer_id)
 171 {
 172         g_source_remove (timer_id);
 173 }
 174
 175 void
 176 report_errors (AnjutaCommand *command, guint return_code)
 177 {
 178         gchar *message;
 179
 180         if (return_code != 0)
 181         {
 182                 message = anjuta_command_get_error_message (command);
 183
 184                 if (message)
 185                 {
 186                         anjuta_util_dialog_error (NULL, message);
 187                         g_free (message);
 188                 }
 189         }
 190 }
 191
 192 static void
 193 stop_pulse_timer (gpointer timer_id, GtkProgressBar *progress_bar)
 194 {
 195         g_source_remove (GPOINTER_TO_UINT (timer_id));
 196 }
 197
 198 void
 199 pulse_progress_bar (GtkProgressBar *progress_bar)
 200 {
 201         guint timer_id;
 202
 203         timer_id = g_timeout_add (100, (GSourceFunc) pulse_timer,
 204                                                           progress_bar);
 205         g_object_set_data (G_OBJECT (progress_bar), "pulse-timer-id",
 206                                            GUINT_TO_POINTER (timer_id));
 207
 208         g_object_weak_ref (G_OBJECT (progress_bar),
 209                                            (GWeakNotify) stop_pulse_timer,
 210                                            GUINT_TO_POINTER (timer_id));
 211 }
 212
 213 gchar *
 214 get_filename_from_full_path (gchar *path)
 215 {
 216         gchar *last_slash;
 217
 218         last_slash = strrchr (path, '/');
 219
 220         /* There might be a trailing slash in the string */
 221         if ((last_slash - path) < strlen (path))
 222                 return g_strdup (last_slash + 1);
 223         else
 224                 return g_strdup ("");
 225 }
 226
 227 void
 228 on_status_command_finished (AnjutaCommand *command, guint return_code,
 229                                                         gpointer user_data)
 230 {
 231         report_errors (command, return_code);
 232
 233         g_object_unref (command);
 234 }
 235
 236 void
 237 on_status_command_data_arrived (AnjutaCommand *command,
 238                                                                 AnjutaVcsStatusTreeView *tree_view)
 239 {
 240         GQueue *status_queue;
 241         GitStatus *status;
 242         gchar *path;
 243
 244         status_queue = git_status_command_get_status_queue (GIT_STATUS_COMMAND (command));
 245
 246         while (g_queue_peek_head (status_queue))
 247         {
 248                 status = g_queue_pop_head (status_queue);
 249                 path = git_status_get_path (status);
 250
 251                 anjuta_vcs_status_tree_view_add (tree_view, path,
 252                                                                   git_status_get_vcs_status (status),
 253                                                                   FALSE);
 254
 255                 g_object_unref (status);
 256                 g_free (path);
 257         }
 258 }
 259
 260 void
 261 on_command_info_arrived (AnjutaCommand *command, Git *plugin)
 262 {
 263         GQueue *info;
 264         gchar *message;
 265
 266         info = git_command_get_info_queue (GIT_COMMAND (command));
 267
 268         while (g_queue_peek_head (info))
 269         {
 270                 message = g_queue_pop_head (info);
 271                 ianjuta_message_view_append (plugin->message_view,
 272                                                                      IANJUTA_MESSAGE_VIEW_TYPE_INFO,
 273                                                                          message, "", NULL);
 274                 g_free (message);
 275         }
 276 }
 277
 278 void
 279 select_all_status_items (GtkButton *select_all_button,
 280                                                  AnjutaVcsStatusTreeView *tree_view)
 281 {
 282         anjuta_vcs_status_tree_view_select_all (tree_view);
 283 }
 284
 285 void
 286 clear_all_status_selections (GtkButton *clear_button,
 287                                                          AnjutaVcsStatusTreeView *tree_view)
 288 {
 289         anjuta_vcs_status_tree_view_unselect_all (tree_view);
 290 }
 291
 292 void
 293 init_whole_project (Git *plugin, GtkWidget* project, gboolean active)
 294 {
 295         gboolean project_loaded;
 296
 297         project_loaded = (plugin->project_root_directory != NULL);
 298
 299         gtk_widget_set_sensitive(project, project_loaded);
 300
 301         if (project_loaded)
 302                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (project), active);
 303 }
 304
 305 void
 306 on_whole_project_toggled (GtkToggleButton* project, Git *plugin)
 307 {
 308         GtkEntry* file_entry;
 309
 310         file_entry = g_object_get_data (G_OBJECT (project), "file_entry");
 311
 312         if (gtk_toggle_button_get_active(project) && plugin->project_root_directory)
 313         {
 314                 gtk_entry_set_text (file_entry, plugin->project_root_directory);
 315                 gtk_widget_set_sensitive(GTK_WIDGET(file_entry), FALSE);
 316         }
 317         else
 318                 gtk_widget_set_sensitive(GTK_WIDGET(file_entry), TRUE);
 319 }
 320
 321 void
 322 send_diff_command_output_to_editor (AnjutaCommand *command,
 323                                                                         IAnjutaEditor *editor)
 324 {
 325         GQueue *output;
 326         gchar *line;
 327
 328         output = git_diff_command_get_output (GIT_DIFF_COMMAND (command));
 329
 330         while (g_queue_peek_head (output))
 331         {
 332                 line = g_queue_pop_head (output);
 333                 ianjuta_editor_append (editor, line, strlen (line), NULL);
 334                 g_free (line);
 335         }
 336 }
 337
 338 void
 339 on_diff_command_finished (AnjutaCommand *command, guint return_code,
 340                                                   Git *plugin)
 341 {
 342         AnjutaStatus *status;
 343
 344         status = anjuta_shell_get_status (ANJUTA_PLUGIN (plugin)->shell,
 345                                                                           NULL);
 346
 347         anjuta_status (status, _("Git: Diff complete."), 5);
 348
 349         report_errors (command, return_code);
 350
 351         g_object_unref (command);
 352 }
 353
 354 void
 355 stop_status_bar_progress_pulse (AnjutaCommand *command, guint return_code,
 356                                                                 gpointer timer_id)
 357 {
 358         clear_status_bar_progress_pulse (GPOINTER_TO_UINT (timer_id));
 359 }
 360
 361 void
 362 hide_pulse_progress_bar (AnjutaCommand *command, guint return_code,
 363                                                  GtkProgressBar *progress_bar)
 364 {
 365         guint timer_id;
 366
 367         /* If the progress bar has already been destroyed, the timer should be
 368          * stopped by stop_pulse_timer */
 369         if (GTK_IS_PROGRESS_BAR (progress_bar))
 370         {
 371                 timer_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (progress_bar),
 372                                                                                                                 "pulse-timer-id"));
 373
 374                 g_source_remove (GPOINTER_TO_UINT (timer_id));
 375                 gtk_widget_hide (GTK_WIDGET (progress_bar));
 376         }
 377 }
 378
 379 /* This function is normally intended to disconnect stock data-arrived signal
 380  * handlers in this file. It is assumed that object is the user data for the
 381  * callback. If you use any of the stock callbacks defined here, make sure
 382  * to weak ref its target with this callback. Make sure to cancel this ref
 383  * by connecting cancel_data_arrived_signal_disconnect to the command-finished
 384  * signal so we don't try to disconnect signals on a destroyed command. */
 385 void
 386 disconnect_data_arrived_signals (AnjutaCommand *command, GObject *object)
 387 {
 388         guint data_arrived_signal;
 389
 390         if (ANJUTA_IS_COMMAND (command))
 391         {
 392                 data_arrived_signal = g_signal_lookup ("data-arrived",
 393                                                                                            ANJUTA_TYPE_COMMAND);
 394
 395                 g_signal_handlers_disconnect_matched (command,
 396                                                                                           G_SIGNAL_MATCH_DATA,
 397                                                                                           data_arrived_signal,
 398                                                                                           0,
 399                                                                                           NULL,
 400                                                                                           NULL,
 401                                                                                           object);
 402         }
 403
 404 }
 405
 406 void
 407 cancel_data_arrived_signal_disconnect (AnjutaCommand *command,
 408                                                                            guint return_code,
 409                                                                            GObject *signal_target)
 410 {
 411         g_object_weak_unref (signal_target,
 412                                                  (GWeakNotify) disconnect_data_arrived_signals,
 413                                                  command);
 414 }