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 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));
			}
		}

		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 OnProjectTemplateWizardsChanged (object sender, ExtensionNodeEventArgs args)
		{
			var wizard = args.ExtensionObject as TemplateWizard;
			if (args.Change == ExtensionChange.Add) {
				projectTemplateWizards.Add (wizard);
			} else {
				projectTemplateWizards.Remove (wizard);
			}
		}

		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 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); 
		}

		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);
			}
		}

 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;
     }
 }

		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 ();
			}
		}