public string FormatText (CSharpFormattingPolicy policy, TextStylePolicy textPolicy, string mimeType, string input, int startOffset, int endOffset)
{
var data = new TextEditorData ();
data.Document.SuppressHighlightUpdate = true;
data.Document.MimeType = mimeType;
data.Document.FileName = "toformat.cs";
if (textPolicy != null) {
data.Options.TabsToSpaces = textPolicy.TabsToSpaces;
data.Options.TabSize = textPolicy.TabWidth;
data.Options.IndentationSize = textPolicy.IndentWidth;
data.Options.IndentStyle = textPolicy.RemoveTrailingWhitespace ? IndentStyle.Virtual : IndentStyle.Smart;
}
data.Text = input;
// System.Console.WriteLine ("-----");
// System.Console.WriteLine (data.Text.Replace (" ", ".").Replace ("\t", "->"));
// System.Console.WriteLine ("-----");
var parser = new CSharpParser ();
var compilationUnit = parser.Parse (data);
bool hadErrors = parser.HasErrors;
if (hadErrors) {
// foreach (var e in parser.ErrorReportPrinter.Errors)
// Console.WriteLine (e.Message);
return input.Substring (startOffset, Math.Max (0, Math.Min (endOffset, input.Length) - startOffset));
}
var originalVersion = data.Document.Version;
var textEditorOptions = data.CreateNRefactoryTextEditorOptions ();
var formattingVisitor = new ICSharpCode.NRefactory.CSharp.CSharpFormatter (
policy.CreateOptions (),
textEditorOptions
) {
FormattingMode = FormattingMode.Intrusive
};
var changes = formattingVisitor.AnalyzeFormatting (data.Document, compilationUnit);
try {
changes.ApplyChanges (startOffset, endOffset - startOffset);
} catch (Exception e) {
LoggingService.LogError ("Error in code formatter", e);
return input.Substring (startOffset, Math.Max (0, Math.Min (endOffset, input.Length) - startOffset));
}
// check if the formatter has produced errors
parser = new CSharpParser ();
parser.Parse (data);
if (parser.HasErrors) {
LoggingService.LogError ("C# formatter produced source code errors. See console for output.");
return input.Substring (startOffset, Math.Max (0, Math.Min (endOffset, input.Length) - startOffset));
}
var currentVersion = data.Document.Version;
string result = data.GetTextBetween (startOffset, originalVersion.MoveOffsetTo (currentVersion, endOffset, ICSharpCode.NRefactory.Editor.AnchorMovementType.Default));
data.Dispose ();
return result;
}
public void TestNamespaceBraceStyle ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.NamespaceBraceStyle = BraceStyle.EndOfLine;
policy.ClassBraceStyle = BraceStyle.DoNotChange;
var adapter = Test (policy, @"namespace A
{
namespace B {
class Test {}
}
}",
@"namespace A {
namespace B {
class Test {}
}
}");
policy.NamespaceBraceStyle = BraceStyle.NextLineShifted;
Continue (policy, adapter,
@"namespace A
{
namespace B
{
class Test {}
}
}");
}
public void TestBlankLinesBeforeUsings ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.BlankLinesAfterUsings = 0;
policy.BlankLinesBeforeUsings = 2;
var adapter = Test (policy, @"using System;
using System.Text;
namespace Test
{
}",
@"
using System;
using System.Text;
namespace Test
{
}");
policy.BlankLinesBeforeUsings = 0;
Continue (policy, adapter,
@"using System;
using System.Text;
namespace Test
{
}");
}
public void TestClassIndentationInNamespacesCase2 ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.NamespaceBraceStyle = BraceStyle.NextLine;
policy.ClassBraceStyle = BraceStyle.NextLine;
policy.ConstructorBraceStyle = BraceStyle.NextLine;
Test (policy,
@"using System;
namespace MonoDevelop.CSharp.Formatting {
public class FormattingProfileService {
public FormattingProfileService () {
}
}
}",
@"using System;
namespace MonoDevelop.CSharp.Formatting
{
public class FormattingProfileService
{
public FormattingProfileService ()
{
}
}
}");
}
public void TestIndentBlocks ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.IndentBlocks = true;
var adapter = Test (policy,
@"class Test {
Test TestMethod ()
{
{
{}
}
}
}",
@"class Test
{
Test TestMethod ()
{
{
{}
}
}
}");
policy.IndentBlocks = false;
Continue (policy, adapter, @"class Test
{
Test TestMethod ()
{
{
{}
}
}
}");
}
public void TestClassIndentation ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.ClassBraceStyle = BraceStyle.DoNotChange;
Test (policy,
@" class Test {}",
@"class Test {}");
}
public void TestClassBraceStlye ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.ClassBraceStyle = BraceStyle.EndOfLine;
Test (policy,
@"class Test {}",
@"class Test {
}");
}
public void TestStructBraceStyle ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.StructBraceStyle = BraceStyle.NextLine;
Test (policy,
@"struct Test {}",
@"struct Test
{
}");
}
public void TestClassIndentationInNamespaces ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.NamespaceBraceStyle = BraceStyle.EndOfLine;
policy.ClassBraceStyle = BraceStyle.DoNotChange;
Test (policy,
@"namespace A { class Test {} }",
@"namespace A {
class Test {}
}");
}
public void TestFixedFieldSpacesBeforeComma ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.ClassBraceStyle = BraceStyle.EndOfLine;
policy.SpaceAfterFieldDeclarationComma = true;
policy.SpaceBeforeFieldDeclarationComma = true;
Test (policy, @"class Test {
fixed int a[10] , b[10], c[10];
}",
@"class Test {
fixed int a[10] , b[10] , c[10];
}");
}
public void GenerateCode(ITextOutput output, Predicate<IAstTransform> transformAbortCondition)
{
TransformationPipeline.RunTransformationsUntil(astCompileUnit, transformAbortCondition, context);
astCompileUnit.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = true }, null);
var outputFormatter = new TextOutputFormatter(output);
var formattingPolicy = new CSharpFormattingPolicy();
// disable whitespace in front of parentheses:
formattingPolicy.BeforeMethodCallParentheses = false;
formattingPolicy.BeforeMethodDeclarationParentheses = false;
formattingPolicy.BeforeConstructorDeclarationParentheses = false;
formattingPolicy.BeforeDelegateDeclarationParentheses = false;
astCompileUnit.AcceptVisitor(new OutputVisitor(outputFormatter, formattingPolicy), null);
}
public void TestFieldSpacesBeforeComma1 ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.ClassBraceStyle = BraceStyle.EndOfLine;
policy.SpaceBeforeFieldDeclarationComma = false;
policy.SpaceAfterFieldDeclarationComma = false;
Test (policy, @"class Test {
int a , b, c;
}",
@"class Test {
int a,b,c;
}");
}
public void TestBug325187 ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.PlaceElseOnNewLine = true;
TestStatementFormatting (policy,
@"foreach (int i in myints)
if (i == 6)
Console.WriteLine (""Yeah"");
else
Console.WriteLine (""Bad indent"");",
@"foreach (int i in myints)
if (i == 6)
Console.WriteLine (""Yeah"");
else
Console.WriteLine (""Bad indent"");");
}
public void TestBug415469 ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
TestStatementFormatting (policy,
@"switch (condition) {
case CONDITION1:
return foo != null ? foo.Bar : null;
case CONDITION2:
string goo = foo != null ? foo.Bar : null;
return ""Should be indented like this"";
}", @"switch (condition) {
case CONDITION1:
return foo != null ? foo.Bar : null;
case CONDITION2:
string goo = foo != null ? foo.Bar : null;
return ""Should be indented like this"";
}");
}
public void TestInvocationIndentation ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.ClassBraceStyle = BraceStyle.EndOfLine;
Test (policy,
@"class Test {
Test TestMethod ()
{
this.TestMethod ();
}
}",
@"class Test {
Test TestMethod ()
{
this.TestMethod ();
}
}");
}
public void SetUp()
{
policy = new CSharpFormattingPolicy();
}
public void SetUp()
{
policy = new CSharpFormattingPolicy();
}
public void TestSpacesInLambdaExpression ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpacesWithinWhileParentheses = true;
var result = GetResult (policy, @"class Test {
void TestMe ()
{
var v = x=>x!=null;
}
}");
int i1 = result.Text.IndexOf ("x");
int i2 = result.Text.LastIndexOf ("null") + "null".Length;
Assert.AreEqual (@"x => x != null", result.GetTextAt (i1, i2 - i1));
}
public void TestAfterMethodDeclarationParameterComma ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpaceBeforeMethodDeclarationParameterComma = false;
policy.SpaceAfterMethodDeclarationParameterComma = true;
var result = GetResult (policy, @"class Test {
public void Foo (int a,int b,int c) {}
}");
int i1 = result.Text.LastIndexOf ("(");
int i2 = result.Text.LastIndexOf (")") + ")".Length;
Assert.AreEqual (@"(int a, int b, int c)", result.GetTextAt (i1, i2 - i1));
policy.SpaceAfterMethodDeclarationParameterComma = false;
result = GetResult (policy, result.Text);
i1 = result.Text.LastIndexOf ("(");
i2 = result.Text.LastIndexOf (")") + ")".Length;
Assert.AreEqual (@"(int a,int b,int c)", result.GetTextAt (i1, i2 - i1));
}
public void TestFieldDeclarationComma ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpaceBeforeFieldDeclarationComma = false;
policy.SpaceAfterFieldDeclarationComma = true;
var result = GetResult (policy, @"class Test {
int a,b,c;
}");
int i1 = result.Text.LastIndexOf ("int");
int i2 = result.Text.LastIndexOf (";") + ";".Length;
Assert.AreEqual (@"int a, b, c;", result.GetTextAt (i1, i2 - i1));
policy.SpaceBeforeFieldDeclarationComma = true;
result = GetResult (policy, result.Text);
i1 = result.Text.LastIndexOf ("int");
i2 = result.Text.LastIndexOf (";") + ";".Length;
Assert.AreEqual (@"int a , b , c;", result.GetTextAt (i1, i2 - i1));
policy.SpaceBeforeFieldDeclarationComma = false;
policy.SpaceAfterFieldDeclarationComma = false;
result = GetResult (policy, result.Text);
i1 = result.Text.LastIndexOf ("int");
i2 = result.Text.LastIndexOf (";") + ";".Length;
Assert.AreEqual (@"int a,b,c;", result.GetTextAt (i1, i2 - i1));
}
public void TestAfterNewParameterComma ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpaceAfterNewParameterComma = true;
var result = GetResult (policy, @"class Test {
void TestMe ()
{
new Test (1,2);
}
}");
int i1 = result.Text.LastIndexOf ("new");
int i2 = result.Text.LastIndexOf (";") + ";".Length;
Assert.AreEqual (@"new Test (1, 2);", result.GetTextAt (i1, i2 - i1));
}
public void TestBetweenEmptyNewParentheses ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpacesBetweenEmptyNewParentheses = true;
var result = GetResult (policy, @"class Test {
void TestMe ()
{
new Test ();
}
}");
int i1 = result.Text.LastIndexOf ("new");
int i2 = result.Text.LastIndexOf (";") + ";".Length;
Assert.AreEqual (@"new Test ( );", result.GetTextAt (i1, i2 - i1));
}
public CSharpTextEditorIndentation ()
{
IEnumerable<string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
policy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<CSharpFormattingPolicy> (types);
textStylePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<TextStylePolicy> (types);
}
public override void Initialize ()
{
base.Initialize ();
IEnumerable<string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
if (base.Document.Project != null && base.Document.Project.Policies != null) {
policy = base.Document.Project.Policies.Get<CSharpFormattingPolicy> (types);
textStylePolicy = base.Document.Project.Policies.Get<TextStylePolicy> (types);
}
textEditorData = Document.Editor;
if (textEditorData != null) {
textEditorData.IndentationTracker = new IndentVirtualSpaceManager (
textEditorData,
new DocumentStateTracker<CSharpIndentEngine> (new CSharpIndentEngine (policy, textStylePolicy), textEditorData)
);
}
InitTracker ();
// Document.Editor.Paste += HandleTextPaste;
}
public override void AddGlobalNamespaceImport (MonoDevelop.Ide.Gui.Document doc, string nsName)
{
var parsedDocument = doc.ParsedDocument;
var unit = parsedDocument.GetAst<SyntaxTree> ();
if (unit == null)
return;
var policy = doc.Project != null ? doc.Project.Policies.Get <CSharpFormattingPolicy> () : null;
if (policy == null)
policy = Policy;
var node = SearchUsingInsertionPoint (unit);
var text = new StringBuilder ();
int lines = 0;
if (InsertUsingAfter (node)) {
lines = policy.BlankLinesBeforeUsings + 1;
while (lines-- > 0) {
text.Append (doc.Editor.EolMarker);
}
}
text.Append ("using ");
text.Append (nsName);
text.Append (";");
int offset = 0;
if (node != null) {
var loc = InsertUsingAfter (node) ? node.EndLocation : node.StartLocation;
offset = doc.Editor.LocationToOffset (loc);
}
lines = policy.BlankLinesAfterUsings;
lines -= CountBlankLines (doc, doc.Editor.OffsetToLineNumber (offset) + 1);
if (lines > 0)
text.Append (doc.Editor.EolMarker);
while (lines-- > 0) {
text.Append (doc.Editor.EolMarker);
}
doc.Editor.Insert (offset, text.ToString ());
doc.Editor.Document.CommitUpdateAll ();
}
public void TestWithinSizeOfParenthesesSpace ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpacesWithinSizeOfParentheses = true;
var result = GetResult (policy, @"class Test {
void TestMe ()
{
a = sizeof(int);
}
}");
int i1 = result.Text.LastIndexOf ("(");
int i2 = result.Text.LastIndexOf (")") + ")".Length;
Assert.AreEqual (@"( int )", result.GetTextAt (i1, i2 - i1));
}
public string FormatText (CSharpFormattingPolicy policy, TextStylePolicy textPolicy, string mimeType, string input, int startOffset, int endOffset)
{
var data = new TextEditorData ();
data.Document.SuppressHighlightUpdate = true;
data.Document.MimeType = mimeType;
data.Document.FileName = "toformat.cs";
if (textPolicy != null) {
data.Options.TabsToSpaces = textPolicy.TabsToSpaces;
data.Options.TabSize = textPolicy.TabWidth;
data.Options.DefaultEolMarker = textPolicy.GetEolMarker ();
}
data.Options.OverrideDocumentEolMarker = true;
data.Text = input;
// System.Console.WriteLine ("-----");
// System.Console.WriteLine (data.Text.Replace (" ", ".").Replace ("\t", "->"));
// System.Console.WriteLine ("-----");
var parser = new CSharpParser ();
var compilationUnit = parser.Parse (data);
bool hadErrors = parser.HasErrors;
if (hadErrors) {
// foreach (var e in parser.ErrorReportPrinter.Errors)
// Console.WriteLine (e.Message);
return input.Substring (startOffset, Math.Max (0, Math.Min (endOffset, input.Length) - startOffset));
}
var adapter = new TextEditorDataAdapter (data);
var formattingVisitor = new ICSharpCode.NRefactory.CSharp.AstFormattingVisitor (policy.CreateOptions (), adapter, new FormattingActionFactory (data)) {
HadErrors = hadErrors
};
compilationUnit.AcceptVisitor (formattingVisitor, null);
var changes = new List<ICSharpCode.NRefactory.CSharp.Refactoring.Action> ();
changes.AddRange (formattingVisitor.Changes.
Where (c => (startOffset <= c.Offset && c.Offset < endOffset)));
MDRefactoringContext.MdScript.RunActions (changes, null);
// check if the formatter has produced errors
parser = new CSharpParser ();
parser.Parse (data);
if (parser.HasErrors) {
LoggingService.LogError ("C# formatter produced source code errors. See console for output.");
Console.WriteLine (data.Text);
return input.Substring (startOffset, Math.Max (0, Math.Min (endOffset, input.Length) - startOffset));
}
int end = endOffset;
foreach (TextReplaceAction c in changes) {
end -= c.RemovedChars;
if (c.InsertedText != null)
end += c.InsertedText.Length;
}
/* System.Console.WriteLine ("-----");
System.Console.WriteLine (data.Text.Replace (" ", "^").Replace ("\t", "->"));
System.Console.WriteLine ("-----");*/
string result = data.GetTextBetween (startOffset, Math.Min (data.Length, end));
data.Dispose ();
return result;
}
public override void AddLocalNamespaceImport (MonoDevelop.Ide.Gui.Document doc, string nsName, TextLocation caretLocation)
{
var parsedDocument = doc.ParsedDocument;
var unit = parsedDocument.GetAst<SyntaxTree> ();
if (unit == null)
return;
var nsDecl = unit.GetNodeAt<NamespaceDeclaration> (caretLocation);
if (nsDecl == null) {
AddGlobalNamespaceImport (doc, nsName);
return;
}
var policy = doc.Project != null ? doc.Project.Policies.Get <CSharpFormattingPolicy> () : null;
if (policy == null)
policy = Policy;
var node = SearchUsingInsertionPoint (nsDecl);
var text = new StringBuilder ();
int lines = 0;
if (InsertUsingAfter (node)) {
lines = policy.BlankLinesBeforeUsings + 1;
while (lines-- > 0) {
text.Append (doc.Editor.EolMarker);
}
}
string indent = doc.Editor.GetLineIndent (nsDecl.StartLocation.Line) + "\t";
text.Append (indent);
text.Append ("using ");
text.Append (nsName);
text.Append (";");
int offset;
TextLocation loc;
if (node != null) {
loc = InsertUsingAfter (node) ? node.EndLocation : node.StartLocation;
} else {
loc = nsDecl.LBraceToken.EndLocation;
}
offset = doc.Editor.LocationToOffset (loc);
lines = policy.BlankLinesAfterUsings;
lines -= CountBlankLines (doc, doc.Editor.OffsetToLineNumber (offset) + 1);
if (lines > 0)
text.Append (doc.Editor.EolMarker);
while (lines-- > 0) {
text.Append (doc.Editor.EolMarker);
}
doc.Editor.Insert (offset, text.ToString ());
}
public void TestBeforeTypeOfParentheses ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpaceBeforeTypeOfParentheses = true;
var result = GetResult (policy, @"class Test {
void TestMe ()
{
a = typeof(int);
}
}");
int i1 = result.Text.LastIndexOf ("typeof");
int i2 = result.Text.LastIndexOf ("(") + "(".Length;
Assert.AreEqual (@"typeof (", result.GetTextAt (i1, i2 - i1));
}
public CSharpFormattingProfileDialog (CSharpFormattingPolicy profile)
{
this.Build ();
this.profile = profile;
this.Title = profile.IsBuiltIn ? GettextCatalog.GetString ("Show built-in profile") : GettextCatalog.GetString ("Edit Profile");
notebookCategories.SwitchPage += delegate {
TreeView treeView;
switch (notebookCategories.Page) {
case 0:
treeView = treeviewIndentOptions;
break;
case 1:
treeView = treeviewBracePositions;
break;
case 2: // Blank lines
UpdateExample (blankLineExample);
return;
case 3: // white spaces
treeView = treeviewInsertWhiteSpaceCategory;
return;
case 4:
treeView = treeviewNewLines;
break;
default:
return;
}
var model = treeView.Model;
Gtk.TreeIter iter;
if (treeView.Selection.GetSelected (out model, out iter))
UpdateExample (model, iter);
};
notebookCategories.ShowTabs = false;
comboboxCategories.AppendText (GettextCatalog.GetString ("Indentation"));
comboboxCategories.AppendText (GettextCatalog.GetString ("Braces"));
comboboxCategories.AppendText (GettextCatalog.GetString ("Blank lines"));
comboboxCategories.AppendText (GettextCatalog.GetString ("White Space"));
comboboxCategories.AppendText (GettextCatalog.GetString ("New Lines"));
comboboxCategories.Changed += delegate(object sender, EventArgs e) {
texteditor.Text = "";
notebookCategories.Page = comboboxCategories.Active;
};
comboboxCategories.Active = 0;
var options = MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance;
texteditor.Options.FontName = options.FontName;
texteditor.Options.ColorScheme = options.ColorScheme;
texteditor.Options.ShowFoldMargin = false;
texteditor.Options.ShowIconMargin = false;
texteditor.Options.ShowLineNumberMargin = false;
texteditor.Options.ShowInvalidLines = false;
texteditor.Document.ReadOnly = true;
texteditor.Document.MimeType = CSharpFormatter.MimeType;
scrolledwindow.Child = texteditor;
ShowAll ();
#region Indent options
indentOptions = new Gtk.TreeStore (typeof (string), typeof (string), typeof (string), typeof(bool), typeof(bool));
TreeViewColumn column = new TreeViewColumn ();
// pixbuf column
var pixbufCellRenderer = new CellRendererPixbuf ();
column.PackStart (pixbufCellRenderer, false);
column.SetCellDataFunc (pixbufCellRenderer, RenderIcon);
// text column
CellRendererText cellRendererText = new CellRendererText ();
cellRendererText.Ypad = 1;
column.PackStart (cellRendererText, true);
column.SetAttributes (cellRendererText, "text", 1);
treeviewIndentOptions.Model = indentOptions;
treeviewIndentOptions.HeadersVisible = false;
treeviewIndentOptions.Selection.Changed += TreeSelectionChanged;
treeviewIndentOptions.AppendColumn (column);
column = new TreeViewColumn ();
CellRendererCombo cellRendererCombo = new CellRendererCombo ();
cellRendererCombo.Ypad = 1;
cellRendererCombo.Mode = CellRendererMode.Editable;
cellRendererCombo.TextColumn = 1;
cellRendererCombo.Model = comboBoxStore;
cellRendererCombo.HasEntry = false;
cellRendererCombo.Editable = !profile.IsBuiltIn;
cellRendererCombo.Edited += new ComboboxEditedHandler (this, indentOptions).ComboboxEdited;
column.PackStart (cellRendererCombo, false);
column.SetAttributes (cellRendererCombo, "visible", comboVisibleColumn);
column.SetCellDataFunc (cellRendererCombo, ComboboxDataFunc);
CellRendererToggle cellRendererToggle = new CellRendererToggle ();
cellRendererToggle.Ypad = 1;
cellRendererToggle.Activatable = !profile.IsBuiltIn;
cellRendererToggle.Toggled += new CellRendererToggledHandler (this, treeviewIndentOptions, indentOptions).Toggled;
column.PackStart (cellRendererToggle, false);
column.SetAttributes (cellRendererToggle, "visible", toggleVisibleColumn);
column.SetCellDataFunc (cellRendererToggle, ToggleDataFunc);
treeviewIndentOptions.AppendColumn (column);
var category = AddOption (indentOptions, null, GettextCatalog.GetString ("Declarations"), null);
AddOption (indentOptions, category, "IndentNamespaceBody", GettextCatalog.GetString ("within namespaces"), "namespace Test { class AClass {} }");
AddOption (indentOptions, category, "IndentClassBody", GettextCatalog.GetString ("within classes"), "class AClass { int aField; void AMethod () {}}");
AddOption (indentOptions, category, "IndentInterfaceBody", GettextCatalog.GetString ("within interfaces"), "interface IAInterfaces { int AProperty {get;set;} void AMethod ();}");
AddOption (indentOptions, category, "IndentStructBody", GettextCatalog.GetString ("within structs"), "struct AStruct { int aField; void AMethod () {}}");
AddOption (indentOptions, category, "IndentEnumBody", GettextCatalog.GetString ("within enums"), "enum AEnum { A, B, C }");
AddOption (indentOptions, category, "IndentMethodBody", GettextCatalog.GetString ("within methods"), methodSpaceExample);
AddOption (indentOptions, category, "IndentPropertyBody", GettextCatalog.GetString ("within properties"), propertyExample);
AddOption (indentOptions, category, "IndentEventBody", GettextCatalog.GetString ("within events"), eventExample);
category = AddOption (indentOptions, null, GettextCatalog.GetString ("Statements"), null);
AddOption (indentOptions, category, "IndentBlocks", GettextCatalog.GetString ("within blocks"), spaceExample);
AddOption (indentOptions, category, "IndentSwitchBody", GettextCatalog.GetString ("Indent 'switch' body"), spaceExample);
AddOption (indentOptions, category, "IndentCaseBody", GettextCatalog.GetString ("Indent 'case' body"), spaceExample);
AddOption (indentOptions, category, "IndentBreakStatements", GettextCatalog.GetString ("Indent 'break' statements"), spaceExample);
AddOption (indentOptions, category, "AlignEmbeddedIfStatements", GettextCatalog.GetString ("Align embedded 'if' statements"), "class AClass { void AMethod () { if (a) if (b) { int c; } } } ");
AddOption (indentOptions, category, "AlignEmbeddedUsingStatements", GettextCatalog.GetString ("Align embedded 'using' statements"), "class AClass { void AMethod () {using (IDisposable a = null) using (IDisposable b = null) { int c; } } }");
treeviewIndentOptions.ExpandAll ();
#endregion
#region Brace options
bacePositionOptions = new Gtk.TreeStore (typeof (string), typeof (string), typeof (string), typeof(bool), typeof(bool));
column = new TreeViewColumn ();
// pixbuf column
column.PackStart (pixbufCellRenderer, false);
column.SetCellDataFunc (pixbufCellRenderer, RenderIcon);
// text column
cellRendererText = new CellRendererText ();
cellRendererText.Ypad = 1;
column.PackStart (cellRendererText, true);
column.SetAttributes (cellRendererText, "text", 1);
treeviewBracePositions.Model = bacePositionOptions;
treeviewBracePositions.HeadersVisible = false;
treeviewBracePositions.Selection.Changed += TreeSelectionChanged;
treeviewBracePositions.AppendColumn (column);
column = new TreeViewColumn ();
cellRendererCombo = new CellRendererCombo ();
cellRendererCombo.Ypad = 1;
cellRendererCombo.Mode = CellRendererMode.Editable;
cellRendererCombo.TextColumn = 1;
cellRendererCombo.Model = comboBoxStore;
cellRendererCombo.HasEntry = false;
cellRendererCombo.Editable = !profile.IsBuiltIn;
cellRendererCombo.Edited += new ComboboxEditedHandler (this, bacePositionOptions).ComboboxEdited;
column.PackStart (cellRendererCombo, false);
column.SetAttributes (cellRendererCombo, "visible", comboVisibleColumn);
column.SetCellDataFunc (cellRendererCombo, ComboboxDataFunc);
cellRendererToggle = new CellRendererToggle ();
cellRendererToggle.Activatable = !profile.IsBuiltIn;
cellRendererToggle.Ypad = 1;
cellRendererToggle.Toggled += new CellRendererToggledHandler (this, treeviewBracePositions, bacePositionOptions).Toggled;
column.PackStart (cellRendererToggle, false);
column.SetAttributes (cellRendererToggle, "visible", toggleVisibleColumn);
column.SetCellDataFunc (cellRendererToggle, ToggleDataFunc);
treeviewBracePositions.AppendColumn (column);
AddOption (bacePositionOptions, "NamespaceBraceStyle", GettextCatalog.GetString ("Namespace declaration"), "namespace TestNameSpace {}");
AddOption (bacePositionOptions, "ClassBraceStyle", GettextCatalog.GetString ("Class declaration"), "class ClassDeclaration {}");
AddOption (bacePositionOptions, "InterfaceBraceStyle", GettextCatalog.GetString ("Interface declaration"), "interface InterfaceDeclaraction {}");
AddOption (bacePositionOptions, "StructBraceStyle", GettextCatalog.GetString ("Struct declaration"), "struct StructDeclaration {}");
AddOption (bacePositionOptions, "EnumBraceStyle", GettextCatalog.GetString ("Enum declaration"), "enum EnumDeclaration { A, B, C}");
AddOption (bacePositionOptions, "MethodBraceStyle", GettextCatalog.GetString ("Method declaration"), "class ClassDeclaration { void MyMethod () {} }");
AddOption (bacePositionOptions, "AnonymousMethodBraceStyle", GettextCatalog.GetString ("Anonymous methods"), "class ClassDeclaration { void MyMethod () { MyEvent += delegate (object sender, EventArgs e) { if (true) Console.WriteLine (\"Hello World\"); }; } }");
AddOption (bacePositionOptions, "ConstructorBraceStyle", GettextCatalog.GetString ("Constructor declaration"), "class ClassDeclaration { public ClassDeclaration () {} }");
AddOption (bacePositionOptions, "DestructorBraceStyle", GettextCatalog.GetString ("Destructor declaration"), "class ClassDeclaration { ~ClassDeclaration () {} }");
AddOption (bacePositionOptions, "StatementBraceStyle", GettextCatalog.GetString ("Statements"), spaceExample);
category = AddOption (bacePositionOptions, "PropertyBraceStyle", GettextCatalog.GetString ("Property declaration"), propertyExample);
AddOption (bacePositionOptions, category, "PropertyGetBraceStyle", GettextCatalog.GetString ("Get declaration"), propertyExample);
AddOption (bacePositionOptions, category, "AllowPropertyGetBlockInline", GettextCatalog.GetString ("Allow one line get"), propertyExample);
AddOption (bacePositionOptions, category, "PropertySetBraceStyle", GettextCatalog.GetString ("Set declaration"), propertyExample);
AddOption (bacePositionOptions, category, "AllowPropertySetBlockInline", GettextCatalog.GetString ("Allow one line set"), propertyExample);
category = AddOption (bacePositionOptions, "EventBraceStyle", GettextCatalog.GetString ("Event declaration"), eventExample);
AddOption (bacePositionOptions, category, "EventAddBraceStyle", GettextCatalog.GetString ("Add declaration"), eventExample);
AddOption (bacePositionOptions, category, "AllowEventAddBlockInline", GettextCatalog.GetString ("Allow one line add"), eventExample);
AddOption (bacePositionOptions, category, "EventRemoveBraceStyle", GettextCatalog.GetString ("Remove declaration"), eventExample);
AddOption (bacePositionOptions, category, "AllowEventRemoveBlockInline", GettextCatalog.GetString ("Allow one line remove"), eventExample);
category = AddOption (bacePositionOptions, null, GettextCatalog.GetString ("Brace forcement"), null);
AddOption (bacePositionOptions, category, "IfElseBraceForcement", GettextCatalog.GetString ("'if...else' statement"), @"class ClassDeclaration {
public void Test ()
{
if (true) {
Console.WriteLine (""Hello World!"");
}
if (true)
Console.WriteLine (""Hello World!"");
}
}");
AddOption (bacePositionOptions, category, "ForBraceForcement", GettextCatalog.GetString ("'for' statement"), @"class ClassDeclaration {
public void Test ()
{
for (int i = 0; i < 10; i++) {
Console.WriteLine (""Hello World "" + i);
}
for (int i = 0; i < 10; i++)
Console.WriteLine (""Hello World "" + i);
}
}");
AddOption (bacePositionOptions, category, "WhileBraceForcement", GettextCatalog.GetString ("'while' statement"), @"class ClassDeclaration {
public void Test ()
{
int i = 0;
while (i++ < 10) {
Console.WriteLine (""Hello World "" + i);
}
while (i++ < 20)
Console.WriteLine (""Hello World "" + i);
}
}");
AddOption (bacePositionOptions, category, "UsingBraceForcement", GettextCatalog.GetString ("'using' statement"), simpleUsingStatement);
AddOption (bacePositionOptions, category, "FixedBraceForcement", GettextCatalog.GetString ("'fixed' statement"), simpleFixedStatement);
treeviewBracePositions.ExpandAll ();
#endregion
#region New line options
newLineOptions = new Gtk.TreeStore (typeof (string), typeof (string), typeof (string), typeof(bool), typeof(bool));
column = new TreeViewColumn ();
// pixbuf column
column.PackStart (pixbufCellRenderer, false);
column.SetCellDataFunc (pixbufCellRenderer, RenderIcon);
// text column
cellRendererText.Ypad = 1;
column.PackStart (cellRendererText, true);
column.SetAttributes (cellRendererText, "text", 1);
treeviewNewLines.Model = newLineOptions;
treeviewNewLines.HeadersVisible = false;
treeviewNewLines.Selection.Changed += TreeSelectionChanged;
treeviewNewLines.AppendColumn (column);
column = new TreeViewColumn ();
cellRendererCombo = new CellRendererCombo ();
cellRendererCombo.Ypad = 1;
cellRendererCombo.Mode = CellRendererMode.Editable;
cellRendererCombo.TextColumn = 1;
cellRendererCombo.Model = comboBoxStore;
cellRendererCombo.HasEntry = false;
cellRendererCombo.Editable = !profile.IsBuiltIn;
cellRendererCombo.Edited += new ComboboxEditedHandler (this, newLineOptions).ComboboxEdited;
column.PackStart (cellRendererCombo, false);
column.SetAttributes (cellRendererCombo, "visible", comboVisibleColumn);
column.SetCellDataFunc (cellRendererCombo, ComboboxDataFunc);
cellRendererToggle = new CellRendererToggle ();
cellRendererToggle.Activatable = !profile.IsBuiltIn;
cellRendererToggle.Ypad = 1;
cellRendererToggle.Toggled += new CellRendererToggledHandler (this, treeviewNewLines, newLineOptions).Toggled;
column.PackStart (cellRendererToggle, false);
column.SetAttributes (cellRendererToggle, "visible", toggleVisibleColumn);
column.SetCellDataFunc (cellRendererToggle, ToggleDataFunc);
treeviewNewLines.AppendColumn (column);
AddOption (newLineOptions, "PlaceElseOnNewLine", GettextCatalog.GetString ("Place 'else' on new line"), simpleIf);
AddOption (newLineOptions, "PlaceElseIfOnNewLine", GettextCatalog.GetString ("Place 'else if' on new line"), simpleIf);
AddOption (newLineOptions, "PlaceCatchOnNewLine", GettextCatalog.GetString ("Place 'catch' on new line"), simpleCatch);
AddOption (newLineOptions, "PlaceFinallyOnNewLine", GettextCatalog.GetString ("Place 'finally' on new line"), simpleCatch);
AddOption (newLineOptions, "PlaceWhileOnNewLine", GettextCatalog.GetString ("Place 'while' on new line"), simpleDoWhile);
AddOption (newLineOptions, "PlaceArrayInitializersOnNewLine", GettextCatalog.GetString ("Place array initializers on new line"), simpleArrayInitializer);
treeviewNewLines.ExpandAll ();
#endregion
#region White space options
whiteSpaceOptions = new Gtk.TreeStore (typeof (string), typeof (string), typeof (string), typeof(bool), typeof(bool));
column = new TreeViewColumn ();
// pixbuf column
column.PackStart (pixbufCellRenderer, false);
column.SetCellDataFunc (pixbufCellRenderer, RenderIcon);
// text column
cellRendererText.Ypad = 1;
column.PackStart (cellRendererText, true);
column.SetAttributes (cellRendererText, "text", 1);
treeviewInsertWhiteSpaceCategory.Model = whiteSpaceOptions;
treeviewInsertWhiteSpaceCategory.HeadersVisible = false;
treeviewInsertWhiteSpaceCategory.Selection.Changed += TreeSelectionChanged;
treeviewInsertWhiteSpaceCategory.AppendColumn (column);
column = new TreeViewColumn ();
cellRendererCombo = new CellRendererCombo ();
cellRendererCombo.Ypad = 1;
cellRendererCombo.Mode = CellRendererMode.Editable;
cellRendererCombo.TextColumn = 1;
cellRendererCombo.Model = comboBoxStore;
cellRendererCombo.HasEntry = false;
cellRendererCombo.Editable = !profile.IsBuiltIn;
cellRendererCombo.Edited += new ComboboxEditedHandler (this, whiteSpaceOptions).ComboboxEdited;
column.PackStart (cellRendererCombo, false);
column.SetAttributes (cellRendererCombo, "visible", comboVisibleColumn);
column.SetCellDataFunc (cellRendererCombo, ComboboxDataFunc);
cellRendererToggle = new CellRendererToggle ();
cellRendererToggle.Activatable = !profile.IsBuiltIn;
cellRendererToggle.Ypad = 1;
cellRendererToggle.Toggled += new CellRendererToggledHandler (this, treeviewInsertWhiteSpaceCategory, whiteSpaceOptions).Toggled;
column.PackStart (cellRendererToggle, false);
column.SetAttributes (cellRendererToggle, "visible", toggleVisibleColumn);
column.SetCellDataFunc (cellRendererToggle, ToggleDataFunc);
treeviewInsertWhiteSpaceCategory.AppendColumn (column);
string example = @"class Example {
void Test ()
{
}
void Test (int a, int b, int c)
{
}
}";
category = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Declarations"), example);
AddOption (whiteSpaceOptions, category, "BeforeMethodDeclarationParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinMethodDeclarationParentheses", GettextCatalog.GetString ("within parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BetweenEmptyMethodDeclarationParentheses", GettextCatalog.GetString ("between empty parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BeforeMethodDeclarationParameterComma", GettextCatalog.GetString ("before comma in parenthesis"), example);
AddOption (whiteSpaceOptions, category, "AfterMethodDeclarationParameterComma", GettextCatalog.GetString ("after comma in parenthesis"), example);
example = @"class Example {
int a, b, c;
}";
category = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Fields"), example);
AddOption (whiteSpaceOptions, category, "BeforeFieldDeclarationComma", GettextCatalog.GetString ("before comma in multiple field declarations"), example);
AddOption (whiteSpaceOptions, category, "AfterFieldDeclarationComma", GettextCatalog.GetString ("after comma in multiple field declarations"), example);
example = @"class Example {
Example ()
{
}
Example (int a, int b, int c)
{
}
}";
category = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Constructors"), example);
AddOption (whiteSpaceOptions, category, "BeforeConstructorDeclarationParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinConstructorDeclarationParentheses", GettextCatalog.GetString ("within parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BetweenEmptyConstructorDeclarationParentheses", GettextCatalog.GetString ("between empty parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BeforeConstructorDeclarationParameterComma", GettextCatalog.GetString ("before comma in parenthesis"), example);
AddOption (whiteSpaceOptions, category, "AfterConstructorDeclarationParameterComma", GettextCatalog.GetString ("after comma in parenthesis"), example);
example = @"class Example {
public int this[int a, int b] {
get {
return a + b;
}
}
}";
category = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Indexer"), example);
AddOption (whiteSpaceOptions, category, "BeforeIndexerDeclarationBracket", GettextCatalog.GetString ("before opening bracket"), example);
AddOption (whiteSpaceOptions, category, "WithinIndexerDeclarationBracket", GettextCatalog.GetString ("within brackets"), example);
AddOption (whiteSpaceOptions, category, "BeforeIndexerDeclarationParameterComma", GettextCatalog.GetString ("before comma in brackets"), example);
AddOption (whiteSpaceOptions, category, "AfterIndexerDeclarationParameterComma", GettextCatalog.GetString ("after comma in brackets"), example);
example = @"delegate void FooBar (int a, int b, int c);
delegate void BarFoo ();
";
category = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Delegates"), example);
AddOption (whiteSpaceOptions, category, "BeforeDelegateDeclarationParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinDelegateDeclarationParentheses", GettextCatalog.GetString ("within parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BetweenEmptyDelegateDeclarationParentheses", GettextCatalog.GetString ("between empty parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BeforeDelegateDeclarationParameterComma", GettextCatalog.GetString ("before comma in parenthesis"), example);
AddOption (whiteSpaceOptions, category, "AfterDelegateDeclarationParameterComma", GettextCatalog.GetString ("after comma in parenthesis"), example);
var upperCategory = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Statements"), null);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'if'"), simpleIf);
AddOption (whiteSpaceOptions, category, "IfParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleIf);
AddOption (whiteSpaceOptions, category, "WithinIfParentheses", GettextCatalog.GetString ("within parenthesis"), simpleIf);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'while'"), simpleWhile);
AddOption (whiteSpaceOptions, category, "WhileParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleWhile);
AddOption (whiteSpaceOptions, category, "WithinWhileParentheses", GettextCatalog.GetString ("within parenthesis"), simpleWhile);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'for'"), simpleFor);
AddOption (whiteSpaceOptions, category, "ForParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleFor);
AddOption (whiteSpaceOptions, category, "WithinForParentheses", GettextCatalog.GetString ("within parenthesis"), simpleFor);
AddOption (whiteSpaceOptions, category, "SpacesBeforeForSemicolon", GettextCatalog.GetString ("before semicolon"), simpleFor);
AddOption (whiteSpaceOptions, category, "SpacesAfterForSemicolon", GettextCatalog.GetString ("after semicolon"), simpleFor);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'foreach'"), simpleForeach);
AddOption (whiteSpaceOptions, category, "ForeachParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleForeach);
AddOption (whiteSpaceOptions, category, "WithinForEachParentheses", GettextCatalog.GetString ("within parenthesis"), simpleForeach);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'catch'"), simpleCatch);
AddOption (whiteSpaceOptions, category, "CatchParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleCatch);
AddOption (whiteSpaceOptions, category, "WithinCatchParentheses", GettextCatalog.GetString ("within parenthesis"), simpleCatch);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'switch'"), switchExample);
AddOption (whiteSpaceOptions, category, "SwitchParentheses", GettextCatalog.GetString ("before opening parenthesis"), switchExample);
AddOption (whiteSpaceOptions, category, "WithinSwitchParentheses", GettextCatalog.GetString ("within parenthesis"), switchExample);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'lock'"), simpleLock);
AddOption (whiteSpaceOptions, category, "LockParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleLock);
AddOption (whiteSpaceOptions, category, "WithinLockParentheses", GettextCatalog.GetString ("within parenthesis"), simpleLock);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'using'"), simpleUsingStatement);
AddOption (whiteSpaceOptions, category, "UsingParentheses", GettextCatalog.GetString ("before opening parenthesis"), simpleUsingStatement);
AddOption (whiteSpaceOptions, category, "WithinUsingParentheses", GettextCatalog.GetString ("within parenthesis"), simpleUsingStatement);
upperCategory = AddOption (whiteSpaceOptions, null, GettextCatalog.GetString ("Expressions"), null);
example = @"class Example {
void Test ()
{
Console.WriteLine();
Console.WriteLine(""{0} {1}!"", ""Hello"", ""World"");
}
}";
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Method invocations"), example);
AddOption (whiteSpaceOptions, category, "BeforeMethodCallParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinMethodCallParentheses", GettextCatalog.GetString ("within parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BetweenEmptyMethodCallParentheses", GettextCatalog.GetString ("between empty parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BeforeMethodCallParameterComma", GettextCatalog.GetString ("before comma in parenthesis"), example);
AddOption (whiteSpaceOptions, category, "AfterMethodCallParameterComma", GettextCatalog.GetString ("after comma in parenthesis"), example);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Object creation"), example);
example = @"partial class Example {
void Test ()
{
var anExample = new Example (1, 2, 3);
var emptyExample = new Example ();
}
}";
AddOption (whiteSpaceOptions, category, "NewParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinNewParentheses", GettextCatalog.GetString ("within parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BetweenEmptyNewParentheses", GettextCatalog.GetString ("between empty parenthesis"), example);
AddOption (whiteSpaceOptions, category, "BeforeNewParameterComma", GettextCatalog.GetString ("before comma in parenthesis"), example);
AddOption (whiteSpaceOptions, category, "AfterNewParameterComma", GettextCatalog.GetString ("after comma in parenthesis"), example);
example = @"class Example {
void Test ()
{
a[1,2] = b[3];
}
}";
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Element access"), example);
AddOption (whiteSpaceOptions, category, "SpacesBeforeBrackets", GettextCatalog.GetString ("before opening bracket"), example);
AddOption (whiteSpaceOptions, category, "SpacesWithinBrackets", GettextCatalog.GetString ("within brackets"), example);
AddOption (whiteSpaceOptions, category, "BeforeBracketComma", GettextCatalog.GetString ("before comma in brackets"), example);
AddOption (whiteSpaceOptions, category, "AfterBracketComma", GettextCatalog.GetString ("after comma in brackets"), example);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Parentheses"), operatorExample);
AddOption (whiteSpaceOptions, category, "WithinParentheses", GettextCatalog.GetString ("within parenthesis"), operatorExample);
example = @"class ClassDeclaration {
public void Test (object o)
{
int i = (int)o;
}
}";
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Type cast"), example);
AddOption (whiteSpaceOptions, category, "WithinCastParentheses", GettextCatalog.GetString ("within parenthesis"), example);
AddOption (whiteSpaceOptions, category, "SpacesAfterTypecast", GettextCatalog.GetString ("after type cast"), example);
example = @"class ClassDeclaration {
public void Test ()
{
int i = sizeof (ClassDeclaration);
}
}";
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'sizeof'"), example);
AddOption (whiteSpaceOptions, category, "BeforeSizeOfParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinSizeOfParentheses", GettextCatalog.GetString ("within parenthesis"), example);
example = @"class ClassDeclaration {
public void Test ()
{
Type t = typeof (ClassDeclaration);
}
}";
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("'typeof'"), example);
AddOption (whiteSpaceOptions, category, "BeforeTypeOfParentheses", GettextCatalog.GetString ("before opening parenthesis"), example);
AddOption (whiteSpaceOptions, category, "WithinTypeOfParentheses", GettextCatalog.GetString ("within parenthesis"), example);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Around Operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundAssignmentParentheses", GettextCatalog.GetString ("Assignment (=, +=, -=, ...)"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundLogicalOperatorParentheses", GettextCatalog.GetString ("Logical (&&, ||) operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundEqualityOperatorParentheses", GettextCatalog.GetString ("Equality (==, !=) operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundRelationalOperatorParentheses", GettextCatalog.GetString ("Relational (<, >, <=, >=) operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundBitwiseOperatorParentheses", GettextCatalog.GetString ("Bitwise &, |, ^, ~() operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundAdditiveOperatorParentheses", GettextCatalog.GetString ("Additive (+, -) operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundMultiplicativeOperatorParentheses", GettextCatalog.GetString ("Multiplicative (*, /, %) operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundShiftOperatorParentheses", GettextCatalog.GetString ("Shift (<<, >>) operators"), operatorExample);
AddOption (whiteSpaceOptions, category, "AroundNullCoalescingOperator", GettextCatalog.GetString ("Null coalescing (??) operator"), operatorExample);
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Conditional Operator (?:)"), condOpExample);
AddOption (whiteSpaceOptions, category, "ConditionalOperatorBeforeConditionSpace", GettextCatalog.GetString ("before '?'"), condOpExample);
AddOption (whiteSpaceOptions, category, "ConditionalOperatorAfterConditionSpace", GettextCatalog.GetString ("after '?'"), condOpExample);
AddOption (whiteSpaceOptions, category, "ConditionalOperatorBeforeSeparatorSpace", GettextCatalog.GetString ("before ':'"), condOpExample);
AddOption (whiteSpaceOptions, category, "ConditionalOperatorAfterSeparatorSpace", GettextCatalog.GetString ("after ':'"), condOpExample);
example = @"class ClassDeclaration {
string[][] field;
int[] test;
}";
category = AddOption (whiteSpaceOptions, upperCategory, null, GettextCatalog.GetString ("Array Declarations"), example);
AddOption (whiteSpaceOptions, category, "SpacesBeforeArrayDeclarationBrackets", GettextCatalog.GetString ("before opening bracket"), example);
/*
whiteSpaceOptions= new ListStore (typeof (Option), typeof (bool), typeof (bool));
column = new TreeViewColumn ();
// text column
column.PackStart (cellRendererText, true);
column.SetCellDataFunc (cellRendererText, delegate (TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter) {
((CellRendererText)cell).Text = ((Option)model.GetValue (iter, 0)).DisplayName;
});
treeviewInsertWhiteSpaceOptions.AppendColumn (column);
column = new TreeViewColumn ();
cellRendererCombo = new CellRendererCombo ();
cellRendererCombo.Ypad = 1;
cellRendererCombo.Mode = CellRendererMode.Editable;
cellRendererCombo.TextColumn = 1;
cellRendererCombo.Model = comboBoxStore;
cellRendererCombo.HasEntry = false;
cellRendererCombo.Editable = !profile.IsBuiltIn;
cellRendererCombo.Edited += delegate(object o, EditedArgs args) {
TreeIter iter;
var model = whiteSpaceOptions;
if (model.GetIterFromString (out iter, args.Path)) {
var option = (Option)model.GetValue (iter, 0);
PropertyInfo info = GetPropertyByName (option.PropertyName);
if (info == null)
return;
var value = Enum.Parse (info.PropertyType, args.NewText);
info.SetValue (profile, value, null);
UpdateExample (texteditor.Document.Text);
}
};
column.PackStart (cellRendererCombo, false);
column.SetAttributes (cellRendererCombo, "visible", 2);
column.SetCellDataFunc (cellRendererCombo, delegate (TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter) {
((CellRendererCombo)cell).Text = GetValue (((Option)model.GetValue (iter, 0)).PropertyName).ToString ();
});
cellRendererToggle = new CellRendererToggle ();
cellRendererToggle.Activatable = !profile.IsBuiltIn;
cellRendererToggle.Ypad = 1;
cellRendererToggle.Toggled += delegate(object o, ToggledArgs args) {
TreeIter iter;
var model = whiteSpaceOptions;
if (model.GetIterFromString (out iter, args.Path)) {
var option = (Option)model.GetValue (iter, 0);
PropertyInfo info = GetPropertyByName (option.PropertyName);
if (info == null || info.PropertyType != typeof(bool))
return;
bool value = (bool)info.GetValue (this.profile, null);
info.SetValue (profile, !value, null);
UpdateExample (texteditor.Document.Text);
}
};
column.PackStart (cellRendererToggle, false);
column.SetAttributes (cellRendererToggle, "visible", 1);
column.SetCellDataFunc (cellRendererToggle, delegate (TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter) {
((CellRendererToggle)cell).Active = (bool)GetValue (((Option)model.GetValue (iter, 0)).PropertyName);
});
treeviewInsertWhiteSpaceOptions.AppendColumn (column);
treeviewInsertWhiteSpaceOptions.Model = whiteSpaceOptions;*/
treeviewInsertWhiteSpaceCategory.ExpandAll ();
#endregion
#region Blank line options
entryBeforUsings.Text = profile.BlankLinesBeforeUsings.ToString ();
entryAfterUsings.Text = profile.BlankLinesAfterUsings.ToString ();
entryBeforeFirstDeclaration.Text = profile.BlankLinesBeforeFirstDeclaration.ToString ();
entryBetweenTypes.Text = profile.BlankLinesBetweenTypes.ToString ();
entryBetweenFields.Text = profile.BlankLinesBetweenFields.ToString ();
entryBetweenEvents.Text = profile.BlankLinesBetweenEventFields.ToString ();
entryBetweenMembers.Text = profile.BlankLinesBetweenMembers.ToString ();
entryBeforUsings.Changed += HandleEntryBeforUsingsChanged;
entryAfterUsings.Changed += HandleEntryBeforUsingsChanged;
entryBeforeFirstDeclaration.Changed += HandleEntryBeforUsingsChanged;
entryBetweenTypes.Changed += HandleEntryBeforUsingsChanged;
entryBetweenFields.Changed += HandleEntryBeforUsingsChanged;
entryBetweenEvents.Changed += HandleEntryBeforUsingsChanged;
entryBetweenMembers.Changed += HandleEntryBeforUsingsChanged;
#endregion
}
public void TestWithinCheckedExpressionParanthesesSpace ()
{
CSharpFormattingPolicy policy = new CSharpFormattingPolicy ();
policy.SpacesWithinCheckedExpressionParantheses = true;
var result = GetResult (policy, @"class Test {
void TestMe ()
{
a = checked(a + b);
}
}");
int i1 = result.Text.LastIndexOf ("(");
int i2 = result.Text.LastIndexOf (")") + ")".Length;
Assert.AreEqual (@"( a + b )", result.GetTextAt (i1, i2 - i1));
result = GetResult (policy, @"class Test {
void TestMe ()
{
a = unchecked(a + b);
}
}");
result = GetResult (policy, result.Text);
i1 = result.Text.LastIndexOf ("(");
i2 = result.Text.LastIndexOf (")") + ")".Length;
Assert.AreEqual (@"( a + b )", result.GetTextAt (i1, i2 - i1));
}
