Merge branch 'master' of github.com:icsharpcode/SharpDevelop

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin

@@ -510,7 +510,7 @@
 	
 	<!-- Autostart command for initialization -->
 	<Path name = "/SharpDevelop/Autostart">
-		<Class id    = "CSharpFormattingOptionsPersistenceInitCommand"
-		       class = "CSharpBinding.FormattingStrategy.CSharpFormattingOptionsPersistenceInitCommand"/>
+		<Class id    = "CSharpFormattingOptionsPoliciesInitCommand"
+		       class = "CSharpBinding.FormattingStrategy.CSharpFormattingOptionsPoliciesInitCommand"/>
 	</Path>
 </AddIn>

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.csproj

@@ -93,7 +93,7 @@
     </Compile>
     <Compile Include="Src\FormattingStrategy\CSharpFormattingOptionsContainer.cs" />
     <Compile Include="Src\FormattingStrategy\CSharpFormatter.cs" />
-    <Compile Include="Src\FormattingStrategy\CSharpFormattingOptionsPersistence.cs" />
+    <Compile Include="Src\FormattingStrategy\CSharpFormattingPolicies.cs" />
     <Compile Include="Src\FormattingStrategy\FormattingOptionBinding.cs" />
     <Compile Include="Src\FormsDesigner\CSharpDesignerGenerator.cs" />
     <Compile Include="Src\FormsDesigner\CSharpDesignerLoader.cs" />

src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpLanguageBinding.cs

@@ -19,7 +19,9 @@
 using System;
 using System.Collections.Generic;
 
+using System.ComponentModel;
 using System.Threading;
+using ICSharpCode.AvalonEdit;
 using ICSharpCode.AvalonEdit.Highlighting;
 using ICSharpCode.NRefactory;
 using ICSharpCode.NRefactory.TypeSystem;
@@ -62,6 +64,8 @@ namespace CSharpBinding
 		IList<IContextActionProvider> contextActionProviders;
 		CodeManipulation codeManipulation;
 		CaretReferenceHighlightRenderer renderer;
+		CodeEditorFormattingOptionsAdapter options;
+		TextEditorOptions originalEditorOptions;
 		
 		public void Attach(ITextEditor editor)
 		{
@@ -70,14 +74,46 @@ namespace CSharpBinding
 			codeManipulation = new CodeManipulation(editor);
 			renderer = new CaretReferenceHighlightRenderer(editor);
 			
+			// Patch editor options (indentation) to project-specific settings
 			if (!editor.ContextActionProviders.IsReadOnly) {
 				contextActionProviders = AddInTree.BuildItems<IContextActionProvider>("/SharpDevelop/ViewContent/TextEditor/C#/ContextActions", null);
 				editor.ContextActionProviders.AddRange(contextActionProviders);
 			}
+			
+			// Create instance of options adapter and register it as service
+			var formattingPolicy = CSharpFormattingPolicies.Instance.GetProjectOptions(
+				SD.ProjectService.FindProjectContainingFile(editor.FileName));
+			options = new CodeEditorFormattingOptionsAdapter(editor.Options, formattingPolicy.OptionsContainer);
+			var textEditor = editor.GetService<TextEditor>();
+			if (textEditor != null) {
+				var textViewServices = textEditor.TextArea.TextView.Services;
+				
+				// Unregister any previous ITextEditorOptions instance from editor, if existing, register our impl.
+				textViewServices.RemoveService(typeof(ITextEditorOptions));
+				textViewServices.AddService(typeof(ITextEditorOptions), options);
+				
+				// Set TextEditor's options to same object
+				originalEditorOptions = textEditor.Options;
+				textEditor.Options = options;
+			}
 		}
 		
 		public void Detach()
 		{
+			var textEditor = editor.GetService<TextEditor>();
+			if (textEditor != null) {
+				var textView = textEditor.TextArea.TextView;
+				
+				// Unregister our ITextEditorOptions instance from editor
+				var optionsService = textView.GetService<ITextEditorOptions>();
+				if ((optionsService != null) && (optionsService == options))
+					textView.Services.RemoveService(typeof(ITextEditorOptions));
+				
+				// Reset TextEditor options, too?
+				 if ((textEditor.Options != null) && (textEditor.Options == options))
+				 	textEditor.Options = originalEditorOptions;
+			}
+			
 			codeManipulation.Dispose();
 			if (inspectionManager != null) {
 				inspectionManager.Dispose();
@@ -87,7 +123,230 @@ namespace CSharpBinding
 				editor.ContextActionProviders.RemoveAll(contextActionProviders.Contains);
 			}
 			renderer.Dispose();
+			options = null;
 			this.editor = null;
 		}
 	}
+	
+	class CodeEditorFormattingOptionsAdapter : TextEditorOptions, ITextEditorOptions, ICodeEditorOptions
+	{
+		CSharpFormattingOptionsContainer container;
+		readonly ITextEditorOptions globalOptions;
+		readonly ICodeEditorOptions globalCodeEditorOptions;
+		
+		public CodeEditorFormattingOptionsAdapter(ITextEditorOptions globalOptions, CSharpFormattingOptionsContainer container)
+		{
+			if (globalOptions == null)
+				throw new ArgumentNullException("globalOptions");
+			if (container == null)
+				throw new ArgumentNullException("container");
+			
+			this.globalOptions = globalOptions;
+			this.globalCodeEditorOptions = globalOptions as ICodeEditorOptions;
+			this.container = container;
+			
+			CSharpFormattingPolicies.Instance.FormattingPolicyUpdated += OnFormattingPolicyUpdated;
+			globalOptions.PropertyChanged += OnGlobalOptionsPropertyChanged;
+		}
+		
+		void OnFormattingPolicyUpdated(object sender, CSharpBinding.FormattingStrategy.CSharpFormattingPolicyUpdateEventArgs e)
+		{
+			OnPropertyChanged("IndentationSize");
+			OnPropertyChanged("ConvertTabsToSpaces");
+		}
+
+		void OnGlobalOptionsPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+		{
+			OnPropertyChanged(e.PropertyName);
+		}
+		
+		#region ITextEditorOptions implementation
+
+		public override int IndentationSize {
+			get {
+				return container.GetEffectiveIndentationSize() ?? globalOptions.IndentationSize;
+			}
+		}
+
+		public override bool ConvertTabsToSpaces {
+			get {
+				return container.GetEffectiveConvertTabsToSpaces() ?? globalOptions.ConvertTabsToSpaces;
+			}
+		}
+
+		public bool AutoInsertBlockEnd {
+			get {
+				return globalOptions.AutoInsertBlockEnd;
+			}
+		}
+
+		public int VerticalRulerColumn {
+			get {
+				return globalOptions.VerticalRulerColumn;
+			}
+		}
+
+		public bool UnderlineErrors {
+			get {
+				return globalOptions.UnderlineErrors;
+			}
+		}
+
+		public string FontFamily {
+			get {
+				return globalOptions.FontFamily;
+			}
+		}
+
+		public double FontSize {
+			get {
+				return globalOptions.FontSize;
+			}
+		}
+
+		#endregion
+
+		public override bool AllowScrollBelowDocument {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.AllowScrollBelowDocument : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.AllowScrollBelowDocument = value;
+				}
+			}
+		}
+
+		public bool ShowLineNumbers {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.ShowLineNumbers : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.ShowLineNumbers = value;
+				}
+			}
+		}
+
+		public bool EnableChangeMarkerMargin {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.EnableChangeMarkerMargin : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.EnableChangeMarkerMargin = value;
+				}
+			}
+		}
+
+		public bool WordWrap {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.WordWrap : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.WordWrap = value;
+				}
+			}
+		}
+
+		public bool CtrlClickGoToDefinition {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.CtrlClickGoToDefinition : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.CtrlClickGoToDefinition = value;
+				}
+			}
+		}
+
+		public bool MouseWheelZoom {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.MouseWheelZoom : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.MouseWheelZoom = value;
+				}
+			}
+		}
+
+		public bool HighlightBrackets {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.HighlightBrackets : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.HighlightBrackets = value;
+				}
+			}
+		}
+
+		public bool HighlightSymbol {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.HighlightSymbol : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.HighlightSymbol = value;
+				}
+			}
+		}
+
+		public bool EnableAnimations {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.EnableAnimations : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.EnableAnimations = value;
+				}
+			}
+		}
+
+		public bool UseSmartIndentation {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.UseSmartIndentation : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.UseSmartIndentation = value;
+				}
+			}
+		}
+
+		public bool EnableFolding {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.EnableFolding : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.EnableFolding = value;
+				}
+			}
+		}
+
+		public bool EnableQuickClassBrowser {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.EnableQuickClassBrowser : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.EnableQuickClassBrowser = value;
+				}
+			}
+		}
+
+		public bool ShowHiddenDefinitions {
+			get {
+				return (globalCodeEditorOptions != null) ? globalCodeEditorOptions.ShowHiddenDefinitions : default(bool);
+			}
+			set {
+				if (globalCodeEditorOptions != null) {
+					globalCodeEditorOptions.ShowHiddenDefinitions = value;
+				}
+			}
+		}
+	}
 }

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/CSharpCompletionBinding.cs

