You can easily tweak the way Regionerate spaces your code.

Padding the First and Last Child

You can set the amount of new lines that will be added before the first child and after the last child of every region by setting the PadFirstChild and PadLastChild attributes on the CreateRegion element.

For example, this Code Layout snippet will place 2 new lines between the region's declaration and its members:

<CreateRegion Title="Fields" PadFirstChild="2" PadLastChild="2">

     <PutFields/>

</CreateRegion>

Running this Code Layout on this piece of code:

   1:  class MyClass

   2:  {

   3:        private string _myField;

   4:  }

... will result in this:

   1:  public class MyClass

   2:  {

   3:       #region Fields (1) 

   4:   

   5:   

   6:       private int _myField;

   7:   

   8:   

   9:       #endregion Fields 

  10:  }

The default value for PadFirstChild and PadLastChild is 1, meaning that if you don't specify any other value, the items will be padded with a single line.

Separating Consecutive Children

You can also control the amount of new lines between two consecutive children. This can be done at the ForEach level and at the Put level by using the SeparatingLines attribute.

For example, this Code Layout snippet will put 2 separating lines between every two consecutive regions inside an interface:

<ForEach Type="Interface" SeparatingLines="2">

     <CreateRegion Title="Properties">...</CreateRegion>

     <CreateRegion Title="Events">...</CreateRegion>

     <CreateRegion Title="Methods">...</CreateRegion>

</ForEach>

Labels: Code Layout, Code Layout Tricks, Documentation

Here's a short screencast I created that demonstrates how I use free productivity enhancers such as GhostDoc (by Roland Weigelt), Regionerate and Visual Studio's built-in refactoring tools to quickly create and maintain skeleton code. It also demonstrates the usage of Regionerate's new Code Layout Browser.

I know there are some commercial tools that do more, but I'm just presenting a free (partial-)alternative. Make sure your speakers are turned on.

Can you think of other types of Code Layout? Comment here.
To prepare this screencast, I used CamStudio and Roy Osherove's KeyJedi.

Labels: Code Layout, Code Layout Tricks, Documentation

If  you have a custom Code Layout and you want to make it accessible through the Code Layout Browser, all you need to do is place it in the "My Code Layouts" folder under your installation folder. (Typically "C:\Program Files\Regionerate\My Code Layouts")

The file must have an .xml extension. The label inside the Code Layout Browser will be the same as the file name just without the extension. ("My Custom Code Layout.xml" will be shown as "My Custom Code Layout")

If you want to have a custom image assigned to it, just place a 128x128 png file in the same directory with the same name. For example, if you want to have a custom image for "My Custom Code Layout.xml", just name your image "My Custom Code Layout.png". If you don't place a custom image, the default image will be used.

Remember: if you have a custom Code Layout and want to use it as your primary Code Layout (the primary Code Layout is the one that will be accessible when hitting the keyboard shortcut without holding it down), use the settings dialog to select it.

Labels: Code Layout, Code Layout Tricks, Documentation

The Configuration element in your Code Layout document can be used to configure certain settings that define Regionerate's behavior. These settings are shared between all layouts inside the Code Layout document.

• The Symbol element can be used to determine which symbol is embedded in your regions. (What Are Symbols?)
• Use the Unpack element to open certain existing regions. (Read more about unpacking)
• Rendering options:
  • ShowCount - Determines if Regionerated regions will automatically and recursively count their children.
  • Tabs - The amount of tab characters Regionerated regions declarations have.

Labels: Code Layout, Documentation

The term "Unpacking" refers to a pre-processing stage that occurs before your code is analyzed and constructed. When Regionerate unpacks your code, it strips up all members from regions which are managed by it ("Regionerated regions"). After the code is shaped according to the Code Layout, these members are packed back into their regions.

While Regionerate automatically handles Regionerated regions, it allows  you to specify which additional regions should be unpacked.

For example, you might have some regions that were generated by the IDE or a 3rd party tool for default interface implementations, such as:

   1:      public class Foo : IList<string>

   2:      {

   3:          #region IList<string> Members

   4:   

   5:          ...

   6:   

   7:          #endregion

   8:   

   9:          #region ICollection<string> Members

  10:   

  11:          ...

  12:   

  13:          #endregion

  14:      }

<Configuration>

    ...

    <Unpack>

        <Regions ThatMatch="I.*\sMembers" />

    </Unpack>

</Configuration>

   1:      public class Foo : IList<string>

   2:      {

   3:   

   4:          #region Properties (3) 

   5:   

   6:          ...

   7:   

   8:          #endregion Properties 

   9:   

  10:          #region Methods (10) 

  11:   

  12:          ...

  13:   

  14:          #endregion Methods 

  15:   

  16:      }

Another possible use for unpacking is when migrating between symbols. If you used the Prefix symbol (the only option in versions prior to v0.6.6.5) long enough you have a code base filled with regions that look like:

#region [rgn] Fields (3)

