public void RemoveTopLevel(ToolStripMenuItem mi)
{
main.Items.Remove(mi);
menus.Remove(MnemonicEscape(mi.Text));
attrmapmap.Remove(mi);
mi.DropDownOpening -= new EventHandler(toplevel_Popup);
}
void pmi_DropDownOpening(object sender, EventArgs e)
{
ToolStripMenuItem pmi = sender as ToolStripMenuItem;
pmi.DropDownItems.Clear();
MenuItemAttribute mia = attrmap[pmi.clonedfrom] as MenuItemAttribute; // eek??
PropertyInfo pi = mia.invoke as PropertyInfo;
string v = pi.GetValue(this, null) as string;
TypeConverter tc = Activator.CreateInstance(mia.Converter) as TypeConverter;
foreach (string file in tc.GetStandardValues())
{
ToolStripMenuItem smi = new ToolStripMenuItem(file);
pmi.DropDownItems.Add(smi);
smi.Enabled = pmi.Enabled;
if (file == v)
{
smi.Checked = true;
}
smi.Click += new EventHandler(pmi_Click);
}
}
protected override void Initialize()
{
ToolStripMenuItem tl = ServiceHost.Menu["Tools"];
foreach (string name in tools.Keys)
{
ToolStripMenuItem mi = new ToolStripMenuItem(name, null, new EventHandler(InvokeRun));
//mi.Index = tl.MenuItems.Count;
mi.Enabled = File.Exists(((ProcessStartInfo)tools[name]).FileName);
tl.DropDownItems.Add(mi);
}
//LoadView();
}
void ValidateMenuState(ToolStripMenuItem toplevel)
{
Hashtable attrmap = GetAttributeMap(toplevel);
foreach (ToolStripItem pmi in toplevel.DropDownItems)
{
MenuItemAttribute mia = attrmap[pmi] as MenuItemAttribute;
if (mia == null) // in case its a seperator or submenu
{
if (!(pmi is ToolStripSeparator))
{
foreach (ToolStripMenuItem spmi in (pmi as ToolStripMenuItem).DropDownItems)
{
MenuItemAttribute smia = attrmap[spmi] as MenuItemAttribute;
ServiceBase ctr = smia.ctr;
spmi.Enabled = ((ctr.MenuState & smia.State) == smia.State);
if (smia.istogglemenu)
{
try
{
spmi.Checked = (bool)((PropertyInfo)smia.invoke).GetValue(smia.ctr, new object[0]);
}
catch
{
//something not ready, sorts itself out
}
}
}
}
}
else
{
ServiceBase ctr = mia.ctr;
pmi.Enabled = ((ctr.MenuState & mia.State) == mia.State);
if (mia.istogglemenu)
{
try
{
(pmi as ToolStripMenuItem).Checked = (bool)((PropertyInfo)mia.invoke).GetValue(mia.ctr, new object[0]);
}
catch
{
//something not ready, sorts itself out
}
}
}
}
}
public ToolStripMenuItem AddTopLevel(ToolStripMenuItem mi)
{
if (ServiceHost.ToolBar != null)
{
(ServiceHost.ToolBar as ToolBarService).Add(mi, null);
}
mi.DropDownOpening += new EventHandler(toplevel_Popup);
main.Items.Add(mi);
string mit = MnemonicEscape(mi.Text);
menus[mit] = mi;
// mi.Tag = mi.Text;
attrmapmap[mi] = new Hashtable();
return(mi);
}
void pmi_Click(object sender, EventArgs e)
{
ToolStripMenuItem pmi = sender as ToolStripMenuItem;
string v = pmi.Text;
MenuItemAttribute mia = attrmap[((ToolStripMenuItem)pmi.OwnerItem).clonedfrom] as MenuItemAttribute;
PropertyInfo pi = mia.invoke as PropertyInfo;
try
{
pi.SetValue(this, v, null);
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
}
void tl_Popup(object sender, EventArgs e)
{
AdvancedTextBox atb = ServiceHost.File[ServiceHost.File.Current] as AdvancedTextBox;
if (atb != null)
{
Languages.Language l = atb.Buffer.Language;
ToolStripMenuItem[] mma = langtools[l] as ToolStripMenuItem[];
ToolStripMenuItem tl = ServiceHost.Menu["Tools"];
if (mma == null)
{
ArrayList mm = new ArrayList();
foreach (Type t in l.actions)
{
//Build.ProcessAction pa = Activator.CreateInstance(t) as Build.ProcessAction;
//ToolStripMenuItem mi = new ToolStripMenuItem(pa.Name, null, new EventHandler(InvokeLangTool));
////mi.Index = tl.MenuItems.Count;
//mi.Enabled = pa.IsAvailable;
//mi.Tag = pa;
//mm.Add(mi);
}
mma = mm.ToArray(typeof(ToolStripMenuItem)) as ToolStripMenuItem[];
langtools[l] = mma;
}
if (lastset != null)
{
foreach (ToolStripMenuItem mi in lastset)
{
tl.DropDownItems.Remove(mi);
}
lastset = null;
}
tl.DropDownItems.AddRange(lastset = mma);
}
}
internal void DefaultHandler(object sender, EventArgs e)
{
if (InvokeRequired)
{
Invoke(new EventHandler(DefaultHandler), new object[] { sender, e });
return;
}
try
{
ToolStripMenuItem menu = sender as ToolStripMenuItem;
MenuItemAttribute mia = attrmap[menu] as MenuItemAttribute;
if (mia == null)
{
menu = menu.clonedfrom;
mia = attrmap[menu] as MenuItemAttribute;
}
if (mia.istogglemenu)
{
PropertyInfo pi = mia.invoke as PropertyInfo;
menu.Checked = !menu.Checked;
pi.SetValue(this, menu.Checked, new object[0]);
}
else
{
MethodInfo mi = mia.invoke as MethodInfo;
mi.Invoke(this, new object[0]);
}
}
catch (Exception ex)
{
#if DEBUG
Trace.WriteLine(ex);
#else
throw ex;
#endif
}
}
public Hashtable GetAttributeMap(ToolStripMenuItem toplevel)
{
return(attrmapmap[toplevel] as Hashtable);
}
/// <summary>
/// Starts the IDE
/// </summary>
/// <param name="f">the hosting form</param>
public static bool KickStart(Form f)
{
args = new IdeArgs();
if (args.listermode)
{
ST.Mutex m = null;
try
{
m = ST.Mutex.OpenExisting("XACCIDE");
}
catch
{
// must assign, else GC will clean up
real = new System.Threading.Mutex(true, "XACCIDE");
}
if (m != null)
{
if (InvokeClient())
{
return(false);
}
else
{
real.WaitOne();
}
}
}
#if !DEBUG
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
try
{
#endif
System.Threading.Thread.CurrentThread.CurrentCulture =
System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
if (args.listermode)
{
IpcServerChannel server = new IpcServerChannel("XACCIDE");
ChannelServices.RegisterChannel(server, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(ServerService), "ss", WellKnownObjectMode.Singleton);
}
Application.EnableVisualStyles();
SettingsService.idemode = true;
Application.ApplicationExit += new EventHandler(AppExit);
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
AppDomain.CurrentDomain.SetupInformation.LoaderOptimization = LoaderOptimization.MultiDomainHost;
about = new AboutForm();
about.StartPosition = f.StartPosition = FormStartPosition.CenterScreen;
about.Show();
Application.DoEvents();
f.KeyPreview = true;
IWindowService ws = new WindowService(f);
about.progressBar1.Value += 10;
Assembly thisass = typeof(IdeSupport).Assembly;
new PluginManager().LoadAssembly(thisass);
((SettingsService)ServiceHost.Settings).args = args;
IMenuService ms = ServiceHost.Menu;
MenuStrip mm = ms.MainMenu;
f.Font = SystemInformation.MenuFont;
f.Closing += new CancelEventHandler(f_Closing);
f.AllowDrop = true;
f.DragEnter += new DragEventHandler(f_DragEnter);
f.DragDrop += new DragEventHandler(f_DragDrop);
Version ver = typeof(IdeSupport).Assembly.GetName().Version;
string verstr = ver.ToString(4);
f.Text = "xacc.ide " + verstr + (args.debug ? " - DEBUG MODE" : string.Empty);
f.Size = new Size(900, 650);
ToolStripMenuItem view = ms["View"];
f.Icon = new Icon(
thisass.GetManifestResourceStream(
#if VS
"Xacc.Resources." +
#endif
"atb.ico"));
ServiceHost.Window.Document.AllowDrop = true;
ServiceHost.Window.Document.DragEnter += new DragEventHandler(f_DragEnter);
ServiceHost.Window.Document.DragDrop += new DragEventHandler(f_DragDrop);
ServiceHost.Window.Document.BringToFront();
new ViewService();
about.progressBar1.Value += 5;
new KeyboardHandler();
ServiceHost.State = ApplicationState.Normal;
about.progressBar1.Value += 5; //65
//after everything has been loaded
ServiceHost.Initialize();
about.progressBar1.Value += 5;
try
{
ServiceHost.Scripting.InitCommand();
ServiceHost.Shell.InitCommand();
}
catch (Exception ex) // MONO
{
Trace.WriteLine(ex);
}
(ServiceHost.ToolBar as ToolBarService).ValidateToolBarButtons();
//ToolStripManager.LoadSettings(f);
//ServiceHost.ToolBar.Load();
if (args.open != null)
{
foreach (string of in args.open)
{
if (File.Exists(of))
{
StringBuilder sb = new StringBuilder(256);
int len = kernel32.GetLongPathName(of, sb, 255);
try
{
ServiceHost.File.Open(sb.ToString());
}
catch (Exception ex)
{
Trace.WriteLine("Could not load file: " + sb + @" Message:
" + ex);
}
}
else
{
Trace.WriteLine("Could not open missing file: " + of);
}
}
}
#if !DEBUG
}
catch (Exception ex)
{
HandleException(ex, true);
return(false);
}
#endif
f.WindowState = args.form;
if (args.listermode)
{
f.WindowState = FormWindowState.Maximized;
}
about.Close();
return(true);
}
void ISupportInitialize.BeginInit()
{
const BindingFlags BF = BindingFlags.Public | BindingFlags.DeclaredOnly
| BindingFlags.NonPublic | BindingFlags.Instance;
Type tt = GetType();
MenuService ms = ServiceHost.Menu as MenuService;
if (Attribute.IsDefined(tt, typeof(MenuAttribute), false))
{
MenuAttribute mat = tt.GetCustomAttributes(typeof(MenuAttribute), false)[0] as MenuAttribute;
toplevel = ms[mat.Text];
if (toplevel == null)
{
toplevel = new ToolStripMenuItem(mat.Text);
ms.AddTopLevel(toplevel);
}
attrmap = ms.GetAttributeMap(toplevel);
EventHandler ev = new EventHandler(DefaultHandler);
ArrayList submenus = new ArrayList();
foreach (MethodInfo mi in tt.GetMethods(BF))
{
if (mi.GetParameters().Length == 0)
{
bool hasat = Attribute.IsDefined(mi, typeof(MenuItemAttribute));
if (mi.ReturnType == typeof(void) && (!mi.IsPrivate || hasat) &&
!Attribute.IsDefined(mi, typeof(SuppressMenuAttribute), true))
{
(ServiceHost.Keyboard as KeyboardHandler).AddTarget(this, mi);
}
if (hasat)
{
MenuItemAttribute mia = mi.GetCustomAttributes(typeof(MenuItemAttribute), false)[0] as MenuItemAttribute;
mia.invoke = mi;
mia.ctr = this;
submenus.Add(mia);
}
}
}
foreach (PropertyInfo pi in tt.GetProperties(BF))
{
if (pi.PropertyType == typeof(bool) && pi.CanRead && pi.CanWrite)
{
bool hasat = Attribute.IsDefined(pi, typeof(MenuItemAttribute));
if (!Attribute.IsDefined(pi, typeof(SuppressMenuAttribute), true))
{
(ServiceHost.Keyboard as KeyboardHandler).AddToggle(this, pi);
}
if (hasat)
{
MenuItemAttribute mia = pi.GetCustomAttributes(typeof(MenuItemAttribute), false)[0] as MenuItemAttribute;
mia.invoke = pi;
mia.istogglemenu = true;
mia.ctr = this;
submenus.Add(mia);
}
}
else if (pi.PropertyType == typeof(string) && pi.CanRead && pi.CanWrite)
{
if (Attribute.IsDefined(pi, typeof(MenuItemAttribute)))
{
MenuItemAttribute mia = pi.GetCustomAttributes(typeof(MenuItemAttribute), false)[0] as MenuItemAttribute;
mia.invoke = pi;
mia.ctr = this;
submenus.Add(mia);
}
}
}
foreach (ToolStripMenuItem mi in toplevel.DropDownItems)
{
object mia = attrmap[mi];
if (mia != null)
{
submenus.Add(mia);
}
}
submenus.Sort();
int previdx = -1;
int counter = 0;
ToolBarService tbs = ServiceHost.ToolBar as ToolBarService;
foreach (MenuItemAttribute mia in submenus)
{
ToolStripMenuItem pmi = null;
if (mia.mi == null)
{
if (mia.Converter == null)
{
pmi = new ToolStripMenuItem(mia.Text);
pmi.Click += ev;
}
else
{
pmi = new ToolStripMenuItem(mia.Text);
PropertyInfo pi = mia.invoke as PropertyInfo;
string v = pi.GetValue(this, null) as string;
pmi.DropDownOpening += new EventHandler(pmi_DropDownOpening);
TypeConverter tc = Activator.CreateInstance(mia.Converter) as TypeConverter;
foreach (string file in tc.GetStandardValues())
{
ToolStripMenuItem smi = new ToolStripMenuItem(file);
pmi.DropDownItems.Add(smi);
if (file == v)
{
smi.Checked = true;
}
smi.Click += new EventHandler(pmi_Click);
}
}
}
else
{
pmi = mia.mi as ToolStripMenuItem;
}
if (mia.istogglemenu)
{
PropertyInfo pi = mia.invoke as PropertyInfo;
try
{
bool v = (bool)pi.GetValue(this, new object[0]);
pmi.Checked = v;
}
catch
{
//something not ready, sorts itself out
Debugger.Break();
}
}
if (previdx != -1 && mia.Index > previdx + 1)
{
toplevel.DropDownItems.Add("-");
counter++;
}
int imgidx = -1;
if (mia.Image != null)
{
pmi.Tag = mia.Image;
imgidx = ServiceHost.ImageListProvider[mia.Image];
}
mia.mi = pmi;
ToolStripMenuItem top = toplevel;
string miaText = mia.Text;
//if (miaText.IndexOf(':') > 0)
//{
// string[] quals = miaText.Split(':');
// if (quals.Length > 0)
// {
// top = ServiceHost.Menu[quals[0]];
// miaText = miaText.Replace(quals[0] + ":", string.Empty);
// }
//}
// check text
string[] tokens = miaText.Split('\\');
if (tokens.Length > 1)
{
ToolStripMenuItem sub = this.submenus[tokens[0]] as ToolStripMenuItem;
if (sub == null)
{
this.submenus[tokens[0]] = sub = new ToolStripMenuItem(tokens[0]);
top.DropDownItems.Add(sub);
}
top = sub;
pmi.Text = tokens[1];
top.DropDownItems.Add(pmi);
counter--;
}
else
{
string miatext = miaText;
top.DropDownOpening += delegate(object sender, EventArgs e)
{
bool haderror;
string t = GetText(miatext, out haderror);
if (haderror)
{
pmi.Enabled = false;
}
pmi.Text = t;
};
top.DropDownItems.Add(pmi);
}
attrmap[pmi] = mia;
if (SettingsService.idemode)
{
if (mia.AllowToolBar)
{
tbs.Add(toplevel, mia);
}
}
previdx = mia.Index;
counter++;
}
}
Initialize();
}
