ToolStripItem[] BuildMenuByFile(ICollection<INavigationPoint> points, int additionalItems)
{
Dictionary<string, List<INavigationPoint>> files =
new Dictionary<string, List<INavigationPoint>>();
List<string> fileNames = new List<string>();
foreach (INavigationPoint p in points) {
if (p.FileName==null) {
throw new ApplicationException("should not get here!");
}
if (!fileNames.Contains(p.FileName)) {
fileNames.Add(p.FileName);
files.Add(p.FileName, new List<INavigationPoint>());
}
if (!files[p.FileName].Contains(p)) {
files[p.FileName].Add(p);
}
}
fileNames.Sort();
ToolStripItem[] items =
new ToolStripItem[fileNames.Count + additionalItems];
ToolStripMenuItem containerItem = null;
MenuCommand cmd = null;
int i = 0;
foreach (string fname in fileNames) {
// create a menu bucket
containerItem = new ToolStripMenuItem();
containerItem.Text = System.IO.Path.GetFileName(fname);
containerItem.ToolTipText = fname;
// sort and populate the bucket's contents
// files[fname].Sort();
foreach(INavigationPoint p in files[fname]) {
cmd = new MenuCommand(p.Description, new EventHandler(NavigateTo));
cmd.Tag = p;
containerItem.DropDownItems.Add(cmd);
}
// if there's only one nested item, add it
// to the result directly, ignoring the bucket
// if (containerItem.DropDownItems.Count==1) {
// items[i] = containerItem.DropDownItems[0];
// items[i].Text = ((INavigationPoint)items[i].Tag).FullDescription;
// i++;
// } else {
// // add the bucket to the result
// items[i++] = containerItem;
// }
// add the bucket to the result
items[i++] = containerItem;
}
return items;
}
// TODO: refactor BuildSubmenu to add a choice between flat and perfile, eventually per class/method sorting of the list
ToolStripItem[] BuildMenuFlat(ICollection<INavigationPoint> points, int additionalItems)
{
ToolStripItem[] items = new ToolStripItem[points.Count+additionalItems];
MenuCommand cmd = null;
INavigationPoint p = null;
List<INavigationPoint> list = new List<INavigationPoint>(points);
int n = points.Count-1; // the last point
int i = 0;
while (i<points.Count) {
p = list[n-i];
cmd = new MenuCommand(p.Description, new EventHandler(NavigateTo));
cmd.Tag = p;
// if (p == NavigationService.CurrentPosition) {
// cmd.Text = "*** "+cmd.Text;
// }
items[i++] = cmd;
}
return items;
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand[] items = new MenuCommand[ToolLoader.Tool.Count];
for (int i = 0; i < ToolLoader.Tool.Count; ++i) {
MenuCommand item = new MenuCommand(ToolLoader.Tool[i].ToString(), new EventHandler(ToolEvt));
item.Description = "Start tool " + String.Join(String.Empty, ToolLoader.Tool[i].ToString().Split('&'));
items[i] = item;
}
return items;
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
RecentOpen recentOpen = FileService.RecentOpen;
if (recentOpen.RecentProject.Count > 0) {
MenuCommand[] items = new MenuCommand[recentOpen.RecentProject.Count];
for (int i = 0; i < recentOpen.RecentProject.Count; ++i) {
string accelaratorKeyPrefix = i < 10 ? "&" + ((i + 1) % 10) + " " : "";
items[i] = new MenuCommand(accelaratorKeyPrefix + recentOpen.RecentProject[i], new EventHandler(LoadRecentProject));
items[i].Tag = recentOpen.RecentProject[i].ToString();
items[i].Description = StringParser.Parse(ResourceService.GetString("Dialog.Componnents.RichMenuItem.LoadProjectDescription"),
new string[,] { {"PROJECT", recentOpen.RecentProject[i].ToString()} });
}
return items;
}
MenuCommand defaultMenu = new MenuCommand("${res:Dialog.Componnents.RichMenuItem.NoRecentProjectsString}");
defaultMenu.Enabled = false;
return new MenuCommand[] { defaultMenu };
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd = null;
if (NavigationService.CanNavigateBack || NavigationService.CanNavigateForwards) {
ICollection<INavigationPoint> points = NavigationService.Points;
//ToolStripItem[] items = BuildMenuFlat(points, numberOfAdditionalItems);
ToolStripItem[] items = BuildMenuByFile(points, numberOfAdditionalItems);
int i = items.Length - numberOfAdditionalItems;
// additional item 1
items[i++] = new ToolStripSeparator();
// additional item 2
cmd = new MenuCommand("${res:XML.MainMenu.Navigation.ClearHistory}", new EventHandler(ClearHistory));
items[i++] = cmd;
return items;
}
// default is to disable the dropdown feature...
return null;
}
public static void CreateQuickInsertMenu(TextBoxBase targetControl, Control popupControl, string[,] quickInsertMenuItems)
{
ContextMenuStrip contextMenu = new ContextMenuStrip();
for (int i = 0; i < quickInsertMenuItems.GetLength(0); ++i) {
if (quickInsertMenuItems[i, 0] == "-") {
contextMenu.Items.Add(new MenuSeparator());
} else {
MenuCommand cmd = new MenuCommand(quickInsertMenuItems[i, 0],
new QuickInsertMenuHandler(targetControl, quickInsertMenuItems[i, 1]).EventHandler);
contextMenu.Items.Add(cmd);
}
}
new QuickInsertHandler(popupControl, contextMenu);
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd;
IClass c;
ClassNode classNode = owner as ClassNode;
if (classNode != null) {
c = classNode.Class;
} else {
ClassBookmark bookmark = (ClassBookmark)owner;
c = bookmark.Class;
}
ParserService.ParseCurrentViewContent();
c = c.ProjectContent.GetClass(c.FullyQualifiedName, c.TypeParameters.Count);
if (c == null) {
return new ToolStripMenuItem[0];
}
LanguageProperties language = c.ProjectContent.Language;
List<ToolStripItem> list = new List<ToolStripItem>();
if (!FindReferencesAndRenameHelper.IsReadOnly(c)) {
if (c.DeclaringType == null &&
!c.BodyRegion.IsEmpty &&
!c.Name.Equals(Path.GetFileNameWithoutExtension(c.CompilationUnit.FileName),
StringComparison.InvariantCultureIgnoreCase))
{
// File name does not match class name
string correctFileName = Path.Combine(Path.GetDirectoryName(c.CompilationUnit.FileName),
c.Name + Path.GetExtension(c.CompilationUnit.FileName));
if (FileUtility.IsValidFileName(correctFileName)
&& Path.IsPathRooted(correctFileName)
&& !File.Exists(correctFileName))
{
if (c.CompilationUnit.Classes.Count == 1) {
// Rename file to ##
cmd = new MenuCommand(StringParser.Parse("${res:SharpDevelop.Refactoring.RenameFileTo}", new string[,] {{ "FileName", Path.GetFileName(correctFileName) }}),
delegate {
FileService.RenameFile(c.CompilationUnit.FileName, correctFileName, false);
if (c.ProjectContent.Project != null) {
((IProject)c.ProjectContent.Project).Save();
}
});
list.Add(cmd);
} else if (language.RefactoringProvider.SupportsCreateNewFileLikeExisting && language.RefactoringProvider.SupportsGetFullCodeRangeForType) {
// Move class to file ##
cmd = new MenuCommand(StringParser.Parse("${res:SharpDevelop.Refactoring.MoveClassToFile}", new string[,] {{ "FileName", Path.GetFileName(correctFileName) }}),
delegate {
MoveClassToFile(c, correctFileName);
});
list.Add(cmd);
}
}
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.RenameCommand}", Rename);
cmd.Tag = c;
list.Add(cmd);
}
if (c.BaseTypes.Count > 0) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToBaseCommand}", GoToBase);
cmd.Tag = c;
list.Add(cmd);
if (c.ClassType != ClassType.Interface && !FindReferencesAndRenameHelper.IsReadOnly(c)) {
AddImplementInterfaceCommands(c, list);
}
}
if (!c.IsSealed && !c.IsStatic) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindDerivedClassesCommand}", FindDerivedClasses);
cmd.Tag = c;
list.Add(cmd);
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindReferencesCommand}", FindReferences);
cmd.Tag = c;
list.Add(cmd);
return list.ToArray();
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd;
IMember member;
MemberNode memberNode = owner as MemberNode;
if (memberNode != null) {
member = memberNode.Member;
} else {
ClassMemberBookmark bookmark = (ClassMemberBookmark)owner;
member = bookmark.Member;
}
IMethod method = member as IMethod;
List<ToolStripItem> list = new List<ToolStripItem>();
bool canGenerateCode =
member.DeclaringType.ProjectContent.Language.CodeGenerator != null
&& !FindReferencesAndRenameHelper.IsReadOnly(member.DeclaringType);
if (method == null || !method.IsConstructor) {
if (!FindReferencesAndRenameHelper.IsReadOnly(member.DeclaringType) &&
!(member is IProperty && ((IProperty)member).IsIndexer)) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.RenameCommand}", Rename);
cmd.Tag = member;
list.Add(cmd);
}
}
if (member.IsOverride) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToBaseClassCommand}", GoToBase);
cmd.Tag = member;
list.Add(cmd);
}
if (member.IsVirtual || member.IsAbstract || (member.IsOverride && !member.DeclaringType.IsSealed)) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindOverridesCommand}", FindOverrides);
cmd.Tag = member;
list.Add(cmd);
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindReferencesCommand}", FindReferences);
cmd.Tag = member;
list.Add(cmd);
if (member is IField && member.DeclaringType.ClassType != ClassType.Enum) {
IProperty foundProperty = FindReferencesAndRenameHelper.FindProperty(member as IField);
if (foundProperty != null) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToProperty}", GotoTagMember);
cmd.Tag = foundProperty;
list.Add(cmd);
} else {
if (canGenerateCode) {
if (member.IsReadonly) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateProperty}", CreateGetter);
cmd.Tag = member;
list.Add(cmd);
} else {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateGetter}", CreateGetter);
cmd.Tag = member;
list.Add(cmd);
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateProperty}", CreateProperty);
cmd.Tag = member;
list.Add(cmd);
}
}
}
}
if (member is IProperty) {
if (((IProperty)member).CanSet && canGenerateCode) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateChangedEvent}", CreateChangedEvent);
cmd.Tag = member;
list.Add(cmd);
}
}
if (member is IEvent) {
if (canGenerateCode) {
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateOnEventMethod}", CreateOnEventMethod);
cmd.Tag = member;
list.Add(cmd);
}
}
return list.ToArray();
}
