Tried implementing automatical updating of editors after changing policy-specific indentation changes + some refactoring.

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

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

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

@@ -70,6 +70,13 @@ namespace CSharpBinding
 			codeManipulation = new CodeManipulation(editor);
 			renderer = new CaretReferenceHighlightRenderer(editor);
 			
+			// Patch editor options (indentation) to project-specific settings
+			var optionsContainer = CSharpFormattingPolicies.Instance.GetProjectOptions(
+				SD.ProjectService.FindProjectContainingFile(editor.FileName));
+			CustomizeEditorOptions(optionsContainer.OptionsContainer, editor.Options);
+			CSharpFormattingPolicies.Instance.FormattingPolicyUpdated +=
+				(sender, e) => CustomizeEditorOptions(optionsContainer.OptionsContainer, this.editor.Options);
+
 			if (!editor.ContextActionProviders.IsReadOnly) {
 				contextActionProviders = AddInTree.BuildItems<IContextActionProvider>("/SharpDevelop/ViewContent/TextEditor/C#/ContextActions", null);
 				editor.ContextActionProviders.AddRange(contextActionProviders);
@@ -89,5 +96,22 @@ namespace CSharpBinding
 			renderer.Dispose();
 			this.editor = null;
 		}
+		
+		private void CustomizeEditorOptions(CSharpFormattingOptionsContainer container, ITextEditorOptions editorOptions)
+		{
+			if (container == null)
+				return;
+			var textEditorOptions = editorOptions as ICSharpCode.AvalonEdit.TextEditorOptions;
+			if (textEditorOptions == null)
+				return;
+			
+			int? indentationSize = container.GetEffectiveIndentationSize();
+			if (indentationSize.HasValue) {
+				textEditorOptions.IndentationSize = indentationSize.Value;
+			}
+			bool? convertTabsToSpaces = container.GetEffectiveConvertTabsToSpaces();
+			if (convertTabsToSpaces.HasValue)
+				textEditorOptions.ConvertTabsToSpaces = convertTabsToSpaces.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

@@ -32,12 +32,7 @@ namespace CSharpBinding.FormattingStrategy
 		public static void Format(ITextEditor editor, int offset, int length, CSharpFormattingOptionsContainer optionsContainer)
 		{
 			TextEditorOptions editorOptions = editor.ToEditorOptions();
-			int? indentationSize = optionsContainer.GetEffectiveIndentationSize();
+			optionsContainer.CustomizeEditorOptions(editorOptions);
-			if (indentationSize.HasValue)
-				editorOptions.IndentSize = indentationSize.Value;
-			bool? convertTabsToSpaces = optionsContainer.GetEffectiveConvertTabsToSpaces();
-			if (convertTabsToSpaces.HasValue)
-				editorOptions.TabsToSpaces = convertTabsToSpaces.Value;
 			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));

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

@@ -364,6 +364,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)
@@ -407,4 +420,3 @@ namespace CSharpBinding.FormattingStrategy
 		}
 	}
 }
-	

src/AddIns/BackendBindings/CSharpBinding/Project/Src/FormattingStrategy/CSharpFormattingOptionsPersistence.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,42 +26,41 @@ 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();
+			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;
+		public static readonly CSharpFormattingPolicies Instance = new CSharpFormattingPolicies();
-		static Dictionary<string, CSharpFormattingOptionsPersistence> projectOptions;
 		
-		static CSharpFormattingOptionsPersistence()
+		public event EventHandler<CSharpFormattingPolicyUpdateEventArgs> FormattingPolicyUpdated;
-		{
+		
-			Initialize();
+		static bool initialized;
-		}
+		static Dictionary<string, CSharpFormattingPolicy> projectOptions;
 		
