← Back to branch summary

~ubuntu-branches/ubuntu/hoary/monodevelop/hoary

« back to all changes in this revision

Viewing changes to src/Libraries/MonoDevelop.Gui.Widgets/FileBrowser/FileBrowser.cs

  • Committer: Bazaar Package Importer
  • Author(s): Brandon Hale
  • Date: 2004-10-07 11:51:11 UTC
  • Revision ID: james.westby@ubuntu.com-20041007115111-pxcqnwfxyq5mhcx5
Tags: 0.5.1-3
Use dh_netdeps in debian/rules and debian/control

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Libraries/MonoDevelop.Gui.Widgets/FileBrowser/FileBrowser.cs
 
1
//
 
2
// Author: John Luke  <jluke@cfl.rr.com>
 
3
// Author: Inigo Illan <kodeport@terra.es>
 
4
// License: LGPL
 
5
//
 
6
// Copyright 2004 John Luke
 
7
//
 
8
 
 
9
using System;
 
10
using System.Collections;
 
11
using System.Diagnostics;
 
12
using System.IO;
 
13
using Gtk;
 
14
 
 
15
using MonoDevelop.Core.Properties;
 
16
using MonoDevelop.Core.Services;
 
17
using MonoDevelop.Gui.Utils;
 
18
using MonoDevelop.Services;
 
19
 
 
20
namespace MonoDevelop.Gui.Widgets
 
