← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ProjectPad/SolutionFolderNodeBuilder.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2009-02-18 08:40:51 UTC
  • mfrom: (1.2.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090218084051-gh8m6ukvokbwj7cf
Tags: 1.9.2+dfsg-1ubuntu1
https://launchpad.net/bugs/330519
* Merge from Debian Experimental (LP: #330519), remaining Ubuntu changes:
  + debian/control:
    - Update for Gnome# 2.24
    - Add libmono-cairo1.0-cil to build-deps to fool pkg-config check

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ProjectPad/SolutionFolderNodeBuilder.cs
 
1
//
 
2
// CombineNodeBuilder.cs
 
3
//
 
4
// Author:
 
5
//   Lluis Sanchez Gual
 
6
//
 
7
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
 
8
//
 
9
// Permission is hereby granted, free of charge, to any person obtaining
 
10
// a copy of this software and associated documentation files (the
 
11
// "Software"), to deal in the Software without restriction, including
 
12
// without limitation the rights to use, copy, modify, merge, publish,
 
13
// distribute, sublicense, and/or sell copies of the Software, and to
 
14
// permit persons to whom the Software is furnished to do so, subject to
 
15
// the following conditions:
 
16
// 
 
17
// The above copyright notice and this permission notice shall be
 
18
// included in all copies or substantial portions of the Software.
 
19
// 
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
21
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
22
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
23
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
24
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
25
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
27
//
 
28
 
 
29
using System;
 
30
using System.Collections;
 
31
 
 
32
using MonoDevelop.Projects;
 
33
using MonoDevelop.Core;
 
34
using MonoDevelop.Core.Collections;
 
35
using MonoDevelop.Ide.Commands;
 
36
using MonoDevelop.Ide.Gui;
 
37
using MonoDevelop.Core.Gui;
 
38
using MonoDevelop.Components.Commands;
 
39
using MonoDevelop.Ide.Gui.Search;
 
40
using MonoDevelop.Ide.Gui.Components;
 
41
 
 
42
namespace MonoDevelop.Ide.Gui.Pads.ProjectPad
 
43
{
 
44
        public class SolutionFolderNodeBuilder: TypeNodeBuilder
 
45
        {
 
46
                SolutionItemRenamedEventHandler combineNameChanged;
 
47
                
 
48
                public SolutionFolderNodeBuilder ()
 
49
                {
 
50
                        combineNameChanged = (SolutionItemRenamedEventHandler) DispatchService.GuiDispatch (new SolutionItemRenamedEventHandler (OnCombineRenamed));
 
51
                }
 
52
 
 
53
                public override Type NodeDataType {
 
54
                        get { return typeof(SolutionFolder); }
 
55
                }
 
56
                
 
57
                public override Type CommandHandlerType {
 
58
                        get { return typeof(CombineNodeCommandHandler); }
 
59
                }
 
60
                
 
61
                public override string GetNodeName (ITreeNavigator thisNode, object dataObject)
 
62
                {
 
63
                        return ((SolutionFolder)dataObject).Name;
 
64
                }
 
65
                
 
66
                public override void GetNodeAttributes (ITreeNavigator treeNavigator, object dataObject, ref NodeAttributes attributes)
 
67
                {
 
68
                        attributes |= NodeAttributes.AllowRename;
 
69
                }
 
70
                
 
71
                public override string ContextMenuAddinPath {
 
72
                        get { return "/MonoDevelop/Ide/ContextMenu/ProjectPad/SolutionFolder"; }
 
73
                }
 
74
                
 
75
                public override void BuildNode (ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
 
76
                {
 
77
                        SolutionFolder combine = dataObject as SolutionFolder;
 
78
                        label = combine.Name;
 
79
                        icon = Context.GetIcon (Stock.SolutionFolderOpen);
 
80
                        closedIcon = Context.GetIcon (Stock.SolutionFolderClosed);
 
81
                }
 
82
 
 
83
                public override void BuildChildNodes (ITreeBuilder ctx, object dataObject)
 
84
                {
 
85
                        SolutionFolder combine = (SolutionFolder) dataObject;
 
86
                        foreach (SolutionItem entry in combine.Items)
 
87
                                ctx.AddChild (entry);
 
88
                }
 
89
 
 
90
                public override bool HasChildNodes (ITreeBuilder builder, object dataObject)
 
91
                {
 
92
                        return ((SolutionFolder) dataObject).Items.Count > 0;
 
93
                }
 
94
                
 
95
                public override object GetParentObject (object dataObject)
 
96
                {
 
97
                        SolutionItem sf = (SolutionItem) dataObject;
 
98
                        return sf.ParentFolder.IsRoot ? (object) sf.ParentSolution : (object) sf.ParentFolder;
 
99
                }
 
100
                
 
101
                public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode)
 
102
                {
 
103
                        if (otherNode.DataItem is SolutionFolder)
 
104
                                return DefaultSort;
 
105
                        else
 
106
                                return -1;
 
107
                }
 
108
 
 
109
                public override void OnNodeAdded (object dataObject)
 
110
                {
 
111
                        SolutionFolder combine = (SolutionFolder) dataObject;
 
112
                        combine.NameChanged += combineNameChanged;
 
113
                }
 
114
                
 
115
                public override void OnNodeRemoved (object dataObject)
 
116
                {
 
117
                        SolutionFolder combine = (SolutionFolder) dataObject;
 
118
                        combine.NameChanged -= combineNameChanged;
 
119
                }
 
120
                
 
121
                void OnCombineRenamed (object sender, SolutionItemRenamedEventArgs e)
 
122
                {
 
123
                        ITreeBuilder tb = Context.GetTreeBuilder (e.SolutionItem);
 
124
                        if (tb != null) tb.Update ();
 
125
                }
 
126
        }
 
127
        
 
128
        public class CombineNodeCommandHandler: NodeCommandHandler
 
129
        {
 
130
                public override void RenameItem (string newName)
 
131
                {
 
132
                        if (newName.IndexOfAny (new char [] { '\'', '(', ')', '"', '{', '}', '|' } ) != -1) {
 
133
                                MessageService.ShowError (GettextCatalog.GetString ("Solution name may not contain any of the following characters: {0}", "', (, ), \", {, }, |"));
 
134
                                return;
 
135
                        }
 
136
                        
 
137
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
 
138
                        folder.Name = newName;
 
139
                        IdeApp.Workspace.Save();
 
140
                }
 
141
                
 
142
                public override DragOperation CanDragNode ()
 
143
                {
 
144
                        return DragOperation.Move;
 
145
                }
 
146
                
 
147
                public override bool CanDropNode (object dataObject, DragOperation operation)
 
148
                {
 
149
                        SolutionItem it = dataObject as SolutionItem;
 
150
                        return it != null && operation == DragOperation.Move;
 
151
                }
 
152
                
 
153
                public override void OnNodeDrop (object dataObject, DragOperation operation)
 
154
                {
 
155
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
 
156
                        SolutionItem it = (SolutionItem) dataObject;
 
157
                        if (!MessageService.Confirm (GettextCatalog.GetString ("Are you sure you want to move the item '{0}' to the solution folder '{1}'?", it.Name, folder.Name), AlertButton.Move))
 
158
                                return;
 
159
                        
 
160
                        it.ParentFolder.Items.Remove (it);
 
161
                        folder.Items.Add (it);
 
162
                        IdeApp.ProjectOperations.Save (folder.ParentSolution);
 
163
                }
 
164
                        
 
165
                public override void ActivateMultipleItems ()
 
166
                {
 
167
                        SolutionFolder folder = CurrentNode.DataItem as SolutionFolder;
 
168
                        IdeApp.ProjectOperations.ShowOptions (folder);
 
169
                }
 
170
                
 
171
                public override void DeleteItem ()
 
172
                {
 
173
                        SolutionFolder folder = CurrentNode.DataItem as SolutionFolder;
 
174
                        SolutionFolder parent = folder.ParentFolder;
 
175
                        if (parent == null) return;
 
176
                        
 
177
                        bool yes = MessageService.Confirm (GettextCatalog.GetString ("Do you really want to remove the folder '{0}' from '{1}'?", folder.Name, parent.Name), AlertButton.Remove);
 
178
                        if (yes) {
 
179
                                Solution sol = folder.ParentSolution;
 
180
                                parent.Items.Remove (folder);
 
181
                                folder.Dispose ();
 
182
                                IdeApp.ProjectOperations.Save (sol);
 
183
                        }
 
184
                }
 
185
                
 
186
                [CommandHandler (ProjectCommands.AddNewProject)]
 
187
                public void AddNewProjectToCombine()
 
188
                {
 
189
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
 
190
                        SolutionItem ce = IdeApp.ProjectOperations.CreateProject (folder);
 
191
                        if (ce == null) return;
 
192
                        Tree.AddNodeInsertCallback (ce, new TreeNodeCallback (OnEntryInserted));
 
193
                        CurrentNode.Expanded = true;
 
194
                }
 
195
                
 
196
                [CommandHandler (ProjectCommands.AddProject)]
 
197
                public void AddProjectToCombine()
 
198
                {
 
199
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
 
200
                        SolutionItem ce = IdeApp.ProjectOperations.AddSolutionItem (folder);
 
201
                        if (ce == null) return;
 
202
                        Tree.AddNodeInsertCallback (ce, new TreeNodeCallback (OnEntryInserted));
 
203
                        CurrentNode.Expanded = true;
 
204
                }
 
205
                
 
206
                [CommandHandler (ProjectCommands.AddSolutionFolder)]
 
207
                public void AddFolder()
 
208
                {
 
209
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
 
210
                        SolutionFolder ce = new SolutionFolder ();
 
211
                        ce.Name = GettextCatalog.GetString ("New Folder");
 
212
                        folder.Items.Add (ce);
 
213
                        Tree.AddNodeInsertCallback (ce, OnFolderInserted);
 
214
                        CurrentNode.Expanded = true;
 
215
                }
 
216
                
 
217
                [CommandHandler (ProjectCommands.Reload)]
 
218
                [AllowMultiSelection]
 
219
                public void OnReload ()
 
220
                {
 
221
                        using (IProgressMonitor m = IdeApp.Workbench.ProgressMonitors.GetLoadProgressMonitor (true)) {
 
222
                                m.BeginTask (null, CurrentNodes.Length);
 
223
                                foreach (ITreeNavigator node in CurrentNodes) {
 
224
                                        SolutionFolder folder = (SolutionFolder) node.DataItem;
 
225
                                        folder.ParentFolder.ReloadItem (m, folder);
 
226
                                        m.Step (1);
 
227
                                }
 
228
                                m.EndTask ();
 
229
                        }
 
230
                }
 
231
                
 
232
                [CommandUpdateHandler (ProjectCommands.Reload)]
 
233
                public void OnUpdateReload (CommandInfo info)
 
234
                {
 
235
                        foreach (ITreeNavigator node in CurrentNodes) {
 
236
                                SolutionFolder folder = (SolutionFolder) node.DataItem;
 
237
                                if (folder.ParentFolder == null || !folder.NeedsReload) {
 
238
                                        info.Visible = false;
 
239
                                        return;
 
240
                                }
 
241
                        }
 
242
                }
 
243
                
 
244
                [CommandHandler (FileCommands.OpenContainingFolder)]
 
245
                [AllowMultiSelection]
 
246
                public void OpenContainingFolder ()
 
247
                {
 
248
                        Set<string> paths = new Set<string> ();
 
249
                        foreach (ITreeNavigator node in CurrentNodes) {
 
250
                                SolutionFolder folder = (SolutionFolder) node.DataItem;
 
251
                                if (paths.Add (folder.BaseDirectory))
 
252
                                        System.Diagnostics.Process.Start ("file://" + folder.BaseDirectory);
 
253
                        }
 
254
                }
 
255
                
 
256
                [CommandHandler (SearchCommands.FindInFiles)]
 
257
                public void OnFindInFiles ()
 
258
                {
 
259
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
 
260
                        SearchReplaceInFilesManager.ShowFindDialog (folder.BaseDirectory);
 
261
                }
 
262
                
 
263
                void OnEntryInserted (ITreeNavigator nav)
 
264
                {
 
265
                        nav.Selected = true;
 
266
                        nav.Expanded = true;
 
267
                }
 
268
                
 
269
                void OnFolderInserted (ITreeNavigator nav)
 
270
                {
 
271
                        nav.Selected = true;
 
272
                        nav.Expanded = true;
 
273
                        Tree.StartLabelEdit ();
 
274
                }
 
275
        }
 
276
}