← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/MonoDevelop.Ide/MonoDevelop.Ide.Gui.Pads.ProjectPad/SolutionFolderNodeBuilder.cs
1
1
//
2
 
// CombineNodeBuilder.cs
 
2
// SolutionFolderNodeBuilder.cs
3
3
//
4
4
// Author:
5
5
//   Lluis Sanchez Gual
27
27
//
28
28
 
29
29
using System;
30
 
using System.Collections;
31
30
 
32
31
using MonoDevelop.Projects;
33
32
using MonoDevelop.Core;
34
 
using MonoDevelop.Core.Collections;
35
33
using MonoDevelop.Ide.Commands;
36
34
using MonoDevelop.Ide.Gui;
37
35
using MonoDevelop.Components.Commands;
38
36
using MonoDevelop.Ide.Gui.Components;
39
 
using MonoDevelop.Components;
40
37
 
41
38
namespace MonoDevelop.Ide.Gui.Pads.ProjectPad
42
39
{
43
 
        public class SolutionFolderNodeBuilder: TypeNodeBuilder
 
40
        class SolutionFolderNodeBuilder: TypeNodeBuilder
44
41
        {
45
 
                SolutionItemRenamedEventHandler combineNameChanged;
46
 
                SolutionItemChangeEventHandler combineEntryAdded;
47
 
                SolutionItemChangeEventHandler combineEntryRemoved;
 
42
                SolutionItemRenamedEventHandler nameChanged;
 
43
                SolutionItemChangeEventHandler entryAdded;
 
44
                SolutionItemChangeEventHandler entryRemoved;
48
45
                EventHandler<SolutionItemFileEventArgs> fileAdded;
49
46
                EventHandler<SolutionItemFileEventArgs> fileRemoved;
50
47
                
51
48
                public SolutionFolderNodeBuilder ()
52
49
                {
53
 
                        combineNameChanged = (SolutionItemRenamedEventHandler) DispatchService.GuiDispatch (new SolutionItemRenamedEventHandler (OnCombineRenamed));
54
 
                        combineEntryAdded = (SolutionItemChangeEventHandler) DispatchService.GuiDispatch (new SolutionItemChangeEventHandler (OnEntryAdded));
55
 
                        combineEntryRemoved = (SolutionItemChangeEventHandler) DispatchService.GuiDispatch (new SolutionItemChangeEventHandler (OnEntryRemoved));
56
 
                        fileAdded = (EventHandler<SolutionItemFileEventArgs>) DispatchService.GuiDispatch (new EventHandler<SolutionItemFileEventArgs> (OnFileAdded));
57
 
                        fileRemoved = (EventHandler<SolutionItemFileEventArgs>) DispatchService.GuiDispatch (new EventHandler<SolutionItemFileEventArgs> (OnFileRemoved));
 
50
                        nameChanged = DispatchService.GuiDispatch<SolutionItemRenamedEventHandler> (OnSolutionFolderRenamed);
 
51
                        entryAdded = DispatchService.GuiDispatch<SolutionItemChangeEventHandler> (OnEntryAdded);
 
52
                        entryRemoved = DispatchService.GuiDispatch<SolutionItemChangeEventHandler> (OnEntryRemoved);
 
53
                        fileAdded = DispatchService.GuiDispatch<EventHandler<SolutionItemFileEventArgs>> (OnFileAdded);
 
54
                        fileRemoved =  DispatchService.GuiDispatch<EventHandler<SolutionItemFileEventArgs>> (OnFileRemoved);
58
55
                }
59
56
 
60
57
                public override Type NodeDataType {
62
59
                }
63
60
                
64
61
                public override Type CommandHandlerType {
65
 
                        get { return typeof(CombineNodeCommandHandler); }
 
62
                        get { return typeof(SolutionFolderNodeCommandHandler); }
66
63
                }
67
64
                
68
65
                public override string GetNodeName (ITreeNavigator thisNode, object dataObject)
77
74
                
78
75
                public override void BuildNode (ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
79
76
                {
80
 
                        SolutionFolder combine = dataObject as SolutionFolder;
81
 
                        label = GLib.Markup.EscapeText (combine.Name);
 
77
                        SolutionFolder folder = dataObject as SolutionFolder;
 
78
                        label = GLib.Markup.EscapeText (folder.Name);
82
79
                        icon = Context.GetIcon (Stock.SolutionFolderOpen);
83
80
                        closedIcon = Context.GetIcon (Stock.SolutionFolderClosed);
84
81
                }
115
112
                public override void OnNodeAdded (object dataObject)
116
113
                {
117
114
                        SolutionFolder folder = (SolutionFolder) dataObject;
118
 
                        folder.NameChanged += combineNameChanged;
119
 
                        folder.ItemAdded += combineEntryAdded;
120
 
                        folder.ItemRemoved += combineEntryRemoved;
 
115
                        folder.NameChanged += nameChanged;
 
116
                        folder.ItemAdded += entryAdded;
 
117
                        folder.ItemRemoved += entryRemoved;
121
118
                        folder.SolutionItemFileAdded += fileAdded;
122
119
                        folder.SolutionItemFileRemoved += fileRemoved;
123
120
                }
125
122
                public override void OnNodeRemoved (object dataObject)
126
123
                {
127
124
                        SolutionFolder folder = (SolutionFolder) dataObject;
128
 
                        folder.NameChanged -= combineNameChanged;
129
 
                        folder.ItemAdded -= combineEntryAdded;
130
 
                        folder.ItemRemoved -= combineEntryRemoved;
 
125
                        folder.NameChanged -= nameChanged;
 
126
                        folder.ItemAdded -= entryAdded;
 
127
                        folder.ItemRemoved -= entryRemoved;
131
128
                        folder.SolutionItemFileAdded -= fileAdded;
132
129
                        folder.SolutionItemFileRemoved -= fileRemoved;
133
130
                }
134
131
                
135
 
                void OnCombineRenamed (object sender, SolutionItemRenamedEventArgs e)
 
132
                void OnSolutionFolderRenamed (object sender, SolutionItemRenamedEventArgs e)
136
133
                {
137
134
                        ITreeBuilder tb = Context.GetTreeBuilder (e.SolutionItem);
138
135
                        if (tb != null) tb.Update ();
174
171
                }
175
172
        }
176
173
        
177
 
        public class CombineNodeCommandHandler: NodeCommandHandler
 
174
        class SolutionFolderNodeCommandHandler: NodeCommandHandler
178
175
        {
 
176
                public override void ActivateItem ()
 
177
                {
 
178
                        CurrentNode.Expanded = !CurrentNode.Expanded;
 
179
                }
 
180
 
179
181
                public override void RenameItem (string newName)
180
182
                {
181
183
                        if (newName.IndexOfAny (new char [] { '\'', '(', ')', '"', '{', '}', '|' } ) != -1) {
222
224
                internal static void DropFile (SolutionFolder folder, IFileItem fileItem, DragOperation operation)
223
225
                {
224
226
                        FilePath dest = folder.BaseDirectory.Combine (fileItem.FileName.FileName);
225
 
                        if (operation == DragOperation.Copy)
 
227
                        if (operation == DragOperation.Copy) {
 
228
                                if (dest == fileItem.FileName)
 
229
                                        dest = ProjectOperations.GetTargetCopyName (dest, false);
226
230
                                FileService.CopyFile (fileItem.FileName, dest);
227
 
                        else
 
231
                        }
 
232
                        else {
 
233
                                var pf = fileItem as ProjectFile;
 
234
                                if (pf != null && pf.Project != null)
 
235
                                        pf.Project.Files.Remove (pf);
 
236
                                var fn = fileItem as SolutionFolderFileNode;
 
237
                                if (fn != null) {
 
238
                                        if (fn.Parent == folder)
 
239
                                                return;
 
240
                                        fn.Parent.Files.Remove (fileItem.FileName);
 
241
                                }
228
242
                                FileService.MoveFile (fileItem.FileName, dest);
 
243
                        }
229
244
                        folder.Files.Add (dest);
230
245
                }
231
246
                        
251
266
                }
252
267
                
253
268
                [CommandHandler (ProjectCommands.AddNewProject)]
254
 
                public void AddNewProjectToCombine()
 
269
                public void AddNewProjectToSolutionFolder()
255
270
                {
256
271
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
257
272
                        SolutionItem ce = IdeApp.ProjectOperations.CreateProject (folder);
261
276
                }
262
277
                
263
278
                [CommandHandler (ProjectCommands.AddProject)]
264
 
                public void AddProjectToCombine()
 
279
                public void AddProjectToSolutionFolder()
265
280
                {
266
281
                        SolutionFolder folder = (SolutionFolder) CurrentNode.DataItem;
267
282
                        SolutionItem ce = IdeApp.ProjectOperations.AddSolutionItem (folder);