static void OnExtensionChanged (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add)
providers.Add ((IGettingStartedProvider)args.ExtensionObject);
else if (args.Change == ExtensionChange.Remove)
providers.Remove ((IGettingStartedProvider)args.ExtensionObject);
}
static void OnSyntaxModeExtensionChanged (object s, ExtensionNodeEventArgs args)
{
TemplateCodon codon = (TemplateCodon)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
Mono.TextEditor.Highlighting.SyntaxModeService.AddSyntaxMode (new StreamProviderWrapper(codon));
}
}
void OnExtensionChange (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add) {
ProjectService ps = MonoDevelop.Projects.Services.ProjectService;
ITestProvider provider = args.ExtensionObject as ITestProvider;
providers.Add (provider);
Type[] types = provider.GetOptionTypes ();
if (types != null) {
foreach (Type t in types) {
if (!typeof(ICloneable).IsAssignableFrom (t)) {
LoggingService.LogError ("Option types must implement ICloneable: " + t);
continue;
}
ps.DataContext.IncludeType (t);
}
}
}
else {
ITestProvider provider = args.ExtensionObject as ITestProvider;
providers.Remove (provider);
// The types returned by provider.GetOptionTypes should probably be unregistered
// from the DataContext, but DataContext does not allow unregisterig.
// This is not a big issue anyway.
}
}
static void OnTagExtensionChanged (object sender, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add)
tags.Add (args.ExtensionNode.Id);
else
tags.Remove (args.ExtensionNode.Id);
}
static void extensionHandler (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add)
loaders.Add ((IWebBrowserLoader) args.ExtensionObject);
else if (args.Change == ExtensionChange.Remove)
loaders.Remove ((IWebBrowserLoader) args.ExtensionObject);
}
static void OnExtensionChanged (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add)
templates.Add ((FileTemplateTypeCodon) args.ExtensionNode);
else
templates.Remove ((FileTemplateTypeCodon) args.ExtensionNode);
}
static void OnStylesExtensionChanged (object s, ExtensionNodeEventArgs args)
{
TemplateCodon codon = (TemplateCodon)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
SyntaxModeService.AddStyle (codon);
} else {
SyntaxModeService.RemoveStyle (codon);
}
}
static void OnExtensionChanged (object sender, ExtensionNodeEventArgs args)
{
var node = (TypeExtensionNode)args.ExtensionNode;
var value = (LocaleSetProvider)node.GetInstance (typeof (LocaleSetProvider));
if (args.Change == ExtensionChange.Add)
locales.Add (value.LocaleSet);
else
locales.Remove (value.LocaleSet);
}
void OnTemplateImagesChanged (object sender, ExtensionNodeEventArgs args)
{
var codon = args.ExtensionNode as ImageCodon;
if (args.Change == ExtensionChange.Add) {
projectTemplateImages.Add (codon);
} else {
projectTemplateImages.Remove (codon);
}
}
void OnTemplatingProvidersChanged (object sender, ExtensionNodeEventArgs args)
{
var provider = args.ExtensionObject as IProjectTemplatingProvider;
if (args.Change == ExtensionChange.Add) {
templateProviders.Add (provider);
} else {
templateProviders.Remove (provider);
}
}
void OnProjectTemplateWizardsChanged (object sender, ExtensionNodeEventArgs args)
{
var wizard = args.ExtensionObject as TemplateWizard;
if (args.Change == ExtensionChange.Add) {
projectTemplateWizards.Add (wizard);
} else {
projectTemplateWizards.Remove (wizard);
}
}
void OnTemplateCategoriesChanged (object sender, ExtensionNodeEventArgs args)
{
var codon = (TemplateCategoryCodon)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
projectTemplateCategories.Add (codon.ToTopLevelTemplateCategory ());
} else {
projectTemplateCategories.RemoveAll (category => category.Id == codon.Id);
}
}
static void OnSyntaxModeExtensionChanged (object s, ExtensionNodeEventArgs args)
{
TemplateCodon codon = (TemplateCodon)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
Mono.TextEditor.Highlighting.SyntaxModeService.AddSyntaxMode (codon);
} else {
Mono.TextEditor.Highlighting.SyntaxModeService.RemoveSyntaxMode (codon);
}
}
/// <summary>
/// Handler for codon addition/removal.
/// </summary>
private static void OnCodeBehindGenerationChanged(object sender, ExtensionNodeEventArgs args)
{
CodeBehindGeneratorCodon codon = (CodeBehindGeneratorCodon)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
generators.Add (codon.Id, codon.Generator);
} else {
generators.Remove (codon.Id);
}
}
static void HandleInstrumentationHandlerExtension (object sender, ExtensionNodeEventArgs args)
{
var handler = (InstrumentationConsumer)args.ExtensionObject;
if (args.Change == ExtensionChange.Add) {
RegisterInstrumentationConsumer (handler);
}
else {
UnregisterInstrumentationConsumer (handler);
}
}
private void OnExtensionChanged (object o, ExtensionNodeEventArgs args)
{
InstanceExtensionNode node = (InstanceExtensionNode)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
RegisterPhotoSource (node.CreateInstance () as IPhotoSourceInfo);
} else {
throw new NotImplementedException (); // TODO: Handle this
}
}
static void OnCompletionCharsAdded (object sender, ExtensionNodeEventArgs args)
{
var codon = (CompletionCharacterCodon)args.ExtensionNode;
var c = codon.CreateCompletionChar ();
c.CompleteOnSpace = PropertyService.Get ("CompletionCharacters." + c.Language + ".CompleteOnSpace", c.CompleteOnSpace);
c.CompleteOnChars = PropertyService.Get ("CompletionCharacters." + c.Language + ".CompleteOnChars", c.CompleteOnChars);
completionChars.Add (c);
}
static void FormatterExtHandler(object sender, ExtensionNodeEventArgs args)
{
switch (args.Change) {
case ExtensionChange.Add:
nodes.Add ((CodeFormatterExtensionNode) args.ExtensionNode);
break;
case ExtensionChange.Remove:
nodes.Remove ((CodeFormatterExtensionNode) args.ExtensionNode);
break;
}
}
private void OnExtensionChanged (object s, ExtensionNodeEventArgs args) {
// FIXME: We do not do run-time removal of editors yet!
if (args.Change == ExtensionChange.Add) {
Editor editor = (args.ExtensionNode as EditorNode).GetEditor ();
editor.ProcessingStarted += OnProcessingStarted;
editor.ProcessingStep += OnProcessingStep;
editor.ProcessingFinished += OnProcessingFinished;
editors.Add (editor);
PackButton (editor);
}
}
private void OnUtilityAddinDisable(Mono.Addins.ExtensionNodeEventArgs args)
{
Mono.Addins.TypeExtensionNode node = args.ExtensionNode as Mono.Addins.TypeExtensionNode;
try
{
OnDisableAddin(node.Id);
}
catch (Exception ex)
{
Log.Error("Error unloading add-in: " + ex.Message);
}
}
static void OnExtensionChange (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add) {
ProjectService ps = MonoDevelop.Projects.Services.ProjectService;
ITestProvider provider = args.ExtensionObject as ITestProvider;
providers.Add (provider);
}
else {
ITestProvider provider = args.ExtensionObject as ITestProvider;
providers.Remove (provider);
provider.Dispose ();
}
}
void ScriptsChanged(object s, ExtensionNodeEventArgs args)
{
IScriptingEngine eng = (IScriptingEngine)args.ExtensionObject;
switch (args.Change)
{
case ExtensionChange.Add:
engines.Add(args.ExtensionNode.Id, eng.Engine);
break;
case ExtensionChange.Remove:
engines.Remove(args.ExtensionNode.Id);
break;
}
}
static void OnMapsChanged (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add) {
SerializationMapNode node = (SerializationMapNode) args.ExtensionNode;
attributeProvider.AddMap (node.Addin, node.FileContent, node.FileId);
}
else {
SerializationMapNode node = (SerializationMapNode) args.ExtensionNode;
attributeProvider.RemoveMap (node.FileId);
}
// Regenerate the data context
dataContext = null;
}
static void HandleUserDataMigration (object sender, ExtensionNodeEventArgs args)
{
if (args.Change != ExtensionChange.Add)
return;
//FIXME: support ranges in SourceVersion
var node = (UserDataMigrationNode) args.ExtensionNode;
if (node.SourceVersion != version)
return;
FilePath source = FilePath.Null;
FilePath target = FilePath.Null;
try {
source = profile.GetLocation (node.SourceKind).Combine (node.SourcePath);
target = UserProfile.Current.GetLocation (node.TargetKind).Combine (node.TargetPath);
bool sourceIsDirectory = Directory.Exists (source);
if (sourceIsDirectory) {
if (Directory.Exists (target))
return;
} else {
if (File.Exists (target) || Directory.Exists (target) || !File.Exists (source))
return;
}
LoggingService.LogInfo ("Migrating '{0}' to '{1}'", source, target);
if (!sourceIsDirectory)
FileService.EnsureDirectoryExists (target.ParentDirectory);
var handler = node.GetHandler ();
if (handler != null) {
handler.Migrate (source, target);
return;
}
if (sourceIsDirectory) {
DirectoryCopy (source, target);
} else {
File.Copy (source, target);
}
} catch (Exception ex) {
string message = string.Format ("{0}: Failed to migrate '{1}' to '{2}'",
node.Addin.Id, source.ToString () ?? "", target.ToString () ?? "");
LoggingService.LogError (message, ex);
}
}
void OnExtensionChange (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add) {
ProjectService ps = MonoDevelop.Projects.Services.ProjectService;
ITestProvider provider = args.ExtensionObject as ITestProvider;
providers.Add (provider);
}
else {
ITestProvider provider = args.ExtensionObject as ITestProvider;
providers.Remove (provider);
// The types returned by provider.GetOptionTypes should probably be unregistered
// from the DataContext, but DataContext does not allow unregisterig.
// This is not a big issue anyway.
}
}
private void OnStartupAddins_ExtensionHandler(object sender, Mono.Addins.ExtensionNodeEventArgs args)
{
Log.Debug("Entering");
Mono.Addins.TypeExtensionNode extNode = args.ExtensionNode as Mono.Addins.TypeExtensionNode;
PrintInfo(ExtensionPath.OnStartup, args, extNode);
// Execute via class interface definition of extension path
// IOnStartupExtension ext = (IOnStartupExtension)args.ExtensionObject;
IOnStartupExtension addin = extNode.GetInstance(typeof(IOnStartupExtension)) as IOnStartupExtension;
addin.Execute();
// Push event changed out to listeners
OnApplicationAddinListChanged?.Invoke(sender, args);
}
private void OnExtensionChanged(object o, ExtensionNodeEventArgs args)
{
TypeExtensionNode node = (TypeExtensionNode)args.ExtensionNode;
if (args.Change == ExtensionChange.Add) {
var page = (BaseContextPage) node.CreateInstance ();
pane.AddPage (page);
pages.Add (node.Id, page);
} else {
if (pages.ContainsKey (node.Id)) {
var page = pages[node.Id];
pane.RemovePage (page);
page.Dispose ();
pages.Remove (node.Id);
}
}
}
private void StartupHandler_ExtensionChanged(object sender, Mono.Addins.ExtensionNodeEventArgs args)
{
LogDebug("OnStartChanged {");
LogDebug($" Path - {args.Path}");
LogDebug($" Node - {args.ExtensionNode}");
LogDebug($" Object - {args.ExtensionObject}");
LogDebug($" Changed - {args.Change.ToString()}");
Mono.Addins.TypeExtensionNode extNode = args.ExtensionNode as Mono.Addins.TypeExtensionNode;
LogDebug($" ExtNode: {extNode.ToString()}");
LogDebug(" Running...");
IStartupExtension ext = (IStartupExtension)args.ExtensionObject;
ext.Run();
LogDebug("}");
}
private void OnExtensionChanged (object o, ExtensionNodeEventArgs args)
{
var tnode = (TypeExtensionNode)args.ExtensionNode;
RandomBy random_by = null;
if (args.Change == ExtensionChange.Add) {
lock (random_modes) {
try {
random_by = (RandomBy) tnode.CreateInstance ();
random_by.SetShuffler (this);
random_modes.Add (random_by);
node_map[tnode] = random_by;
} catch (Exception e) {
Log.Exception (String.Format ("Failed to load RandomBy extension: {0}", args.Path), e);
}
}
if (random_by != null) {
if (!random_by.GetType ().AssemblyQualifiedName.Contains ("Banshee.Service")) {
Log.DebugFormat ("Loaded new mode into {0} shuffler: {1}", this.Id, random_by.Id);
}
var handler = RandomModeAdded;
if (handler != null) {
handler (random_by);
}
}
} else {
lock (random_modes) {
if (node_map.ContainsKey (tnode)) {
random_by = node_map[tnode];
node_map.Remove (tnode);
random_modes.Remove (random_by);
}
}
if (random_by != null) {
Log.DebugFormat ("Removed mode from {0} shuffler: {1}", this.Id, random_by.Id);
var handler = RandomModeRemoved;
if (handler != null) {
handler (random_by);
}
}
}
}
static void HandleInstrumentationHandlerExtension (object sender, ExtensionNodeEventArgs args)
{
var handler = (IInstrumentationConsumer)args.ExtensionObject;
if (args.Change == ExtensionChange.Add) {
handlers.Add (handler);
lock (counters) {
foreach (var c in counters.Values) {
if (handler.SupportsCounter (c))
c.Handlers.Add (handler);
}
}
}
else {
handlers.Remove (handler);
lock (counters) {
foreach (var c in counters.Values)
c.Handlers.Remove (handler);
}
}
UpdateCounterStatus ();
}
private void OnStartupExtensionChanged(object sender, Mono.Addins.ExtensionNodeEventArgs args)
{
Log.Debug("###########################");
Log.Debug("OnStartChanged {");
Log.Debug($" Id - '{args.ExtensionNode.Id}'");
Log.Debug($" Path - '{args.Path}'");
Log.Debug($" Node - '{args.ExtensionNode}'");
Log.Debug($" Object - '{args.ExtensionObject}'");
Log.Debug($" Changed - '{args.Change.ToString()}'");
Mono.Addins.TypeExtensionNode extNode = args.ExtensionNode as Mono.Addins.TypeExtensionNode;
Log.Debug(" --[ ExtensionNode ]------");
Log.Debug($" Id - '{extNode.Id}'");
Log.Debug($" ToString- '{extNode.ToString()}'");
Log.Debug($" TypeName- '{extNode.TypeName}'");
Log.Debug("# # # # # # # # # # #");
Log.Debug(" Running...");
IStartupExtension ext = (IStartupExtension)args.ExtensionObject;
ext.Run();
Log.Debug("}");
}
static void OnCopierExtensionChanged (object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add) {
copiers.Add (new FileCopyHandler ((IFileCopyHandler)args.ExtensionObject));
}
else {
IFileCopyHandler h = (IFileCopyHandler)args.ExtensionObject;
foreach (FileCopyHandler c in copiers) {
if (c.Id == h.Id) {
copiers.Remove (c);
break;
}
}
}
}
void OnLayoutsExtensionChanged(object s, ExtensionNodeEventArgs args)
{
if (args.Change == ExtensionChange.Add)
layouts.Add (((LayoutExtensionNode)args.ExtensionNode).Name);
else
layouts.Remove (((LayoutExtensionNode)args.ExtensionNode).Name);
}
void OnExtensionChanged(object s, ExtensionNodeEventArgs args)
{
if (initializing)
return;
if (args.Change == ExtensionChange.Add) {
ShowPadNode (args.ExtensionNode);
}
else {
RemovePadNode (args.ExtensionNode);
}
}
private void OnUtilityAddinEnable(Mono.Addins.ExtensionNodeEventArgs args)
{
Log.Debug("Entering (not used)");
// Cycle through and attach to in-memory
}