@@ -99,7 +99,7 @@ namespace CSharpBinding.Completion
 				completionContext.ProjectContent,
 				completionContext.TypeResolveContextAtCaret
 			);
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(completionContext.Compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(completionContext.Compilation.GetProject());
 			cce.FormattingPolicy = formattingOptions.OptionsContainer.GetEffectiveOptions();
 			cce.EolMarker = DocumentUtilities.GetLineTerminator(completionContext.Document, currentLocation.Line);
 			

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/CSharpInsightItem.cs

@@ -72,7 +72,7 @@ namespace CSharpBinding.Completion
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
 			var stringBuilder = new StringBuilder();
 			var formatter = new ParameterHighlightingOutputFormatter(stringBuilder, highlightedParameterIndex);
-			ambience.ConvertSymbol(Method, formatter, CSharpFormattingOptionsPersistence.GlobalOptions.OptionsContainer.GetEffectiveOptions());
+			ambience.ConvertSymbol(Method, formatter, CSharpFormattingPolicies.Instance.GlobalOptions.OptionsContainer.GetEffectiveOptions());
 			
 			var documentation = XmlDocumentationElement.Get(Method);
 			ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/OverrideCompletionData.cs

@@ -98,7 +98,7 @@ namespace CSharpBinding.Completion
 			
 			var document = context.Editor.Document;
 			StringWriter w = new StringWriter();
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(contextAtCaret.Compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject());
 			var segmentDict = SegmentTrackingOutputFormatter.WriteNode(
 				w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options);
 			

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/OverrideEqualsGetHashCodeCompletionData.cs

@@ -84,7 +84,7 @@ namespace CSharpBinding.Completion
 			
 			var document = context.Editor.Document;
 			StringWriter w = new StringWriter();
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(contextAtCaret.Compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject());
 			var segmentDict = SegmentTrackingOutputFormatter.WriteNode(
 				w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options);
 			

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/OverrideToStringCompletionData.cs

@@ -81,7 +81,7 @@ namespace CSharpBinding.Completion
 			
 			var document = context.Editor.Document;
 			StringWriter w = new StringWriter();
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(contextAtCaret.Compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject());
 			var segmentDict = SegmentTrackingOutputFormatter.WriteNode(
 				w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options);
 			

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/PartialCompletionData.cs

@@ -64,7 +64,7 @@ namespace CSharpBinding.Completion
 			
 			var document = context.Editor.Document;
 			StringWriter w = new StringWriter();
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(contextAtCaret.Compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject());
 			var segmentDict = SegmentTrackingOutputFormatter.WriteNode(
 				w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options);
 			

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormattingStrategy/CSharpFormatter.cs

@@ -31,7 +31,9 @@ namespace CSharpBinding.FormattingStrategy
 		/// </summary>
 		public static void Format(ITextEditor editor, int offset, int length, CSharpFormattingOptionsContainer optionsContainer)
 		{
-			var formatter = new CSharpFormatter(optionsContainer.GetEffectiveOptions(), editor.ToEditorOptions());
+			TextEditorOptions editorOptions = editor.ToEditorOptions();
+			optionsContainer.CustomizeEditorOptions(editorOptions);
+			var formatter = new CSharpFormatter(optionsContainer.GetEffectiveOptions(), editorOptions);
 			formatter.AddFormattingRegion(new DomRegion(editor.Document.GetLocation(offset), editor.Document.GetLocation(offset + length)));
 			var changes = formatter.AnalyzeFormatting(editor.Document, SyntaxTree.Parse(editor.Document));
 			changes.ApplyChanges(offset, length);

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormattingStrategy/CSharpFormattingOptionsContainer.cs

@@ -34,8 +34,13 @@ namespace CSharpBinding.FormattingStrategy
 	/// </summary>
 	internal class CSharpFormattingOptionsContainer : INotifyPropertyChanged
 	{
+		private const string IndentationSizePropertyName = "IndentationSize";
+		private const string ConvertTabsToSpacesPropertyName = "ConvertTabsToSpaces";
+		
 		CSharpFormattingOptionsContainer parent;
 		CSharpFormattingOptions cachedOptions;
+		int? indentationSize;
+		bool? convertTabsToSpaces;
 		
 		readonly HashSet<string> activeOptions;
 		
@@ -106,6 +111,8 @@ namespace CSharpBinding.FormattingStrategy
 			foreach (var activeOption in options.activeOptions)
 				activeOptions.Add(activeOption);
 			cachedOptions = options.cachedOptions.Clone();
+			indentationSize = options.indentationSize;
+			convertTabsToSpaces = options.convertTabsToSpaces;
 			OnPropertyChanged(null);
 		}
 		
@@ -127,6 +134,14 @@ namespace CSharpBinding.FormattingStrategy
 			if ((e.PropertyName == "Parent") || (e.PropertyName == null)) {
 				// All properties might have changed -> update everything
 				cachedOptions = CreateCachedOptions();
+			} else if (e.PropertyName == IndentationSizePropertyName) {
+				if (!indentationSize.HasValue) {
+					indentationSize = GetEffectiveIndentationSize();
+				}
+			} else if (e.PropertyName == ConvertTabsToSpacesPropertyName) {
+				if (!convertTabsToSpaces.HasValue) {
+					convertTabsToSpaces = GetEffectiveConvertTabsToSpaces();
+				}
 			} else {
 				// Some other property has changed, check if we have our own value for it
 				if (!activeOptions.Contains(e.PropertyName)) {
@@ -148,10 +163,18 @@ namespace CSharpBinding.FormattingStrategy
 		public object GetOption(string option)
 		{
 			// Run up the hierarchy until we find a defined value for property
-			if (activeOptions.Contains(option)) {
-				PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
-				if (propertyInfo != null) {
-					return propertyInfo.GetValue(cachedOptions);
+			if (option == IndentationSizePropertyName) {
+				if (indentationSize.HasValue)
+					return indentationSize.Value;
+			} else if (option == ConvertTabsToSpacesPropertyName) {
+				if (convertTabsToSpaces.HasValue)
+					return convertTabsToSpaces.Value;
+			} else {
+				if (activeOptions.Contains(option)) {
+					PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
+					if (propertyInfo != null) {
+						return propertyInfo.GetValue(cachedOptions);
+					}
 				}
 			}
 			
@@ -186,6 +209,68 @@ namespace CSharpBinding.FormattingStrategy
 			return null;
 		}
 		
+		public int? IndentationSize
+		{
+			get {
+				return indentationSize;
+			}
+			set {
+				indentationSize = value;
+				OnPropertyChanged(IndentationSizePropertyName);
+			}
+		}
+		
+		/// <summary>
+		/// Retrieves the value of "IndentationSize" option by looking at current and (if nothing set here) parent
+		/// containers.
+		/// </summary>
+		public int? GetEffectiveIndentationSize()
+		{
+			// Run up the hierarchy until we find a defined value for property
+			CSharpFormattingOptionsContainer container = this;
+			do
+			{
+				int? val = container.indentationSize;
+				if (val.HasValue) {
+					return val.Value;
+				}
+				container = container.parent;
+			} while (container != null);
+			
+			return null;
+		}
+		
+		public bool? ConvertTabsToSpaces
+		{
+			get {
+				return convertTabsToSpaces;
+			}
+			set {
+				convertTabsToSpaces = value;
+				OnPropertyChanged(ConvertTabsToSpacesPropertyName);
+			}
+		}
+		
+		/// <summary>
+		/// Retrieves the value of v option by looking at current and (if nothing set here) parent
+		/// containers.
+		/// </summary>
+		public bool? GetEffectiveConvertTabsToSpaces()
+		{
+			// Run up the hierarchy until we find a defined value for property
+			CSharpFormattingOptionsContainer container = this;
+			do
+			{
+				bool? val = container.convertTabsToSpaces;
+				if (val.HasValue) {
+					return val.Value;
+				}
+				container = container.parent;
+			} while (container != null);
+			
+			return null;
+		}
+		
 		/// <summary>
 		/// Sets an option.
 		/// </summary>
@@ -195,18 +280,32 @@ namespace CSharpBinding.FormattingStrategy
 		{
 			if (value != null) {
 				// Save value in option values and cached options
-				activeOptions.Add(option);
-				PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
-				if ((propertyInfo != null) && (propertyInfo.PropertyType == value.GetType())) {
-					propertyInfo.SetValue(cachedOptions, value);
+				if (option == IndentationSizePropertyName) {
+					if (value is int)
+						indentationSize = (int) value;
+				} else if (option == ConvertTabsToSpacesPropertyName) {
+					if (value is bool)
+						convertTabsToSpaces = (bool) value;
+				} else {
+					activeOptions.Add(option);
+					PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
+					if ((propertyInfo != null) && (propertyInfo.PropertyType == value.GetType())) {
+						propertyInfo.SetValue(cachedOptions, value);
+					}
 				}
 			} else {
 				// Reset this option
-				activeOptions.Remove(option);
-				// Update formatting options object from parents
-				PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
-				if (propertyInfo != null) {
-					propertyInfo.SetValue(cachedOptions, GetEffectiveOption(option));
+				if (option == IndentationSizePropertyName) {
+					indentationSize = null;
+				} else if (option == ConvertTabsToSpacesPropertyName) {
+					convertTabsToSpaces = null;
+				} else {
+					activeOptions.Remove(option);
+					// Update formatting options object from parents
+					PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
+					if (propertyInfo != null) {
+						propertyInfo.SetValue(cachedOptions, GetEffectiveOption(option));
+					}
 				}
 			}
 			OnPropertyChanged(option);
@@ -219,6 +318,11 @@ namespace CSharpBinding.FormattingStrategy
 		/// <returns>Option's type.</returns>
 		public Type GetOptionType(string option)
 		{
+			if (option == IndentationSizePropertyName)
+				return typeof(int);
+			if (option == ConvertTabsToSpacesPropertyName)
+				return typeof(bool);
+			
 			PropertyInfo propertyInfo = typeof(CSharpFormattingOptions).GetProperty(option);
 			if (propertyInfo != null) {
 				return propertyInfo.PropertyType;
@@ -258,6 +362,19 @@ namespace CSharpBinding.FormattingStrategy
 			return outputOptions;
 		}
 		
+		public void CustomizeEditorOptions(TextEditorOptions editorOptions)
+		{
+			int? indentationSize = GetEffectiveIndentationSize();
+			if (indentationSize.HasValue) {
+				editorOptions.IndentSize = indentationSize.Value;
+				editorOptions.TabSize = indentationSize.Value;
+				editorOptions.ContinuationIndent = indentationSize.Value;
+			}
+			bool? convertTabsToSpaces = GetEffectiveConvertTabsToSpaces();
+			if (convertTabsToSpaces.HasValue)
+				editorOptions.TabsToSpaces = convertTabsToSpaces.Value;
+		}
+		
 		public void Load(Properties parentProperties)
 		{
 			if (parentProperties == null)
@@ -275,6 +392,9 @@ namespace CSharpBinding.FormattingStrategy
 						}
 					}
 				}
+				
+				indentationSize = formatProperties.Get(IndentationSizePropertyName, new int?());
+				convertTabsToSpaces = formatProperties.Get(ConvertTabsToSpacesPropertyName, new bool?());
 			}
 		}
 		
@@ -291,6 +411,10 @@ namespace CSharpBinding.FormattingStrategy
 					formatProperties.Set(activeOption, val);
 				}
 			}
+			if (indentationSize.HasValue)
+				formatProperties.Set(IndentationSizePropertyName, indentationSize.Value);
+			if (convertTabsToSpaces.HasValue)
+				formatProperties.Set(ConvertTabsToSpacesPropertyName, convertTabsToSpaces.Value);
 			
 			parentProperties.SetNestedProperties("CSharpFormatting", formatProperties);
 		}

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormattingStrategy/CSharpFormattingPolicies.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using ICSharpCode.Core;
 using ICSharpCode.NRefactory.CSharp;
 using ICSharpCode.SharpDevelop;
@@ -25,43 +26,50 @@ using ICSharpCode.SharpDevelop.Project;
 
 namespace CSharpBinding.FormattingStrategy
 {
-	public class CSharpFormattingOptionsPersistenceInitCommand : SimpleCommand
+	public class CSharpFormattingOptionsPoliciesInitCommand : SimpleCommand
 	{
 		public override void Execute(object parameter)
 		{
-			// Initialize CSharpFormattingOptionsPersistence as early as possible (before solution is opened)
-			CSharpFormattingOptionsPersistence.Initialize();
+			// Initialize CSharpFormattingPolicies as early as possible (before solution is opened)
+			CSharpFormattingPolicies.Instance.Initialize();
 		}
 	}
 	
 	/// <summary>
-	/// Persistence helper for C# formatting options.
+	/// Management class for formatting policies.
 	/// </summary>
-	internal class CSharpFormattingOptionsPersistence
+	internal class CSharpFormattingPolicies
 	{
-		static bool initialized;
-		static Dictionary<string, CSharpFormattingOptionsPersistence> projectOptions;
+		static readonly Lazy<CSharpFormattingPolicies> LazyInstance =
+			new Lazy<CSharpFormattingPolicies>(() => new CSharpFormattingPolicies());
 		
-		static CSharpFormattingOptionsPersistence()
+		public static CSharpFormattingPolicies Instance {
+			get { return LazyInstance.Value; }
+		}
+		
+		public event EventHandler<CSharpFormattingPolicyUpdateEventArgs> FormattingPolicyUpdated;
+		
+		bool initialized;
+		Dictionary<string, CSharpFormattingPolicy> projectOptions;
+		
+		public CSharpFormattingPolicies()
 		{
-			Initialize();
+			// Load global settings
+			GlobalOptions = new CSharpFormattingPolicy(
+				SD.PropertyService.MainPropertiesContainer, new CSharpFormattingOptionsContainer() {
+					DefaultText = StringParser.Parse("${res:CSharpBinding.Formatting.GlobalOptionReference}")
+				});
+			GlobalOptions.FormattingPolicyUpdated += OnFormattingPolicyUpdated;
+			GlobalOptions.Load();
 		}
 		
-		public static void Initialize()
+		public void Initialize()
 		{
 			if (initialized)
 				return;
 			
 			initialized = true;
-			projectOptions = new Dictionary<string, CSharpFormattingOptionsPersistence>();
-			
-			// Load global settings
-			GlobalOptions = new CSharpFormattingOptionsPersistence(
-				SD.PropertyService.MainPropertiesContainer, new CSharpFormattingOptionsContainer()
-				{
-					DefaultText = StringParser.Parse("${res:CSharpBinding.Formatting.GlobalOptionReference}")
-				});
-			GlobalOptions.Load();
+			projectOptions = new Dictionary<string, CSharpFormattingPolicy>();
 			
 			// Handlers for solution loading/unloading
 			var projectService = SD.GetService<IProjectService>();
@@ -71,8 +79,7 @@ namespace CSharpBinding.FormattingStrategy
 			}
 		}
 		
-		public static bool AutoFormatting
-		{
+		public static bool AutoFormatting {
 			get {
 				return SD.PropertyService.Get("CSharpBinding.Formatting.AutoFormatting", false);
 			}
@@ -81,31 +88,32 @@ namespace CSharpBinding.FormattingStrategy
 			}
 		}
 		
-		public static CSharpFormattingOptionsPersistence GlobalOptions
-		{
+		public CSharpFormattingPolicy GlobalOptions {
 			get;
 			private set;
 		}
 		
-		public static CSharpFormattingOptionsPersistence SolutionOptions
-		{
+		public CSharpFormattingPolicy SolutionOptions {
 			get;
 			private set;
 		}
 		
-		public static CSharpFormattingOptionsPersistence GetProjectOptions(IProject project)
+		public CSharpFormattingPolicy GetProjectOptions(IProject project)
 		{
+			if (!initialized)
+				return GlobalOptions;
+			
 			var csproject = project as CSharpProject;
 			if (csproject != null) {
 				string key = project.FileName;
 				if (!projectOptions.ContainsKey(key)) {
 					// Lazily create options container for project
-					var projectFormattingPersistence = new CSharpFormattingOptionsPersistence(
+					var projectFormattingPersistence = new CSharpFormattingPolicy(
 						csproject.GlobalPreferences,
-						new CSharpFormattingOptionsContainer((SolutionOptions ?? GlobalOptions).OptionsContainer)
-						{
+						new CSharpFormattingOptionsContainer((SolutionOptions ?? GlobalOptions).OptionsContainer) {
 							DefaultText = StringParser.Parse("${res:CSharpBinding.Formatting.ProjectOptionReference}")
 						});
+					projectFormattingPersistence.FormattingPolicyUpdated += OnFormattingPolicyUpdated;
 					projectFormattingPersistence.Load();
 					projectOptions[key] = projectFormattingPersistence;
 				}
@@ -116,34 +124,70 @@ namespace CSharpBinding.FormattingStrategy
 			return SolutionOptions ?? GlobalOptions;
 		}
 		
-		static void SolutionOpened(object sender, SolutionEventArgs e)
+		void SolutionOpened(object sender, SolutionEventArgs e)
 		{
 			// Load solution settings
-			SolutionOptions = new CSharpFormattingOptionsPersistence(
+			SolutionOptions = new CSharpFormattingPolicy(
 				e.Solution.SDSettings,
-				new CSharpFormattingOptionsContainer(GlobalOptions.OptionsContainer)
-				{
+				new CSharpFormattingOptionsContainer(GlobalOptions.OptionsContainer) {
 					DefaultText = StringParser.Parse("${res:CSharpBinding.Formatting.SolutionOptionReference}")
 				});
+			SolutionOptions.FormattingPolicyUpdated += OnFormattingPolicyUpdated;
 			SolutionOptions.Load();
 		}
 		
-		static void SolutionClosed(object sender, SolutionEventArgs e)
+		void SolutionClosed(object sender, SolutionEventArgs e)
 		{
+			SolutionOptions.FormattingPolicyUpdated -= OnFormattingPolicyUpdated;
 			SolutionOptions = null;
 			projectOptions.Clear();
 		}
 		
+		void OnFormattingPolicyUpdated(object sender, CSharpFormattingPolicyUpdateEventArgs e)
+		{
+			if (FormattingPolicyUpdated != null) {
+				FormattingPolicyUpdated(sender, e);
+			}
+		}
+	}
+	
+	/// <summary>
+	/// Contains event data for formatting policy update events.
+	/// </summary>
+	internal class CSharpFormattingPolicyUpdateEventArgs : EventArgs
+	{
+		public CSharpFormattingPolicyUpdateEventArgs(CSharpFormattingOptionsContainer container)
+		{
+			OptionsContainer = container;
+		}
+		
+		/// <summary>
+		/// Returns updated options container.
+		/// </summary>
+		public CSharpFormattingOptionsContainer OptionsContainer
+		{
+			get;
+			private set;
+		}
+	}
+	
+	/// <summary>
+	/// Persistence helper for C# formatting options of a certain policy (e.g. global, solution, project).
+	/// </summary>
+	internal class CSharpFormattingPolicy
+	{
+		public event EventHandler<CSharpFormattingPolicyUpdateEventArgs> FormattingPolicyUpdated;
+		
 		readonly Properties propertiesContainer;
-		CSharpFormattingOptionsContainer optionsContainer;
+		readonly CSharpFormattingOptionsContainer optionsContainer;
 		CSharpFormattingOptionsContainer optionsContainerWorkingCopy;
 		
 		/// <summary>
-		/// Creates a new instance of formatting options persistence helper, using given options to predefine the options container.
+		/// Creates a new instance of formatting options policy, using given options to predefine the options container.
 		/// </summary>
 		/// <param name="propertiesContainer">Properties container to load from and save to.</param>
 		/// <param name="initialContainer">Initial (empty) instance of formatting options container.</param>
-		public CSharpFormattingOptionsPersistence(Properties propertiesContainer, CSharpFormattingOptionsContainer initialContainer)
+		public CSharpFormattingPolicy(Properties propertiesContainer, CSharpFormattingOptionsContainer initialContainer)
 		{
 			if (initialContainer == null)
 				throw new ArgumentNullException("initialContainer");
@@ -153,7 +197,7 @@ namespace CSharpBinding.FormattingStrategy
 		}
 		
 		/// <summary>
-		/// Returns the option container managed by this helper.
+		/// Returns the option container for this policy.
 		/// </summary>
 		public CSharpFormattingOptionsContainer OptionsContainer
 		{
@@ -196,7 +240,15 @@ namespace CSharpBinding.FormattingStrategy
 			
 			// Convert to SD properties
 			optionsContainer.Save(propertiesContainer);
+			OnFormattingPolicyUpdated(this, optionsContainer);
 			return true;
 		}
+		
+		void OnFormattingPolicyUpdated(object sender, CSharpFormattingOptionsContainer container)
+		{
+			if (FormattingPolicyUpdated != null) {
+				FormattingPolicyUpdated(sender, new CSharpFormattingPolicyUpdateEventArgs(container));
+			}
+		}
 	}
 }

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormattingStrategy/CSharpFormattingStrategy.cs

@@ -48,7 +48,7 @@ namespace CSharpBinding.FormattingStrategy
 			DocumentAccessor acc = new DocumentAccessor(editor.Document, lineNr, lineNr);
 			
 			CSharpIndentationStrategy indentStrategy = new CSharpIndentationStrategy();
-			indentStrategy.IndentationString = editor.Options.IndentationString;
+			indentStrategy.IndentationString = GetIndentationString(editor);
 			indentStrategy.Indent(acc, false);
 			
 			string t = acc.Text;
@@ -62,33 +62,64 @@ namespace CSharpBinding.FormattingStrategy
 		{
 			DocumentAccessor acc = new DocumentAccessor(editor.Document, beginLine, endLine);
 			CSharpIndentationStrategy indentStrategy = new CSharpIndentationStrategy();
-			indentStrategy.IndentationString = editor.Options.IndentationString;
+			indentStrategy.IndentationString = GetIndentationString(editor);
 			indentStrategy.Indent(acc, true);
 		}
 		
+		CSharpFormattingOptionsContainer GetOptionsContainerForEditor(ITextEditor editor)
+		{
+			var currentProject = SD.ProjectService.FindProjectContainingFile(editor.FileName);
+			if (currentProject != null) {
+				var persistence = CSharpFormattingPolicies.Instance.GetProjectOptions(currentProject);
+				if (persistence != null) {
+					return persistence.OptionsContainer;
+				}
+			}
+			
+			return null;
+		}
+		
+		string GetIndentationString(ITextEditor editor)
+		{
+			// Get current indentation option values
+			int indentationSize = editor.Options.IndentationSize;
+			bool convertTabsToSpaces = editor.Options.ConvertTabsToSpaces;
+			var container = GetOptionsContainerForEditor(editor);
+			if (container != null) {
+				int? effectiveIndentationSize = container.GetEffectiveIndentationSize();
+				if (effectiveIndentationSize.HasValue)
+					indentationSize = effectiveIndentationSize.Value;
+				bool? effectiveConvertTabsToSpaces = container.GetEffectiveConvertTabsToSpaces();
+				if (effectiveConvertTabsToSpaces.HasValue)
+					convertTabsToSpaces = effectiveConvertTabsToSpaces.Value;
+			}
+			
+			return ICSharpCode.AvalonEdit.TextEditorOptions.GetIndentationString(1, indentationSize, convertTabsToSpaces);
+		}
+		
 		/* NR indent engine (temporarily?) disabled as per #447
 		static void IndentSingleLine(CacheIndentEngine engine, IDocument document, IDocumentLine line)
 		{
-			engine.Update(line.EndOffset);
-			if (engine.NeedsReindent) {
-				var indentation = TextUtilities.GetWhitespaceAfter(document, line.Offset);
-				// replacing the indentation in two steps is necessary to make the caret move accordingly.
-				document.Replace(indentation.Offset, indentation.Length, "");
-				document.Replace(indentation.Offset, 0, engine.ThisLineIndent);
-				engine.ResetEngineToPosition(line.Offset);
-			}
+		engine.Update(line.EndOffset);
+		if (engine.NeedsReindent) {
+		var indentation = TextUtilities.GetWhitespaceAfter(document, line.Offset);
+		// replacing the indentation in two steps is necessary to make the caret move accordingly.
+		document.Replace(indentation.Offset, indentation.Length, "");
+		document.Replace(indentation.Offset, 0, engine.ThisLineIndent);
+		engine.ResetEngineToPosition(line.Offset);
+		}
 		}
 		
 		static CacheIndentEngine CreateIndentEngine(IDocument document, TextEditorOptions options)
 		{
-			IProject currentProject = null;
-			var projectService = SD.GetService<IProjectService>();
-			if (projectService != null) {
-				currentProject = projectService.FindProjectContainingFile(new FileName(document.FileName));
-			}
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(currentProject);
-			var engine = new CSharpIndentEngine(document, options, formattingOptions.OptionsContainer.GetEffectiveOptions());
-			return new CacheIndentEngine(engine);
+		IProject currentProject = null;
+		var projectService = SD.GetService<IProjectService>();
+		if (projectService != null) {
+		currentProject = projectService.FindProjectContainingFile(new FileName(document.FileName));
+		}
+		var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(currentProject);
+		var engine = new CSharpIndentEngine(document, options, formattingOptions.OptionsContainer.GetEffectiveOptions());
+		return new CacheIndentEngine(engine);
 		}
 		*/
 		#endregion
@@ -302,11 +333,11 @@ namespace CSharpBinding.FormattingStrategy
 		{
 			if ((offset > textArea.Document.TextLength) || ((offset + length) > textArea.Document.TextLength))
 				return false;
-			if (respectAutoFormattingSetting && !CSharpFormattingOptionsPersistence.AutoFormatting)
+			if (respectAutoFormattingSetting && !CSharpFormattingPolicies.AutoFormatting)
 				return false;
 			
 			using (textArea.Document.OpenUndoGroup()) {
-				var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(SD.ProjectService.CurrentProject);
+				var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(SD.ProjectService.CurrentProject);
 				try {
 					CSharpFormatterHelper.Format(textArea, offset, length, formattingOptions.OptionsContainer);
 				} catch (Exception) {

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormattingStrategy/FormattingOptionBinding.cs

@@ -22,6 +22,7 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using ICSharpCode.NRefactory.CSharp;
+using CSharpBinding.OptionPanels;
 
 namespace CSharpBinding.FormattingStrategy
 {
@@ -32,11 +33,8 @@ namespace CSharpBinding.FormattingStrategy
 	{
 		public static readonly DependencyProperty ContainerProperty =
 			DependencyProperty.RegisterAttached("Container", typeof(CSharpFormattingOptionsContainer),
-			                                    typeof(FormattingOptionBinding),
-			                                    new FrameworkPropertyMetadata());
-		public static readonly DependencyProperty OptionProperty =
-			DependencyProperty.RegisterAttached("Option", typeof(string), typeof(FormattingOptionBinding),
-			                                    new FrameworkPropertyMetadata(OnOptionPropertyChanged));
+				typeof(FormattingOptionBinding),
+				new FrameworkPropertyMetadata((o, e) => UpdateOptionBinding(o)));
 		
 		public static CSharpFormattingOptionsContainer GetContainer(Selector element)
 		{
@@ -48,21 +46,26 @@ namespace CSharpBinding.FormattingStrategy
 			element.SetValue(ContainerProperty, container);
 		}
 		
-		public static string GetOption(Selector element)
+		public static readonly DependencyProperty FormattingOptionProperty =
+			DependencyProperty.RegisterAttached("FormattingOption", typeof(FormattingOption),
+				typeof(FormattingOptionBinding),
+				new FrameworkPropertyMetadata((o, e) => UpdateOptionBinding(o)));
+		
+		public static FormattingOption GetFormattingOption(Selector element)
 		{
-			return (string) element.GetValue(OptionProperty);
+			return (FormattingOption) element.GetValue(FormattingOptionProperty);
 		}
 		
-		public static void SetOption(Selector element, string option)
+		public static void SetFormattingOption(Selector element, FormattingOption container)
 		{
-			element.SetValue(OptionProperty, option);
+			element.SetValue(FormattingOptionProperty, container);
 		}
 		
-		static void OnOptionPropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
+		static void UpdateOptionBinding(DependencyObject o)
 		{
-			string option = e.NewValue as string;
 			ComboBox comboBox = o as ComboBox;
 			CSharpFormattingOptionsContainer container = GetContainer(comboBox);
+			FormattingOption option = GetFormattingOption(comboBox);
 			if ((option != null) && (comboBox != null) && (container != null)) {
 				if (container != null) {
 					if (container.Parent != null) {
@@ -72,17 +75,24 @@ namespace CSharpBinding.FormattingStrategy
 							Tag = null
 						});
 						comboBox.SelectedIndex = 0;
+					} else if (option.AlwaysAllowDefault) {
+						// Also add "default" entry, but without changeable text by container
+						comboBox.Items.Add(new ComboBoxItem {
+							Content = "(default)",
+							Tag = null
+						});
+						comboBox.SelectedIndex = 0;
 					}
 					
-					Type optionType = container.GetOptionType(option);
+					Type optionType = container.GetOptionType(option.Option);
 					FillComboValues(comboBox, optionType);
-					UpdateComboBoxValue(container, option, comboBox);
+					UpdateComboBoxValue(container, option.Option, comboBox);
 					
 					comboBox.SelectionChanged += ComboBox_SelectionChanged;
 					container.PropertyChanged += (sender, eventArgs) =>
 					{
-						if ((eventArgs.PropertyName == null) || (eventArgs.PropertyName == option))
-							UpdateComboBoxValue(container, option, comboBox);
+						if ((eventArgs.PropertyName == null) || (eventArgs.PropertyName == option.Option))
+							UpdateComboBoxValue(container, option.Option, comboBox);
 					};
 				}
 			}
@@ -98,13 +108,13 @@ namespace CSharpBinding.FormattingStrategy
 		{
 			ComboBox comboBox = sender as ComboBox;
 			if (comboBox != null) {
-				string option = GetOption(comboBox);
+				FormattingOption option = GetFormattingOption(comboBox);
 				CSharpFormattingOptionsContainer container = GetContainer(comboBox);
 				if ((container != null) && (option != null)) {
 					ComboBoxItem selectedItem = comboBox.SelectedItem as ComboBoxItem;
 					if (selectedItem != null) {
 						// Set option to appropriate value
-						container.SetOption(option, selectedItem.Tag);
+						container.SetOption(option.Option, selectedItem.Tag);
 					}
 				}
 			}
@@ -140,11 +150,10 @@ namespace CSharpBinding.FormattingStrategy
 		
 		static void FillIntComboValues(ComboBox comboBox)
 		{
-			comboBox.Items.Add(new ComboBoxItem { Content = "0", Tag = 0 });
-			comboBox.Items.Add(new ComboBoxItem { Content = "1", Tag = 1 });
-			comboBox.Items.Add(new ComboBoxItem { Content = "2", Tag = 2 });
-			comboBox.Items.Add(new ComboBoxItem { Content = "3", Tag = 3 });
-			comboBox.Items.Add(new ComboBoxItem { Content = "4", Tag = 4 });
+			for (int i = 0; i < 11; i++)
+			{
+				comboBox.Items.Add(new ComboBoxItem { Content = i.ToString(), Tag = i });
+			}
 		}
 		
 		static void FillBraceStyleComboValues(ComboBox comboBox)

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormsDesigner/CSharpDesignerGenerator.cs

@@ -155,7 +155,7 @@ namespace CSharpBinding.FormsDesigner
 			
 			IDocument document = context.GetDocument(fileNameObj);
 			var ctx = SDRefactoringContext.Create(fileNameObj, document);
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(compilation.GetProject());
 			script = new DocumentScript(document, formattingOptions.OptionsContainer.GetEffectiveOptions(), new TextEditorOptions());
 			scripts.Add(fileNameObj, script);
 			return script;

src/AddIns/BackendBindings/CSharpBinding/Project/Src/OptionPanels/CSharpFormattingEditor.xaml

@@ -274,13 +274,13 @@
 					<DataTemplate>
 						<Grid Margin="0,0,0,0">
 							<Grid.ColumnDefinitions>
-								<ColumnDefinition Width="*" />
+								<ColumnDefinition Width="*" MaxWidth="400" />
 								<ColumnDefinition Width="Auto" SharedSizeGroup="ComboBoxColumn" />
 							</Grid.ColumnDefinitions>
 							<ComboBox Grid.Column="1" Margin="0,0,0,0" MinWidth="100"
 							          VerticalAlignment="Center"
 							          format:FormattingOptionBinding.Container="{Binding ElementName=CSharpFormattingEditor_Self, Path=OptionsContainer}"
-							          format:FormattingOptionBinding.Option="{Binding Option}" />
+							          format:FormattingOptionBinding.FormattingOption="{Binding}" />
 							<sd:RestrictDesiredSize RestrictHeight="False" MinWidth="150">
 								<TextBlock Grid.Column="0"
 								           Text="{Binding Text}"
@@ -297,9 +297,39 @@
 	</UserControl.Resources>
 	
 	<DockPanel>
+		<Grid DockPanel.Dock="Top"
+		      Visibility="{Binding Path=OverrideGlobalIndentation, Converter={StaticResource boolToVisibilityConverter}}">
+			<Grid.ColumnDefinitions>
+				<ColumnDefinition Width="Auto" />
+				<ColumnDefinition Width="Auto" />
+			</Grid.ColumnDefinitions>
+			<Grid.RowDefinitions>
+				<RowDefinition Height="Auto" />
+				<RowDefinition Height="Auto" />
+			</Grid.RowDefinitions>
+			
+			<Label Grid.Column="0" Grid.Row="0"
+			       Content="{core:Localize Dialog.Options.IDEOptions.TextEditor.Behaviour.IndentLabel}" />
+			<ComboBox Grid.Column="1" Grid.Row="0" MinWidth="100" Margin="0,0,0,3"
+			          format:FormattingOptionBinding.Container="{Binding ElementName=CSharpFormattingEditor_Self, Path=OptionsContainer}">
+				<format:FormattingOptionBinding.FormattingOption>
+					<local:FormattingOption Option="IndentationSize" AlwaysAllowDefault="True" />
+				</format:FormattingOptionBinding.FormattingOption>
+			</ComboBox>
+			
+			<Label Grid.Column="0" Grid.Row="1"
+			       Content="{core:Localize Dialog.Options.IDEOptions.TextEditor.Behaviour.ConvertTabsToSpacesCheckBox}" />
+			<ComboBox Grid.Column="1" Grid.Row="1" MinWidth="100" Margin="0,0,0,3"
+			          format:FormattingOptionBinding.Container="{Binding ElementName=CSharpFormattingEditor_Self, Path=OptionsContainer}">
+				<format:FormattingOptionBinding.FormattingOption>
+					<local:FormattingOption Option="ConvertTabsToSpaces" AlwaysAllowDefault="True" />
+				</format:FormattingOptionBinding.FormattingOption>
+			</ComboBox>
+		</Grid>
+		
 		<Grid
 			Visibility="{Binding Path=AllowPresets, Converter={StaticResource boolToVisibilityConverter}}"
-			DockPanel.Dock="Top">
+			DockPanel.Dock="Top" Margin="0,5,0,0">
 			<Grid.ColumnDefinitions>
 				<ColumnDefinition Width="Auto" />
 				<ColumnDefinition Width="*" />

src/AddIns/BackendBindings/CSharpBinding/Project/Src/OptionPanels/CSharpFormattingEditor.xaml.cs

@@ -29,21 +29,13 @@ using CSharpBinding.FormattingStrategy;
 
 namespace CSharpBinding.OptionPanels
 {
-	/// <summary>
-	/// Marker interface for group or option container.
-	/// It doesn't need to have any members.
-	/// </summary>
-	internal interface IFormattingItemContainer
-	{
-	}
-	
 	/// <summary>
 	/// Represents a container item for other container items in formatting editor list
 	/// </summary>
 	[ContentProperty("Children")]
-	internal class FormattingGroupContainer : DependencyObject, IFormattingItemContainer
+	internal class FormattingGroupContainer : DependencyObject
 	{
-		readonly ObservableCollection<IFormattingItemContainer> children = new ObservableCollection<IFormattingItemContainer>();
+		readonly ObservableCollection<DependencyObject> children = new ObservableCollection<DependencyObject>();
 		
 		public static readonly DependencyProperty TextProperty =
 			DependencyProperty.Register("Text", typeof(string), typeof(FormattingGroupContainer),
@@ -54,7 +46,7 @@ namespace CSharpBinding.OptionPanels
 			set { SetValue(TextProperty, value); }
 		}
 		
-		public ObservableCollection<IFormattingItemContainer> Children
+		public ObservableCollection<DependencyObject> Children
 		{
 			get {
 				return children;
@@ -66,7 +58,7 @@ namespace CSharpBinding.OptionPanels
 	/// Represents a container for formatting options.
 	/// </summary>
 	[ContentProperty("Children")]
-	internal class FormattingOptionContainer : DependencyObject, IFormattingItemContainer
+	internal class FormattingOptionContainer : DependencyObject
 	{
 		readonly ObservableCollection<FormattingOption> children = new ObservableCollection<FormattingOption>();
 		
@@ -91,11 +83,26 @@ namespace CSharpBinding.OptionPanels
 			set { SetValue(TextProperty, value); }
 		}
 		
+//		public static readonly DependencyProperty AlwaysAllowDefaultProperty =
+//			DependencyProperty.Register("AlwaysAllowDefault", typeof(bool), typeof(FormattingOption),
+//			                            new FrameworkPropertyMetadata());
+//		
+//		public bool AlwaysAllowDefault {
+//			get { return (bool)GetValue(AlwaysAllowDefaultProperty); }
+//			set { SetValue(AlwaysAllowDefaultProperty, value); }
+//		}
+		
 		public string Option
 		{
 			get;
 			set;
 		}
+		
+		public bool AlwaysAllowDefault
+		{
+			get;
+			set;
+		}
 	}
 	
 	/// <summary>
@@ -133,6 +140,15 @@ namespace CSharpBinding.OptionPanels
 			set { SetValue(AllowPresetsProperty, value); }
 		}
 		
+		public static readonly DependencyProperty OverrideGlobalIndentationProperty =
+			DependencyProperty.Register("OverrideGlobalIndentation", typeof(bool), typeof(CSharpFormattingEditor),
+			                            new FrameworkPropertyMetadata());
+		
+		public bool OverrideGlobalIndentation {
+			get { return (bool)GetValue(OverrideGlobalIndentationProperty); }
+			set { SetValue(OverrideGlobalIndentationProperty, value); }
+		}
+		
 		static void OnOptionsContainerPropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
 		{
 			var editor = o as CSharpFormattingEditor;
@@ -197,7 +213,7 @@ namespace CSharpBinding.OptionPanels
 			}
 		}
 		
-		public ObservableCollection<IFormattingItemContainer> RootChildren
+		public ObservableCollection<DependencyObject> RootChildren
 		{
 			get {
 				// rootEntries object is only the root container, its children should be shown directly

src/AddIns/BackendBindings/CSharpBinding/Project/Src/OptionPanels/CSharpFormattingOptionPanel.xaml

@@ -19,7 +19,7 @@
 		<CheckBox
 			Name="autoFormattingCheckBox"
 			Content="{core:Localize CSharpBinding.Formatting.AutoFormat}"
-			IsChecked="{sd:OptionBinding fstrategy:CSharpFormattingOptionsPersistence.AutoFormatting}"
+			IsChecked="{sd:OptionBinding fstrategy:CSharpFormattingPolicies.AutoFormatting}"
 			Margin="0,0,0,10" />
 		<local:CSharpFormattingEditor x:Name="formattingEditor" Grid.Row="1" Margin="0,0,0,0" />
 	</Grid>

src/AddIns/BackendBindings/CSharpBinding/Project/Src/OptionPanels/CSharpFormattingOptionPanel.xaml.cs

@@ -40,7 +40,7 @@ namespace CSharpBinding.OptionPanels
 	internal class CSharpGlobalFormattingOptionPanel : CSharpFormattingOptionPanel
 	{
 		public CSharpGlobalFormattingOptionPanel()
-			: base(CSharpFormattingOptionsPersistence.GlobalOptions, true)
+			: base(CSharpFormattingPolicies.Instance.GlobalOptions, true, false)
 		{
 			autoFormattingCheckBox.Visibility = Visibility.Visible;
 		}
@@ -52,7 +52,7 @@ namespace CSharpBinding.OptionPanels
 	internal class CSharpSolutionFormattingOptionPanel : CSharpFormattingOptionPanel
 	{
 		public CSharpSolutionFormattingOptionPanel()
-			: base(CSharpFormattingOptionsPersistence.SolutionOptions, true)
+			: base(CSharpFormattingPolicies.Instance.SolutionOptions, true, true)
 		{
 			autoFormattingCheckBox.Visibility = Visibility.Collapsed;
 		}
@@ -63,25 +63,26 @@ namespace CSharpBinding.OptionPanels
 	/// </summary>
 	internal partial class CSharpFormattingOptionPanel : OptionPanel
 	{
-		readonly CSharpFormattingOptionsPersistence persistenceHelper;
+		readonly CSharpFormattingPolicy formattingPolicy;
 		bool isDirty;
 		
-		public CSharpFormattingOptionPanel(CSharpFormattingOptionsPersistence persistenceHelper, bool allowPresets)
+		public CSharpFormattingOptionPanel(CSharpFormattingPolicy persistenceHelper, bool allowPresets, bool overrideGlobalIndentation)
 		{
 			if (persistenceHelper == null)
 				throw new ArgumentNullException("persistenceHelper");
 			
-			this.persistenceHelper = persistenceHelper;
+			this.formattingPolicy = persistenceHelper;
 			this.isDirty = false;
 			InitializeComponent();			
 			
 			formattingEditor.AllowPresets = allowPresets;
+			formattingEditor.OverrideGlobalIndentation = overrideGlobalIndentation;
 		}
 		
 		public override void LoadOptions()
 		{
 			base.LoadOptions();
-			formattingEditor.OptionsContainer = persistenceHelper.StartEditing();
+			formattingEditor.OptionsContainer = formattingPolicy.StartEditing();
 			formattingEditor.OptionsContainer.PropertyChanged += ContainerPropertyChanged;
 		}
 
@@ -94,7 +95,7 @@ namespace CSharpBinding.OptionPanels
 		{
 			// Only save container, if some option really has changed
 			formattingEditor.OptionsContainer.PropertyChanged -= ContainerPropertyChanged;
-			return (!isDirty || persistenceHelper.Save()) && base.SaveOptions();
+			return (!isDirty || formattingPolicy.Save()) && base.SaveOptions();
 		}
 	}
 }

src/AddIns/BackendBindings/CSharpBinding/Project/Src/OptionPanels/CSharpProjectFormattingOptions.xaml.cs

@@ -35,7 +35,7 @@ namespace CSharpBinding.OptionPanels
 	/// </summary>
 	internal partial class CSharpProjectFormattingOptionPanel : ProjectOptionPanel
 	{
-		CSharpFormattingOptionsPersistence persistenceHelper;
+		CSharpFormattingPolicy formattingPolicy;
 		
 		public CSharpProjectFormattingOptionPanel()
 		{
@@ -45,18 +45,19 @@ namespace CSharpBinding.OptionPanels
 		protected override void Load(ICSharpCode.SharpDevelop.Project.MSBuildBasedProject project, string configuration, string platform)
 		{
 			base.Load(project, configuration, platform);
-			if (persistenceHelper != null) {
-				persistenceHelper.OptionsContainer.PropertyChanged -= ContainerPropertyChanged;
+			if (formattingPolicy != null) {
+				formattingPolicy.OptionsContainer.PropertyChanged -= ContainerPropertyChanged;
 			}
-			persistenceHelper = CSharpFormattingOptionsPersistence.GetProjectOptions(project);
-			formattingEditor.OptionsContainer = persistenceHelper.OptionsContainer;
+			formattingPolicy = CSharpFormattingPolicies.Instance.GetProjectOptions(project);
+			formattingEditor.OptionsContainer = formattingPolicy.OptionsContainer;
 			formattingEditor.AllowPresets = true;
-			persistenceHelper.OptionsContainer.PropertyChanged += ContainerPropertyChanged;
+			formattingEditor.OverrideGlobalIndentation = true;
+			formattingPolicy.OptionsContainer.PropertyChanged += ContainerPropertyChanged;
 		}
 		
 		protected override bool Save(ICSharpCode.SharpDevelop.Project.MSBuildBasedProject project, string configuration, string platform)
 		{
-			bool success = (persistenceHelper != null) && persistenceHelper.Save();
+			bool success = (formattingPolicy != null) && formattingPolicy.Save();
 			return base.Save(project, configuration, platform) && success;
 		}
 

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/InsertCtorDialog.xaml.cs

@@ -171,7 +171,7 @@ namespace CSharpBinding.Refactoring
 
 				using (StringWriter textWriter = new StringWriter(pList)) {
 					// Output parameter list as string
-					var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(refactoringContext.Compilation.GetProject());
+					var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(refactoringContext.Compilation.GetProject());
 					CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor(textWriter, formattingOptions.OptionsContainer.GetEffectiveOptions());
 					for (int i = 0; i < parameters.Count; i++) {
 						if (i > 0)

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/MoveTypeToFileContextAction.cs

@@ -109,7 +109,7 @@ namespace CSharpBinding.Refactoring
 			                                       || ch is UsingAliasDeclaration
 			                                       || ch is ExternAliasDeclaration);
 			StringBuilder newCode = new StringBuilder(header);
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(compilation.GetProject());
 			CSharpOutputVisitor visitor = new CSharpOutputVisitor(new StringWriter(newCode), formattingOptions.OptionsContainer.GetEffectiveOptions());
 			
 			foreach (var topLevelUsing in topLevelUsings)

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/SDRefactoringContext.cs

@@ -119,13 +119,16 @@ namespace CSharpBinding.Refactoring
 		
 		public Script StartScript()
 		{
-			var formattingOptions = CSharpFormattingOptionsPersistence.GetProjectOptions(resolver.Compilation.GetProject());
+			var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(resolver.Compilation.GetProject());
 			if (editor != null)
 				return new EditorScript(editor, this, formattingOptions.OptionsContainer.GetEffectiveOptions());
 			else if (document == null || document is ReadOnlyDocument)
 				throw new InvalidOperationException("Cannot start a script in a read-only context");
-			else
-				return new DocumentScript(document, formattingOptions.OptionsContainer.GetEffectiveOptions(), this.TextEditorOptions);
+			else {
+				var textEditorOptions = this.TextEditorOptions;
+				formattingOptions.OptionsContainer.CustomizeEditorOptions(textEditorOptions);
+				return new DocumentScript(document, formattingOptions.OptionsContainer.GetEffectiveOptions(), textEditorOptions);
+			}
 		}
 		
 		public IDocument Document {

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditorAdapter.cs

@@ -38,12 +38,14 @@ namespace ICSharpCode.AvalonEdit.AddIn
 	sealed class CodeEditorAdapter : CodeCompletionEditorAdapter
 	{
 		readonly CodeEditor codeEditor;
+		ITextEditorOptions options;
 		
 		public CodeEditorAdapter(CodeEditor codeEditor, CodeEditorView textEditor) : base(textEditor)
 		{
 			if (codeEditor == null)
 				throw new ArgumentNullException("codeEditor");
 			this.codeEditor = codeEditor;
+			options = CodeEditorOptions.Instance;
 		}
 		
 		public override FileName FileName {
@@ -78,9 +80,14 @@ namespace ICSharpCode.AvalonEdit.AddIn
 		internal void DetachExtensions()
 		{
 			if (extensions != null) {
-				foreach (var extension in extensions)
-					extension.Detach();
+				// Detach extensions in reverse order
+				for (int i = extensions.Count - 1; i >= 0; i--) {
+					extensions[i].Detach();
+				}
 			}
+			
+			// Switch to global options, if no specific options service is registered
+			options = this.GetService<ITextEditorOptions>() ?? CodeEditorOptions.Instance;
 		}
 		
 		
@@ -90,6 +97,13 @@ namespace ICSharpCode.AvalonEdit.AddIn
 				foreach (var extension in extensions)
 					extension.Attach(this);
 			}
+			
+			// If we have any registered ITextEditorOptions service now, use it, otherwise global options
+			options = this.GetService<ITextEditorOptions>() ?? CodeEditorOptions.Instance;
+		}
+		
+		public override ITextEditorOptions Options {
+			get { return options; }
 		}
 		
 		sealed class OptionControlledIndentationStrategy : IndentationStrategyAdapter

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.Designer/Project/Extensions/SnaplinePlacementBehavior.cs

@@ -189,7 +189,7 @@ namespace ICSharpCode.WpfDesign.Designer.Extensions
 					yield return designItem;
 					if (designItem.ContentProperty.Value != null) {
 						yield return designItem.ContentProperty.Value;
-						designItem = designItem.ContentProperty.Value;
+						designItem = ExtendedItem; //set designitem back to current control after yield
 					}
 				}
 			}

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/InstallPackageCmdlet.cs

@@ -66,7 +66,9 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		{
 			ThrowErrorIfProjectNotOpen();
 			using (IConsoleHostFileConflictResolver resolver = CreateFileConflictResolver()) {
-				InstallPackage();
+				using (IDisposable logger = ConsoleHost.CreateLogger(this)) {
+					InstallPackage();
+				}
 			}
 		}
 		

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/PackageManagementCmdlet.cs

@@ -25,7 +25,7 @@ using NuGet;
 
 namespace ICSharpCode.PackageManagement.Cmdlets
 {
-	public abstract class PackageManagementCmdlet : PSCmdlet, ITerminatingCmdlet, IPackageScriptSession, IPackageScriptRunner
+	public abstract class PackageManagementCmdlet : PSCmdlet, ITerminatingCmdlet, IPackageScriptSession, IPackageScriptRunner, ICmdletLogger
 	{
 		IPackageManagementConsoleHost consoleHost;
 		ICmdletTerminatingError terminatingError;
@@ -114,5 +114,10 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 				script.Run(this);
 			}
 		}
+		
+		void ICmdletLogger.WriteLine(string message)
+		{
+			Host.UI.WriteLine(message);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/UninstallPackageCmdlet.cs

@@ -59,7 +59,9 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		protected override void ProcessRecord()
 		{
 			ThrowErrorIfProjectNotOpen();
-			UninstallPackage();
+			using (IDisposable logger = ConsoleHost.CreateLogger(this)) {
+				UninstallPackage();
+			}
 		}
 		
 		void UninstallPackage()

src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/UpdatePackageCmdlet.cs

@@ -73,7 +73,9 @@ namespace ICSharpCode.PackageManagement.Cmdlets
 		{
 			ThrowErrorIfProjectNotOpen();
 			using (IConsoleHostFileConflictResolver resolver = CreateFileConflictResolver()) {
-				RunUpdate();
+				using (IDisposable logger = ConsoleHost.CreateLogger(this)) {
+					RunUpdate();
+				}
 			}
 		}
 		

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Src/InstallPackageCmdletTests.cs

@@ -321,5 +321,19 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			operationAwareRepository.AssertOperationWasStartedAndDisposed(RepositoryOperationNames.Install, "Test");
 		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_ConsoleHostLoggerIsDisposed()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			
+			RunCmdlet();
+			
+			fakeConsoleHost.AssertLoggerIsDisposed();
+			Assert.AreEqual(cmdlet, fakeConsoleHost.CmdletLoggerUsedToCreateLogger);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Src/UninstallPackageCmdletTests.cs

@@ -237,8 +237,22 @@ namespace PackageManagement.Cmdlets.Tests
 			RunCmdlet();
 			
 			IPackageScriptRunner scriptRunner = uninstallPackageAction.PackageScriptRunner;
-						
+		
 			Assert.AreEqual(cmdlet, scriptRunner);
 		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_ConsoleHostLoggerIsDisposed()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			
+			RunCmdlet();
+			
+			fakeConsoleHost.AssertLoggerIsDisposed();
+			Assert.AreEqual(cmdlet, fakeConsoleHost.CmdletLoggerUsedToCreateLogger);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Cmdlets/Test/Src/UpdatePackageCmdletTests.cs

@@ -832,5 +832,19 @@ namespace PackageManagement.Cmdlets.Tests
 			
 			operationAwareRepository.AssertOperationWasStartedAndDisposed(RepositoryOperationNames.Update, "Test2");
 		}
+		
+		[Test]
+		public void ProcessRecord_PackageIdSpecified_ConsoleHostLoggerIsDisposed()
+		{
+			CreateCmdletWithoutActiveProject();
+			AddDefaultProjectToConsoleHost();
+			AddPackageSourceToConsoleHost();
+			SetIdParameter("Test");
+			
+			RunCmdlet();
+			
+			fakeConsoleHost.AssertLoggerIsDisposed();
+			Assert.AreEqual(cmdlet, fakeConsoleHost.CmdletLoggerUsedToCreateLogger);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj

@@ -58,6 +58,7 @@
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
     <Reference Include="System.Drawing" />
+    <Reference Include="System.Management.Automation, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xaml">
       <RequiredTargetFramework>4.0</RequiredTargetFramework>
@@ -243,6 +244,7 @@
     <Compile Include="Src\Scripting\ConsoleHostFileConflictResolver.cs" />
     <Compile Include="Src\Scripting\FileConflictAction.cs" />
     <Compile Include="Src\Scripting\GlobalMSBuildProjectCollection.cs" />
+    <Compile Include="Src\Scripting\ICmdletLogger.cs" />
     <Compile Include="Src\Scripting\IConsoleHostFileConflictResolver.cs" />
     <Compile Include="Src\Scripting\IGlobalMSBuildProjectCollection.cs" />
     <Compile Include="Src\Scripting\MSBuildProjectImportsMerger.cs" />
@@ -250,6 +252,7 @@
     <Compile Include="Src\Scripting\MSBuildProjectPropertiesMerger.cs" />
     <Compile Include="Src\Scripting\MSBuildProjectPropertiesMergeResult.cs" />
     <Compile Include="Src\Scripting\NullGlobalMSBuildProjectCollection.cs" />
+    <Compile Include="Src\Scripting\PackageManagementConsoleHostLogger.cs" />
     <Compile Include="Src\Scripting\RunAllProjectPackageScriptsAction.cs" />
     <Compile Include="Src\ServiceWithWorkbenchOwner.cs" />
     <Compile Include="Src\SettingsProvider.cs" />

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/ICmdletLogger.cs

@@ -0,0 +1,31 @@
+// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Management.Automation;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public interface ICmdletLogger
+	{
+		void WriteError(ErrorRecord error);
+		void WriteLine(string message);
+		void WriteVerbose(string message);
+		void WriteWarning(string message);
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/IPackageManagementConsoleHost.cs

@@ -42,6 +42,7 @@ namespace ICSharpCode.PackageManagement.Scripting
 		void SetDefaultRunspace();
 		
 		IConsoleHostFileConflictResolver CreateFileConflictResolver(FileConflictAction fileConflictAction);
+		IDisposable CreateLogger(ICmdletLogger logger);
 		
 		IPackageManagementProject GetProject(string packageSource, string projectName);
 		IPackageManagementProject GetProject(IPackageRepository sourceRepository, string projectName);

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/PackageManagementConsoleHost.cs

@@ -295,5 +295,10 @@ namespace ICSharpCode.PackageManagement.Scripting
 		{
 			return new ConsoleHostFileConflictResolver(packageEvents, fileConflictAction);
 		}
+		
+		public IDisposable CreateLogger(ICmdletLogger logger)
+		{
+			return new PackageManagementConsoleHostLogger(logger, packageEvents);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/PackageManagementConsoleHostLogger.cs

@@ -0,0 +1,75 @@
+// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Management.Automation;
+using NuGet;
+
+namespace ICSharpCode.PackageManagement.Scripting
+{
+	public class PackageManagementConsoleHostLogger : IDisposable
+	{
+		ICmdletLogger logger;
+		IPackageManagementEvents packageEvents;
+		
+		public PackageManagementConsoleHostLogger(ICmdletLogger logger, IPackageManagementEvents packageEvents)
+		{
+			this.logger = logger;
+			this.packageEvents = packageEvents;
+			
+			packageEvents.PackageOperationMessageLogged += PackageOperationMessageLogged;
+		}
+		
+		void PackageOperationMessageLogged(object sender, PackageOperationMessageLoggedEventArgs e)
+		{
+			Log(e.Message.Level, e.Message.ToString());
+		}
+		
+		void Log(MessageLevel level, string message)
+		{
+			switch (level) {
+				case MessageLevel.Debug:
+					logger.WriteVerbose(message);
+					break;
+				case MessageLevel.Warning:
+					logger.WriteWarning(message);
+					break;
+				case MessageLevel.Error:
+					logger.WriteError(CreateErrorRecord(message));
+					break;
+				default:
+					logger.WriteLine(message);
+					break;
+			}
+		}
+		
+		ErrorRecord CreateErrorRecord(string message)
+		{
+			return new ErrorRecord(
+				new ApplicationException(message),
+				"PackageManagementError",
+				ErrorCategory.NotSpecified,
+				null);
+		}
+		
+		public void Dispose()
+		{
+			packageEvents.PackageOperationMessageLogged -= PackageOperationMessageLogged;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Project/Src/Scripting/PowerShellMissingConsoleHost.cs

@@ -100,5 +100,10 @@ namespace ICSharpCode.PackageManagement.Scripting
 		{
 			return null;
 		}
+		
+		public IDisposable CreateLogger(ICmdletLogger logger)
+		{
+			return null;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj

@@ -108,6 +108,7 @@
     <Compile Include="Src\Helpers\CodeElementsExtensions.cs" />
     <Compile Include="Src\Helpers\ExceptionThrowingPackageActionRunner.cs" />
     <Compile Include="Src\Helpers\ExceptionThrowingProcessPackageAction.cs" />
+    <Compile Include="Src\Helpers\FakeCmdletLogger.cs" />
     <Compile Include="Src\Helpers\FakeCodeGenerator.cs" />
     <Compile Include="Src\Helpers\FakeOperationAwarePackageRepository.cs" />
     <Compile Include="Src\Helpers\FakeSelectProjectsService.cs" />
@@ -194,6 +195,7 @@
     <Compile Include="Src\Scripting\ConsoleHostFileConflictResolverTests.cs" />
     <Compile Include="Src\Scripting\MSBuildProjectImportsMergerTests.cs" />
     <Compile Include="Src\Scripting\MSBuildProjectPropertiesMergerTests.cs" />
+    <Compile Include="Src\Scripting\PackageManagementConsoleHostLoggerTests.cs" />
     <Compile Include="Src\SettingsProviderTests.cs" />
     <Compile Include="Src\UpdatedPackagesTests.cs" />
     <Compile Include="Src\UpdatePackagesActionTests.cs" />

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakeCmdletLogger.cs

@@ -0,0 +1,55 @@
+// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Management.Automation;
+using ICSharpCode.PackageManagement.Scripting;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FakeCmdletLogger : ICmdletLogger
+	{
+		public ErrorRecord ErrorRecordLogged;
+		
+		public void WriteError(ErrorRecord error)
+		{
+			ErrorRecordLogged = error;
+		}
+		
+		public string LineLogged;
+		
+		public void WriteLine(string message)
+		{
+			LineLogged = message;
+		}
+		
+		public string VerboseMessageLogged;
+		
+		public void WriteVerbose(string message)
+		{
+			VerboseMessageLogged = message;
+		}
+		
+		public string WarningMessageLogged;
+		
+		public void WriteWarning(string message)
+		{
+			WarningMessageLogged = message;
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageManagementConsoleHost.cs

@@ -169,5 +169,21 @@ namespace PackageManagement.Tests.Helpers
 		{
 			FakeFileConflictResolver.AssertWasCalled(resolver => resolver.Dispose());
 		}
+		
+		public IDisposable FakeConsoleHostLogger =
+			MockRepository.GenerateStub<IDisposable>();
+		
+		public void AssertLoggerIsDisposed()
+		{
+			FakeConsoleHostLogger.AssertWasCalled(logger => logger.Dispose());
+		}
+		
+		public ICmdletLogger CmdletLoggerUsedToCreateLogger;
+		
+		public IDisposable CreateLogger(ICmdletLogger logger)
+		{
+			CmdletLoggerUsedToCreateLogger = logger;
+			return FakeConsoleHostLogger;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Scripting/PackageManagementConsoleHostLoggerTests.cs

@@ -0,0 +1,85 @@
+// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Management.Automation;
+using ICSharpCode.PackageManagement;
+using ICSharpCode.PackageManagement.Scripting;
+using NuGet;
+using NUnit.Framework;
+using PackageManagement.Tests.Helpers;
+
+namespace PackageManagement.Tests.Scripting
+{
+	[TestFixture]
+	public class PackageManagementConsoleHostLoggerTests
+	{
+		FakeCmdletLogger cmdletLogger;
+		PackageManagementConsoleHostLogger consoleHostLogger;
+		PackageManagementEvents packageEvents;
+		
+		void CreateConsoleHostLogger()
+		{
+			cmdletLogger = new FakeCmdletLogger();
+			packageEvents = new PackageManagementEvents();
+			consoleHostLogger = new PackageManagementConsoleHostLogger(cmdletLogger, packageEvents);
+		}
+		
+		[Test]
+		public void OnPackageOperationMessageLogged_DebugMessage_WrittenAsVerboseMessageToCmdlet()
+		{
+			CreateConsoleHostLogger();
+			
+			packageEvents.OnPackageOperationMessageLogged(MessageLevel.Debug, "test");
+			
+			Assert.AreEqual("test", cmdletLogger.VerboseMessageLogged);
+		}
+		
+		[Test]
+		public void OnPackageOperationMessageLogged_WarningMessage_WrittenAsWarningMessageToCmdlet()
+		{
+			CreateConsoleHostLogger();
+			
+			packageEvents.OnPackageOperationMessageLogged(MessageLevel.Warning, "test");
+			
+			Assert.AreEqual("test", cmdletLogger.WarningMessageLogged);
+		}
+		
+		[Test]
+		public void OnPackageOperationMessageLogged_InfoMessage_WrittenAsLineToCmdlet()
+		{
+			CreateConsoleHostLogger();
+			
+			packageEvents.OnPackageOperationMessageLogged(MessageLevel.Info, "test");
+			
+			Assert.AreEqual("test", cmdletLogger.LineLogged);
+		}
+		
+		[Test]
+		public void OnPackageOperationMessageLogged_ErrorMessage_WrittenAsErrorRecordCmdlet()
+		{
+			CreateConsoleHostLogger();
+			
+			packageEvents.OnPackageOperationMessageLogged(MessageLevel.Error, "test");
+			
+			Assert.IsNotNull(cmdletLogger.ErrorRecordLogged);
+			Assert.AreEqual("test", cmdletLogger.ErrorRecordLogged.Exception.Message);
+			Assert.AreEqual(ErrorCategory.NotSpecified, cmdletLogger.ErrorRecordLogged.CategoryInfo.Category);
+		}
+	}
+}

src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/TextEditorOptions.cs

@@ -264,11 +264,19 @@ namespace ICSharpCode.AvalonEdit
 		/// Gets text required to indent from the specified <paramref name="column"/> to the next indentation level.
 		/// </summary>
 		public virtual string GetIndentationString(int column)
+		{
+			return GetIndentationString(column, IndentationSize, ConvertTabsToSpaces);
+		}
+		
+		/// <summary>
+		/// Gets text required to indent from the specified <paramref name="column"/> to the next indentation level,
+		/// considering given <paramref name="indentationSize"/> and <paramref name="convertTabsToSpaces"/> settings.
+		/// </summary>
+		public static string GetIndentationString(int column, int indentationSize, bool convertTabsToSpaces)
 		{
 			if (column < 1)
 				throw new ArgumentOutOfRangeException("column", column, "Value must be at least 1.");
-			int indentationSize = this.IndentationSize;
-			if (ConvertTabsToSpaces) {
+			if (convertTabsToSpaces) {
 				return new string(' ', indentationSize - ((column - 1) % indentationSize));
 			} else {
 				return "\t";