← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/monodevelop/oneiric

« back to all changes in this revision

Viewing changes to src/core/MonoDevelop.Ide/MonoDevelop.Components.Extensions/ISelectFileDialog.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2011-06-27 17:03:13 UTC
  • mto: (1.8.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 54.
  • Revision ID: james.westby@ubuntu.com-20110627170313-6cvz3s19x6e9hqe9
Import upstream version 2.5.92+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/MonoDevelop.Ide/MonoDevelop.Components.Extensions/ISelectFileDialog.cs
29
29
using System.Linq;
30
30
using MonoDevelop.Core;
31
31
using MonoDevelop.Ide;
 
32
using Mono.Addins;
32
33
 
33
34
namespace MonoDevelop.Components.Extensions
34
35
{
36
37
        /// This interface can be implemented to provide a custom implementation
37
38
        /// for the SelectFileDialog dialog.
38
39
        /// </summary>
39
 
        public interface ISelectFileDialogHandler
40
 
        {
41
 
                bool Run (SelectFileDialogData data);
 
40
        public interface ISelectFileDialogHandler : IDialogHandler<SelectFileDialogData>
 
41
        {
42
42
        }
43
43
        
44
44
        /// <summary>
67
67
                        this.Patterns = patterns;
68
68
                }
69
69
                
 
70
                public SelectFileDialogFilter (string name, IList<string> patterns, IList<string> mimetypes)
 
71
                {
 
72
                        this.Name = name;
 
73
                        this.Patterns = patterns;
 
74
                        this.MimeTypes = mimetypes;
 
75
                }
 
76
                
70
77
                /// <summary>Label for the filter</summary>
71
78
                public string Name { get; private set; }
72
79
                
75
82
                
76
83
                /// <summary>MIME types permitted by this filter</summary>
77
84
                public IList<string> MimeTypes { get; private set; }
 
85
                
 
86
                public static SelectFileDialogFilter AllFiles {
 
87
                        get {
 
88
                                return new SelectFileDialogFilter (GettextCatalog.GetString ("All Files"), "*");
 
89
                        }
 
90
                }
78
91
        }
79
92
        
80
93
        /// <summary>
82
95
        /// The T type argument is the type of the handler.
83
96
        /// The U type is the type of the data parameter (must subclass SelectFileDialogData)
84
97
        /// </summary>
85
 
        public class SelectFileDialog<T,U>: PlatformDialog<T,U> where U:SelectFileDialogData, new()
 
98
        public abstract class SelectFileDialog<T>: PlatformDialog<T> where T:SelectFileDialogData, new()
86
99
        {
87
100
                /// <summary>
88
101
                /// Action to perform with the file dialog.
154
167
                
155
168
                public SelectFileDialogFilter AddFilter (SelectFileDialogFilter filter)
156
169
                {
 
170
                        if (useDefaultFilters)
 
171
                                throw new InvalidOperationException ("Cannot mix default filters and custom filters");
157
172
                        data.Filters.Add (filter);
158
173
                        return filter;
159
174
                }
160
175
                
161
176
                public SelectFileDialogFilter AddAllFilesFilter ()
162
177
                {
163
 
                        return AddFilter (GettextCatalog.GetString ("All Files"), "*");
 
178
                        return AddFilter (SelectFileDialogFilter.AllFiles);
 
179
                }
 
180
                
 
181
                public bool HasFilters {
 
182
                        get {
 
183
                                return data.Filters != null && data.Filters.Count > 0;
 
184
                        }
 
185
                }
 
186
                
 
187
                /// <summary>
 
188
                /// Adds the default file filters registered by MD core and addins. Includes the All Files filter.
 
189
                /// </summary>
 
190
                public void AddDefaultFileFilters ()
 
191
                {
 
192
                        if (HasFilters)
 
193
                                throw new InvalidOperationException ("Cannot mix default filters and custom filters");
 
194
                        if (useDefaultFilters)
 
195
                                throw new InvalidOperationException ("Already called");
 
196
                        
 
197
                        useDefaultFilters = true;
 
198
                        
 
199
                        foreach (var f in GetDefaultFilters ())
 
200
                                data.Filters.Add (f);
 
201
                        data.Filters.Add (SelectFileDialogFilter.AllFiles);
 
202
                        
 
203
                        LoadDefaultFilter ();
 
204
                }
 
205
                
 
206
                bool useDefaultFilters;
 
207
                
 
208
                ///<summary>Loads last default filter from MD prefs</summary>
 
209
                void LoadDefaultFilter ()
 
210
                {
 
211
                        // Load last used filter pattern
 
212
                        var lastPattern = PropertyService.Get ("Monodevelop.FileSelector.LastPattern", "*");
 
213
                        foreach (var filter in Filters) {
 
214
                                if (filter.Patterns != null && filter.Patterns.Contains (lastPattern)) {
 
215
                                        DefaultFilter = filter;
 
216
                                        break;
 
217
                                }
 
218
                        }
 
219
                }
 
220
                
 
221
                ///<summary>Saves last default filter to MD prefs, if necessary</summary>
 
222
                protected void SaveDefaultFilter ()
 
223
                {
 
224
                        if (!useDefaultFilters)
 
225
                                return;
 
226
                        
 
227
                        // Save active filter
 
228
                        //it may be null if e.g. SetSelectedFile was used
 
229
                        if (DefaultFilter != null && DefaultFilter.Patterns != null && DefaultFilter.Patterns.Count > 0)
 
230
                                PropertyService.Set ("Monodevelop.FileSelector.LastPattern", DefaultFilter.Patterns[0]);
 
231
                }
 
232
                
 
233
                static IEnumerable<SelectFileDialogFilter> GetDefaultFilters ()
 
234
                {
 
235
                        foreach (var f in ParseFilters (AddinManager.GetExtensionObjects ("/MonoDevelop/Ide/ProjectFileFilters")))
 
236
                                yield return f;
 
237
                        foreach (var f in ParseFilters (AddinManager.GetExtensionObjects ("/MonoDevelop/Ide/FileFilters")))
 
238
                                yield return f;
 
239
                }
 
240
                
 
241
                static IEnumerable<SelectFileDialogFilter> ParseFilters (System.Collections.IEnumerable filterStrings)
 
242
                {
 
243
                        if (filterStrings == null)
 
244
                                yield break;
 
245
                        foreach (string filterStr in filterStrings) {
 
246
                                var parts = filterStr.Split ('|');
 
247
                                var f = new SelectFileDialogFilter (parts[0], parts[1].Split (';'));
 
248
                                yield return f;
 
249
                        }
164
250
                }
165
251
 
166
252
                void SetGtkFileFilters (FileSelector fdiag)
195
281
                [GLib.ConnectBefore]
196
282
                void CaptureDefaultFilter (object sender, EventArgs e)
197
283
                {
198
 
                        
 
284
                        FileSelector fsel = (FileSelector) sender;
 
285
                        if (fsel.Filter == null)
 
286
                                return;
 
287
                        var name = fsel.Filter.Name;
 
288
                        foreach (var filter in data.Filters) {
 
289
                                if (filter.Name == name) {
 
290
                                        data.DefaultFilter = filter;
 
291
                                        return;
 
292
                                }
 
293
                        }
199
294
                }
200
295
                
201
296
                #endregion
237
332
                        }
238
333
                }
239
334
                
240
 
                /// <summary>
241
 
                /// Runs the default implementation of the dialog.
242
 
                /// </summary>
243
 
                protected bool RunDefault ()
244
 
                {
245
 
                        var fdiag  = new FileSelector ();
 
335
                public override bool Run ()
 
336
                {
 
337
                        if (!HasFilters)
 
338
                                AddDefaultFileFilters ();
 
339
                        
 
340
                        bool success = base.Run ();
 
341
                        
 
342
                        if (success && useDefaultFilters)
 
343
                                SaveDefaultFilter ();
 
344
                        
 
345
                        return success;
 
346
                }
 
347
                
 
348
                /// <summary>Runs the default implementation of the dialog.</summary>
 
349
                protected override bool RunDefault ()
 
350
                {
 
351
                        var fdiag = new FileSelector ();
246
352
                        SetDefaultProperties (fdiag);
247
353
                        try {
248
354
                                int result = MessageService.RunCustomDialog (fdiag, data.TransientFor ?? MessageService.RootWindow);