/// <summary> /// Provides startup services /// </summary> protected override void StartMyServices() { base.StartMyServices(); try { // assimilate the proprties of the starting executable this.MorphAttributesToReflectStartingExecutable(); // use the window positioning engine to manage our state WindowPositioningEngine.WindowPositioningEngineSnapIn.Instance.Manage(this, WindowPositioningEngineKey); // wire up to previous instance events SnapInHostingEngine.GetExecutingInstance().InstanceManager.CommandLineReceivedFromAnotherInstance += new ApplicationInstanceManagerEventHandler(OnCommandLineReceivedFromAnotherInstance); // add ourself as a top level window to the hosting engine's application context SnapInHostingEngine.Instance.ApplicationContext.AddTopLevelWindow(this); // show ourself this.Show(); } catch (Exception ex) { Trace.WriteLine(ex); } }
/// <summary> /// Provides shutdown services /// </summary> protected override void StopMyServices() { base.StopMyServices(); // wire up to previous instance events SnapInHostingEngine.GetExecutingInstance().InstanceManager.CommandLineReceivedFromAnotherInstance -= new ApplicationInstanceManagerEventHandler(OnCommandLineReceivedFromAnotherInstance); // close ourself this.Close(); }
public static void Main(string[] args) { bool tracedExceptionThrown = false; try { // define the data paths string subPath = @"CodeReflection\Razor"; // safely use a hosting engine configured with an additional common data path and additional local user data path using (SnapInHostingEngine host = new SnapInHostingEngine(subPath, subPath)) { try { // run the hosting engine using the command line and the currently executing assembly (aka. the exe for the process) host.Run(args, System.Reflection.Assembly.GetExecutingAssembly()); } catch (System.Exception systemException) { // flag the fact that we are going to trace this exception and rethrow it tracedExceptionThrown = true; // give the loggers a chance to catch it if they have been successfully loaded before the // host is disposed of and the logging sub system detached from the Trace and Debug output System.Diagnostics.Trace.WriteLine(systemException); // rethrow the exception so that it may be displayed for the user throw systemException; } } } catch (System.Exception systemException) { // if the exception hasn't already been traced if (!tracedExceptionThrown) { tracedExceptionThrown = true; // trace it now System.Diagnostics.Trace.WriteLine(systemException); } // also, since it's more likely we'll not have a debugger attached, display the exception to the user string info = string.Format("The following exception was thrown by '{0}'.\n\nPlease refer to the log files for further information.\n\n{1}", Application.ProductName, systemException.ToString()); System.Windows.Forms.MessageBox.Show(null, info, "Application Exception"); // exit the current thread to force safe application shutdown Application.ExitThread(); } finally { // one final trace to let everyone know we have shutdown completely System.Diagnostics.Trace.WriteLine("'" + Application.ProductName + "' has " + (tracedExceptionThrown ? "terminated because of an exception." : "exited gracefully.")); } }
public SnapInDescriptorsWindow(SnapInDescriptor[] descriptors) { this.InitializeComponent(); this.InitializesSortManagers(); this.DisplayDescriptors(descriptors); // this.SelectFirstItem(); SnapInHostingEngine.GetExecutingInstance().SnapInStarted += new SnapInDescriptorEventHandler(SnapInDescriptorsWindow_SnapInStarted); SnapInHostingEngine.GetExecutingInstance().SnapInStopped += new SnapInDescriptorEventHandler(SnapInDescriptorsWindow_SnapInStopped); SnapInHostingEngine.GetExecutingInstance().SnapInInstalled += new SnapInDescriptorEventHandler(SnapInDescriptorsWindow_SnapInInstalled); SnapInHostingEngine.GetExecutingInstance().SnapInUninstalled += new SnapInDescriptorEventHandler(SnapInDescriptorsWindow_SnapInUninstalled); }
/// <summary> /// Returns an instance of the ISnapIn that supports the Type specified by the SubClass of this SnapInProxy. /// </summary> /// <param name="instance"></param> /// <param name="hostingEngine"></param> /// <returns></returns> public bool GetInstance(out object instance) { instance = null; try { SnapInDescriptor descriptor = SnapInHostingEngine.GetExecutingInstance().FindDescriptorByType(this.GetTypeForReferenceInternal()); if (descriptor != null) { instance = descriptor.SnapIn; return(true); } } catch (System.Exception systemException) { _lastException = systemException; } return(false); }
private void DisplayReferencesFor(TreeNodeCollection nodes, SnapInDescriptor descriptor) { foreach (Type t in descriptor.Dependencies) { SnapInDescriptor dependencyDescriptor = SnapInHostingEngine.GetExecutingInstance().FindDescriptorByType(t); if (dependencyDescriptor != null) { TreeNode node = new TreeNode(dependencyDescriptor.MetaData.Title); node.Tag = dependencyDescriptor; if (dependencyDescriptor.IsUninstalled) { node.ForeColor = SystemColors.GrayText; } node.Nodes.Add(string.Empty); nodes.Add(node); } } }
private void DisplayReferencesTo(TreeNodeCollection nodes, SnapInDescriptor descriptor) { SnapInDescriptor[] descriptors = SnapInHostingEngine.GetExecutingInstance().SnapInDescriptors; foreach (SnapInDescriptor otherDescriptor in descriptors) { foreach (Type t in otherDescriptor.Dependencies) { if (t == descriptor.Type) { TreeNode node = new TreeNode(otherDescriptor.MetaData.Title); node.Tag = otherDescriptor; if (otherDescriptor.IsUninstalled) { node.ForeColor = SystemColors.GrayText; } node.Nodes.Add(string.Empty); nodes.Add(node); } } } }
/// <summary> /// Reflect upon the starting executable and snag it's properties /// </summary> protected void MorphAttributesToReflectStartingExecutable() { try { Assembly assembly = SnapInHostingEngine.GetExecutingInstance().StartingExecutable; if (assembly != null) { // snag the name of the file minus path and extention and set it as the heading string filename = System.IO.Path.GetFileName(assembly.Location); filename = filename.Replace(System.IO.Path.GetExtension(assembly.Location), null); AssemblyAttributeReader reader = new AssemblyAttributeReader(assembly); // snag the company that made the assembly, and set it in the title System.Reflection.AssemblyCompanyAttribute[] companyAttributes = reader.GetAssemblyCompanyAttributes(); if (companyAttributes != null) { if (companyAttributes.Length > 0) { if (companyAttributes[0].Company != null && companyAttributes[0].Company != string.Empty) { this.Text = filename; // companyAttributes[0].Company + " " + filename; } } } // snag the image from the assembly, it should be an executable so... Icon icon = ShellInformation.GetIconFromPath(assembly.Location, IconSizes.SmallIconSize, IconStyles.NormalIconStyle, FileAttributes.Normal); if (icon != null) { this.Icon = icon; } } } catch (System.Exception systemException) { System.Diagnostics.Trace.WriteLine(systemException); } }
private void OnMenuItemClick(object sender, System.EventArgs e) { SnapInDescriptor descriptor = null; try { ListViewItem item = _listView.SelectedItems[0]; if (item != null) { descriptor = item.Tag as SnapInDescriptor; } } catch (System.Exception systemException) { System.Diagnostics.Trace.WriteLine(systemException); } MenuItem menuItem = sender as MenuItem; if (menuItem != null) { if (menuItem == menuItemStart) { if (descriptor != null) { SnapInHostingEngine.StartWithProgress(descriptor); } } if (menuItem == menuItemStop) { if (descriptor != null) { SnapInHostingEngine.StopWithProgress(descriptor); } } if (menuItem == menuItemReinstall) { if (descriptor != null) { SnapInHostingEngine.ReinstallWithProgress(descriptor); } } if (menuItem == menuItemUninstall) { if (descriptor != null) { SnapInHostingEngine.StopAndUninstallWithProgress(descriptor); } } if (menuItem == menuItemProperties) { if (descriptor != null) { SnapInDescriptorPropertyWindow window = new SnapInDescriptorPropertyWindow(descriptor); window.ShowDialog(this); } } } }
/// <summary> /// Occurs when the Options menu item is clicked /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnOptionsClicked(object sender, EventArgs e) { SnapInHostingEngine.GetExecutingInstance().ShowConfigurationWindow(this); }
/// <summary> /// Occurs when the SnapIns menu item is clicked /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnSnapInsClicked(object sender, EventArgs e) { SnapInHostingEngine.GetExecutingInstance().ShowSnapInsWindow(this); }
/// <summary> /// Occurs when the Features menu item is clicked /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnFeaturesClicked(object sender, EventArgs e) { FeatureEngine.ShowFeatureWindow(this, SnapInHostingEngine.GetExecutingInstance()); }
/// <summary> /// Occurs when a window position listener needs a configuration to read/write to/from /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnListenerNeedsConfiguration(object sender, XmlConfigurationEventArgs e) { /// save everything to the local user configuration e.Element = SnapInHostingEngine.GetExecutingInstance().LocalUserConfiguration; }
private void buttonReInstall_Click(object sender, System.EventArgs e) { SnapInHostingEngine.ReinstallWithProgress(_descriptor); this.UpdateButtonsBasedOnAdvice(); }