| public ConfigureExternalAddIns ( string addInConfigurationFile ) : void | ||
| addInConfigurationFile | string | |
| 리턴 | void | |
public void InitSharpDevelopCore(SharpDevelopHost.CallbackHelper callback, StartupSettings properties)
{
LoggingService.Info("InitSharpDevelop...");
this.callback = callback;
CoreStartup startup = new CoreStartup(properties.ApplicationName);
if (properties.UseSharpDevelopErrorHandler) {
this.useSharpDevelopErrorHandler = true;
ExceptionBox.RegisterExceptionBoxForUnhandledExceptions();
}
startup.ConfigDirectory = properties.ConfigDirectory;
startup.DataDirectory = properties.DataDirectory;
if (properties.PropertiesName != null) {
startup.PropertiesName = properties.PropertiesName;
}
// disable RTL: translations for the RTL languages are inactive
RightToLeftConverter.RightToLeftLanguages = new string[0];
if (properties.ApplicationRootPath != null) {
FileUtility.ApplicationRootPath = properties.ApplicationRootPath;
}
startup.StartCoreServices();
Assembly exe = Assembly.Load(properties.ResourceAssemblyName);
ResourceService.RegisterNeutralStrings(new ResourceManager("Resources.StringResources", exe));
ResourceService.RegisterNeutralImages(new ResourceManager("Resources.BitmapResources", exe));
MenuCommand.LinkCommandCreator = delegate(string link) { return new LinkCommand(link); };
StringParser.RegisterStringTagProvider(new SharpDevelopStringTagProvider());
LoggingService.Info("Looking for AddIns...");
foreach (string file in properties.addInFiles) {
startup.AddAddInFile(file);
}
foreach (string dir in properties.addInDirectories) {
startup.AddAddInsFromDirectory(dir);
}
if (properties.AllowAddInConfigurationAndExternalAddIns) {
startup.ConfigureExternalAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddIns.xml"));
}
if (properties.AllowUserAddIns) {
startup.ConfigureUserAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddInInstallTemp"),
Path.Combine(PropertyService.ConfigDirectory, "AddIns"));
}
LoggingService.Info("Loading AddInTree...");
startup.RunInitialization();
// Register events to marshal back
Project.ProjectService.StartBuild += delegate { this.callback.StartBuild(); };
Project.ProjectService.EndBuild += delegate { this.callback.EndBuild(); };
Project.ProjectService.SolutionLoaded += delegate { this.callback.SolutionLoaded(); };
Project.ProjectService.SolutionClosed += delegate { this.callback.SolutionClosed(); };
Project.ProjectService.SolutionConfigurationChanged += delegate { this.callback.SolutionConfigurationChanged(); };
FileUtility.FileLoaded += delegate(object sender, FileNameEventArgs e) { this.callback.FileLoaded(e.FileName); };
FileUtility.FileSaved += delegate(object sender, FileNameEventArgs e) { this.callback.FileSaved(e.FileName); };
LoggingService.Info("InitSharpDevelop finished");
}
public void InitSharpDevelopCore(SharpDevelopHost.CallbackHelper callback, StartupSettings properties)
{
// Initialize the most important services:
var container = new SharpDevelopServiceContainer(ServiceSingleton.FallbackServiceProvider);
container.AddService(typeof(IMessageService), new SDMessageService());
container.AddService(typeof(ILoggingService), new log4netLoggingService());
ServiceSingleton.ServiceProvider = container;
LoggingService.Info("InitSharpDevelop...");
this.callback = callback;
CoreStartup startup = new CoreStartup(properties.ApplicationName);
if (properties.UseSharpDevelopErrorHandler) {
this.useSharpDevelopErrorHandler = true;
ExceptionBox.RegisterExceptionBoxForUnhandledExceptions();
}
string configDirectory = properties.ConfigDirectory;
string dataDirectory = properties.DataDirectory;
string propertiesName;
if (properties.PropertiesName != null) {
propertiesName = properties.PropertiesName;
} else {
propertiesName = properties.ApplicationName + "Properties";
}
if (properties.ApplicationRootPath != null) {
FileUtility.ApplicationRootPath = properties.ApplicationRootPath;
}
if (configDirectory == null)
configDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
properties.ApplicationName);
var propertyService = new PropertyService(
DirectoryName.Create(configDirectory),
DirectoryName.Create(dataDirectory ?? Path.Combine(FileUtility.ApplicationRootPath, "data")),
propertiesName);
startup.StartCoreServices(propertyService);
Assembly exe = Assembly.Load(properties.ResourceAssemblyName);
SD.ResourceService.RegisterNeutralStrings(new ResourceManager("ICSharpCode.SharpDevelop.Resources.StringResources", exe));
SD.ResourceService.RegisterNeutralImages(new ResourceManager("ICSharpCode.SharpDevelop.Resources.BitmapResources", exe));
CommandWrapper.LinkCommandCreator = (link => new LinkCommand(link));
CommandWrapper.WellKnownCommandCreator = Core.Presentation.MenuService.GetKnownCommand;
CommandWrapper.RegisterConditionRequerySuggestedHandler = (eh => CommandManager.RequerySuggested += eh);
CommandWrapper.UnregisterConditionRequerySuggestedHandler = (eh => CommandManager.RequerySuggested -= eh);
StringParser.RegisterStringTagProvider(new SharpDevelopStringTagProvider());
LoggingService.Info("Looking for AddIns...");
foreach (string file in properties.addInFiles) {
startup.AddAddInFile(file);
}
foreach (string dir in properties.addInDirectories) {
startup.AddAddInsFromDirectory(dir);
}
if (properties.AllowAddInConfigurationAndExternalAddIns) {
startup.ConfigureExternalAddIns(Path.Combine(configDirectory, "AddIns.xml"));
}
if (properties.AllowUserAddIns) {
startup.ConfigureUserAddIns(Path.Combine(configDirectory, "AddInInstallTemp"),
Path.Combine(configDirectory, "AddIns"));
}
LoggingService.Info("Loading AddInTree...");
startup.RunInitialization();
((AssemblyParserService)SD.AssemblyParserService).DomPersistencePath = properties.DomPersistencePath;
// Register events to marshal back
Project.ProjectService.BuildStarted += delegate { this.callback.StartBuild(); };
Project.ProjectService.BuildFinished += delegate { this.callback.EndBuild(); };
Project.ProjectService.SolutionLoaded += delegate { this.callback.SolutionLoaded(); };
Project.ProjectService.SolutionClosed += delegate { this.callback.SolutionClosed(); };
FileUtility.FileLoaded += delegate(object sender, FileNameEventArgs e) { this.callback.FileLoaded(e.FileName); };
FileUtility.FileSaved += delegate(object sender, FileNameEventArgs e) { this.callback.FileSaved(e.FileName); };
LoggingService.Info("InitSharpDevelop finished");
}
static void DoStartup(string[] args)
{
LoggingService.Info("Application start");
Assembly exe = typeof(Startup).Assembly;
FileUtility.ApplicationRootPath = Path.GetDirectoryName(exe.Location);
LoggingService.Info("Starting core services...");
CoreStartup coreStartup = new CoreStartup("Paint");
coreStartup.PropertiesName = "AppProperties";
coreStartup.StartCoreServices();
ResourceService.RegisterNeutralStrings(
new ResourceManager("Startup.StringResources", exe));
ResourceService.RegisterNeutralImages(
new ResourceManager("Startup.ImageResources", exe));
LoggingService.Info("Looking for AddIns...");
// Searches for ".addin" files in the
// application directory.
coreStartup.AddAddInsFromDirectory(
Path.Combine(FileUtility.ApplicationRootPath, "AddIns"));
coreStartup.ConfigureExternalAddIns(
Path.Combine(PropertyService.ConfigDirectory, "AddIns.xml"));
coreStartup.ConfigureUserAddIns(
Path.Combine(PropertyService.ConfigDirectory, "AddInInstallTemp"),
Path.Combine(PropertyService.ConfigDirectory, "AddIns"));
LoggingService.Info("Loading AddInTree...");
// Now finally initialize the application.
// This parses the ".addin" files and
// creates the AddIn tree. It also
// automatically runs the commands in
// "/Workspace/Autostart"
coreStartup.RunInitialization();
LoggingService.Info("Initializing Workbench...");
// Workbench is our class from the base
// project, this method creates an instance
// of the main form.
Workbench.InitializeWorkbench();
try
{
LoggingService.Info("Running application...");
Application.Run(Workbench.Instance);
}
finally
{
try
{
PropertyService.Save();
}
catch (Exception ex)
{
MessageService.ShowError(ex, "Error storing properties");
}
}
LoggingService.Info("Application shutdown");
SingleInstanceController controller = new SingleInstanceController();
controller.Run(args);
}
private static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
LoggingService.Info("Application start");
var exe = typeof (Program).Assembly;
FileUtility.ApplicationRootPath = Path.GetDirectoryName(exe.Location);
LoggingService.Info("Starting core services...");
var coreStartup = new CoreStartup("NasuTek Grabbie") {
PropertiesName = "AppProperties"
};
if (Directory.Exists(Path.Combine(FileUtility.ApplicationRootPath, "Config")))
coreStartup.ConfigDirectory = Path.Combine(FileUtility.ApplicationRootPath, "Config");
coreStartup.StartCoreServices();
LoggingService.Info("Looking for AddIns...");
coreStartup.AddAddInsFromDirectory(Path.Combine(FileUtility.ApplicationRootPath, "Plugins"));
coreStartup.ConfigureExternalAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddIns.xml"));
coreStartup.ConfigureUserAddIns(
Path.Combine(PropertyService.ConfigDirectory, "AddInInstallTemp"),
Path.Combine(PropertyService.ConfigDirectory, "AddIns"));
LoggingService.Info("Loading AddInTree...");
coreStartup.RunInitialization();
LoggingService.Info("Initializing Grabbie Engine...");
Engine = new GrabbieEngine {
UploadNotificationSystem = new StatusForm()
};
Engine.AlertTypes.Add("None", new NeNone());
Engine.AlertTypes.Add("System Default", new NeBalloon());
if (AddInTree.ExistsTreeNode("/Grabbie/CaptureServices")) {
foreach (
var obj in
AddInTree.GetTreeNode("/Grabbie/CaptureServices").Codons.Select(
codon => codon.AddIn.CreateObject(codon.Properties["class"])).OfType<ICaptureType>()) {
obj.Hotkey.Shortcut =
PropertyService.Get("Grabbie.Hotkey." + obj.Hotkey.ShortcutName.Replace(" ", ""),
obj.Hotkey.Shortcut);
Engine.CaptureTypes.Add(obj);
}
}
if (AddInTree.ExistsTreeNode("/Grabbie/FileNameServices")) {
foreach (var codon in AddInTree.GetTreeNode("/Grabbie/FileNameServices").Codons) {
var obj = codon.AddIn.CreateObject(codon.Properties["class"]) as IFileNameType;
if (obj != null)
Engine.FileNameTypes.Add(codon.Properties["name"], obj);
}
}
if (AddInTree.ExistsTreeNode("/Grabbie/UrlShornerServices")) {
foreach (var codon in AddInTree.GetTreeNode("/Grabbie/UrlShornerServices").Codons) {
var obj = codon.AddIn.CreateObject(codon.Properties["class"]) as IUrlShortnerType;
if (obj != null)
Engine.UrlShortnerTypes.Add(codon.Properties["name"], obj);
}
}
if (AddInTree.ExistsTreeNode("/Grabbie/Uploaders")) {
foreach (var codon in AddInTree.GetTreeNode("/Grabbie/Uploaders").Codons) {
var obj = codon.AddIn.CreateObject(codon.Properties["class"]) as IUploadType;
if (obj != null)
Engine.UploadTypes.Add(codon.Properties["name"], obj);
}
}
if (AddInTree.ExistsTreeNode("/Grabbie/Alerters")) {
foreach (var codon in AddInTree.GetTreeNode("/Grabbie/Alerters").Codons) {
var obj = codon.AddIn.CreateObject(codon.Properties["class"]) as IAlertType;
if (obj != null)
Engine.AlertTypes.Add(codon.Properties["name"], obj);
}
}
if (AddInTree.ExistsTreeNode("/Grabbie/SettingsPages")) {
foreach (
var obj in
AddInTree.GetTreeNode("/Grabbie/SettingsPages").Codons.Select(
codon => codon.AddIn.CreateObject(codon.Properties["class"])).OfType<SettingsPage>())
Engine.SettingsPages.Add(obj);
}
LoggingService.Info("Initializing Grabbie Core...");
Core = new Grabbie();
LoggingService.Info("Running Grabbie...");
try {
Application.Run();
} finally {
try {
PropertyService.Save();
} catch (Exception ex) {
MessageService.ShowException(ex, "Error storing properties");
}
}
LoggingService.Info("Application shutdown");
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(true);
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
string lang = PreferredSiteList.InitCulture();
//var btw = BroadcastTextWriter.Instance;
// Logging service by default uses System.Diagnostics.Debug. Re-route this
// to our writer
//var wfmsg = WinFormsMessageService.Instance;
//ServiceManager.LoggingService = new TextWriterLoggingService(btw);
//ServiceManager.MessageService = wfmsg;
ServiceManager.Instance = new MaestroServiceManager();
LoggingService.Info("Application start"); //NOXLATE
// Setup Platform.ini if required
if (!Platform.IsRunningOnMono)
{
if (!File.Exists("Platform.ini") && File.Exists("LocalConfigure.exe")) //NOXLATE
{
var proc = new ProcessStartInfo("LocalConfigure.exe");
if (Environment.OSVersion.Version.Major >= 6)
proc.Verb = "runas"; //NOXLATE
var p = Process.Start(proc);
p.WaitForExit();
}
}
if (Platform.IsRunningOnMono)
{
LoggingService.Info(Strings.Warn_Mono);
}
//Init our default set of resource validators
ResourceValidatorLoader.LoadStockValidators();
AppDomain.CurrentDomain.AssemblyLoad += new AssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
// Get a reference to the entry assembly (Startup.exe)
Assembly exe = typeof(Program).Assembly;
// Set the root path of our application. ICSharpCode.Core looks for some other
// paths relative to the application root:
// "data/resources" for language resources, "data/options" for default options
FileUtility.ApplicationRootPath = Path.GetDirectoryName(exe.Location);
LoggingService.Info("Starting core services..."); //NOXLATE
// CoreStartup is a helper class making starting the Core easier.
// The parameter is used as the application name, e.g. for the default title of
// MessageService.ShowMessage() calls.
CoreStartup coreStartup = new CoreStartup("MapGuide Maestro"); //NOXLATE
// It is also used as default storage location for the application settings:
// "%Application Data%\%Application Name%", but you can override that by setting c.ConfigDirectory
// #1955: Each version of Maestro from here on in will store their user data under
// %APPDATA%\Maestro-x.y
coreStartup.ConfigDirectory = MaestroPaths.BasePath;
// Specify the name of the application settings file (.xml is automatically appended)
coreStartup.PropertiesName = "AppProperties"; //NOXLATE
// Initializes the Core services (ResourceService, PropertyService, etc.)
coreStartup.StartCoreServices();
LoggingService.Info("Looking for AddIns..."); //NOXLATE
// Searches for ".addin" files in the application directory.
coreStartup.AddAddInsFromDirectory(Path.Combine(FileUtility.ApplicationRootPath, "AddIns")); //NOXLATE
// Searches for a "AddIns.xml" in the user profile that specifies the names of the
// add-ins that were deactivated by the user, and adds "external" AddIns.
coreStartup.ConfigureExternalAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddIns.xml")); //NOXLATE
// Searches for add-ins installed by the user into his profile directory. This also
// performs the job of installing, uninstalling or upgrading add-ins if the user
// requested it the last time this application was running.
coreStartup.ConfigureUserAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddInInstallTemp"), //NOXLATE
Path.Combine(PropertyService.ConfigDirectory, "AddIns")); //NOXLATE
ResourceService.Language = lang;
LoggingService.Info("Loading AddInTree..."); //NOXLATE
// Now finally initialize the application. This parses the ".addin" files and
// creates the AddIn tree. It also automatically runs the commands in
// "/Workspace/Autostart"
coreStartup.RunInitialization();
LoggingService.Info("Initializing Workbench..."); //NOXLATE
// Workbench is our class from the base project, this method creates an instance
// of the main form.
ServiceRegistry.Initialize(() => {
//DIRTY DIRTY HACK: I'm getting tired of Mono workarounds. But background resource
//preview preparation has a chance of clogging up if the main window is initially maximized
Workbench.InitializeWorkbench(new WorkbenchInitializer(!Platform.IsRunningOnMono));
try
{
LoggingService.Info("Running application..."); //NOXLATE
// Workbench.Instance is the instance of the main form, run the message loop.
Application.Run(Workbench.Instance);
}
finally
{
try
{
// Save changed properties
PropertyService.Save();
}
catch (Exception ex)
{
ErrorDialog.Show(Strings.Error_StoreProperties, ex.ToString());
}
}
LoggingService.Info("Application shutdown"); //NOXLATE
});
}
public static void Main(string[] args)
{
// The LoggingService is a small wrapper around log4net.
// Our application contains a .config file telling log4net to write
// to System.Diagnostics.Trace.
LoggingService.Info("Application start");
// Get a reference to the entry assembly (Startup.exe)
Assembly exe = typeof(Start).Assembly;
// Set the root path of our application. ICSharpCode.Core looks for some other
// paths relative to the application root:
// "data/resources" for language resources, "data/options" for default options
FileUtility.ApplicationRootPath = Path.GetDirectoryName(exe.Location);
LoggingService.Info("Starting core services...");
// CoreStartup is a helper class making starting the Core easier.
// The parameter is used as the application name, e.g. for the default title of
// MessageService.ShowMessage() calls.
CoreStartup coreStartup = new CoreStartup("Test application");
// It is also used as default storage location for the application settings:
// "%Application Data%\%Application Name%", but you can override that by setting c.ConfigDirectory
// Specify the name of the application settings file (.xml is automatically appended)
coreStartup.PropertiesName = "AppProperties";
// Initializes the Core services (ResourceService, PropertyService, etc.)
coreStartup.StartCoreServices();
// Registeres the default (English) strings and images. They are compiled as
// "EmbeddedResource" into Startup.exe.
// Localized strings are automatically picked up when they are put into the
// "data/resources" directory.
ResourceService.RegisterNeutralStrings(new ResourceManager("Startup.StringResources", exe));
ResourceService.RegisterNeutralImages(new ResourceManager("Startup.ImageResources", exe));
LoggingService.Info("Looking for AddIns...");
// Searches for ".addin" files in the application directory.
coreStartup.AddAddInsFromDirectory(Path.Combine(FileUtility.ApplicationRootPath, "AddIns"));
// Searches for a "AddIns.xml" in the user profile that specifies the names of the
// add-ins that were deactivated by the user, and adds "external" AddIns.
coreStartup.ConfigureExternalAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddIns.xml"));
// Searches for add-ins installed by the user into his profile directory. This also
// performs the job of installing, uninstalling or upgrading add-ins if the user
// requested it the last time this application was running.
coreStartup.ConfigureUserAddIns(Path.Combine(PropertyService.ConfigDirectory, "AddInInstallTemp"),
Path.Combine(PropertyService.ConfigDirectory, "AddIns"));
LoggingService.Info("Loading AddInTree...");
// Now finally initialize the application. This parses the ".addin" files and
// creates the AddIn tree. It also automatically runs the commands in
// "/Workspace/Autostart"
coreStartup.RunInitialization();
LoggingService.Info("Initializing Workbench...");
// Workbench is our class from the base project, this method creates an instance
// of the main form.
Workbench.InitializeWorkbench();
try {
LoggingService.Info("Running application...");
// Workbench.Instance is the instance of the main form, run the message loop.
Application.Run(Workbench.Instance);
} finally {
try {
// Save changed properties
PropertyService.Save();
} catch (Exception ex) {
MessageService.ShowError(ex, "Error storing properties");
}
}
LoggingService.Info("Application shutdown");
}