src/giggle-window.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 Imendio AB
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include <glib/gi18n.h>
  23 #include <gtk/gtk.h>
  24 #include <string.h>
  25
  26 #include "giggle-window.h"
  27 #include "giggle-git.h"
  28 #include "giggle-personal-details-window.h"
  29 #include "giggle-view-summary.h"
  30 #include "giggle-view-history.h"
  31 #include "giggle-view-file.h"
  32 #include "giggle-searchable.h"
  33 #include "giggle-diff-window.h"
  34 #include "eggfindbar.h"
  35
  36 typedef struct GiggleWindowPriv GiggleWindowPriv;
  37
  38 struct GiggleWindowPriv {
  39         GtkWidget           *content_vbox;
  40         GtkWidget           *main_notebook;
  41
  42         /* Views */
  43         GtkWidget           *summary_view;
  44         GtkWidget           *history_view;
  45         GtkWidget           *file_view;
  46
  47         /* Menu */
  48         GtkUIManager        *ui_manager;
  49         GtkRecentManager    *recent_manager;
  50         GtkActionGroup      *recent_action_group;
  51
  52         GtkWidget           *find_bar;
  53
  54         GiggleGit           *git;
  55
  56         GtkWidget           *personal_details_window;
  57         GtkWidget           *diff_current_window;
  58 };
  59
  60 enum {
  61         SEARCH_NEXT,
  62         SEARCH_PREV
  63 };
  64
  65
  66 static void window_finalize                       (GObject           *object);
  67
  68 static void window_add_widget_cb                  (GtkUIManager      *merge,
  69                                                    GtkWidget         *widget,
  70                                                    GiggleWindow      *window);
  71
  72 static void window_action_quit_cb                 (GtkAction         *action,
  73                                                    GiggleWindow      *window);
  74 static void window_action_open_cb                 (GtkAction         *action,
  75                                                    GiggleWindow      *window);
  76 static void window_action_save_patch_cb           (GtkAction         *action,
  77                                                    GiggleWindow      *window);
  78 static void window_action_diff_cb                 (GtkAction         *action,
  79                                                    GiggleWindow      *window);
  80 static void window_action_find_cb                 (GtkAction         *action,
  81                                                    GiggleWindow      *window);
  82 static void window_action_personal_details_cb     (GtkAction         *action,
  83                                                    GiggleWindow      *window);
  84 static void window_action_about_cb                (GtkAction         *action,
  85                                                    GiggleWindow      *window);
  86 static void window_action_compact_mode_cb         (GtkAction         *action,
  87                                                    GiggleWindow      *window);
  88 static void window_directory_changed_cb           (GiggleGit         *git,
  89                                                    GParamSpec        *arg,
  90                                                    GiggleWindow      *window);
  91 static void window_recent_repositories_add        (GiggleWindow      *window);
  92 static void window_recent_repositories_update     (GiggleWindow      *window);
  93
  94 static void window_notebook_switch_page_cb        (GtkNotebook       *notebook,
  95                                                    GtkNotebookPage   *page,
  96                                                    guint              page_num,
  97                                                    GiggleWindow      *window);
  98
  99 static void window_find_next                      (GtkWidget         *widget,
 100                                                    GiggleWindow      *window);
 101 static void window_find_previous                  (GtkWidget         *widget,
 102                                                    GiggleWindow      *window);
 103
 104 static const GtkToggleActionEntry toggle_action_entries[] = {
 105         { "CompactMode", NULL,
 106           N_("_Compact mode"), "F7", NULL,
 107           G_CALLBACK (window_action_compact_mode_cb), FALSE
 108         },
 109 };
 110
 111 static const GtkActionEntry action_entries[] = {
 112         { "ProjectMenu", NULL,
 113           N_("_Project"), NULL, NULL,
 114           NULL
 115         },
 116         { "EditMenu", NULL,
 117           N_("_Edit"), NULL, NULL,
 118           NULL
 119         },
 120         { "ViewMenu", NULL,
 121           N_("_View"), NULL, NULL,
 122           NULL
 123         },
 124         { "HelpMenu", NULL,
 125           N_("_Help"), NULL, NULL,
 126           NULL
 127         },
 128         { "Open", GTK_STOCK_OPEN,
 129           N_("_Open"), "<control>O", N_("Open a GIT repository"),
 130           G_CALLBACK (window_action_open_cb)
 131         },
 132         { "SavePatch", GTK_STOCK_SAVE,
 133           N_("_Save patch"), "<control>S", N_("Save a patch"),
 134           G_CALLBACK (window_action_save_patch_cb)
 135         },
 136         { "Diff", NULL,
 137           N_("_Diff current changes"), "<control>D", N_("Diff current changes"),
 138           G_CALLBACK (window_action_diff_cb)
 139         },
 140         { "Quit", GTK_STOCK_QUIT,
 141           N_("_Quit"), "<control>Q", N_("Quit the application"),
 142           G_CALLBACK (window_action_quit_cb)
 143         },
 144         { "PersonalDetails", GTK_STOCK_PREFERENCES,
 145           N_("Edit Personal _Details"), NULL, N_("Edit Personal details"),
 146           G_CALLBACK (window_action_personal_details_cb)
 147         },
 148         { "Find", GTK_STOCK_FIND,
 149           N_("Find..."), NULL, N_("Find..."),
 150           G_CALLBACK (window_action_find_cb)
 151         },
 152         { "About", GTK_STOCK_ABOUT,
 153           N_("_About"), NULL, N_("About this application"),
 154           G_CALLBACK (window_action_about_cb)
 155         }
 156 };
 157
 158 static const gchar *ui_layout =
 159         "<ui>"
 160         "  <menubar name='MainMenubar'>"
 161         "    <menu action='ProjectMenu'>"
 162         "      <menuitem action='Open'/>"
 163 /*
 164         "      <menuitem action='SavePatch'/>"
 165 */
 166         "      <menuitem action='Diff'/>"
 167         "      <separator/>"
 168         "      <placeholder name='RecentRepositories'/>"
 169         "      <separator/>"
 170         "      <menuitem action='Quit'/>"
 171         "    </menu>"
 172         "    <menu action='EditMenu'>"
 173         "      <menuitem action='PersonalDetails'/>"
 174         "      <separator/>"
 175         "      <menuitem action='Find'/>"
 176         "    </menu>"
 177         "    <menu action='ViewMenu'>"
 178         "      <menuitem action='CompactMode'/>"
 179         "    </menu>"
 180         "    <menu action='HelpMenu'>"
 181         "      <menuitem action='About'/>"
 182         "    </menu>"
 183         "  </menubar>"
 184         "</ui>";
 185
 186
 187 G_DEFINE_TYPE (GiggleWindow, giggle_window, GTK_TYPE_WINDOW)
 188
 189 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GIGGLE_TYPE_WINDOW, GiggleWindowPriv))
 190
 191 #define RECENT_FILES_GROUP "giggle"
 192 #define SAVE_PATCH_UI_PATH "/ui/MainMenubar/ProjectMenu/SavePatch"
 193 #define FIND_PATH "/ui/MainMenubar/EditMenu/Find"
 194 #define RECENT_REPOS_PLACEHOLDER_PATH "/ui/MainMenubar/ProjectMenu/RecentRepositories"
 195
 196 static void
 197 giggle_window_class_init (GiggleWindowClass *class)
 198 {
 199         GObjectClass *object_class = G_OBJECT_CLASS (class);
 200
 201         object_class->finalize = window_finalize;
 202
 203         g_type_class_add_private (object_class, sizeof (GiggleWindowPriv));
 204 }
 205
 206 static void
 207 window_create_menu (GiggleWindow *window)
 208 {
 209         GiggleWindowPriv *priv;
 210         GtkActionGroup   *action_group;
 211         GError           *error = NULL;
 212
 213         priv = GET_PRIV (window);
 214         priv->ui_manager = gtk_ui_manager_new ();
 215         g_signal_connect (priv->ui_manager,
 216                           "add_widget",
 217                           G_CALLBACK (window_add_widget_cb),
 218                           window);
 219
 220         action_group = gtk_action_group_new ("MainActions");
 221         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 222         gtk_action_group_add_actions (action_group,
 223                                       action_entries,
 224                                       G_N_ELEMENTS (action_entries),
 225                                       window);
 226         gtk_action_group_add_toggle_actions (action_group,
 227                                              toggle_action_entries,
 228                                              G_N_ELEMENTS (toggle_action_entries),
 229                                              window);
 230         gtk_ui_manager_insert_action_group (priv->ui_manager, action_group, 0);
 231
 232         gtk_window_add_accel_group (GTK_WINDOW (window),
 233                                     gtk_ui_manager_get_accel_group (priv->ui_manager));
 234
 235         g_object_unref (action_group);
 236
 237         gtk_ui_manager_add_ui_from_string (priv->ui_manager, ui_layout, -1, &error);
 238         if (error) {
 239                 g_error ("Couldn't create UI: %s\n", error->message);
 240         }
 241
 242         gtk_ui_manager_ensure_update (priv->ui_manager);
 243
 244         /* create recent repositories resources */
 245         priv->recent_action_group = gtk_action_group_new ("RecentRepositories");
 246         gtk_ui_manager_insert_action_group (priv->ui_manager, priv->recent_action_group, 0);
 247
 248         priv->recent_manager = gtk_recent_manager_get_default ();
 249         g_signal_connect_swapped (priv->recent_manager, "changed",
 250                                   G_CALLBACK (window_recent_repositories_update), window);
 251
 252         window_recent_repositories_update (window);
 253 }
 254
 255 void
 256 giggle_window_set_directory (GiggleWindow *window,
 257                       const gchar  *directory)
 258 {
 259         GiggleWindowPriv *priv;
 260         GError           *error = NULL;
 261
 262         priv = GET_PRIV (window);
 263
 264         if (!giggle_git_set_directory (priv->git, directory, &error)) {
 265                 GtkWidget *dialog;
 266
 267                 dialog = gtk_message_dialog_new (GTK_WINDOW (window),
 268                                                  GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 269                                                  GTK_MESSAGE_ERROR,
 270                                                  GTK_BUTTONS_OK,
 271                                                  _("The directory '%s' does not look like a "
 272                                                    "GIT repository."), directory);
 273
 274                 gtk_dialog_run (GTK_DIALOG (dialog));
 275                 gtk_widget_destroy (dialog);
 276         }
 277 }
 278
 279 static void
 280 giggle_window_init (GiggleWindow *window)
 281 {
 282         GiggleWindowPriv *priv;
 283
 284         priv = GET_PRIV (window);
 285
 286         priv->git = giggle_git_get ();
 287
 288         g_signal_connect (priv->git,
 289                           "notify::directory",
 290                           G_CALLBACK (window_directory_changed_cb),
 291                           window);
 292         g_signal_connect_swapped (priv->git,
 293                                   "notify::project-dir",
 294                                   G_CALLBACK (window_recent_repositories_add),
 295                                   window);
 296
 297         priv->content_vbox = gtk_vbox_new (FALSE, 0);
 298         gtk_widget_show (priv->content_vbox);
 299         gtk_container_add (GTK_CONTAINER (window), priv->content_vbox);
 300
 301         window_create_menu (window);
 302
 303         priv->main_notebook = gtk_notebook_new ();
 304         gtk_widget_show (priv->main_notebook);
 305         gtk_box_pack_start_defaults (GTK_BOX (priv->content_vbox), priv->main_notebook);
 306
 307         g_signal_connect (priv->main_notebook, "switch-page",
 308                           G_CALLBACK (window_notebook_switch_page_cb), window);
 309
 310         /* setup find bar */
 311         priv->find_bar = egg_find_bar_new ();
 312         gtk_box_pack_end (GTK_BOX (priv->content_vbox), priv->find_bar, FALSE, FALSE, 0);
 313
 314         g_signal_connect (G_OBJECT (priv->find_bar), "close",
 315                           G_CALLBACK (gtk_widget_hide), NULL);
 316         g_signal_connect (G_OBJECT (priv->find_bar), "next",
 317                           G_CALLBACK (window_find_next), window);
 318         g_signal_connect (G_OBJECT (priv->find_bar), "previous",
 319                           G_CALLBACK (window_find_previous), window);
 320
 321         /* personal details window */
 322         priv->personal_details_window = giggle_personal_details_window_new ();
 323
 324         gtk_window_set_transient_for (GTK_WINDOW (priv->personal_details_window),
 325                                       GTK_WINDOW (window));
 326         g_signal_connect_after (G_OBJECT (priv->personal_details_window), "response",
 327                                 G_CALLBACK (gtk_widget_hide), NULL);
 328
 329         /* diff current window */
 330         priv->diff_current_window = giggle_diff_window_new ();
 331
 332         gtk_window_set_transient_for (GTK_WINDOW (priv->diff_current_window),
 333                                       GTK_WINDOW (window));
 334         g_signal_connect_after (G_OBJECT (priv->diff_current_window), "response",
 335                                 G_CALLBACK (gtk_widget_hide), NULL);
 336
 337         /* append history view */
 338         priv->history_view = giggle_view_history_new ();
 339         gtk_widget_show (priv->history_view);
 340
 341         gtk_notebook_append_page (GTK_NOTEBOOK (priv->main_notebook),
 342                                   priv->history_view,
 343                                   gtk_label_new (_("History")));
 344
 345         /* append file view */
 346         /*
 347         priv->file_view = giggle_view_file_new ();
 348         gtk_widget_show (priv->file_view);
 349
 350         gtk_notebook_append_page (GTK_NOTEBOOK (priv->main_notebook),
 351                                   priv->file_view,
 352                                   gtk_label_new (_("Files")));
 353         */
 354
 355         /* append summary view */
 356         priv->summary_view = giggle_view_summary_new ();
 357         gtk_widget_show (priv->summary_view);
 358
 359         gtk_notebook_append_page (GTK_NOTEBOOK (priv->main_notebook),
 360                                   priv->summary_view,
 361                                   gtk_label_new (_("Summary")));
 362
 363 }
 364
 365 static void
 366 window_finalize (GObject *object)
 367 {
 368         GiggleWindowPriv *priv;
 369
 370         priv = GET_PRIV (object);
 371
 372         g_object_unref (priv->ui_manager);
 373         g_object_unref (priv->git);
 374         g_object_unref (priv->recent_manager);
 375         g_object_unref (priv->recent_action_group);
 376
 377         G_OBJECT_CLASS (giggle_window_parent_class)->finalize (object);
 378 }
 379
 380 static void
 381 window_recent_repositories_add (GiggleWindow *window)
 382 {
 383         static gchar     *groups[] = { RECENT_FILES_GROUP, NULL };
 384         GiggleWindowPriv *priv;
 385         GtkRecentData    *data;
 386         const gchar      *repository;
 387         gchar            *tmp_string;
 388
 389         priv = GET_PRIV (window);
 390
 391         repository = giggle_git_get_project_dir (priv->git);
 392         if(!repository) {
 393                 repository = giggle_git_get_git_dir (priv->git);
 394         }
 395
 396         g_return_if_fail (repository != NULL);
 397
 398         data = g_slice_new0 (GtkRecentData);
 399         data->display_name = g_strdup (giggle_git_get_project_name (priv->git));
 400         data->groups = groups;
 401         data->mime_type = g_strdup ("x-directory/normal");
 402         data->app_name = (gchar *) g_get_application_name ();
 403         data->app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);
 404
 405         tmp_string = g_filename_to_uri (repository, NULL, NULL);
 406         gtk_recent_manager_add_full (priv->recent_manager,
 407                                      tmp_string, data);
 408         g_free (tmp_string);
 409 }
 410
 411 static void
 412 window_recent_repository_activate (GtkAction    *action,
 413                                    GiggleWindow *window)
 414 {
 415         GiggleWindowPriv *priv;
 416         const gchar      *directory;
 417
 418         priv = GET_PRIV (window);
 419
 420         directory = g_object_get_data (G_OBJECT (action), "recent-action-path");
 421         giggle_window_set_directory (window, directory);
 422 }
 423
 424 static void
 425 window_recent_repositories_clear (GiggleWindow *window)
 426 {
 427         GiggleWindowPriv *priv;
 428         GList            *actions, *l;
 429
 430         priv = GET_PRIV (window);
 431         actions = l = gtk_action_group_list_actions (priv->recent_action_group);
 432
 433         for (l = actions; l != NULL; l = l->next) {
 434                 gtk_action_group_remove_action (priv->recent_action_group, l->data);
 435         }
 436
 437         g_list_free (actions);
 438 }
 439
 440 /* this should not be necessary when there's
 441  * GtkRecentManager/GtkUIManager integration
 442  */
 443 static void
 444 window_recent_repositories_reload (GiggleWindow *window)
 445 {
 446         GiggleWindowPriv *priv;
 447         GList            *recent_items, *l;
 448         GtkRecentInfo    *info;
 449         GtkAction        *action;
 450         guint             recent_menu_id;
 451         gchar            *action_name, *label;
 452         gint              count = 0;
 453
 454         priv = GET_PRIV (window);
 455
 456         recent_items = l = gtk_recent_manager_get_items (priv->recent_manager);
 457         recent_menu_id = gtk_ui_manager_new_merge_id (priv->ui_manager);
 458
 459         /* FIXME: the max count is hardcoded */
 460         while (l && count < 10) {
 461                 info = l->data;
 462
 463                 if (gtk_recent_info_has_group (info, RECENT_FILES_GROUP)) {
 464                         action_name = g_strdup_printf ("recent-repository-%d", count);
 465                         label = g_strdup (gtk_recent_info_get_uri_display (info));
 466
 467                         /* FIXME: add accel? */
 468
 469                         action = gtk_action_new (action_name,
 470                                                  label,
 471                                                  NULL,
 472                                                  NULL);
 473
 474                         g_object_set_data_full (G_OBJECT (action), "recent-action-path",
 475                                                 g_strdup (gtk_recent_info_get_uri_display (info)),
 476                                                 (GDestroyNotify) g_free);
 477
 478                         g_signal_connect (action,
 479                                           "activate",
 480                                           G_CALLBACK (window_recent_repository_activate),
 481                                           window);
 482
 483                         gtk_action_group_add_action (priv->recent_action_group, action);
 484
 485                         gtk_ui_manager_add_ui (priv->ui_manager,
 486                                                recent_menu_id,
 487                                                RECENT_REPOS_PLACEHOLDER_PATH,
 488                                                action_name,
 489                                                action_name,
 490                                                GTK_UI_MANAGER_MENUITEM,
 491                                                FALSE);
 492
 493                         g_object_unref (action);
 494                         g_free (action_name);
 495                         g_free (label);
 496                         count++;
 497                 }
 498
 499                 l = l->next;
 500         }
 501
 502         g_list_foreach (recent_items, (GFunc) gtk_recent_info_unref, NULL);
 503         g_list_free (recent_items);
 504 }
 505
 506 static void
 507 window_recent_repositories_update (GiggleWindow *window)
 508 {
 509         window_recent_repositories_clear (window);
 510         window_recent_repositories_reload (window);
 511 }
 512
 513 /* Update revision info. If previous_revision is not NULL, a diff between it and
 514  * the current revision will be shown.
 515  */
 516
 517 static void
 518 window_add_widget_cb (GtkUIManager *merge,
 519                       GtkWidget    *widget,
 520                       GiggleWindow *window)
 521 {
 522         GiggleWindowPriv *priv;
 523
 524         priv = GET_PRIV (window);
 525
 526         gtk_box_pack_start (GTK_BOX (priv->content_vbox), widget, FALSE, FALSE, 0);
 527 }
 528
 529 static void
 530 window_action_quit_cb (GtkAction    *action,
 531                        GiggleWindow *window)
 532 {
 533         gtk_main_quit ();
 534 }
 535
 536 static void
 537 window_action_open_cb (GtkAction    *action,
 538                        GiggleWindow *window)
 539 {
 540         GiggleWindowPriv *priv;
 541         GtkWidget        *file_chooser;
 542         const gchar      *directory;
 543
 544         priv = GET_PRIV (window);
 545
 546         file_chooser = gtk_file_chooser_dialog_new (
 547                 _("Select GIT repository"),
 548                 GTK_WINDOW (window),
 549                 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
 550                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 551                 GTK_STOCK_OK, GTK_RESPONSE_OK,
 552                 NULL);
 553
 554         gtk_file_chooser_set_current_folder (
 555                 GTK_FILE_CHOOSER (file_chooser),
 556                 giggle_git_get_directory (priv->git));
 557
 558         if (gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_OK) {
 559                 directory = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (file_chooser));
 560                 giggle_window_set_directory (window, directory);
 561         }
 562
 563         gtk_widget_destroy (file_chooser);
 564 }
 565
 566 static void
 567 window_action_save_patch_cb (GtkAction    *action,
 568                              GiggleWindow *window)
 569 {
 570 /* FIXME: implement this again with GiggleView */
 571 #if 0
 572         GiggleWindowPriv *priv;
 573         GtkWidget        *file_chooser;
 574         GtkTextBuffer    *text_buffer;
 575         GtkTextIter       iter_start, iter_end;
 576         gchar            *text, *path;
 577         GError           *error = NULL;
 578
 579         priv = GET_PRIV (window);
 580
 581         file_chooser = gtk_file_chooser_dialog_new (
 582                 _("Save patch file"),
 583                 GTK_WINDOW (window),
 584                 GTK_FILE_CHOOSER_ACTION_SAVE,
 585                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 586                 GTK_STOCK_OK, GTK_RESPONSE_OK,
 587                 NULL);
 588
 589         gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (file_chooser), TRUE);
 590
 591         /* FIXME: remember the last selected folder */
 592
 593         if (gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_OK) {
 594                 text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->diff_textview));
 595                 gtk_text_buffer_get_bounds (text_buffer, &iter_start, &iter_end);
 596
 597                 text = gtk_text_buffer_get_text (text_buffer, &iter_start, &iter_end, TRUE);
 598                 path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser));
 599
 600                 if (!g_file_set_contents (path, text, strlen (text), &error)) {
 601                         window_show_error (window,
 602                                            N_("An error ocurred when saving to file:\n%s"),
 603                                            error);
 604                         g_error_free (error);
 605                 }
 606         }
 607
 608         gtk_widget_destroy (file_chooser);
 609 #endif
 610 }
 611
 612 static void
 613 window_action_diff_cb (GtkAction    *action,
 614                        GiggleWindow *window)
 615 {
 616         GiggleWindowPriv *priv;
 617
 618         priv = GET_PRIV (window);
 619
 620         gtk_widget_show (priv->diff_current_window);
 621 }
 622
 623 static void
 624 window_notebook_switch_page_cb (GtkNotebook     *notebook,
 625                                 GtkNotebookPage *page,
 626                                 guint            page_num,
 627                                 GiggleWindow    *window)
 628 {
 629         GiggleWindowPriv *priv;
 630         GtkWidget        *page_widget;
 631         GtkAction        *action;
 632
 633         priv = GET_PRIV (window);
 634         page_widget = gtk_notebook_get_nth_page (notebook, page_num);
 635
 636         action = gtk_ui_manager_get_action (priv->ui_manager, FIND_PATH);
 637         gtk_action_set_sensitive (action, GIGGLE_IS_SEARCHABLE (page_widget));
 638 }
 639
 640 static void
 641 window_action_find_cb (GtkAction    *action,
 642                        GiggleWindow *window)
 643 {
 644         GiggleWindowPriv *priv;
 645
 646         priv = GET_PRIV (window);
 647
 648         gtk_widget_show (priv->find_bar);
 649         gtk_widget_grab_focus (priv->find_bar);
 650 }
 651
 652 static void
 653 window_action_compact_mode_cb (GtkAction    *action,
 654                                GiggleWindow *window)
 655 {
 656         GiggleWindowPriv *priv;
 657         gboolean          active;
 658
 659         priv = GET_PRIV (window);
 660         active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 661
 662         giggle_view_history_set_compact_mode (GIGGLE_VIEW_HISTORY (priv->history_view), active);
 663 }
 664
 665 static void
 666 window_find (GtkWidget             *widget,
 667              GiggleWindow          *window,
 668              GiggleSearchDirection  direction)
 669 {
 670         GiggleWindowPriv *priv;
 671         GtkWidget        *page;
 672         guint             page_num;
 673         const gchar      *search_string;
 674
 675         priv = GET_PRIV (window);
 676         page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->main_notebook));
 677         page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (priv->main_notebook), page_num);
 678
 679         g_return_if_fail (GIGGLE_IS_SEARCHABLE (page));
 680
 681         search_string = egg_find_bar_get_search_string (EGG_FIND_BAR (widget));
 682         giggle_searchable_search (GIGGLE_SEARCHABLE (page),
 683                                   search_string, direction);
 684 }
 685
 686 static void
 687 window_find_next (GtkWidget    *widget,
 688                   GiggleWindow *window)
 689 {
 690         window_find (widget, window, GIGGLE_SEARCH_DIRECTION_NEXT);
 691 }
 692
 693 static void
 694 window_find_previous (GtkWidget    *widget,
 695                       GiggleWindow *window)
 696 {
 697         window_find (widget, window, GIGGLE_SEARCH_DIRECTION_PREV);
 698 }
 699
 700 static void
 701 window_action_personal_details_cb (GtkAction    *action,
 702                                    GiggleWindow *window)
 703 {
 704         GiggleWindowPriv *priv;
 705
 706         priv = GET_PRIV (window);
 707
 708         gtk_widget_show (priv->personal_details_window);
 709 }
 710
 711 static void
 712 window_action_about_cb (GtkAction    *action,
 713                         GiggleWindow *window)
 714 {
 715         const gchar *authors[] = {
 716                 "Sven Herzberg",
 717                 "Mikael Hallendal",
 718                 "Richard Hult",
 719                 "Carlos Garnacho",
 720                 NULL
 721         };
 722
 723         gtk_show_about_dialog (GTK_WINDOW (window),
 724                                "name", "Giggle",
 725                                "copyright", "Copyright \xc2\xa9 2007 Imendio AB",
 726                                "translator-credits", _("translator-credits"),
 727                                "version", VERSION,
 728                                "authors", authors,
 729                                NULL);
 730 }
 731
 732 static void
 733 window_directory_changed_cb (GiggleGit    *git,
 734                              GParamSpec   *arg,
 735                              GiggleWindow *window)
 736 {
 737         GiggleWindowPriv *priv;
 738         gchar            *title;
 739         const gchar      *directory;
 740
 741         priv = GET_PRIV (window);
 742
 743         directory = giggle_git_get_directory (git);
 744         title = g_strdup_printf ("%s - Giggle", directory);
 745         gtk_window_set_title (GTK_WINDOW (window), title);
 746         g_free (title);
 747 }
 748
 749 GtkWidget *
 750 giggle_window_new (void)
 751 {
 752         GtkWidget *window;
 753
 754         window = g_object_new (GIGGLE_TYPE_WINDOW, NULL);
 755
 756         return window;
 757 }
 758
 759 GiggleGit *
 760 giggle_window_get_git (GiggleWindow *self)
 761 {
 762         g_return_val_if_fail (GIGGLE_IS_WINDOW (self), NULL);
 763
 764         return GET_PRIV (self)->git;
 765 }
 766