21
{
 
22
        public delegate void DirectoryChangedEventHandler (string path);
 
23
 
 
24
        private enum PerformingTask
 
25
        {
 
26
                None,
 
27
                Renaming,
 
28
                CreatingNew
 
29
        }
 
30
 
 
31
        public class FileBrowser : VBox
 
32
        {
 
33
                public DirectoryChangedEventHandler DirectoryChangedEvent;
 
34
                private static GLib.GType gtype;
 
35
 
 
36
                private Gtk.TreeView tv;
 
37
                private Gtk.ScrolledWindow scrolledwindow;
 
38
                private Gtk.Button upbutton, homebutton;
 
39
                private Gtk.Entry entry;
 
40
                private IMessageService messageService;
 
41
                private Gtk.CellRendererText text_render;
 
42
                private ListStore store;
 
43
                private string currentDir;
 
44
                private bool ignoreHidden = true;
 
45
                private bool init = false;
 
46
 
 
47
                private PerformingTask performingtask = PerformingTask.None;
 
48
                private ArrayList files = new ArrayList ();
 
49
                private Hashtable hiddenfolders = new Hashtable ();
 
50
 
 
51
                PropertyService PropertyService = (PropertyService) ServiceManager.GetService (typeof (PropertyService));
 
52
 
 
53
                public FileBrowser () : base (GType)
 
54
                {
 
55
                        if (!Vfs.Initialized) {
 
56
                                Vfs.Init ();
 
57
                        }
 
58
 
 
59
                        messageService = (IMessageService) ServiceManager.GetService (typeof (IMessageService));
 
60
 
 
61
                        scrolledwindow = new ScrolledWindow ();
 
62
                        scrolledwindow.VscrollbarPolicy = PolicyType.Automatic;
 
63
                        scrolledwindow.HscrollbarPolicy = PolicyType.Automatic;
 
64
 
 
65
                        homebutton = new Button ();
 
66
                        homebutton.Add (new Image (Stock.Home, IconSize.SmallToolbar));
 
67
                        homebutton.Relief = ReliefStyle.None;
 
68
                        homebutton.Clicked += new EventHandler (OnHomeClicked);
 
69
 
 
70
                        upbutton = new Button ();
 
71
                        upbutton.Add (new Image (Stock.GoUp, IconSize.SmallToolbar));
 
72
                        upbutton.Relief = ReliefStyle.None;
 
73
                        upbutton.Clicked += new EventHandler (OnUpClicked);
 
74
 
 
75
                        entry = new Entry ();
 
76
                        entry.Activated += new EventHandler (OnEntryActivated);
 
77
 
 
78
                        Toolbar toolbar = new Toolbar ();
 
79
                        toolbar.AppendWidget (upbutton, GettextCatalog.GetString ("Up one level"), GettextCatalog.GetString ("Up one level"));
 
80
                        toolbar.AppendWidget (homebutton, GettextCatalog.GetString ("Home"), GettextCatalog.GetString ("Home"));
 
81
                        toolbar.AppendWidget (entry, GettextCatalog.GetString ("Location"), GettextCatalog.GetString ("Location"));
 
82
 
 
83
                        IProperties p = (IProperties) PropertyService.GetProperty ("SharpDevelop.UI.SelectStyleOptions", new DefaultProperties ());
 
84
                        ignoreHidden = !p.GetProperty ("MonoDevelop.Gui.FileScout.ShowHidden", false);
 
85
 
 
86
                        tv = new Gtk.TreeView ();
 
87
                        tv.RulesHint = true;
 
88
 
 
89
                        TreeViewColumn directorycolumn = new TreeViewColumn ();
 
90
                        directorycolumn.Title = "Directories";
 
91
                        
 
92
                        CellRendererPixbuf pix_render = new CellRendererPixbuf ();
 
93
                        directorycolumn.PackStart (pix_render, false);
 
94
                        directorycolumn.AddAttribute (pix_render, "pixbuf", 0);
 
95
 
 
96
                        text_render = new CellRendererText ();
 
97
                        text_render.Edited += new EditedHandler (OnDirEdited);
 
98
                        directorycolumn.PackStart (text_render, false);
 
99
                        directorycolumn.AddAttribute (text_render, "text", 1);
 
100
                        
 
101
                        tv.AppendColumn (directorycolumn);
 
102
 
 
103
                        store = new ListStore (typeof (Gdk.Pixbuf), typeof (string));
 
104
                        CurrentDir = Environment.GetEnvironmentVariable ("HOME");
 
105
                        tv.Model = store;
 
106
 
 
107
                        tv.RowActivated += new RowActivatedHandler (OnRowActivated);
 
108
                        tv.ButtonReleaseEvent += new ButtonReleaseEventHandler (OnButtonRelease);                       
 
109
                        tv.PopupMenu += new PopupMenuHandler (OnPopupMenu);                     
 
110
 
 
111
                        scrolledwindow.Add (tv);
 
112
                        this.Homogeneous = false;
 
113
                        this.PackStart (toolbar, false, false, 0);
 
114
                        this.PackStart (scrolledwindow);
 
115
                        this.ShowAll ();
 
116
                        init = true;
 
117
                }
 
118
 
 
119
                // FIXME: we should watch the PropertyChanged event instead
 
120
                // of exposing the set part
 
121
                public bool IgnoreHidden
 
122
                {
 
123
                        get { return ignoreHidden; }
 
124
                        set {
 
125
                                /* for some reasont his code crashes (NullReferenceException on the Populate() call
 
126
                                if (ignoreHidden != value) {
 
127
                                        ignoreHidden = value; 
 
128
                                        // redraw folder list
 
129
                                        System.Console.WriteLine("before poplate call");
 
130
                                        Populate ();
 
131
                                }
 
132
                                */
 
133
                                
 
134
                                ignoreHidden = value;
 
135
                                Populate ();
 
136
                        }
 
137
                }
 
138
 
 
139
                public string CurrentDir
 
140
                {
 
141
                        get { return currentDir; }
 
142
                        set { 
 
143
                                        currentDir = System.IO.Path.GetFullPath (value);
 
144
                                        GetListOfHiddenFolders ();
 
145
                                        Populate ();
 
146
 
 
147
                                        if (DirectoryChangedEvent != null) {
 
148
                                                DirectoryChangedEvent (CurrentDir);
 
149
                                        }
 
150
                                }
 
151
                }
 
152
 
 
153
                public string[] Files
 
154
                {
 
155
                        get {
 
156
                                return (string[]) files.ToArray (typeof (string)); 
 
157
                        }
 
158
                }
 
159
 
 
160
                public static new GLib.GType GType
 
161
                {
 
162
                        get
 
163
                        {
 
164
                                if (gtype == GLib.GType.Invalid)
 
165
                                        gtype = RegisterGType (typeof (FileBrowser));
 
166
                                return gtype;
 
167
                        }
 
168
                }
 
169
 
 
170
                public void SelectFirst ()
 
171
                {
 
172
                        tv.Selection.SelectPath (new TreePath ("0"));
 
173
                }
 
174
 
 
175
                void Populate ()
 
176
                {
 
177
                        store.Clear ();
 
178
 
 
179
                        // FIXME: never turns back on
 
180
                        if (System.IO.Path.GetPathRoot (CurrentDir) == CurrentDir)
 
181
                                upbutton.Sensitive = false;
 
182
                        else if (upbutton.Sensitive == false)
 
183
                                upbutton.Sensitive = true;
 
184
 
 
185
                        DirectoryInfo di = new DirectoryInfo (CurrentDir);
 
186
                        DirectoryInfo[] dirs = di.GetDirectories ();
 
187
                        
 
188
                        foreach (DirectoryInfo d in dirs)
 
189
                        {
 
190
                                if (ignoreHidden)
 
191
                                {
 
192
                                        if (!d.Name.StartsWith (".") && NotHidden(d.Name))
 
193
                                                store.AppendValues (FileIconLoader.GetPixbufForFile (System.IO.Path.Combine (CurrentDir, d.Name), 24, 24), d.Name);
 
194
                                }
 
195
                                else
 
196
                                {
 
197
                                        store.AppendValues (FileIconLoader.GetPixbufForFile (System.IO.Path.Combine (CurrentDir, d.Name), 24, 24), d.Name);
 
198
                                }
 
199
                        }
 
200
 
 
201
                        if (init == true)
 
202
                                tv.Selection.SelectPath (new Gtk.TreePath ("0"));
 
203
 
 
204
                        entry.Text = CurrentDir;
 
205
                        string[] filesaux = Directory.GetFiles (CurrentDir);
 
206
 
 
207
                        files.Clear ();
 
208
                        for (int cont = 0; cont < filesaux.Length; cont++)
 
209
                        {
 
210
                                if (ignoreHidden)
 
211
                                {
 
212
                                        if (NotHidden (System.IO.Path.GetFileName(filesaux[cont])))
 
213
                                        {
 
214
                                                files.Add (filesaux[cont]);
 
215
                                        }
 
216
                                }
 
217
                                else
 
218
                                {
 
219
                                        files.Add (filesaux[cont]);
 
220
                                }
 
221
                        }
 
222
                }
 
223
 
 
224
                private void OnRowActivated (object o, RowActivatedArgs args)
 
225
                {
 
226
                        TreeIter iter;
 
227
                        store.GetIter (out iter, args.Path);
 
228
                        string file = (string) store.GetValue (iter, 1);
 
229
                        string newDir = System.IO.Path.Combine (currentDir, file);
 
230
 
 
231
                        if (Directory.Exists (newDir))
 
232
                        {
 
233
                                CurrentDir = newDir;
 
234
                        }
 
235
                }
 
236
                
 
237
                private void OnButtonRelease (object o, ButtonReleaseEventArgs args)
 
238
                {
 
239
                        if (args.Event.Button == 3)
 
240
                        {
 
241
                                ShowPopup ();
 
242
                        }       
 
243
                }
 
244
 
 
245
                private void OnPopupMenu (object o, PopupMenuArgs args)
 
246
                {
 
247
                        ShowPopup ();
 
248
                }
 
249
 
 
250
                private void ShowPopup ()
 
251
                {
 
252
                        Menu menu = new Menu ();
 
253
                        MenuItem openfilebrowser = new MenuItem (GettextCatalog.GetString ("Open with file browser"));
 
254
                        openfilebrowser.Activated += new EventHandler (OpenFileBrowser);
 
255
 
 
256
                        MenuItem openterminal = new MenuItem (GettextCatalog.GetString ("Open with terminal"));
 
257
                        openterminal.Activated += new EventHandler (OpenTerminal);
 
258
 
 
259
                        MenuItem rename = new MenuItem (GettextCatalog.GetString ("Rename"));
 
260
                        rename.Activated += new EventHandler (OnDirRename);
 
261
 
 
262
                        MenuItem delete = new MenuItem (GettextCatalog.GetString ("Delete"));
 
263
                        delete.Activated += new EventHandler (OnDirDelete);
 
264
 
 
265
                        MenuItem newfolder = new MenuItem (GettextCatalog.GetString ("Create new folder"));
 
266
                        newfolder.Activated += new EventHandler (OnNewDir);
 
267
 
 
268
                        menu.Append (newfolder);
 
269
                        menu.Append (new MenuItem ());
 
270
                        menu.Append (delete);
 
271
                        menu.Append (rename);
 
272
                        menu.Append (new MenuItem ());
 
273
                        menu.Append (openterminal);
 
274
                        menu.Append (openfilebrowser);
 
275
                        menu.Popup (null, null, null, IntPtr.Zero, 3, Global.CurrentEventTime);
 
276
                        menu.ShowAll ();
 
277
                }
 
278
                
 
279
                private void OpenFileBrowser (object o, EventArgs args)
 
280
                {
 
281
                        TreeIter iter;
 
282
                        TreeModel model;
 
283
                        // FIXME: look in GConf for the settings
 
284
                        // but strangely there is not one
 
285
                        string commandline = "nautilus \"";
 
286
 
 
287
                        if (tv.Selection.GetSelected (out model, out iter))
 
288
                        {
 
289
                                string selection = (string) store.GetValue (iter, 1);
 
290
                                commandline += System.IO.Path.Combine (currentDir, selection) + "\"";
 
291
                                Process.Start (commandline);
 
292
                        }
 
293
                }
 
294
                
 
295
                private void OpenTerminal (object o, EventArgs args)
 
296
                {
 
297
                        TreeIter iter;
 
298
                        TreeModel model;
 
299
                        // FIXME: look in GConf for the settings
 
300
                        // but the args will be terminal dependent
 
301
                        // leaving as hardcoded for now
 
302
                        string commandline = "gnome-terminal --working-directory=\"";
 
303
                        if (tv.Selection.GetSelected (out model, out iter))
 
304
                        {
 
305
                                string selection = (string) store.GetValue (iter, 1);
 
306
                                commandline += System.IO.Path.Combine (currentDir, selection) + "\"";
 
307
                                Process.Start (commandline);
 
308
                        }
 
309
                }
 
310
                
 
311
                private void OnUpClicked (object o, EventArgs args)
 
312
                {
 
313
                        if (System.IO.Path.GetPathRoot (CurrentDir) != CurrentDir)
 
314
                                CurrentDir = System.IO.Path.Combine (CurrentDir, "..");
 
315
                }
 
316
                
 
317
                private void OnHomeClicked (object o, EventArgs args)
 
318
                {
 
319
                        CurrentDir = Environment.GetEnvironmentVariable ("HOME");
 
320
                }
 
321
 
 
322
                private void OnEntryActivated (object sender, EventArgs args)
 
323
                {
 
324
                        if (Directory.Exists (entry.Text.Trim ()))
 
325
                                CurrentDir = entry.Text;
 
326
                        else
 
327
                        {
 
328
                        messageService.ShowError (null, String.Format (GettextCatalog.GetString ("Cannot enter '{0}' folder"), entry.Text));
 
329
                        }
 
330
                }
 
331
 
 
332
                private void OnDirRename (object o, EventArgs args)
 
333
                {
 
334
                        TreePath treepath;
 
335
                        TreeViewColumn column;
 
336
 
 
337
                        performingtask = PerformingTask.Renaming;
 
338
                        text_render.Editable = true;
 
339
 
 
340
                        tv.GetCursor (out treepath, out column);
 
341
 
 
342
                        tv.SetCursor (treepath, column, true);
 
343
                }
 
344
 
 
345
                private void OnDirEdited (object o, EditedArgs args)
 
346
                {
 
347
                        text_render.Editable = false;
 
348
 
 
349
                        switch (performingtask)
 
350
                        {
 
351
                                case PerformingTask.Renaming:
 
352
                                        TreeIter iter;
 
353
                                        tv.Model.IterNthChild (out iter, Int32.Parse (args.Path));
 
354
                                        string oldpath = (string) store.GetValue (iter, 1);
 
355
 
 
356
                                        if (oldpath != args.NewText)
 
357
                                        {
 
358
                                        try
 
359
                                        {
 
360
                                                System.IO.Directory.Move (System.IO.Path.Combine(CurrentDir, oldpath), System.IO.Path.Combine(CurrentDir, args.NewText));
 
361
                                        }
 
362
                                        catch (Exception ex)
 
363
                                        {
 
364
                                                messageService.ShowError (ex, String.Format (GettextCatalog.GetString ("Could not rename folder '{0}' to '{1}'"), oldpath, args.NewText));
 
365
                                        }
 
366
                                        finally
 
367
                                        {
 
368
                                                Populate ();
 
369
                                        }
 
370
                                        }
 
371
 
 
372
                                        break;
 
373
 
 
374
                                case PerformingTask.CreatingNew:
 
375
                                        System.IO.DirectoryInfo dirinfo = new DirectoryInfo (CurrentDir);
 
376
                                        try
 
377
                                        {
 
378
                                                dirinfo.CreateSubdirectory(args.NewText);
 
379
                                        }
 
380
                                        catch (Exception ex)
 
381
                                        {
 
382
                                        messageService.ShowError (ex, String.Format (GettextCatalog.GetString ("Could not create new folder '{0}'"), args.NewText));
 
383
                                        }
 
384
                                        finally
 
385
                                        {
 
386
                                                Populate ();
 
387
                                        }
 
388
 
 
389
                                        break;
 
390
                                                                                        
 
391
                                default:
 
392
                                        Console.WriteLine ("This should not be happening");
 
393
                                        break;
 
394
                        }
 
395
 
 
396
                        performingtask = PerformingTask.None;
 
397
                }
 
398
 
 
399
                private void OnDirDelete (object o, EventArgs args)
 
400
                {
 
401
                        TreeIter iter;
 
402
                        TreeModel model;
 
403
 
 
404
                        if (messageService.AskQuestion (GettextCatalog.GetString ("Are you sure you want to delete this folder?"), GettextCatalog.GetString ("Delete folder")))
 
405
                        {
 
406
                                if (tv.Selection.GetSelected (out model, out iter))
 
407
                                {
 
408
                                        try
 
409
                                        {
 
410
                                                Directory.Delete (System.IO.Path.Combine (CurrentDir, (string) store.GetValue (iter, 1)), true);
 
411
                                        }
 
412
                                        catch (Exception ex)
 
413
                                        {
 
414
                                                messageService.ShowError (ex, String.Format (GettextCatalog.GetString ("Could not delete folder '{0}'"), System.IO.Path.Combine (CurrentDir, (string) store.GetValue (iter, 1))));
 
415
                                        }
 
416
                                        finally
 
417
                                        {
 
418
                                                Populate ();
 
419
                                        }
 
420
                                }
 
421
                        }
 
422
                }
 
423
 
 
424
                // FIXME: When the scrollbars of the directory list
 
425
                // are shown, and we perform a new dir action
 
426
                // the column is never edited, but Populate is called
 
427
                private void OnNewDir (object o, EventArgs args)
 
428
                {
 
429
                        TreeIter iter;
 
430
                        TreePath treepath;
 
431
                        TreeViewColumn column;
 
432
 
 
433
                        performingtask = PerformingTask.CreatingNew;
 
434
                        text_render.Editable = true;
 
435
 
 
436
                        tv.Reorderable = false;
 
437
                        iter = store.AppendValues (FileIconLoader.GetPixbufForFile (CurrentDir, 24, 24), "folder name");
 
438
                        treepath = tv.Model.GetPath(iter);
 
439
 
 
440
                        column = tv.GetColumn (0);
 
441
                        tv.SetCursor (treepath, column, true);
 
442
                }
 
443
 
 
444
                private void GetListOfHiddenFolders ()
 
445
                {
 
446
                        hiddenfolders.Clear ();
 
447
 
 
448
                        if (System.IO.File.Exists (CurrentDir + System.IO.Path.DirectorySeparatorChar + ".hidden"))
 
449
                        {
 
450
                                StreamReader stream =  new StreamReader (CurrentDir + System.IO.Path.DirectorySeparatorChar + ".hidden");
 
451
                                string foldertohide = stream.ReadLine ();
 
452
 
 
453
                                while (foldertohide != null)
 
454
                                {
 
455
                                        hiddenfolders.Add (foldertohide, foldertohide);
 
456
                                        foldertohide = stream.ReadLine ();
 
457
                                }
 
458
 
 
459
                                stream.Close ();
 
460
                        }                       
 
461
                }
 
462
 
 
463
                private Boolean NotHidden (string folder)
 
464
                {
 
465
                        return !hiddenfolders.Contains (folder);
 
466
                } 
 
467
        }
 
468
}
 
469