-		public static void Initialize()
+		public void Initialize()
 		{
 			if (initialized)
 				return;
 			
 			initialized = true;
-			projectOptions = new Dictionary<string, CSharpFormattingOptionsPersistence>();
+			projectOptions = new Dictionary<string, CSharpFormattingPolicy>();
 			
 			// Load global settings
-			GlobalOptions = new CSharpFormattingOptionsPersistence(
+			GlobalOptions = new CSharpFormattingPolicy(
-				SD.PropertyService.MainPropertiesContainer, new CSharpFormattingOptionsContainer()
+				SD.PropertyService.MainPropertiesContainer, new CSharpFormattingOptionsContainer() {
-				{
 					DefaultText = StringParser.Parse("${res:CSharpBinding.Formatting.GlobalOptionReference}")
 				});
+			GlobalOptions.FormattingPolicyUpdated += OnFormattingPolicyUpdated;
 			GlobalOptions.Load();
 			
 			// Handlers for solution loading/unloading
@@ -71,8 +71,7 @@ namespace CSharpBinding.FormattingStrategy
 			}
 		}
 		
-		public static bool AutoFormatting
+		public static bool AutoFormatting {
-		{
 			get {
 				return SD.PropertyService.Get("CSharpBinding.Formatting.AutoFormatting", false);
 			}
@@ -81,31 +80,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 (projectOptions == null)
+				return null;
+			
 			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 +116,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 +189,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 +232,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

@@ -70,7 +70,7 @@ namespace CSharpBinding.FormattingStrategy
 		{
 			var currentProject = SD.ProjectService.FindProjectContainingFile(editor.FileName);
 			if (currentProject != null) {
-				var persistence = CSharpFormattingOptionsPersistence.GetProjectOptions(currentProject);
+				var persistence = CSharpFormattingPolicies.Instance.GetProjectOptions(currentProject);
 				if (persistence != null) {
 					return persistence.OptionsContainer;
 				}
@@ -333,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/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

@@ -297,7 +297,8 @@
 	</UserControl.Resources>
 	
 	<DockPanel>
-		<Grid DockPanel.Dock="Top">
+		<Grid DockPanel.Dock="Top"
+		      Visibility="{Binding Path=OverrideGlobalIndentation, Converter={StaticResource boolToVisibilityConverter}}">
 			<Grid.ColumnDefinitions>
 				<ColumnDefinition Width="*" MaxWidth="400" />
 				<ColumnDefinition Width="Auto" />

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

@@ -140,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;

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,28 +63,29 @@ namespace CSharpBinding.OptionPanels
 	/// </summary>
 	internal partial class CSharpFormattingOptionPanel : OptionPanel
 	{
-		readonly CSharpFormattingOptionsPersistence persistenceHelper;
+		readonly CSharpFormattingPolicy formattingPolicy;
 		
-		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;
 			InitializeComponent();			
 			
 			formattingEditor.AllowPresets = allowPresets;
+			formattingEditor.OverrideGlobalIndentation = overrideGlobalIndentation;
 		}
 		
 		public override void LoadOptions()
 		{
 			base.LoadOptions();
-			formattingEditor.OptionsContainer = persistenceHelper.StartEditing(); 
+			formattingEditor.OptionsContainer = formattingPolicy.StartEditing(); 
 		}
 		
 		public override bool SaveOptions()
 		{
-			return persistenceHelper.Save() && base.SaveOptions();
+			return 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) {
+			if (formattingPolicy != null) {
-				persistenceHelper.OptionsContainer.PropertyChanged -= ContainerPropertyChanged;
+				formattingPolicy.OptionsContainer.PropertyChanged -= ContainerPropertyChanged;
 			}
-			persistenceHelper = CSharpFormattingOptionsPersistence.GetProjectOptions(project);
+			formattingPolicy = CSharpFormattingPolicies.Instance.GetProjectOptions(project);
-			formattingEditor.OptionsContainer = persistenceHelper.OptionsContainer;
+			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
+			else {
-				return new DocumentScript(document, formattingOptions.OptionsContainer.GetEffectiveOptions(), this.TextEditorOptions);
+				var textEditorOptions = this.TextEditorOptions;
+				formattingOptions.OptionsContainer.CustomizeEditorOptions(textEditorOptions);
+				return new DocumentScript(document, formattingOptions.OptionsContainer.GetEffectiveOptions(), textEditorOptions);
+			}
 		}
 		
 		public IDocument Document {