plugins/subversion/subversion-log-dialog.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 "subversion-log-dialog.h"
  26
  27 #define BROWSE_BUTTON_LOG_DIALOG "browse_button_log_dialog"
  28
  29 typedef struct
  30 {
  31         glong revisions[2];
  32         gint pos;
  33 } SelectedDiffData;
  34
  35 typedef struct
  36 {
  37         GtkBuilder *bxml;
  38         Subversion *plugin;
  39         gchar *path;
  40         GtkListStore *log_store;
  41         GHashTable *selected_diff_revisions;
  42 } LogData;
  43
  44 enum
  45 {
  46         COL_DIFF_SELECTED,
  47         COL_AUTHOR,
  48         COL_DATE,
  49         COL_REVISION,
  50         COL_SHORT_LOG,
  51         COL_FULL_LOG,
  52         NUM_COLS
  53 };
  54
  55 static void
  56 on_diff_selected_column_toggled (GtkCellRendererToggle *renderer,
  57                                                                  gchar *tree_path,
  58                                                                  LogData *data)
  59 {
  60         GtkTreeIter iter;
  61         glong revision;
  62         GtkWidget *log_diff_selected_button;
  63         gboolean selected;
  64
  65         gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (data->log_store),
  66                                                                                 &iter, tree_path);
  67         gtk_tree_model_get (GTK_TREE_MODEL (data->log_store), &iter,
  68                                                 COL_DIFF_SELECTED, &selected,
  69                                                 COL_REVISION, &revision,
  70                                                 -1);
  71
  72         log_diff_selected_button = GTK_WIDGET (gtk_builder_get_object (data->bxml,
  73                                                                                                          "log_diff_selected_button"));
  74
  75         selected = !selected;
  76
  77         if (selected)
  78         {
  79                 /* Only allow two log items to be selected at once. */
  80                 if (g_hash_table_size (data->selected_diff_revisions) < 2)
  81                 {
  82                         g_hash_table_insert (data->selected_diff_revisions,
  83                                                                  GINT_TO_POINTER (revision), NULL);
  84
  85                         gtk_list_store_set (data->log_store, &iter,
  86                                                                 COL_DIFF_SELECTED, TRUE,
  87                                                                 -1);
  88                 }
  89         }
  90         else
  91         {
  92                 g_hash_table_remove (data->selected_diff_revisions,
  93                                                          GINT_TO_POINTER (revision));
  94
  95                 gtk_list_store_set (data->log_store, &iter,
  96                                                         COL_DIFF_SELECTED, FALSE,
  97                                                         -1);
  98         }
  99
 100         /* For diff selected to work, exactly 2 revisions must be selected. */
 101         gtk_widget_set_sensitive (log_diff_selected_button,
 102                                                           g_hash_table_size (data->selected_diff_revisions) == 2);
 103
 104 }
 105
 106 static void
 107 create_columns (LogData *data)
 108 {
 109         GtkWidget *log_changes_view;
 110         GtkTreeViewColumn *column;
 111         GtkCellRenderer *renderer;
 112
 113         log_changes_view = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_changes_view"));
 114
 115         /* Selected for diff  */
 116         column = gtk_tree_view_column_new ();
 117         renderer = gtk_cell_renderer_toggle_new ();
 118         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 119         gtk_tree_view_column_set_title (column, _("Diff"));
 120         gtk_tree_view_append_column (GTK_TREE_VIEW (log_changes_view), column);
 121         gtk_tree_view_column_add_attribute (column, renderer, "active",
 122                                                                                 COL_DIFF_SELECTED);
 123
 124         g_signal_connect (G_OBJECT (renderer), "toggled",
 125                                           G_CALLBACK (on_diff_selected_column_toggled),
 126                                           data);
 127
 128         /* Author */
 129         column = gtk_tree_view_column_new ();
 130         renderer = gtk_cell_renderer_text_new ();
 131         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 132         gtk_tree_view_column_set_title (column, _("Author"));
 133         gtk_tree_view_append_column (GTK_TREE_VIEW (log_changes_view), column);
 134         gtk_tree_view_column_add_attribute (column, renderer, "text",
 135                                                                                 COL_AUTHOR);
 136
 137         /* Date */
 138         column = gtk_tree_view_column_new ();
 139         renderer = gtk_cell_renderer_text_new ();
 140         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 141         gtk_tree_view_column_set_title (column, _("Date"));
 142         gtk_tree_view_append_column (GTK_TREE_VIEW (log_changes_view), column);
 143         gtk_tree_view_column_add_attribute (column, renderer, "text",
 144                                                                                 COL_DATE);
 145
 146
 147         /* Revision */
 148         column = gtk_tree_view_column_new ();
 149         renderer = gtk_cell_renderer_text_new ();
 150         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 151         gtk_tree_view_column_set_title (column, _("Revision"));
 152         gtk_tree_view_append_column (GTK_TREE_VIEW (log_changes_view), column);
 153         gtk_tree_view_column_add_attribute (column, renderer, "text",
 154                                                                                 COL_REVISION);
 155
 156         /* Short log */
 157         column = gtk_tree_view_column_new ();
 158         renderer = gtk_cell_renderer_text_new ();
 159         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 160         gtk_tree_view_column_set_title (column, _("Short Log"));
 161         gtk_tree_view_append_column (GTK_TREE_VIEW (log_changes_view), column);
 162         gtk_tree_view_column_add_attribute (column, renderer, "text",
 163                                                                                 COL_SHORT_LOG);
 164
 165 }
 166
 167 static void
 168 on_log_command_finished (AnjutaCommand *command, guint return_code,
 169                                                  LogData *data)
 170 {
 171         GtkWidget *log_changes_view;
 172         GQueue *log_queue;
 173         SvnLogEntry *log_entry;
 174         GtkTreeIter iter;
 175         gchar *author;
 176         gchar *date;
 177         glong revision;
 178         gchar *short_log;
 179         gchar *full_log;
 180
 181         g_object_ref (data->log_store);
 182         log_changes_view = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_changes_view"));
 183         gtk_tree_view_set_model (GTK_TREE_VIEW (log_changes_view), NULL);
 184         g_hash_table_remove_all (data->selected_diff_revisions);
 185
 186         log_queue = svn_log_command_get_entry_queue (SVN_LOG_COMMAND (command));
 187
 188         while (g_queue_peek_tail (log_queue))
 189         {
 190                 log_entry = g_queue_pop_tail (log_queue);
 191
 192                 author = svn_log_entry_get_author (log_entry);
 193                 date = svn_log_entry_get_date (log_entry);
 194                 revision = svn_log_entry_get_revision (log_entry);
 195                 short_log = svn_log_entry_get_short_log (log_entry);
 196                 full_log = svn_log_entry_get_full_log (log_entry);
 197
 198                 gtk_list_store_prepend (data->log_store, &iter);
 199                 gtk_list_store_set (data->log_store, &iter,
 200                                                         COL_DIFF_SELECTED, FALSE,
 201                                                         COL_AUTHOR, author,
 202                                                         COL_DATE, date,
 203                                                         COL_REVISION, revision,
 204                                                         COL_SHORT_LOG, short_log,
 205                                                         COL_FULL_LOG, full_log,
 206                                                         -1);
 207
 208                 g_free (author);
 209                 g_free (date);
 210                 g_free (short_log);
 211                 g_free (full_log);
 212                 svn_log_entry_destroy (log_entry);
 213         }
 214
 215         report_errors (command, return_code);
 216
 217         svn_log_command_destroy (SVN_LOG_COMMAND (command));
 218
 219         gtk_tree_view_set_model (GTK_TREE_VIEW (log_changes_view),
 220                                                          GTK_TREE_MODEL (data->log_store));
 221         g_object_unref (data->log_store);
 222 }
 223
 224 static void
 225 subversion_show_log (LogData *data)
 226 {
 227         GtkWidget *log_changes_view;
 228         GtkWidget *log_file_entry;
 229         GtkWidget *log_diff_previous_button;
 230         GtkWidget *log_diff_selected_button;
 231         GtkWidget *log_view_selected_button;
 232         const gchar *path;
 233         SvnLogCommand *log_command;
 234         guint pulse_timer_id;
 235
 236         log_changes_view = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_changes_view"));
 237         log_file_entry = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_file_entry"));
 238         log_diff_previous_button = GTK_WIDGET (gtk_builder_get_object (data->bxml,
 239                                                                                                          "log_diff_previous_button"));
 240         log_diff_selected_button = GTK_WIDGET (gtk_builder_get_object (data->bxml,
 241                                                                                                          "log_diff_selected_button"));
 242         log_view_selected_button = GTK_WIDGET (gtk_builder_get_object (data->bxml,
 243                                                                                                          "log_view_selected_button"));
 244         path = gtk_entry_get_text (GTK_ENTRY (log_file_entry));
 245
 246         if (data->path)
 247                 g_free (data->path);
 248
 249         data->path = g_strdup (path);
 250
 251         if (strlen (path) > 0)
 252         {
 253
 254                 log_command = svn_log_command_new ((gchar *) path);
 255
 256                 pulse_timer_id = status_bar_progress_pulse (data->plugin,
 257                                                                                                           _("Subversion: Retrieving"
 258                                                                                                                 " log…"));
 259
 260                 g_signal_connect (G_OBJECT (log_command), "command-finished",
 261                                                   G_CALLBACK (stop_status_bar_progress_pulse),
 262                                                   GUINT_TO_POINTER (pulse_timer_id));
 263
 264                 g_signal_connect (G_OBJECT (log_command), "command-finished",
 265                                                   G_CALLBACK (on_log_command_finished),
 266                                                   data);
 267
 268                 anjuta_command_start (ANJUTA_COMMAND (log_command));
 269         }
 270
 271         gtk_widget_set_sensitive (log_diff_previous_button, FALSE);
 272         gtk_widget_set_sensitive (log_diff_selected_button, FALSE);
 273         gtk_widget_set_sensitive (log_view_selected_button, FALSE);
 274
 275         gtk_list_store_clear (data->log_store);
 276 }
 277
 278 static void
 279 on_log_view_button_clicked (GtkButton *button, LogData *data)
 280 {
 281         subversion_show_log (data);
 282 }
 283
 284 static void
 285 on_cat_command_data_arrived (AnjutaCommand *command, IAnjutaEditor *editor)
 286 {
 287         GQueue *output;
 288         gchar *line;
 289
 290         output = svn_cat_command_get_output (SVN_CAT_COMMAND (command));
 291
 292         while (g_queue_peek_head (output))
 293         {
 294                 line = g_queue_pop_head (output);
 295                 ianjuta_editor_append (editor, line, strlen (line), NULL);
 296                 g_free (line);
 297         }
 298 }
 299
 300 static void
 301 on_cat_command_finished (AnjutaCommand *command, guint return_code,
 302                                                  Subversion *plugin)
 303 {
 304         AnjutaStatus *status;
 305
 306         status = anjuta_shell_get_status (ANJUTA_PLUGIN (plugin)->shell,
 307                                                                           NULL);
 308
 309         anjuta_status (status, _("Subversion: File retrieved."), 5);
 310
 311         report_errors (command, return_code);
 312
 313         svn_cat_command_destroy (SVN_CAT_COMMAND (command));
 314 }
 315
 316 static void
 317 on_log_view_selected_button_clicked (GtkButton *button, LogData *data)
 318 {
 319         GtkWidget *log_changes_view;
 320         GtkTreeModel *log_store;
 321         GtkTreeSelection *selection;
 322         GtkTreeIter selected_iter;
 323         glong revision;
 324         SvnCatCommand *cat_command;;
 325         gchar *filename;
 326         gchar *editor_name;
 327         IAnjutaDocumentManager *docman;
 328         IAnjutaEditor *editor;
 329         guint pulse_timer_id;
 330
 331         log_changes_view = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_changes_view"));
 332         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_changes_view));
 333         gtk_tree_selection_get_selected (selection, &log_store, &selected_iter);
 334
 335         gtk_tree_model_get (log_store, &selected_iter,
 336                                                 COL_REVISION, &revision,
 337                                                 -1);
 338
 339         cat_command = svn_cat_command_new (data->path, revision);
 340
 341         filename = get_filename_from_full_path (data->path);
 342         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (data->plugin)->shell,
 343                                                  IAnjutaDocumentManager, NULL);
 344         editor_name = g_strdup_printf ("[Revision %ld] %s", revision, filename);
 345         editor = ianjuta_document_manager_add_buffer(docman, editor_name, "",
 346                                                                                                  NULL);
 347         g_free (filename);
 348         g_free (editor_name);
 349
 350         pulse_timer_id = status_bar_progress_pulse (data->plugin,
 351                                                                                                 _("Subversion: Retrieving "
 352                                                                                                   "file…"));
 353
 354         g_signal_connect (G_OBJECT (cat_command), "command-finished",
 355                                           G_CALLBACK (stop_status_bar_progress_pulse),
 356                                           GUINT_TO_POINTER (pulse_timer_id));
 357
 358         g_signal_connect (G_OBJECT (cat_command), "data-arrived",
 359                                           G_CALLBACK (on_cat_command_data_arrived),
 360                                           editor);
 361
 362         g_signal_connect (G_OBJECT (cat_command), "command-finished",
 363                                           G_CALLBACK (on_cat_command_finished),
 364                                           data->plugin);
 365
 366         g_object_weak_ref (G_OBJECT (editor),
 367                                            (GWeakNotify) disconnect_data_arrived_signals,
 368                                            cat_command);
 369
 370         anjuta_command_start (ANJUTA_COMMAND (cat_command));
 371 }
 372
 373 static void
 374 get_selected_revisions (gpointer revision, gpointer value,
 375                                                 SelectedDiffData *data)
 376 {
 377         data->revisions[data->pos] = GPOINTER_TO_INT (revision);
 378         data->pos++;
 379 }
 380
 381 static void
 382 on_log_diff_selected_button_clicked (GtkButton *button, LogData *data)
 383 {
 384         SelectedDiffData *selected_diff_data;
 385         SvnDiffCommand *diff_command;
 386         glong revision1;
 387         glong revision2;
 388         IAnjutaDocumentManager *docman;
 389         gchar *filename;
 390         gchar *editor_name;
 391         IAnjutaEditor *editor;
 392         guint pulse_timer_id;
 393
 394         if (g_hash_table_size (data->selected_diff_revisions) == 2)
 395         {
 396                 selected_diff_data = g_new0 (SelectedDiffData, 1);
 397
 398                 g_hash_table_foreach (data->selected_diff_revisions,
 399                                                           (GHFunc) get_selected_revisions,
 400                                                           selected_diff_data);
 401
 402                 revision1 = MIN (selected_diff_data->revisions[0],
 403                                                  selected_diff_data->revisions[1]);
 404                 revision2 = MAX (selected_diff_data->revisions[0],
 405                                                  selected_diff_data->revisions[1]);
 406
 407                 diff_command = svn_diff_command_new (data->path,
 408                                                                                          revision1,
 409                                                                                          revision2,
 410                                                                                          data->plugin->project_root_dir,
 411                                                                                          TRUE);
 412
 413                 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (data->plugin)->shell,
 414                                                  IAnjutaDocumentManager, NULL);
 415                 filename = get_filename_from_full_path (data->path);
 416                 editor_name = g_strdup_printf ("[Revisions %ld/%ld] %s.diff",
 417                                                                            revision1, revision2, filename);
 418
 419                 editor = ianjuta_document_manager_add_buffer(docman, editor_name, "",
 420                                                                                                          NULL);
 421
 422                 g_free (filename);
 423                 g_free (editor_name);
 424
 425                 pulse_timer_id = status_bar_progress_pulse (data->plugin,
 426                                                                                                         _("Subversion: Retrieving "
 427                                                                                                           "diff…"));
 428
 429                 g_signal_connect (G_OBJECT (diff_command), "command-finished",
 430                                                   G_CALLBACK (stop_status_bar_progress_pulse),
 431                                                   GUINT_TO_POINTER (pulse_timer_id));
 432
 433                 g_signal_connect (G_OBJECT (diff_command), "data-arrived",
 434                                                   G_CALLBACK (send_diff_command_output_to_editor),
 435                                                   editor);
 436
 437                 g_signal_connect (G_OBJECT (diff_command), "command-finished",
 438                                                   G_CALLBACK (on_diff_command_finished),
 439                                                   data->plugin);
 440
 441                 g_object_weak_ref (G_OBJECT (editor),
 442                                                    (GWeakNotify) disconnect_data_arrived_signals,
 443                                                    diff_command);
 444
 445                 anjuta_command_start (ANJUTA_COMMAND (diff_command));
 446
 447                 g_free (selected_diff_data);
 448
 449         }
 450 }
 451
 452 static void
 453 on_log_diff_previous_button_clicked (GtkButton *button, LogData *data)
 454 {
 455         GtkWidget *log_changes_view;
 456         GtkTreeModel *log_store;
 457         GtkTreeSelection *selection;
 458         GtkTreeIter selected_iter;
 459         glong revision;
 460         SvnDiffCommand *diff_command;
 461         IAnjutaDocumentManager *docman;
 462         gchar *filename;
 463         gchar *editor_name;
 464         IAnjutaEditor *editor;
 465         guint pulse_timer_id;
 466
 467         log_changes_view = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_changes_view"));
 468         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_changes_view));
 469         gtk_tree_selection_get_selected (selection, &log_store, &selected_iter);
 470
 471         gtk_tree_model_get (log_store, &selected_iter,
 472                                                 COL_REVISION, &revision,
 473                                                 -1);
 474
 475         diff_command = svn_diff_command_new (data->path,
 476                                                                                  SVN_DIFF_REVISION_PREVIOUS,
 477                                                                                  revision,
 478                                                                                  data->plugin->project_root_dir,
 479                                                                                  TRUE);
 480
 481         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (data->plugin)->shell,
 482                                              IAnjutaDocumentManager, NULL);
 483         filename = get_filename_from_full_path (data->path);
 484         editor_name = g_strdup_printf ("[Revisions %ld/%ld] %s.diff",
 485                                                                    revision - 1, revision, filename);
 486         editor = ianjuta_document_manager_add_buffer(docman, editor_name, "",
 487                                                                                                  NULL);
 488
 489         g_free (filename);
 490         g_free (editor_name);
 491
 492         pulse_timer_id = status_bar_progress_pulse (data->plugin,
 493                                                                                                 _("Subversion: Retrieving "
 494                                                                                                   "diff…"));
 495
 496         g_signal_connect (G_OBJECT (diff_command), "command-finished",
 497                                           G_CALLBACK (stop_status_bar_progress_pulse),
 498                                           GUINT_TO_POINTER (pulse_timer_id));
 499
 500         g_signal_connect (G_OBJECT (diff_command), "data-arrived",
 501                                           G_CALLBACK (send_diff_command_output_to_editor),
 502                                           editor);
 503
 504         g_signal_connect (G_OBJECT (diff_command), "command-finished",
 505                                           G_CALLBACK (on_diff_command_finished),
 506                                           data->plugin);
 507
 508         g_object_weak_ref (G_OBJECT (editor),
 509                                            (GWeakNotify) disconnect_data_arrived_signals,
 510                                            diff_command);
 511
 512         anjuta_command_start (ANJUTA_COMMAND (diff_command));
 513 }
 514
 515 static void
 516 on_subversion_log_vbox_destroy (GtkWidget *subversion_log, LogData *data)
 517 {
 518         g_hash_table_destroy (data->selected_diff_revisions);
 519         g_free (data->path);
 520         g_free (data);
 521 }
 522
 523 static gboolean
 524 on_log_changes_view_row_selected (GtkTreeSelection *selection,
 525                                                                   GtkTreeModel *model,
 526                                                                   GtkTreePath *path,
 527                                                                   gboolean path_currently_selected,
 528                                                                   LogData *data)
 529 {
 530         GtkTreeIter iter;
 531         GtkWidget *log_message_text;
 532         GtkWidget *log_diff_previous_button;
 533         GtkWidget *log_view_selected_button;
 534         GtkTextBuffer *buffer;
 535         gchar *log_message;
 536
 537         gtk_tree_model_get_iter (model, &iter, path);
 538         log_message_text = GTK_WIDGET (gtk_builder_get_object (data->bxml, "log_message_text"));
 539         log_diff_previous_button = GTK_WIDGET (gtk_builder_get_object (data->bxml,
 540                                                                                                          "log_diff_previous_button"));
 541         log_view_selected_button = GTK_WIDGET (gtk_builder_get_object (data->bxml,
 542                                                                                                          "log_view_selected_button"));
 543         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (log_message_text));
 544         gtk_tree_model_get (model, &iter,
 545                                                 COL_FULL_LOG, &log_message,
 546                                                 -1);
 547
 548         gtk_text_buffer_set_text (buffer, log_message, strlen (log_message));
 549         gtk_widget_set_sensitive (log_diff_previous_button,
 550                                                           TRUE);
 551         if (data->path)
 552         {
 553                 gtk_widget_set_sensitive (log_view_selected_button,
 554                                                                   !g_file_test (data->path,
 555                                                                                                 G_FILE_TEST_IS_DIR));
 556         }
 557
 558         return TRUE;
 559 }
 560
 561 GtkWidget *
 562 subversion_log_window_create (Subversion *plugin)
 563 {
 564         LogData *data;
 565         GtkWidget *subversion_log;
 566         GtkWidget *subversion_log_vbox;
 567         GtkWidget *log_changes_view;
 568         GtkWidget *log_whole_project_check;
 569         GtkWidget *log_file_entry;
 570         GtkWidget *log_view_button;
 571         GtkWidget *log_diff_previous_button;
 572         GtkWidget *log_diff_selected_button;
 573         GtkWidget *log_view_selected_button;
 574         GtkWidget *button;
 575         GtkListStore *log_list_store;
 576         GtkTreeSelection *selection;
 577
 578         data = g_new0 (LogData, 1);
 579         data->bxml = plugin->log_bxml;
 580         data->selected_diff_revisions = g_hash_table_new (g_direct_hash,
 581                                                                                                           g_direct_equal);
 582         data->plugin = plugin;
 583         data->path = NULL;
 584
 585         subversion_log = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, "subversion_log"));
 586         subversion_log_vbox = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, "subversion_log_vbox"));
 587         log_changes_view = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, "log_changes_view"));
 588         log_whole_project_check = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml,
 589                                                                                                         "log_whole_project_check"));
 590         log_file_entry = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, "log_file_entry"));
 591         log_view_button = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, "log_view_button"));
 592         log_diff_previous_button = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml,
 593                                                                                                          "log_diff_previous_button"));
 594         log_diff_selected_button = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml,
 595                                                                                                          "log_diff_selected_button"));
 596         log_view_selected_button = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml,
 597                                                                                                          "log_view_selected_button"));
 598         button = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, BROWSE_BUTTON_LOG_DIALOG));
 599         g_signal_connect(G_OBJECT(button), "clicked",
 600                 G_CALLBACK(on_subversion_browse_button_clicked), log_file_entry);
 601
 602         g_signal_connect (G_OBJECT (log_view_button), "clicked",
 603                                           G_CALLBACK (on_log_view_button_clicked),
 604                                           data);
 605
 606         g_signal_connect (G_OBJECT (log_diff_previous_button), "clicked",
 607                                           G_CALLBACK (on_log_diff_previous_button_clicked),
 608                                           data);
 609
 610         g_signal_connect (G_OBJECT (log_diff_selected_button), "clicked",
 611                                           G_CALLBACK (on_log_diff_selected_button_clicked),
 612                                           data);
 613
 614         g_signal_connect (G_OBJECT (log_view_selected_button), "clicked",
 615                                           G_CALLBACK (on_log_view_selected_button_clicked),
 616                                           data);
 617
 618
 619         g_object_set_data (G_OBJECT (log_whole_project_check), "fileentry",
 620                                            log_file_entry);
 621         g_object_set_data (G_OBJECT (subversion_log_vbox), "log-data", data);
 622         g_signal_connect (G_OBJECT (log_whole_project_check), "toggled",
 623                                           G_CALLBACK (on_whole_project_toggled), plugin);
 624         init_whole_project (plugin, log_whole_project_check, FALSE);
 625
 626         log_list_store = gtk_list_store_new (NUM_COLS,
 627                                                                                  G_TYPE_BOOLEAN,
 628                                                                                  G_TYPE_STRING,
 629                                                                                  G_TYPE_STRING,
 630                                                                                  G_TYPE_LONG,
 631                                                                                  G_TYPE_STRING,
 632                                                                                  G_TYPE_STRING);
 633         create_columns (data);
 634         gtk_tree_view_set_model (GTK_TREE_VIEW (log_changes_view),
 635                                                          GTK_TREE_MODEL (log_list_store));
 636
 637         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_changes_view));
 638         gtk_tree_selection_set_select_function (selection,
 639                                                                                         (GtkTreeSelectionFunc) on_log_changes_view_row_selected,
 640                                                                                         data, NULL);
 641
 642         data->log_store = log_list_store;
 643         g_object_unref (log_list_store);
 644
 645         g_signal_connect (G_OBJECT (subversion_log_vbox), "destroy",
 646                                           G_CALLBACK (on_subversion_log_vbox_destroy),
 647                                           data);
 648
 649         g_object_ref (subversion_log_vbox);
 650         gtk_container_remove (GTK_CONTAINER (subversion_log), subversion_log_vbox);
 651         gtk_widget_destroy (subversion_log);
 652
 653         return subversion_log_vbox;
 654 }
 655
 656 void
 657 on_menu_subversion_log (GtkAction *action, Subversion *plugin)
 658 {
 659         anjuta_shell_present_widget (ANJUTA_PLUGIN (plugin)->shell,
 660                                                                  plugin->log_viewer, NULL);
 661 }
 662
 663 void
 664 on_fm_subversion_log (GtkAction *action, Subversion *plugin)
 665 {
 666         GtkWidget *log_file_entry;
 667         GtkWidget *log_whole_project_check;
 668
 669         log_file_entry = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml, "log_file_entry"));
 670         log_whole_project_check = GTK_WIDGET (gtk_builder_get_object (plugin->log_bxml,
 671                                                                                                         "log_whole_project_check"));
 672
 673         gtk_entry_set_text (GTK_ENTRY (log_file_entry),
 674                                                 plugin->fm_current_filename);
 675         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (log_whole_project_check),
 676                                                                   FALSE);
 677
 678         anjuta_shell_present_widget (ANJUTA_PLUGIN (plugin)->shell,
 679                                                                  plugin->log_viewer, NULL);
 680
 681         subversion_show_log (g_object_get_data (G_OBJECT (plugin->log_viewer),
 682                                                                                         "log-data"));
 683 }
 684
 685 void
 686 subversion_log_set_whole_project_sensitive (GtkBuilder *log_bxml,
 687                                                                                         gboolean sensitive)
 688 {
 689         GtkWidget *log_whole_project_check;
 690
 691         log_whole_project_check = GTK_WIDGET (gtk_builder_get_object (log_bxml,
 692                                                                                                         "log_whole_project_check"));
 693
 694         gtk_widget_set_sensitive (log_whole_project_check, sensitive);
 695
 696         if (!sensitive)
 697         {
 698                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (log_whole_project_check),
 699                                                                           FALSE);
 700         }
 701 }