This button sets all coding style configuration settings to the default value.

This field defines the brace style for all generated code. Available options are:

• K&R
• Allman
• IMT (Modified K&R)

KR Brace Style

In KR Brace style, all opening braces are placed on the same line.
Keywords after braces are placed on the same line.

Allman Brace Style

In Allman Brace style, all opening braces are placed on a new line.
Keywords after braces are placed on a new line.

IMT Brace Style

In IMT Brace style, all opening braces are placed on the same line.
Keywords after braces are placed on a new line.

Indent with tabs

Example with 2 tabs per indent:

Indent with spaces

Example with 4 spaces per indent:

The line endings can be configured to use windows or unit style line endings. Generated code files will always end with a newline to avoid issues with command line based tools.

Windows Line Endings

For Windows line endings, an CR followed by an LF character is used:

Unix Line Endings

For Unix line endings, an LF character is used:

Namespace Content Indent

Indents namespace contents by the given number of levels in relation to the parent block.

Example for C++ with indent of 2 spaces:

// level 0
namespace dataflow{
int a;
}

// level 1
namespace dataflow{
  int a;
}

// level 2
namespace dataflow{
    int a;
}

Class Content Indent

Indents class contents by the given number of levels in relation to the parent block.

Example for C++ with indent of 2 spaces:

// level 0
class A{
public:
A();
};

// level 1
class A{
public:
  A();
};

// level 2
class A{
public:
    A();
};

Other Block Indent

Indents blocks contents that are neither a class or namspace (e.g. function, if, else, ...) by the given number of levels in relation to the parent block.

Example for C++ with indent of 2 spaces:

// level 0
void a(int b){
if (b == 0) {
c();
}
else {
d();
}
}

// level 1
void a(int b){
  if (b == 0) {
    c();
  }
  else {
    d();
  }
}

// level 2
void a(int b){
    if (b == 0) {
        c();
    }
    else {
        d();
    }
}

Brace Indent

Indents braces by the given number of levels in relation to the parent block.

Example with indent of 2 spaces and allman style:

// level 0
void a(int b)
{
if (b == 0)
{
c();
}
}

// level 1
void a(int b)
  {
if (b == 0)
  {
c();
  }
  }

// level 2
void a(int b)
    {
if (b == 0)
    {
c();
    }
    }

Access Specifier Indent

Indents c++ access specifiers in classes by the given number of levels in relation to the class contents.

Example with indent of 2 spaces:

// level 0
class A{
public:
A();
};

// level 1
class A{
  public:
A();
};

// level 2
class A{
    public:
A();
};

Case Label Indent

Indents case labels in switch case blocks by the given number of levels in relation to the switch contents.

Example with indent of 2 spaces:

// level 0
switch(a){
case 1:
break;
default:
break;
}

// level 1
switch(a){
  case 1:
break;
  default:
break;
}

// level 2
switch(a){
    case 1:
break;
    default:
break;
}

Case Content Indent

Indents case contents in switch case blocks by the given number of levels in relation to the switch contents.

Example with indent of 2 spaces:

// level 0
switch(a){
case 1:
break;
default:
break;
}

// level 1
switch(a){
case 1:
  break;
default:
  break;
}

// level 2
switch(a){
case 1:
    break;
default:
    break;
}

Defines the padding for the given code symbol. Padding adds spaces before and/or after the symbol. For lists, adding a space before, in between and after arguments can also be enabled.

The code generator will merge multiple spaces into one, e.g. when there is a space after an open parentheses and one before the first argument.

Brace Padding

Adds spaces before and after braces:

if(a){c();};      // no brace padding
if(a) {c();};     // brace padding before open
if(a){ c();};     // brace padding after open
if(a){c(); };     // brace padding before close
if(a) { c(); };   // all brace padding together

Before argument and after argument have no effect. C++ Initializers use the specific style below and ignore this style.

Bracket Padding

Add spaces before and after brackets:

int a[2];     // no bracket padding
int a [2];    // bracket padding before open
int a[ 2];    // bracket padding after open
int a[2 ];    // bracket padding before close
int a [ 2 ];  // all bracket padding together

When a bracket contains coma seperated arguments, spaces are added before and after the coma:

int a[2,3,4];         // no bracket padding
int a[2 ,3 ,4];       // bracket padding before coma
int a[2, 3, 4];       // bracket padding after coma
int a[2 , 3 , 4];     // bracket padding before and after coma
int a [ 2 , 3 , 4 ];  // all bracket padding together

Parenthese Padding

Add spaces before and after parentheses:

void a(int a){        // no parenthese padding
void a (int a){       // parenthese padding before open
void a( int a){       // parenthese padding after open
void a(int a ){       // parenthese padding before close
void a(int a) {       // parenthese padding after close
void a ( int a ) {    // all parenthese padding together

When a parenthese contains coma seperated arguments, spaces are added before and after the coma:

void a(int a,bool b,float c){          // no parenthese padding
void a(int a ,bool b ,float c){        // parenthese padding before coma
void a(int a, bool b, float c){        // parenthese padding after coma
void a(int a , bool b , float c){      // parenthese padding before and after coma
void a ( int a , bool b , float c ) {  // all parenthese padding together

Initializer Padding

Add spaces before and after braces in C++ initializer:

int a={1};     // no initializer padding
int a= {1};    // initializer padding before open
int a={ 1};    // initializer padding after open
int a={1 };    // initializer padding before close
int a={1};     // initializer padding after close (ignored because of semicolon)
int a= { 1 };  // all initializer padding together

When a parentheses contains coma separated argument, spaces are added before and after the coma:

int a[]={1,2,3};         // no initializer padding
int a[]={1 ,2 ,3};       // initializer padding before coma
int a[]={1, 2, 3};       // initializer padding after coma
int a[]={1 , 2 , 3};     // initializer padding before and after coma
int a[]= { 1 , 2 , 3 };  // all initializer padding together

Operator Padding

Add spaces before and after operators:

 int a=b+c;      // no operator padding
 int a =b +c;    // operator padding before
 int a= b+ c;    // all operator padding after
 int a = b + c;  // all operator padding

Keyword Padding

Add spaces before and after keywords:

 }else if(a){    // no keyword padding
 } else if(a){   // keyword padding before
 }else if (a){   // keyword padding after
 } else if (a){  // all keyword padding