tools/Settings.cs

   1 //
   2 // Settings.cs
   3 //
   4 // Copyright (C) 2005 Novell, Inc.
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a copy
   9 // of this software and associated documentation files (the "Software"), to deal
  10 // in the Software without restriction, including without limitation the rights
  11 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 // copies of the Software, and to permit persons to whom the Software is
  13 // furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in all
  16 // copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24 // SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.IO;
  29 using System.Collections;
  30 using System.Threading;
  31
  32 using Gtk;
  33 using Gdk;
  34 using Glade;
  35 using Mono.Unix;
  36
  37 using Beagle;
  38 using Beagle.Util;
  39
  40 public class SettingsDialog
  41 {
  42         public static void Main (string[] args)
  43         {
  44                 SettingsDialog settings = new SettingsDialog ();
  45                 settings.Run ();
  46         }
  47
  48         ////////////////////////////////////////////////////////////////
  49         // Widgets
  50
  51         [Widget] VBox administration_frame;
  52         [Widget] CheckButton allow_root_toggle;
  53
  54         [Widget] CheckButton autostart_toggle;
  55         [Widget] CheckButton battery_toggle;
  56
  57         [Widget] CheckButton press_ctrl_toggle;
  58         [Widget] CheckButton press_alt_toggle;
  59         [Widget] Entry show_search_window_entry;
  60         [Widget] SpinButton max_displayed_spinbutton;
  61
  62         [Widget] CheckButton index_home_toggle;
  63         [Widget] Button remove_include_button;
  64         [Widget] Button remove_exclude_button;
  65
  66         [Widget] Button display_up_button;
  67         [Widget] Button display_down_button;
  68
  69         [Widget] Gtk.Window settings_dialog;
  70
  71         [Widget] ScrolledWindow display_sw;
  72
  73         [Widget] ScrolledWindow include_sw;
  74         [Widget] ScrolledWindow exclude_sw;
  75
  76 #if false
  77         DisplayView display_view;
  78 #endif
  79
  80         IncludeView include_view;
  81         ExcludeView exclude_view;
  82
  83         ////////////////////////////////////////////////////////////////
  84         // WebServices
  85
  86         [Widget] VBox networking_box;
  87         [Widget] CheckButton allow_global_access_toggle;
  88         [Widget] Button remove_publicfolder_button;
  89         [Widget] Button remove_netbeagle_button;
  90
  91         [Widget] ScrolledWindow publicfolder_sw;
  92         [Widget] ScrolledWindow netbeagle_sw;
  93
  94         [Widget] Dialog netbeagle_entry_dialog;
  95         [Widget] Entry netbeagle_textentry;
  96
  97         PublicfolderView        publicfolder_view;
  98         NetbeagleView           netbeagle_view;
  99
 100         ////////////////////////////////////////////////////////////////
 101         // Initialize
 102
 103         public SettingsDialog ()
 104         {
 105                 Application.Init ();
 106
 107                 Catalog.Init ("beagle", ExternalStringsHack.LocaleDir);
 108
 109                 Glade.XML glade = new Glade.XML (null, "settings.glade", "settings_dialog", "beagle");
 110                 glade.Autoconnect (this);
 111
 112                 administration_frame.Visible = (Environment.UserName == "root");
 113
 114 #if false
 115                 display_view = new DisplayView ();
 116                 display_view.Selection.Changed += new EventHandler (OnDisplaySelected);
 117                 display_view.Show ();
 118                 // The display sorting stuff is something i have been testing locally, Best CVS wont use it
 119                 display_sw.Child = display_view;
 120 #endif
 121                 include_view = new IncludeView ();
 122                 include_view.Selection.Changed += new EventHandler (OnIncludeSelected);
 123                 include_view.Show ();
 124                 include_sw.Child = include_view;
 125
 126                 exclude_view = new ExcludeView ();
 127                 exclude_view.Selection.Changed += new EventHandler (OnExcludeSelected);
 128                 exclude_view.Show ();
 129                 exclude_sw.Child = exclude_view;
 130
 131 #if ENABLE_WEBSERVICES
 132                 networking_box.Visible = true;
 133
 134                 publicfolder_view = new PublicfolderView ();
 135                 publicfolder_view.Selection.Changed += new EventHandler (OnPublicfolderSelected);
 136                 publicfolder_view.Show ();
 137                 publicfolder_sw.Child = publicfolder_view;
 138
 139                 netbeagle_view = new NetbeagleView ();
 140                 netbeagle_view.Selection.Changed += new EventHandler (OnNetbeagleSelected);
 141                 netbeagle_view.Show ();
 142                 netbeagle_sw.Child = netbeagle_view;
 143 #endif
 144                 LoadConfiguration ();
 145
 146                 Conf.Subscribe (typeof (Conf.IndexingConfig), new Conf.ConfigUpdateHandler (OnConfigurationChanged));
 147                 Conf.Subscribe (typeof (Conf.SearchingConfig), new Conf.ConfigUpdateHandler (OnConfigurationChanged));
 148
 149 #if ENABLE_WEBSERVICES
 150                 Conf.Subscribe (typeof (Conf.NetworkingConfig), new Conf.ConfigUpdateHandler (OnConfigurationChanged));
 151                 Conf.Subscribe (typeof (Conf.WebServicesConfig), new Conf.ConfigUpdateHandler (OnConfigurationChanged));
 152 #endif
 153         }
 154
 155         public void Run ()
 156         {
 157                 Application.Run ();
 158         }
 159
 160         ////////////////////////////////////////////////////////////////
 161         // Configuration
 162
 163         private void LoadConfiguration ()
 164         {
 165                 allow_root_toggle.Active = Conf.Daemon.AllowRoot;
 166                 autostart_toggle.Active = Conf.Searching.Autostart;
 167                 battery_toggle.Active = Conf.Indexing.IndexOnBattery;
 168
 169                 KeyBinding show_binding = Conf.Searching.ShowSearchWindowBinding;
 170                 press_ctrl_toggle.Active = show_binding.Ctrl;
 171                 press_alt_toggle.Active = show_binding.Alt;
 172                 show_search_window_entry.Text = show_binding.Key;
 173                 max_displayed_spinbutton.Value = (uint) Conf.Searching.MaxDisplayed;
 174
 175                 if (Conf.Indexing.IndexHomeDir)
 176                         index_home_toggle.Active = true;
 177
 178                 foreach (string include in Conf.Indexing.Roots)
 179                         include_view.AddPath (include);
 180
 181                 foreach (ExcludeItem exclude_item in Conf.Indexing.Excludes)
 182                         exclude_view.AddItem (exclude_item);
 183
 184 #if ENABLE_WEBSERVICES
 185                 foreach (string netbeagle in Conf.Networking.NetBeagleNodes)
 186                                 netbeagle_view.AddNode (netbeagle);
 187
 188                 if (Conf.WebServices.AllowGlobalAccess)
 189                                 allow_global_access_toggle.Active = true;
 190
 191                 foreach (string publicfolder in Conf.WebServices.PublicFolders)
 192                         publicfolder_view.AddPath (publicfolder);
 193 #endif
 194         }
 195
 196         private void SaveConfiguration ()
 197         {
 198                 Conf.Daemon.AllowRoot = allow_root_toggle.Active;
 199                 Conf.Searching.Autostart = autostart_toggle.Active;
 200                 Conf.Indexing.IndexOnBattery = battery_toggle.Active;
 201
 202                 Conf.Searching.ShowSearchWindowBinding = new KeyBinding (show_search_window_entry.Text,
 203                                                                          press_ctrl_toggle.Active,
 204                                                                          press_alt_toggle.Active);
 205
 206                 Conf.Searching.MaxDisplayed = (int) max_displayed_spinbutton.Value;
 207                 Conf.Indexing.IndexHomeDir = index_home_toggle.Active;
 208
 209                 Conf.Indexing.Roots = include_view.Includes;
 210                 Conf.Indexing.Excludes = exclude_view.Excludes;
 211
 212 #if ENABLE_WEBSERVICES
 213                 Conf.Networking.NetBeagleNodes = netbeagle_view.Netbeagles;
 214                 Conf.WebServices.AllowGlobalAccess = allow_global_access_toggle.Active;
 215                 Conf.WebServices.PublicFolders = publicfolder_view.Publicfolders;
 216 #endif
 217                 Conf.Save (true);
 218         }
 219
 220         private void OnConfigurationChanged (Conf.Section section)
 221         {
 222                 HigMessageDialog dialog = new HigMessageDialog (settings_dialog,
 223                                                                 DialogFlags.Modal,
 224                                                                 MessageType.Question,
 225                                                                 ButtonsType.YesNo,
 226                                                                 Catalog.GetString ("Reload configuration"),
 227                                                                 Catalog.GetString ("The configuration file has been modified by another application. " +
 228                                                                                    "Do you wish to discard the currently displayed values and reload configuration from disk?"));
 229
 230                 ResponseType response = (ResponseType) dialog.Run ();
 231
 232                 if (response == ResponseType.Yes)
 233                         LoadConfiguration ();
 234
 235                 dialog.Destroy ();
 236         }
 237
 238         ////////////////////////////////////////////////////////////////
 239         // Eventhandlers
 240
 241         private void OnDialogResponse (object o, ResponseArgs args)
 242         {
 243                 switch (args.ResponseId) {
 244                 case ResponseType.Help:
 245                         Gnome.Url.Show ("http://beagle-project.org/Configuring");
 246                         break;
 247                 case ResponseType.Ok:
 248                         SaveConfiguration ();
 249                         Application.Quit ();
 250                         break;
 251                 default:
 252                         Application.Quit ();
 253                         break;
 254                 }
 255         }
 256
 257         private void OnDisplaySelected (object o, EventArgs args)
 258         {
 259                 display_up_button.Sensitive = true;
 260                 display_down_button.Sensitive = true;
 261         }
 262
 263         private void OnAddIncludeClicked (object o, EventArgs args)
 264         {
 265                 CompatFileChooserDialog fs_dialog = new CompatFileChooserDialog (Catalog.GetString ("Select Path"),
 266                                                                                  settings_dialog,
 267                                                                                  CompatFileChooserDialog.Action.SelectFolder);
 268                 fs_dialog.SelectMultiple = false;
 269
 270                 ResponseType fs_response = (ResponseType) fs_dialog.Run ();
 271                 string new_include = fs_dialog.Filename;
 272                 fs_dialog.Destroy ();
 273
 274                 if (fs_response == ResponseType.Ok) {
 275                         string error_message = "";
 276                         bool throw_error = false;
 277                         ArrayList obsolete_includes = new ArrayList ();
 278
 279                         // Check and see if the current data collides with the new path in any way
 280                         // FIXME: Do this with System.IO.Path or something
 281                         foreach (string old_include in include_view.Includes) {
 282                                 if (new_include == old_include) {
 283                                         throw_error = true;
 284                                         error_message = Catalog.GetString ("The selected path is already selected for indexing and wasn't added.");
 285                                 } else if (new_include.StartsWith (old_include)) {
 286                                         throw_error = true;
 287                                         error_message = Catalog.GetString ("The selected path wasn't added. The list contains items that supercedes it and the data is already being indexed.");
 288                                 } else if (old_include.StartsWith (new_include)) {
 289                                         obsolete_includes.Add (old_include);
 290                                 }
 291                         }
 292
 293                         if (throw_error) {
 294                                 HigMessageDialog.RunHigMessageDialog (settings_dialog,
 295                                                                       DialogFlags.Modal,
 296                                                                       MessageType.Warning,
 297                                                                       ButtonsType.Ok,
 298                                                                       Catalog.GetString ("Path not added"),
 299                                                                       error_message);
 300                         } else {
 301                                 // Confirm the removal of obsolete includes
 302                                 if (obsolete_includes.Count != 0) {
 303                                         HigMessageDialog dialog = new HigMessageDialog (settings_dialog,
 304                                                                                         DialogFlags.Modal,
 305                                                                                         MessageType.Question,
 306                                                                                         ButtonsType.YesNo,
 307                                                                                         Catalog.GetString ("Remove obsolete paths"),
 308                                                                                         Catalog.GetString ("Adding this path will obsolete some of the existing include paths. " +
 309                                                                                                            "This will result in the removal of the old obsolete paths. Do you still wish to add it?"));
 310
 311                                         ResponseType confirm_response = (ResponseType) dialog.Run ();
 312
 313                                         if (confirm_response != ResponseType.Yes)
 314                                                 return;
 315
 316                                         foreach (string obsolete_include in obsolete_includes)
 317                                                 include_view.RemovePath (obsolete_include);
 318
 319                                         dialog.Destroy ();
 320                                 }
 321
 322                                 include_view.AddPath (new_include);
 323                         }
 324                 }
 325         }
 326
 327         private void OnRemoveIncludeClicked (object o, EventArgs args)
 328         {
 329                 // Confirm removal
 330                 HigMessageDialog dialog  = new HigMessageDialog (settings_dialog,
 331                                                                  DialogFlags.Modal,
 332                                                                  MessageType.Question,
 333                                                                  ButtonsType.YesNo,
 334                                                                  Catalog.GetString ("Remove path"),
 335                                                                  Catalog.GetString ("Are you sure you wish to remove this path from the list of directories to be included for indexing?"));
 336                 ResponseType response = (ResponseType) dialog.Run ();
 337                 dialog.Destroy ();
 338
 339                 if (response != ResponseType.Yes)
 340                         return;
 341
 342                 include_view.RemoveSelectedPath ();
 343                 remove_include_button.Sensitive = false;
 344         }
 345
 346         private void OnIncludeSelected (object o, EventArgs args)
 347         {
 348                 remove_include_button.Sensitive = true;
 349         }
 350
 351         private void OnAddExcludeClicked (object o, EventArgs args)
 352         {
 353                 AddExcludeDialog dialog = new AddExcludeDialog (settings_dialog);
 354                 dialog.ExcludeItemAddedEvent += new ExcludeItemAddedHandler (OnExcludeItemAdded);
 355
 356         }
 357
 358         private void OnRemoveExcludeClicked (object o, EventArgs args)
 359         {
 360                 HigMessageDialog dialog = new HigMessageDialog (settings_dialog,
 361                                                                 DialogFlags.Modal,
 362                                                                 MessageType.Question,
 363                                                                 ButtonsType.YesNo,
 364                                                                 Catalog.GetString ("Remove item"),
 365                                                                 Catalog.GetString ("Are you sure you wish to remove this item from the list of data to be excluded from indexing?"));
 366
 367                 ResponseType response = (ResponseType) dialog.Run ();
 368                 dialog.Destroy ();
 369
 370                 if (response != ResponseType.Yes)
 371                         return;
 372
 373                 exclude_view.RemoveSelectedItem ();
 374                 remove_exclude_button.Sensitive = false;
 375         }
 376
 377         private void OnExcludeSelected (object o, EventArgs args)
 378         {
 379                 remove_exclude_button.Sensitive = true;
 380         }
 381
 382         private void OnExcludeItemAdded (ExcludeItem exclude_item)
 383         {
 384                 exclude_view.AddItem (exclude_item);
 385         }
 386
 387         //Netbeagle: Add, Remove operations
 388         private void OnAddNetbeagleClicked (object o, EventArgs args)
 389         {
 390                 Glade.XML glade = new Glade.XML (null, "settings.glade", "netbeagle_entry_dialog", "beagle");
 391                 glade.Autoconnect (this);
 392                 ResponseType nbed_response = (ResponseType) netbeagle_entry_dialog.Run ();
 393
 394                 string new_node = netbeagle_textentry.Text.Trim();
 395
 396                 if ((new_node.Length > 1) && (((string[])new_node.Split(':')).Length < 2))
 397                         new_node += ":8888";
 398
 399                 netbeagle_entry_dialog.Destroy ();
 400
 401                 if (nbed_response == ResponseType.Ok) {
 402                         string error_message = "";
 403                         bool throw_error = false;
 404
 405                         if (new_node.Length < 2)
 406                         {
 407                                 throw_error = true;
 408                                 error_message = Catalog.GetString ("Invalid host entry");
 409                         }
 410                         else
 411                                 // Check if the new entry matches an existing netbeagle entry
 412                                 foreach (string old_node in netbeagle_view.Netbeagles) {
 413                                         if (new_node == old_node) {
 414                                                 throw_error = true;
 415                                                 error_message = Catalog.GetString ("Remote host already present in the list.");
 416                                         }
 417                                 }
 418
 419                         if (throw_error) {
 420                                 HigMessageDialog.RunHigMessageDialog (settings_dialog,
 421                                                                       DialogFlags.Modal,
 422                                                                       MessageType.Warning,
 423                                                                       ButtonsType.Ok,
 424                                                                       Catalog.GetString ("Netbeagle Node not added"),
 425                                                                       error_message);
 426                         }
 427                         else
 428                                         netbeagle_view.AddNode (new_node);
 429
 430                 }
 431         }
 432
 433         private void OnRemoveNetbeagleClicked (object o, EventArgs args)
 434         {
 435                 // Confirm removal
 436                 HigMessageDialog dialog  = new HigMessageDialog (settings_dialog,
 437                                                                  DialogFlags.Modal,
 438                                                                  MessageType.Question,
 439                                                                  ButtonsType.YesNo,
 440                                                                  Catalog.GetString ("Remove host"),
 441                                                                  Catalog.GetString ("Are you sure you wish to remove this host from the list?"));
 442
 443                 ResponseType response = (ResponseType) dialog.Run ();
 444                 dialog.Destroy ();
 445
 446                 if (response != ResponseType.Yes)
 447                         return;
 448
 449                 netbeagle_view.RemoveSelectedNode ();
 450
 451                 remove_netbeagle_button.Sensitive = false;
 452         }
 453
 454         private void OnNetbeagleSelected (object o, EventArgs args)
 455         {
 456                 remove_netbeagle_button.Sensitive = true;
 457         }
 458
 459         //Publicfolders: Add, Remove operations
 460         private void OnAddPublicfolderClicked (object o, EventArgs args)
 461         {
 462                 CompatFileChooserDialog fs_dialog = new CompatFileChooserDialog (Catalog.GetString ("Select path"),
 463                                                                                  settings_dialog,
 464                                                                                  CompatFileChooserDialog.Action.SelectFolder);
 465                 fs_dialog.SelectMultiple = false;
 466
 467                 ResponseType fs_response = (ResponseType) fs_dialog.Run ();
 468                 string new_pf = fs_dialog.Filename;
 469                 fs_dialog.Destroy ();
 470
 471                 if (fs_response == ResponseType.Ok) {
 472
 473                         string error_message = "";
 474                         bool throw_error = false;
 475
 476                         // Check and see if the current data collides with the new path in any way
 477                         // FIXME: Do this with System.IO.Path or something
 478                         foreach (string old_pf in publicfolder_view.Publicfolders) {
 479                                 if (new_pf == old_pf) {
 480                                         throw_error = true;
 481                                         error_message = Catalog.GetString ("The selected path is already configured for external access.");
 482                                 }
 483                         }
 484
 485                         if (throw_error) {
 486                                 HigMessageDialog.RunHigMessageDialog (settings_dialog,
 487                                                                       DialogFlags.Modal,
 488                                                                       MessageType.Warning,
 489                                                                       ButtonsType.Ok,
 490                                                                       Catalog.GetString ("Path not added"),
 491                                                                       error_message);
 492                         }
 493                         else
 494                                         publicfolder_view.AddPath (new_pf);
 495                 }
 496         }
 497
 498         private void OnRemovePublicfolderClicked (object o, EventArgs args)
 499         {
 500                 // Confirm removal
 501                 HigMessageDialog dialog  = new HigMessageDialog (settings_dialog,
 502                                                                  DialogFlags.Modal,
 503                                                                  MessageType.Question,
 504                                                                  ButtonsType.YesNo,
 505                                                                  Catalog.GetString ("Remove public path"),
 506                                                                  Catalog.GetString ("Are you sure you wish to remove this entry from the list of public paths?"));
 507
 508                 ResponseType response = (ResponseType) dialog.Run ();
 509                 dialog.Destroy ();
 510
 511                 if (response != ResponseType.Yes)
 512                         return;
 513
 514                 publicfolder_view.RemoveSelectedPath ();
 515                 remove_publicfolder_button.Sensitive = false;
 516         }
 517
 518         private void OnPublicfolderSelected (object o, EventArgs args)
 519         {
 520                 remove_publicfolder_button.Sensitive  = true;
 521         }
 522
 523         ////////////////////////////////////////////////////////////////
 524         // IncludeView
 525
 526         class IncludeView : TreeView
 527         {
 528                 private ListStore store;
 529
 530                 private ArrayList includes = new ArrayList ();
 531
 532                 public ArrayList Includes {
 533                         get { return includes; }
 534                 }
 535
 536                 private enum TargetType {
 537                         Uri,
 538                 };
 539
 540                 private static TargetEntry [] target_table = new TargetEntry [] {
 541                         new TargetEntry ("STRING", 0, (uint) TargetType.Uri ),
 542                         new TargetEntry ("text/plain", 0, (uint) TargetType.Uri),
 543                 };
 544
 545                 public IncludeView ()
 546                 {
 547                         store = new ListStore (typeof (string));
 548
 549                         this.Model = store;
 550
 551                         AppendColumn (Catalog.GetString ("Name"), new CellRendererText (), "text", 0);
 552
 553                         // Enable drag and drop folders from nautilus
 554                         Gtk.Drag.DestSet (this, DestDefaults.All, target_table, DragAction.Copy | DragAction.Move);
 555                         DragDataReceived += new DragDataReceivedHandler (HandleData);
 556                 }
 557
 558                 public void AddPath (string path)
 559                 {
 560                         includes.Add (path);
 561                         store.AppendValues (path);
 562                 }
 563
 564                 public void RemovePath (string path)
 565                 {
 566                         find_path = path;
 567                         found_iter = TreeIter.Zero;
 568
 569                         this.Model.Foreach (new TreeModelForeachFunc (ForeachFindPath));
 570
 571                         store.Remove (ref found_iter);
 572                         includes.Remove (path);
 573                 }
 574
 575                 private string find_path;
 576                 private TreeIter found_iter;
 577
 578                 private bool ForeachFindPath (TreeModel model, TreePath path, TreeIter iter)
 579                 {
 580                         if ((string) model.GetValue (iter, 0) == find_path) {
 581                                 found_iter = iter;
 582                                 return true;
 583                         }
 584
 585                         return false;
 586                 }
 587
 588                 public void RemoveSelectedPath ()
 589                 {
 590                         TreeModel model;
 591                         TreeIter iter;
 592
 593                         if (!this.Selection.GetSelected(out model, out iter)) {
 594                                 return;
 595                         }
 596                         string path = (string)model.GetValue(iter, 0);
 597
 598                         store.Remove (ref iter);
 599                         includes.Remove (path);
 600                 }
 601
 602                 // Handle drag and drop data. Enables users to drag a folder that he wishes
 603                 // to add for indexing from Nautilus.
 604                 // FIXME: Pass checks as in OnAddIncludeButtonClicked
 605                 private void HandleData (object o, DragDataReceivedArgs args) {
 606                         Uri uri;
 607                         if (args.SelectionData.Length >=0 && args.SelectionData.Format == 8) {
 608                                 uri = new Uri (args.SelectionData.Text.Trim ());
 609                                 AddPath (uri.LocalPath);
 610                                 Gtk.Drag.Finish (args.Context, true, false, args.Time);
 611                         }
 612                         Gtk.Drag.Finish (args.Context, false, false, args.Time);
 613                 }
 614         }
 615
 616         ////////////////////////////////////////////////////////////////
 617         // Exclude view
 618
 619         class ExcludeView : TreeView
 620         {
 621                 ArrayList excludes = new ArrayList ();
 622
 623                 public ArrayList Excludes {
 624                         get { return excludes; }
 625                 }
 626
 627                 public ExcludeView ()
 628                 {
 629                         this.Model =  new ListStore (typeof (ExcludeItem));
 630
 631                         CellRendererText renderer_text = new CellRendererText ();
 632
 633                         TreeViewColumn type_column = new TreeViewColumn ();
 634                         type_column.Title = Catalog.GetString ("Type");
 635                         type_column.PackStart (renderer_text, false);
 636                         type_column.SetCellDataFunc (renderer_text, new TreeCellDataFunc (TypeCellDataFunc));
 637                         AppendColumn (type_column);
 638
 639                         TreeViewColumn name_column = new TreeViewColumn ();
 640                         name_column.Title = Catalog.GetString ("Name");
 641                         name_column.PackStart (renderer_text, false);
 642                         name_column.SetCellDataFunc (renderer_text, new TreeCellDataFunc (NameCellDataFunc));
 643                         AppendColumn (name_column);
 644                 }
 645
 646                 public void RemoveSelectedItem ()
 647                 {
 648                         TreeModel model;
 649                         TreeIter iter;
 650
 651                         if (!this.Selection.GetSelected(out model, out iter)) {
 652                                 return;
 653                         }
 654                         ExcludeItem exclude_item = (ExcludeItem) model.GetValue(iter, 0);
 655
 656                         ((ListStore)this.Model).Remove (ref iter);
 657                         excludes.Remove (exclude_item);
 658                 }
 659
 660                 public void AddItem (ExcludeItem exclude_item)
 661                 {
 662                         excludes.Add (exclude_item);
 663                         ((ListStore)this.Model).AppendValues (exclude_item);
 664                 }
 665
 666                 private void NameCellDataFunc (TreeViewColumn column,
 667                                                CellRenderer renderer,
 668                                                TreeModel model,
 669                                                TreeIter iter)
 670                 {
 671                         ExcludeItem exclude_item = (ExcludeItem) model.GetValue (iter, 0);
 672                         if (exclude_item.Type == ExcludeType.MailFolder)
 673                                 ((CellRendererText)renderer).Text = MailFolder.GetNameForPath (exclude_item.Value);
 674                         else
 675                                 ((CellRendererText)renderer).Text = exclude_item.Value;
 676                 }
 677
 678                 private void TypeCellDataFunc (TreeViewColumn column,
 679                                                 CellRenderer renderer,
 680                                                 TreeModel model,
 681                                                 TreeIter iter)
 682                 {
 683                         ExcludeItem exclude_item = (ExcludeItem) model.GetValue (iter, 0);
 684
 685                         switch (exclude_item.Type) {
 686                         case ExcludeType.Path:
 687                                 ((CellRendererText)renderer).Text = Catalog.GetString ("Path:");
 688                                 break;
 689                         case ExcludeType.Pattern:
 690                                 ((CellRendererText)renderer).Text = Catalog.GetString ("Pattern:");
 691                                 break;
 692                         case ExcludeType.MailFolder:
 693                                 ((CellRendererText)renderer).Text = Catalog.GetString ("Mail folder:");
 694                                 break;
 695                         }
 696                 }
 697         }
 698
 699         ////////////////////////////////////////////////////////////////
 700
 701         // NetbeagleView
 702         class NetbeagleView : TreeView
 703         {
 704                 private ListStore store;
 705
 706                 private ArrayList netBeagleList = new ArrayList ();
 707
 708                 public ArrayList Netbeagles {
 709                         get { return netBeagleList; }
 710                 }
 711
 712                 public NetbeagleView ()
 713                 {
 714                         store = new ListStore (typeof (string));
 715
 716                         this.Model = store;
 717
 718                         AppendColumn (Catalog.GetString ("Name"), new CellRendererText (), "text", 0);
 719                 }
 720
 721                 public void AddNode (string node)
 722                 {
 723                         netBeagleList.Add (node);
 724                         store.AppendValues (node);
 725                 }
 726
 727                 public void RemoveNode (string node)
 728                 {
 729                         find_node = node;
 730                         found_iter = TreeIter.Zero;
 731
 732                         this.Model.Foreach (new TreeModelForeachFunc (ForeachFindNode));
 733
 734                         store.Remove (ref found_iter);
 735                         netBeagleList.Remove (node);
 736                 }
 737
 738                 private string find_node;
 739                 private TreeIter found_iter;
 740
 741                 private bool ForeachFindNode (TreeModel model, TreePath path, TreeIter iter)
 742                 {
 743                         if ((string) model.GetValue (iter, 0) == find_node) {
 744                                 found_iter = iter;
 745                                 return true;
 746                         }
 747
 748                         return false;
 749                 }
 750
 751                 public void RemoveSelectedNode ()
 752                 {
 753                         TreeModel model;
 754                         TreeIter iter;
 755
 756                         if (!this.Selection.GetSelected(out model, out iter)) {
 757                                 return;
 758                         }
 759                         string node = (string)model.GetValue(iter, 0);
 760
 761                         store.Remove (ref iter);
 762                         netBeagleList.Remove (node);
 763                 }
 764
 765         }
 766         ////////////////////////////////////////////////////////////////
 767         // PublicfolderView
 768
 769         class PublicfolderView: TreeView
 770         {
 771                 private ListStore store;
 772
 773                 private ArrayList publicFolders = new ArrayList ();
 774
 775                 public ArrayList Publicfolders {
 776                         get { return publicFolders; }
 777                 }
 778
 779                 private enum TargetType {
 780                         Uri,
 781                 };
 782
 783                 private static TargetEntry [] target_table = new TargetEntry [] {
 784                         new TargetEntry ("STRING", 0, (uint) TargetType.Uri ),
 785                         new TargetEntry ("text/plain", 0, (uint) TargetType.Uri),
 786                 };
 787
 788                 public PublicfolderView ()
 789                 {
 790                         store = new ListStore (typeof (string));
 791
 792                         this.Model = store;
 793
 794                         AppendColumn (Catalog.GetString ("Name"), new CellRendererText (), "text", 0);
 795
 796                         // Enable drag and drop folders from nautilus
 797                         Gtk.Drag.DestSet (this, DestDefaults.All, target_table, DragAction.Copy | DragAction.Move);
 798                         DragDataReceived += new DragDataReceivedHandler (HandleData);
 799                 }
 800
 801                 public void AddPath (string path)
 802                 {
 803                         publicFolders.Add (path);
 804                         store.AppendValues (path);
 805                 }
 806
 807                 public void RemovePath (string path)
 808                 {
 809                         find_path = path;
 810                         found_iter = TreeIter.Zero;
 811
 812                         this.Model.Foreach (new TreeModelForeachFunc (ForeachFindPath));
 813
 814                         store.Remove (ref found_iter);
 815                         publicFolders.Remove (path);
 816                 }
 817
 818                 private string find_path;
 819                 private TreeIter found_iter;
 820
 821                 private bool ForeachFindPath (TreeModel model, TreePath path, TreeIter iter)
 822                 {
 823                         if ((string) model.GetValue (iter, 0) == find_path) {
 824                                 found_iter = iter;
 825                                 return true;
 826                         }
 827
 828                         return false;
 829                 }
 830
 831                 public void RemoveSelectedPath ()
 832                 {
 833                         TreeModel model;
 834                         TreeIter iter;
 835
 836                         if (!this.Selection.GetSelected(out model, out iter)) {
 837                                 return;
 838                         }
 839                         string path = (string)model.GetValue(iter, 0);
 840
 841                         store.Remove (ref iter);
 842                         publicFolders.Remove (path);
 843                 }
 844
 845             // Handle drag and drop data. Enables users to drag a folder that he wishes
 846                 // to add for indexing from Nautilus.
 847                 // FIXME: Pass checks as in OnAddIncludeButtonClicked
 848                 private void HandleData (object o, DragDataReceivedArgs args) {
 849                         Uri uri;
 850                         if (args.SelectionData.Length >=0 && args.SelectionData.Format == 8) {
 851                                 uri = new Uri (args.SelectionData.Text.Trim ());
 852                                 AddPath (uri.LocalPath);
 853                                 Gtk.Drag.Finish (args.Context, true, false, args.Time);
 854                         }
 855                         Gtk.Drag.Finish (args.Context, false, false, args.Time);
 856                 }
 857         }
 858
 859         ////////////////////////////////////////////////////////////////
 860         // Mail folder dialog
 861
 862         class MailFolderDialog
 863         {
 864                 Gtk.Window parent;
 865                 FolderView folder_view;
 866
 867                 [Widget] Dialog mail_folder_dialog;
 868                 [Widget] ScrolledWindow folder_sw;
 869
 870                 public event ExcludeItemAddedHandler ExcludeItemAddedEvent;
 871
 872                 public MailFolderDialog (Gtk.Window parent)
 873                 {
 874                         this.parent = parent;
 875
 876                         Glade.XML glade = new Glade.XML (null, "settings.glade", "mail_folder_dialog", "beagle");
 877                         glade.Autoconnect (this);
 878
 879                         folder_view = new FolderView ();
 880                         folder_view.Show ();
 881                         folder_sw.Child = folder_view;
 882                 }
 883
 884                 private void OnDialogResponse (object o, ResponseArgs args)
 885                 {
 886                         if (args.ResponseId == ResponseType.Cancel) {
 887                                 mail_folder_dialog.Destroy ();
 888                                 return;
 889                         }
 890
 891                         ExcludeItem exclude_item;
 892                         object obj = folder_view.GetCurrentItem ();
 893
 894                         if (obj is MailAccount) {
 895
 896                         } else if (obj is MailFolder) {
 897                                 MailFolder folder = (MailFolder) obj;
 898                                 exclude_item = new ExcludeItem (ExcludeType.MailFolder, folder.Path);
 899
 900                                 if (ExcludeItemAddedEvent != null)
 901                                         ExcludeItemAddedEvent (exclude_item);
 902
 903                                 mail_folder_dialog.Destroy ();
 904                         }
 905                 }
 906
 907                 class FolderView : TreeView
 908                 {
 909                         TreeStore store;
 910                         Gdk.Pixbuf folder_icon;
 911
 912                         public FolderView ()
 913                         {
 914                                 store = new TreeStore (typeof (MailFolder));
 915                                 this.Model = store;
 916
 917                                 folder_icon = this.RenderIcon (Stock.Open, IconSize.Menu, "");
 918
 919                                 HeadersVisible = false;
 920
 921                                 TreeViewColumn column = new TreeViewColumn ();
 922                                 CellRendererPixbuf renderer_icon = new CellRendererPixbuf ();
 923                                 column.PackStart (renderer_icon, false);
 924                                 column.SetCellDataFunc (renderer_icon, new TreeCellDataFunc (IconCellDataFunc));
 925
 926                                 CellRendererText renderer_text = new CellRendererText ();
 927                                 column.PackStart (renderer_text, false);
 928                                 column.SetCellDataFunc (renderer_text, new TreeCellDataFunc (NameCellDataFunc));
 929                                 AppendColumn (column);
 930
 931                                 foreach (MailAccount account in Beagle.Util.Evolution.Accounts) {
 932                                         TreeIter iter = store.AppendValues (account);
 933
 934                                         foreach (MailFolder folder in account.Children) {
 935                                                 Add (iter, folder);
 936                                         }
 937                                 }
 938                         }
 939
 940                         private void Add (TreeIter parent, MailFolder folder)
 941                         {
 942                                 TreeIter current = store.AppendValues (parent, folder);
 943
 944                                 foreach (MailFolder child in folder.Children)
 945                                         Add (current, child);
 946                         }
 947
 948                         private void IconCellDataFunc (TreeViewColumn column,
 949                                                        CellRenderer renderer,
 950                                                        TreeModel model,
 951                                                        TreeIter iter)
 952                         {
 953                                 object obj = model.GetValue (iter, 0);
 954                                 ((CellRendererPixbuf)renderer).Pixbuf = (obj is MailAccount) ? null : folder_icon;
 955                         }
 956
 957                         private void NameCellDataFunc (TreeViewColumn column,
 958                                                        CellRenderer renderer,
 959                                                        TreeModel model,
 960                                                        TreeIter iter)
 961                         {
 962                                 object obj = model.GetValue (iter, 0);
 963
 964                                 if (obj is MailAccount) {
 965                                         MailAccount account = obj as MailAccount;
 966                                         ((CellRendererText)renderer).Markup = String.Format ("<b>{0}</b>",account.Name);
 967                                 } else {
 968                                         MailFolder folder = obj as MailFolder;
 969                                         ((CellRendererText)renderer).Text = folder.Name;
 970                                 }
 971                         }
 972
 973                         public MailFolder GetCurrentItem ()
 974                         {
 975                                 TreeModel model;
 976                                 TreeIter iter;
 977
 978                                 if (!this.Selection.GetSelected (out model, out iter)) {
 979                                         return null;
 980                                 }
 981
 982                                 return (MailFolder) model.GetValue (iter, 0);
 983                         }
 984                 }
 985         }
 986
 987         ////////////////////////////////////////////////////////////////
 988         // Exclude dialog
 989
 990         private delegate void ExcludeItemAddedHandler (ExcludeItem item);
 991
 992         class AddExcludeDialog
 993         {
 994                 Gtk.Window parent;
 995
 996                 [Widget] Dialog add_exclude_dialog;
 997                 [Widget] Entry value_entry;
 998                 [Widget] Label value_name_label;
 999                 [Widget] Button browse_button;
1000
1001                 [Widget] RadioButton type_path_radio;
1002                 [Widget] RadioButton type_pattern_radio;
1003                 [Widget] RadioButton type_mailfolder_radio;
1004
1005                 public event ExcludeItemAddedHandler ExcludeItemAddedEvent;
1006
1007                 private string value;
1008
1009                 public string Value {
1010                         get {
1011                                 if (Type == ExcludeType.MailFolder)
1012                                         return value;
1013                                 else
1014                                         return value_entry.Text;
1015                         }
1016                 }
1017
1018                 public ExcludeType Type {
1019                         get {
1020                                 if (type_path_radio.Active)
1021                                         return ExcludeType.Path;
1022                                 else if (type_pattern_radio.Active)
1023                                         return ExcludeType.Pattern;
1024                                 else
1025                                         return ExcludeType.MailFolder;
1026                         }
1027                 }
1028
1029                 public AddExcludeDialog (Gtk.Window parent)
1030                 {
1031                         this.parent = parent;
1032
1033                         Glade.XML glade = new Glade.XML (null, "settings.glade", "add_exclude_dialog", "beagle");
1034                         glade.Autoconnect (this);
1035                 }
1036
1037                 private void OnBrowseButtonClicked (object o, EventArgs args)
1038                 {
1039                         switch (Type) {
1040                         case ExcludeType.Path:
1041                                 CompatFileChooserDialog fs_dialog = new CompatFileChooserDialog (Catalog.GetString ("Select Folder"),
1042                                                                                                  add_exclude_dialog,
1043                                                                                                  CompatFileChooserDialog.Action.SelectFolder);
1044                                 fs_dialog.SelectMultiple = false;
1045
1046                                 ResponseType response = (ResponseType) fs_dialog.Run ();
1047
1048                                 if (response == ResponseType.Ok)
1049                                         value_entry.Text = fs_dialog.Filename;
1050
1051                                 fs_dialog.Destroy ();
1052                                 break;
1053                         case ExcludeType.MailFolder:
1054                                 MailFolderDialog mf_dialog = new MailFolderDialog (add_exclude_dialog);
1055                                 mf_dialog.ExcludeItemAddedEvent += new ExcludeItemAddedHandler (OnExcludeItemAdded);
1056                                 break;
1057                         }
1058                 }
1059
1060                 private void OnRadioGroupChanged (object o, EventArgs args)
1061                 {
1062                         value_entry.Text = "";
1063
1064                         switch (Type) {
1065                         case ExcludeType.Path:
1066                                 browse_button.Sensitive = true;
1067                                 value_name_label.TextWithMnemonic = Catalog.GetString ("P_ath:");
1068                                 value_entry.IsEditable = true;
1069                                 break;
1070                         case ExcludeType.MailFolder:
1071                                 browse_button.Sensitive = true;
1072                                 value_name_label.TextWithMnemonic = Catalog.GetString ("M_ail folder:");
1073                                 value_entry.IsEditable = false;
1074                                 break;
1075                         case ExcludeType.Pattern:
1076                                 browse_button.Sensitive = false;
1077                                 value_name_label.TextWithMnemonic = Catalog.GetString ("P_attern:");
1078                                 value_entry.IsEditable = true;
1079                                 break;
1080                         }
1081                 }
1082
1083                 private void OnExcludeItemAdded (ExcludeItem item)
1084                 {
1085                         value = item.Value;
1086                         value_entry.Text = MailFolder.GetNameForPath (item.Value);
1087                 }
1088
1089                 private void OnDialogResponse (object o, ResponseArgs args)
1090                 {
1091                         if (((ResponseType)args.ResponseId) == ResponseType.Ok) {
1092                                 ExcludeItem exclude_item = new ExcludeItem (Type, Value);
1093
1094                                 switch (Type) {
1095                                 case ExcludeType.Path:
1096                                         if (!Directory.Exists (Value)) {
1097                                                 HigMessageDialog.RunHigMessageDialog(add_exclude_dialog,
1098                                                                                      DialogFlags.Modal,
1099                                                                                      MessageType.Error,
1100                                                                                      ButtonsType.Ok,
1101                                                                                      Catalog.GetString ("Error adding path"),
1102                                                                                      Catalog.GetString ("The specified path could not be found and therefore it could not be added to the list of resources excluded for indexing."));
1103                                                 return;
1104                                         }
1105                                         break;
1106                                 }
1107
1108                                 if (ExcludeItemAddedEvent != null)
1109                                         ExcludeItemAddedEvent (exclude_item);
1110                         }
1111                         add_exclude_dialog.Destroy ();
1112                 }
1113
1114                 public void Destroy ()
1115                 {
1116                         add_exclude_dialog.Destroy ();
1117                 }
1118         }
1119
1120 #if false
1121         ////////////////////////////////////////////////////////////////
1122         // Display view
1123
1124         class DisplayView : TreeView
1125         {
1126                 public DisplayView ()
1127                 {
1128                         ListStore store = new ListStore (typeof(bool),typeof(string));
1129
1130                         this.Model = store;
1131
1132                         AppendColumn (Catalog.GetString ("Show"), new CellRendererToggle (), "active", 0);
1133                         AppendColumn (Catalog.GetString ("Name"), new CellRendererText (), "text", 1);
1134                 }
1135         }
1136 #endif
1137 }