If you change the symbol (lets say, from a Prefix to a Hidden Dragon), Regionerate will unpack and pack only regions the have the Hidden Dragon embedded in them, meaning that all "[rgn]" regions will stay untouched.

To migrate to the new symbol, you should tell Regionerate to unpack "[rgn]" regions:

   1:  <Configuration>

   2:      <Symbol>

   3:          <HiddenDragon />

   4:      </Symbol>

   5:      <Unpack>

   6:          <Regions ThatMatch="\[rgn\]" />

   7:      </Unpack>

   8:  </Configuration>

This way, the first time a code file is Regionerated with the new settings, Regionerate first unpacks all the old "[rgn]" regions and then it merges all the members into new Hidden Dragon symbolized regions.

Labels: Code Layout, Documentation

By using symbols Regionerate knows which regions are self-managed ("Regionerated regions") and which regions should be kept untouched ("exisiting regions") .

Up until v0.6.6.5, symbols were visible as prefixes before the name of the region, for example:

#region [rgn] Fields (5)

Now you can choose between 3 different types of symbols:

1. Hidden Dragon - (default) The Hidden Dragon is a special character (#255) which is not considered whitespace, yet not visible. If you use the Hidden Dragon, the symbol will be transparently embedded in your region declarations and will look like this:

#region Fields (5)

I would recommend you keep using the Hidden Dragon unless you stumble upon any trouble with it or if you want to be able to visually identify Regionerated regions.

2. Prefix - Allows you to add a prefix to Regionerated region headers, for example:

#region [rgn] Fields (5)

3. Wrapper - Allows you to add a prefix and a suffix to Regionerated region headers, for example:

#region [Fields (5)]

The symbol can be declared in your Code Layout document under the Configuration element.

<Configuration>

    <Symbol>

        <HiddenDragon />

    </Symbol>

    ...

</Configuration>

Labels: Code Layout, Documentation

• The Visible region style is the default style which will wrap your selection with #region-#endregion, for example:

• The Comment region style is a simpler style which will display a comment at the beginning of the selection, for example:

// Private Fields (3)

private string a;
private string b;
private string c;

This region style is very useful for regions inside regions which typically have a small amount of elements. For example:

• The Invisible region style will display only the selected items without any header or footer, for example:

private string a;
private string b;
private string c;

Labels: Code Layout, Code Layout Tricks, Documentation

Labels: Code Layout, Code Layout Tricks, Documentation

Here's a quick guide to get you started on writing your own Code Layout.
Code Layouts are simply XML files which follow the Code Layout Schema.

The Code Layout Schema (CodeLayoutSchema.xsd) can be found in your installation directory.
If you are using Visual Studio, the Code Layout Schema is copied during installation into your Visual Studio Schemas directory.

Here are the steps neccesary to start writing a custom Code Layout in Visual Studio:

1. Create a new XML file in Visual Studio (File->New->File->XML File->Open)
2. Type in "<CodeLayout xmlns="http://regionerate.net/schemas/0.6/CodeLayout.xsd">" (substitue 0.6 to the current version you are working with).

If you are using Visual Studio, the file should be linked to the Code Layout Schema immediatly, and you should be able to receive intellisense assistance.

If you are not using Visual Studio, or for some reason you are not getting intellisense assitance:

1. Open the Properties window for the XML file.
2. Choose "Schemas" and click on the button.
3. Click on "Add" and browse for the CodeLayoutSchema.xsd file under your installation directory. (typically C:\Program Files\Regionerate)
4. Click OK. The XML file is now validated by the Code Layout Schema.

The Code Layout Schema structure is pretty simple, I'm sure you'll manage from here.

Once you have your Code Layout all ready, you can easily load it into the Visual Studio add-in by following these steps:

1. Click on Tools->Regionerate Settings.
2. Under "Code Layout" check "Use Custom".
3. Hit the "Browse" button and browse for your custom Code Layout.
4. Click "Save".

Labels: Code Layout, Documentation

Labels: Documentation

Labels: Code Layout, Documentation

Regionerate 101 briefly demonstrates Regionerate's abilities.

You can download Code Layouts from the Gallery or you can easily create a Code Layout yourself. Code Layouts are XML files which follow the Code Layout schema. These files determine which regions you want to create, which types of members you want to place in them, the restrictions you want on these members, their order and more.

You can Regionerate a class by a single click from within your Visual Studio or you can Regionerate your entire code by integrating it to your build machine.

Regionerate is absolutely free, download it here.

Labels: Code Layout, Documentation

• Take a quick look at Regionerate's abilities on Visual Studio with the Regionerate 101 screencast.
• Learn how to get started with Code Layouts.
• Krzysztof Koźmic has also posted an excellent article that covers the basics of Code Layouts.
• Learn how to integrate Regionerate with NAnt and get Regionerate to run nightly!
  

Labels: Code Layout, Documentation

I'm currently working on documentation. It should be available in v0.8. Meanwhile, you can read the tutorials.

• Configuration
• Adding Custom Code Layouts to the Code Layout Browser

Labels: Code Layout, Documentation