Code::Blocks - User contributions [en]

FAQ

2008-03-28T15:26:37Z

Jgm: /* Compiling - version information question*/

[[Category:Code::Blocks Documentation]]
== General ==

==== Q: Is it possible to integrate the win32-help as in dev-cpp, to get help on the items under the caret? ====

'''A:''' Integration of the Win32 API helpfile should be a no-brainer. Someone could just write a really simple plugin and, upon invocation (through a shortcut possibly), look at the word under the cursor and invoke windows help... If you think you 're up to the task, I can help you with all the info you need. If not, I could write it myself but no promises on a release date ;)

==== Q: What licence is Code::Blocks released under? ====

'''A:''' GNU General Public License 3 ([http://www.gnu.org/licenses/gpl-3.0.html GPL])

== Compiling ==

==== Q: What compiler can I use with Code::Blocks? ====

'''A:''' Code::Blocks philosophy is to be able to use any compiler on earth! Well, almost.

As a matter of fact it largely depends on the used compiler plugin. The one provided with the default Code::Blocks installation, supports GNU GCC (MinGW/Cygwin), MS Visual C++ Free Toolkit 2003, Borland's C++ Compiler 5.5, DigitalMars Free Compiler., OpenWatcom and Small Device C Compiler (SDCC).

==== Q: I imported a MSVCToolkit project/workspace, but Code::Blocks insists on trying to use GCC. What's wrong? ====

'''A:''' A little documentation problem ^^;. The "default compiler" is usually GCC, so when you imported it with "the default compiler", you told it to use GCC. To fix this situation, go to "Project", "Build Options" and select VC++ Toolkit as your compiler.

Another possibility is to put the Microsoft compiler as the default one. To do this, choose '''''Settings - Compiler''''', choose the Microsoft compiler in the '''''Selected Compiler''''' section (top of dialog box) and press the '''''Set as default''''' button.

From now onwards, for all new projects the Microsoft compiler will be taken by default.

==== Q: My project should be compiled with a custom makefile. Is it possible with Code::Blocks? ====

'''A:''' Yes, you can. You need to change two different settings:

a) In "Compiler Settings", under the tab "Other", there's a setting called "Build Method". Choose "Work with makefiles".

b) In your project's Properties, you can choose to use a makefile. Check "This is a custom makefile" (WARNING! if you forget to check, the makefile will be OVERWRITTEN!)

And that's it! :)

==== Q: I have downloaded MS VC++ Toolkit 2003 for a compiler. How do I tell Code::Blocks that it is my compiler? ====

'''A:''' Click on "Project/Build options" and select the compiler you want for your project/target.

==== Q: When compiling a wxWidgets project, I get several "variable 'vtable for xxxx' can't be auto-imported". What's wrong? ====

'''A:''' You need to add WXUSINGDLL in "Project->Build options->Compiler #defines" and rebuild your project (or create a new project and use the "Using wxWidgets DLL" project option which adds "-DWXUSINGDLL" to Project->Build options->Other options).
Other errors with the same resolution are:
'unresolved external symbol "char const * const wxEmptyString" (?wxEmptyString@@3PBDB)' or similar.
If you were using 1.0-finalbeta and were trying to build a statically linked wxWidgets project, the cause of the problem was some faulty templates. But that's fixed now.

==== Q: I can't compile a multithreaded app with VC Toolkit! Where are the libraries? ====

'''A:''' Sorry, no fix for your problem...

Your problem doesn't come from CodeBlocks. It exists, because the free VC toolkit (VCTK) doesn't provide all the libraries and tools which are coming with Visual C++ (VC) which isn't free, unfortunately.

Try buying a full-fledged VC++, or even better, download [http://www.mingw.org/ MinGW]

The libraries that can be obtained free of charge are:

Paths:
(VCT3) Visual C++ Toolkit 2003 - C:\Program Files\Microsoft Visual C++ Toolkit 2003\lib
(PSDK) Platform SDK - C:\Program Files\Microsoft Platform SDK\Lib
(NSDK) .NET 1.1 SDK - C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\lib

C runtime libs:
LIBC.LIB Single-threaded, static link (VCT3, NSDK)
LIBCMT.LIB Multithreaded, static link (VCT3, NSDK)
MSVCRT.LIB Multithreaded, dynamic link (import library for MSVCR71.DLL) (NSDK)
LIBCD.LIB Single-threaded, static link (debug) (VCT3, NSDK)
LIBCMTD.LIB Multithreaded, static link (debug) (NSDK)
MSVCRTD.LIB Multithreaded, dynamic link (import library for MSVCR71D.DLL) (debug) (NSDK)

C++ libs:
LIBCP.LIB Single-threaded, static link (VCT3, PSDK)
LIBCPMT.LIB Multithreaded, static link (VCT3)
MSVCPRT.LIB Multithreaded, dynamic link (import library for MSVCP71.dll) (none)
LIBCPD.LIB Single-threaded, static link (debug) (VCT3)
LIBCPMTD.LIB Multithreaded, static link (debug) (none)
MSVCPRTD.LIB Multithreaded, dynamic link (import library for MSVCP71D.DLL) (debug) (none)

Try setting the library linker directories to:
C:\Program Files\Microsoft Visual C++ Toolkit 2003\lib
C:\Program Files\Microsoft Platform SDK\Lib
C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\lib
in that order.

The ones listed as (none) above are actually present in the IA64 and AMD64 subdirectories of the PSDK lib directory. Not sure if these would work on 32-bit windows, however, they may if they are
meant to work in 32-bit compatibility mode on the 64-bit processors. Worth a try. Otherwise, you
can link statically to the C++ library instead of using MSVCP71.dll. If you really want to link against MSVCP71.dll you can try to create MSVCP71.LIB from the dll using lib.exe and sed. Search google for "exports.sed" for detailed steps.

See also: [http://wiki.tcl.tk/2435 tclsh script to extract import .lib from (any?) DLL (MinGW)]

See also: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt_c_run.2d.time_libraries.asp

See also: http://sapdb.2scale.net/moin.cgi/MS_20C_2b_2b_20Toolkit

==== Q: Microsoft calls MSVCRT.DLL a "Known DLL." How do I know if I can/should use it ? ====

Microsoft does not clearly describe what [http://msdn2.microsoft.com/en-us/library/abx4dbyh.aspx 'Known DLL'] means. A [http://www.zlib.net/DLL_FAQ.txt zLib FAQ entry] makes it much more clear. The short answer is that MSVCRT.DLL is a protected system component and to preserve system integrity it cannot be updated by any end user product installers but may be updated from time to time by system updates. If it works use it. If it doesn't you'll need use a non protected library such as MSVCR70 or MSVCR80 which not only can be updated but private versions can be installed. A small and simple C program is likely to work just fine with MSVCRT.DLL. A large and complex C++ program is more likely to need the additional functionality of MSVCR.

The MSVCRT.LIB that ships with 32 bit compiler Visual C++ Toolkit 2003 dynamically links to MSVCR71.DLL which is not present in a freshly installed Windows XP system. MSVCR only appears after some software package that needs it such as [http://www.adobe.com/ Adobe Acrobat Reader] is installed. This means that programs that depend on MSVCR must redistribute it or risk not working on a substantial percentage of systems for reasons not obvious to either the affected end users or the program supplier.

For projects that can safely use MSVCRT and where it is impractical to redistribute MSVCR, a Win32 MSVCRT.LIB that links to MSVCRT.DLL is available in any [http://www.microsoft.com/whdc/devtools/ddk/default.mspx Device Driver Kit]. It is best to preserve the MSVCRT.LIB provided by the compiler and alter the name of the MSVCRT.LIB extracted from a DDK. List your newly named MSVCRTxx in the lib. If you use MSVCRT.LIB from the Windows 2003 DDK you may encounter the link '''error LNK2001: unresolved external symbol ___security_cookie'''. This can be solved by switching to the MSVCRT.LIB in the Windows XP DDK or by linking '''bufferoverflowU.lib''' found in the Windows SDK. A Win64 MSVCRT.LIB that links to MSVCRT.DLL is available in the Windows SDK or Platform [http://www.microsoft.com/downloads/details.aspx?FamilyId=E15438AC-60BE-41BD-AA14-7F1E0F19CA0D&displaylang=en PSDK].

To prevent problems it is recommended to include both /MD and /NODEFAULTLIB:MSVCRT switches so that problems come up at link time instead of random crashes at run time. Be sure to load your programs into [http://www.dependencywalker.com/ Dependancy Walker] to ensure that functions aren't being linked into both MSVCRxx.DLL and MSVCRT.DLL. It is essential that malloc, calloc, realloc, free, and related memory allocation functions all import from the same DLL.

Source: [http://wiki.tcl.tk/11431 TCL Wiki]

==== Q: How can I use a DLL without DEF or LIB files ? ====

'''A:''' I tried to find a solution, and the following script solved the problem for me. I used a cygwin environment for ''tclsh'' and ''sed'', but the MinGW tools for ''objdump'' and ''dlltool''. See here [http://wiki.tcl.tk/2435 tclsh script to extract import .lib from (any?) DLL (MinGW)]

TODO: Someone might add some informations about problems

Request: Is MinGW or Code::Blocks able to support automatic generation of import libraries ?

See also: http://www.mingw.org/mingwfaq.shtml#faq-msvcdll

See also: http://wyw.dcweb.cn/stdcall.htm

==== Q: Where are the libraries for the OpenGL, Ogre3D, SDL, QT, wxWidgets etc. projects? ====

'''A:''' They're not bundled. The templates were provided for your convenience, but you need to download the libraries on your own.
In common terms, "batteries not included" :)

==== Q: Is it possible to use Visual C++ 6.0 with Code::Blocks? ====

'''A:''' Yes. See [[Integrating Microsoft Visual C 6 with Code::Blocks IDE]] for a detailed description on using VC++ 6.0 with Code::Blocks.

==== Q: I get this error when compiling: Symbol "isascii" was not found in "codeblocks.dll" ====
'''A:''' Make sure you didn't mix up the MSVC headers or libs with the MinGW ones.

==== Q: I would like to compile a project using some non-standard libraries. How can I indicate to CodeBlocks that these libraries and include files exist? ====
'''A:''' You can specify them for your global environment or just for your project.

For global environment : 
- Menu Settings/Compiler and debugger 
- In the Global compiler settings, select the directories tab 
- Add the required paths for compiler and linker. 
 
For your project : 
- Right click on the project then select Build options 
- Select the directories tab 
- Add the required paths for compiler and linker. 
- Add your specific libraries in the linker tab. 
- Pay attention to project settings and target settings.
==== Q: How do I use both Debug and Release builds of wx libraries? ====
'''A:''' I would use the default method of doing it and the default folder naming.

Using these C::B custom varibles
WX_SUFFIX="" // ANSI Release
WX_SUFFIX="d" // ANSI Debug
WX_SUFFIX="u" // Unicode Release
WX_SUFFIX="ud" // Unicode debug

I use WX_CFG when I am using a special configuration
WX_CFG="rc3"

Remember, the CodeBlocks globel variable WX needs to point to the wxWidgets folder.

Example minGW build command for "Unicode debug" 2.8.0 RC3

mingw32-make -f makefile.gcc VENDOR=rc3 CFG=rc3 USE_XRC=1 SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1

"VENDOR=" just puts rc3 in the DLL name; "CFG=" sets which folder the DLL is placed in. In this case in lib\gcc_dllrc3

Before using CFG in the mingw32-make build you need to do one prior wxWidget build without using it; else the build errors out. (See note below.)

"__WXDEBUG__" must be defined (in the codeblocks project setting) if you wish to link against the debug version of wxWidgets DLL. Else you will get a runtime error, when you try to run your project output.

Contributed by Tim S

Note:
*I have never gotten the following command to work
mingw32-make -f makefile.gcc VENDOR=rc3 CFG=rc3 USE_XRC=1 SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1

*unless I have first run this command on the same wxWidgets folders
mingw32-make -f makefile.gcc USE_XRC=1 SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1

*I am guessing that the build without the CFG creates a file or directory needed by the build with the CFG.

==== Q: How do I troubleshoot an compiler problem? ====
'''A:''' I would start by turning on full Compiler logging.

This is done by selecting the "Full command line" option Under menu "Settings" -> "Compiler and Debugger" -> "Other Setting" tab, "Compiler logging".

==== Q: How do I add version information to windows executables and dll's? ====
'''A:''' You need to create a reosurce file with the extension .rc and write the version info there. Then add that file to the Code::Blocks project you are working on.

Sample content of a resource file that you can use and modify for your needs:
<pre>
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x3fL // VS_FFI_FILEFLAGSMASK
#ifdef _DEBUG
FILEFLAGS 0x1L // VS_FF_DEBUG|VS_FF_PRIVATEBUILD|VS_FF_PRERELEASE
#else
FILEFLAGS 0x0L // final version
#endif
FILEOS VOS_NT_WINDOWS32
FILETYPE VFT_APP
FILESUBTYPE VFT2_UNKNOWN // not used
{
BLOCK "StringFileInfo"
{
BLOCK "040904E4" // Lang=US English, CharSet=Windows Multilingual
{
VALUE "Build", "August 2007\0"
VALUE "Comments", "Free for personal use only.\0"
VALUE "CompanyName", "Fake Company\0"
VALUE "Developer", "The Developer\0"
VALUE "FileDescription", "Application implementing something\0"
VALUE "FileVersion", "1.0.000\0"
VALUE "InternalName", "AppInternalName\0"
VALUE "LegalCopyright", "Copyright (C) 2007 Fake Company\0"
VALUE "LegalTrademarks", "All rights reserved.\0"
VALUE "OriginalFilename", "TheEXE.exe\0"
VALUE "PrivateBuild", "\0"
VALUE "ProductName", "The EXE\0"
VALUE "ProductVersion", "1.0.000\0"
VALUE "SpecialBuild", "\0"
VALUE "Support", "TheEXE at fake-domain.com\0"
VALUE "Users", "Unlimited.\0"
} // BLOCK "040904E4"
} // BLOCK "StringFileInfo"
BLOCK "VarFileInfo"
{
VALUE "Translation", 0x409, 1252 // 1252 = 0x04E4
} // BLOCK "VarFileInfo"
}
</pre>

Also you can use the the [[AutoVersioning|Auto Versioning]] plugin to assist you on the generation of version information. For documentation of the syntax and values used on windows resource files, you can visit the following websites:
*http://msdn2.microsoft.com/en-us/library/aa380599.aspx
*http://www.cygwin.com/cygwin-ug-net/windres.html

== Settings ==

==== Q: How do I get Code Completion to work? ====
'''A:''' Did you check how code completion is configured ?
See "Settings/Editor", click on "Code-completion and symbols browser" in the left column and check the Code completion and C/C++ parser tabs.

From the 2006/11/30 nightly build, you can also add, in the project properties, directories to be searched when locating a file to parse .Right click on the project, click on Properties and select the C/C++ parser options.

They 're mostly useful when you don't add compiler search dirs in build options but use backticked expressions (e.g. `freetype-config --cflags`). In this case, the parser is not aware of where the source files are located. So, by manually adding the directory in the parser's search dirs you 're actually helping the parser find the files.

Of course, backticked expressions are not the only reason these parser search dirs are useful. As another example, I have a set of projects in a workspace. To minimize maintenance overhead, I 'm using build scripts to configure these projects. Now, although build scripts are an awesome feature, the C/C++ parser faces the same problem: it doesn't know where to search for files. The parser search directories come to the rescue again.

==== Q: How do I make Code::Blocks portable? ====
*run / configure C::B as usual

''Note:''
Code::Blocks will create a default.conf file that usually is placed into:
"C:\Documents and Settings\[your_user_name]\Application Data\codeblocks" (or %APPDATA%) on Windows or your usual home folder ("~/") under Linux.

*place this default.conf file into the directory where the codeblocks binary is
*remove the default.conf file from %APPDATA% / home folder respectively
*just run C::B from within the C::B path and/or via script / link...

''Note:'' Don't forget to remove all bad hacks you might have done previously that modify %USERPROFILE% and/or %APPDATA% on Windows.

''Note:'' If C::B does not find default.conf (it's config) within the %APPDATA% / home folder it looks within the C::B directory (the one where the C::B executable is) next. If there is no config file, too it will be created in the %APPDATA% / home folder. So just make sure you are doing the right thing and C::B is portable just fine.

BTW: This does probably ''not'' apply for any other config file(s) where not C::B is the maintainer but e.g. plugins. The main config file just works like that.

Linking the plugin to a Nightly Build

2008-01-19T01:26:22Z

Jgm: /* Conclusion */

[[Category:Plugin development]]
'''Work in Progress!!!''' 
This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

====Step One====
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

====Step Two====
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

====Step Three====
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly without the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one.

This was a quick howto so is maybe missing info, I will update it later as add some images. Good Luck!

Linking the plugin to a Nightly Build

2008-01-19T01:23:12Z

Jgm:

[[Category:Plugin development]]
'''Work in Progress!!!''' 
This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

====Step One====
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

====Step Two====
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

====Step Three====
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly without the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one. This was a quick howto so is maybe missing info, I will update it later. Good Luck!

Linking the plugin to a Nightly Build

2008-01-19T01:21:16Z

Jgm:

[[Category:Plugin development]]

This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

====Step One====
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

====Step Two====
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

====Step Three====
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly without the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one. This was a quick howto so is maybe missing info, I will update it later. Good Luck!

Linking the plugin to a Nightly Build

2008-01-19T01:18:31Z

Jgm: /* Procedure */

This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

====Step One====
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

====Step Two====
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

====Step Three====
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly without the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one. This was a quick howto so is maybe missing info, I will update it later. Good Luck!

Linking the plugin to a Nightly Build

2008-01-19T01:17:31Z

Jgm: /* Conclusion */

This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

==Step One==
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

==Step Two==
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

==Step Three==
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly without the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one. This was a quick howto so is maybe missing info, I will update it later. Good Luck!

Linking the plugin to a Nightly Build

2008-01-19T01:15:33Z

Jgm: /* Introduction */

This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

==Step One==
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

==Step Two==
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

==Step Three==
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly with out the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one. This was a quick howto so is maybe missing info, I will update it later. Good Luck!

Linking the plugin to a Nightly Build

2008-01-19T01:14:46Z

Jgm: Initial Creation

This article describes how to link your plugin against the dll's shipped with codeblocks on windows.

=Introduction=
Is useful to know how to compile Code::Blocks sources from scratch to link with our plugin, but when we want to share it with the community then we need to link it against the latest nightly build or final release of codeblocks. This is a simple procedure that many people doesn't know at first, and that will help you accelerate your development in many ways. Enjoy :)

=Procedure=
Here are the instructions divided in steps for the easy navigation of our eyes.

==Step One==
Download and install the latest nightly found on this forum /index.php/board,20.0.html Also you will need the Code::Blocks SDK so checkout the sources on berlios.de using svn.

==Step Two==
Get the wxWidgets sources at http://wxwidgets.org and configure the setup.h to be compatible with the actual wxmsw28u_gcc_cb_wxXXX.dll compilation.

==Step Three==
After having your plugin up and running you will need to edit the compiler options and add the directory where your nightly is residing to the linker. Then add the needed libraries to the linker to compile the plugin that usually are wxmsw28u_gcc_cb.dll and libcodeblocks.dll. You don't need to write the .dll extension or the lib word so they will look like this on the linker Options:

*wxmsw28u_gcc_cb
*codeblocks

=Conclusion=
You should now be able to compile the plugin and load it to the current nightly with out the symbols error. A problem that many developers confront after compiling the plugin with a compilation that differs from the official one. This was a quick howto so is maybe missing info, I will update it later. Good Luck!

Developer documentation

2008-01-19T00:21:09Z

Jgm: /* Plug-In development */

[[Category:Code::Blocks Documentation]]
[[Category:Developer Documentation]]
Articles for Code::Blocks developers.

* '''[http://launchpad.net/products/codeblocks/ Translation]'''
:Code::Blocks uses Launchpad to coordinate translation efforts.

* '''[[Coding style]]'''
:The source code formatting style used in the Code::Blocks' source.

* '''[[Creating a custom lexer for Code::Blocks editor]]'''
:How to add support for new syntax lighting schemes.

* '''[[Creating a patch to submit to BerliOS (Patch Tracker)]]'''
:Creating a diff file and then submitting it to the patch tracker.

* '''[[Unicode Standards]]'''
:Information about unicode standards and how unicode is handled in Code::Blocks' source code.

* '''[[Various development tips]]'''
:List of various development tips for Code::Blocks.

* '''[[Scripting Code::Blocks]]'''
:Information about scripting Code::Blocks with [http://www.squirrel-lang.org/ Squirrel].

* '''[[A short overview about Code::Blocks architecture]]'''
:Information about the architecture of Code::Blocks.

* '''[[Code::Blocks SDK events]]'''
:Information about the Code::Blocks SDK events and how to work with them.

* '''[[File formats description]]'''
:Description of the format of each file Code::Blocks produces.

* '''Documentation'''
:[https://www.codeblocks.org/manual.shtml User's manual] in various formats and languages.
:Also see http://developer.berlios.de/projects/codeblocks/ (under the downloads section).

== Plug-In development ==

* [[Creating a simple "Hello World" plugin]]
* [[Creating a Plug-in which modifies CB's Menus]]
* [[Creating a plugin that actually does something]]
* [[Linking the plugin to a Nightly Build]]
* [[Managing Plug-in Resources]]

* [[Research on doing a Plug-in for embedded help in CB]]

* [[wxSmith extensions]]

== Scripting ==

Using scripting to extend Code::Blocks' functionality

* [[Wizard scripts|Creating a new project wizard]]

Nightly Cookbook

2008-01-12T21:55:59Z

Jgm: /* wxWidgets */ Updated the wx version and link to download

This page is under construction by 'killerbot'. Just be patient, some day it will be finished.

== Introduction ==
This article will describe the process used in creating the nightly builds, and can be used as a guideline if you want to build Code::Blocks yourself. It is described as a sequence of 'manual' actions. While it is possible to automate several of these tasks via script, that is beyond the scope of this article.
Current limitation : Windows unicode build.

== Shopping List ==
In order to perform our build tasks, we will need several tools. Let's create an ingredient list for our cooking experiments :
* a compiler
* an initial build system
* the Code::Blocks sources
* zip program
* svn (version control system)
* wxWidgets

While we are at it, maybe someday we want to debug our programs, so let's add a debugger to the list :

* debugger

== Shopping Time ==
=== Compiler ===
Let's start by shopping for the first item on our list, a compiler. Several compilers are available; some free, some expensive. Since the Code::Blocks developers build Code::Blocks using GCC, we might as well use that one. It is very standards compliant, though not the fastest one around. GCC on windows is available in several flavors. There are CygWin ports and MingW ports.

The easiest and cleanest port is MinGW. This is the compiler distributed with Code::Blocks when you download the official package (the one including the compiler). We can find MinGW at [http://www.mingw.org www.mingw.org]. [https://wiki.codeblocks.org/index.php?title=MinGW_installation#gcc_3.4.4_manual_install This post] in the wiki describes how to install MinGW. We will stick to version 3.4.5, which works nicely.

First, a brief explanation of MinGW components:
* gcc-core : the core of the GCC suite
* gcc-g++ : the c++ compiler
* mingw Runtime : implementation of the run time libraries
* mingw utils : several utilities (implementation of smaller programs that GCC itself uses)
* win32Api : the APIs for creating Windows programs
* binutils : several utilities used in build environments
* make : the Gnu make program, so you can build from make files
* GDB : the Gnu debugger : for hunting those nasty bugs (version 6.3.2 or above !!!)

I would suggest extracting (and installing for the GDB) everything in the C:\MinGW directory. The remainder of this article will assume that this is where you have put it. If you already have an installation of Code::Blocks that came bundled with MinGW (for example RC2), I still advise you to install MinGW as described here. A compiler does not belong under the directory tree of an IDE; they are two separate things. Code::Blocks just brings it along in the official versions so that the average user does not need to bother with this process. But, since you are reading this, you are no longer an average user. :-)

You may need to add the 'bin' directory of your MinGW installation to your path (example : C:\MinGW\bin). An easy way to do this is with the following command at the command prompt:

set path=%PATH%;C:\MinGW\bin;C:\MinGW\mingw32\bin;

=== Initial Build System ===
We could try to build Code::Blocks by using makefiles, but there is an easier way: let's build Code::Blocks by using ........ Code::Blocks. All we need to do is get hold of a pre-built version Code::Blocks.

First, download a nightly build. You can make your selection from [/index.php?board=20.0 here]. The nightly builds are unicode versions, containing the core and contributed plug-ins.

Next, unpack the 7-zip file to any directory you like (e.g. C:\CodeBlocksTempNightly). If you don't have 7-zip, you can download it for free from [http://www.7-zip.org the 7-zip website].

Now, Code::Blocks needs one more dll to work correctly: the WxWidgets dll. You can also download it at the nightly builds forum. Just unzip it into the same directory that you unpacked the Code::Blocks nightly build. It also needs the mingwm10.dll, but don't worry - we already have it. It's in the bin directory of our MinGW installation. So, it's important to make sure the bin directory of your MinGW installation is in your path variable (see above).

Finally, start up this new nightly build of Code::Blocks. It should discover the MinGW compiler we just installed.

== Version Control System ==
In order to be able to retrieve the latest and greatest Code::Blocks sources, we need to install a Version Control System.

The Code::Blocks developers provide their sources through the SVN version control system. So, we need a client to access their svn repository of sources. A nice, easy client for Windows is TortoiseSVN, which is freely available from [http://tortoisesvn.tigris.org/ here]. Download and install it, keeping all suggested settings.

Now, go create a directory wherever you like, for example D:\projects\CodeBlocks. Right click on that directory and choose from the pop-up menu : svn-checkout. In the dialog that pops up, fill in the following information:

- Url of Repository : svn://svn.berlios.de/codeblocks/trunk
- leave all other settings as they are

Now be patient while TortoiseSVN retrieves the most recent source files from the Code::Blocks repository into our local directory. Yes; all those Code::Blocks sources are coming your way!

For more info on SVN settings, see [http://codeblocks.org/source_code.shtml info on SVN settings]. If you don't like an Explorer integration or look for a cross-plattform client you might want to have a look at [http://rapidsvn.tigris.org/ RapidSVN] (which is btw. also written using wxWidgets).

All righty, time to continue our shopping session.

== wxWidgets ==
WxWidgets is a platform abstraction that provides an API to support many things such as GUI, sockets, files, registry functionality. By using this API, you can create a platform independent program.

Code::Blocks is a wxWidgets (here after: wx ) application, that means if you want to run Code::Blocks you needed the wx functionality. This can be provided in a couple of ways. It could be a .dll or a static library. Code::Blocks uses wx as a dll and this dll can also be downloaded from the nightly build section of the forum.

However, if we want to build a wx application, we need to include the headers of the wx sources. They tell the compiler about the functionality of wx. In addition to those header files, our application needs to link to the wx import libraries. Well, let's take it step by step.

Wx is provided as a zip file of it's sources, so we need to build that ourselves. We already shopped for the MinGW compiler, so we have all the tools we need at hand.

Download the wx sources (at time of writing : version 2.8.7) [http://internap.dl.sourceforge.net/sourceforge/wxwindows/wxMSW-2.8.7.zip in this .zip here].

Next, let's unzip the wx sources into C:\Projects so we will end up with a wx root directory like this: C:\Projects\wxWidgets-2.8.7. Note that we are going to refer to the wx root directory from now on as <wxDir>

Now, we are going to build the wxWidgets. This is how we do it:

First, make sure C:\MingGW\bin is in your path, during the build some programs will be called that reside in the the MinGW\bin directory. Also, Make has to be version 3.80 or above.

Now it is time to compile wxWidgets. Open the command prompt and change to the wxWidgets directory:
<tt>cd <wxDir>\build\msw</tt>

We are now in the right place. We are first going to clean up the source:
<tt>mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=release UNICODE=1 clean</tt>

Once everything is clean, we can compile wxWidgets:
<tt>mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=release UNICODE=1</tt>

This is going to take some time, so go get yourself a nice ice-cream, a beer, ...

Note: For making the debug build, follow these steps:
First clean any previous compilation with:
<tt>mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1 clean</tt>

And then compile with:
<tt>mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1</tt>

... If you are not on diet, get another ice-cream, a beer, ....

Did you enjoy your refreshment? Well have a little look in the directory (<wxDir>\lib\gcc_dll) now. The import libraries and the dll have shown up and there should also a mswu\wx subdirectory at that position containing setup.h.

Congratulations! You have just built wxWidgets!

Let's do some more preliminary tasks before we get to the real deal of compiling Code::Blocks.

== Zip ==
During the build of Code::Blocks, several resources are going to be zipped in zip files. Therefore, the build process should have access to a zip.exe. We have to download that zip.exe and put it somewhere in our path. A good place is: MingW\bin.

You can download zip.exe for free from [http://www.info-zip.org/pub/infozip/Zip.html this site] and this is a [http://switch.dl.sourceforge.net/sourceforge/infozip/zip232.zip direct link(32bit)] to the most recent version at the time of this writing.

Once downloaded, simply extract zip.exe to the appropriate location.

== Workspace ==
This brings us to the last preliminary task. The Code::Blocks code can be divided into 2 major parts: the core with internal plug-ins, and the contributed plug-ins. You always need to build the core/internal parts before building the contrib part.

To build the internal part, you can use the Code::Blocks project file which you can find at: <cbDir>\src\CodeBlocks.cbp. Our Code::Blocks master directory is from now one mentioned as <cbDir>, by the way. A workspace is something that groups several projects together. To build the contrib plug-ins, they can be found at <cbDir>\src\ContribPlugins.workspace.

But, let's create a workspace containing everything. Let's put that workspace in the master directory <cbDir>. Just use a regular text editor and create a file with the name "CbProjects.workspace" and give it the following content :

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_workspace_file>
<Workspace title="Workspace">
<Project filename="src\CodeBlocks.cbp" active="1" />
<Project filename="src\plugins\contrib\codestat\codestat.cbp" />
<Project filename="src\plugins\contrib\copystrings\copystrings.cbp" />
<Project filename="src\plugins\contrib\dragscroll\dragscroll.cbp" />
<Project filename="src\plugins\contrib\devpak_plugin\DevPakPlugin.cbp" />
<Project filename="src\plugins\contrib\help_plugin\help-plugin.cbp" />
<Project filename="src\plugins\contrib\keybinder\keybinder.cbp" />
<Project filename="src\plugins\contrib\profiler\cbprofiler.cbp" />
<Project filename="src\plugins\contrib\source_exporter\Exporter.cbp" />
<Project filename="src\plugins\contrib\wxSmith\wxSmith.cbp" />
</Workspace>
</CodeBlocks_workspace_file>

We will use this workspace to build all of Code::Blocks.

== Building Code::Blocks ==
Finally we have arrived at the final step; our final goal. Run the Code::Blocks executable from your nightly build download. Choose Open from the File menu and browse for our above created workspace, and open it up. Be a little patient while Code::Blocks is parsing everything, and Code::Blocks will ask us for 2 global variables, these global variables will tell the nightly Code::Blocks where it can find wxWidgets (remember : header files and import libraries) and where it can find .... Code::Blocks, this is needed for the contrib plug-ins, they need to know (as for any user created plug-in) where the sdk (Code::Blocks header files) are.
These are the values in our case :
- wx : <wxDir>
- Code::Blocks (cb) : <cbDir>\src

Now go to the Project Menu and choose (re)build workspace, and off you go. Watch how Code::Blocks is building Code::Blocks.

Once the build is complete, open up a console in <cbDir>\src and run the command "update.bat". This will transfer all built deliverables from <cbDir>\src\devel to <cbDir>\src\output. In addition, it will strip out all debugging symbols. This step is very important - never ever forget it.

Now you can copy the wx dll in both that output and the devel directory.

Then you can close Code::Blocks. That was the downloaded nightly remember?

Time to test it. In the output directory, start up the CodeBlocks.exe. If everything went well, you'll have your very own home-built Code::Blocks running.

Enjoy !!!

AutoVersioning plugin

2007-12-13T21:45:37Z

Jgm: /* Buttons Summary */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores into a temporary file (changes.tmp) the actual data for later procesing into the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:45:12Z

Jgm: /* Buttons Summary */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores into a temporary file "changes.tmp" the actual data for later procesing into the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:44:50Z

Jgm: /* Buttons Summary */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores into a temporary file "changes.tmp" the actual data for later procesing in to the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:44:37Z

Jgm: /* Buttons Summary */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores into a temporary files "changes.tmp" the actual data for later procesing in to the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:43:15Z

Jgm: /* Buttons Summary */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores the actual data of the data grid for later procesing in to the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:43:05Z

Jgm: /* Buttons Summary */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores the actual data of the data grid for later procesing in to the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:42:37Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
*Add - appends a row in to the data grid
*Edit - enables the modification of the selected cell
*Delete - removes the current row from the data grid
*Save - stores the actual data of the data grid for later procesing in to the changes log file
*Write - process the data grid data to the changes log file
*Cancel - just closes the dialog without taking any action

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:40:07Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

===Buttons Summary===
Add - Appends a row in to the data grid
Edit - Enables the modification of the selected cell
Delete - Removes the current row from the data grid

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:33:51Z

Jgm:

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]], [[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:33:34Z

Jgm:

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]]/[[User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:32:44Z

Jgm: changed developers info

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM][User:killerbot|KILLERBOT]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:31:30Z

Jgm: changed version info

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 1.1
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:30:50Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the ChangesLog.txt file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:28:17Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log'''. Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:28:05Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log''' Also if checked '''Show changes editor when incrementing version''' on the changes log settings, the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:26:25Z

Jgm: /* Changes Log */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a '''ChangesLog.txt''' file.

*Show changes editor when incrementing version - will pop up the changes log editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log''' Also if checked '''Show changes editor when incrementing version''' the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:21:06Z

Jgm: /* Output of version.h */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Show changes editor when incrementing version - will pop up the changeslog editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The generated header file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log''' Also if checked '''Show changes editor when incrementing version''' the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:19:45Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Show changes editor when incrementing version - will pop up the changeslog editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu '''Project->Changes Log''' Also if checked '''Show changes editor when incrementing version''' the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:19:06Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Show changes editor when incrementing version - will pop up the changeslog editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
This dialog is accessible from the menu 'Project->Changes Log' Also if checked 'Show changes editor when incrementing version' the window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:16:07Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Show changes editor when incrementing version - will pop up the changeslog editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or an incrementation event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:15:14Z

Jgm: /* Changes Log */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Show changes editor when incrementing version - will pop up the changeslog editor when incrementing the version.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:13:57Z

Jgm: /* Settings */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Do Auto Increment - this tells the plugin to automatically increment the changes when a modification is made, this incrementation will occur before compilation.
*Header language - select the language output of version.h
*Ask to increment - if marked, ''Do Auto Increment'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-12-13T21:09:03Z

Jgm: /* Usage */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a low quality screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, the settings that you entered on the configuration dialog will be stored on the project file, and a version.h file will be created. For now, every time that you hit the '''Project->Autoversioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you don't save the new changes made by the plugin to the project file.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-10-12T02:51:10Z

Jgm: /* Usage */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Autoversioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-10-10T22:55:45Z

Jgm: /* Output of version.h */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static const char DATE[] = "15";
static const char MONTH[] = "09";
static const char YEAR[] = "2007";
static const double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static const char STATUS[] = "Pre-alpha";
static const char STATUS_SHORT[] = "pa";

//Standard Version Type
static const long MAJOR = 0;
static const long MINOR = 10;
static const long BUILD = 1086;
static const long REVISION = 6349;

//Miscellaneous Version Types
static const long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static const char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-10-09T01:56:18Z

Jgm: /* Introduction */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the AutoVersioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-10-09T01:55:50Z

Jgm: Updated plugin version

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.9
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-10-05T22:48:32Z

Jgm:

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8.2
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:19:41Z

Jgm: /* Introduction */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:17:26Z

Jgm: /* Usage */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and versioning related settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:15:44Z

Jgm: /* Scheme */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0. Put a 0 for unlimited.
*Revision maximum - Same as Build Number maximum. Put a 0 for unlimited
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:12:05Z

Jgm: /* Version Values */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the auto versioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:11:52Z

Jgm: /* Usage */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main auto versioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:08:46Z

Jgm: /* Features */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++.
*Generates and auto increment version variables.
*Software status editor.
*Integrated scheme editor for changing the behavior of the auto incrementation of version values.
*Date declarations as month, date and year.
*Ubuntu style version.
*Svn revision check.
*Change log generator.
*Works on Windows and Linux (doesn't have Mac to test).

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:06:11Z

Jgm: /* Change log generator */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++
*Generates and auto increment version variables
*Software status editor
*Integrated scheme editor for changing the behavior of the auto incrementation of version values
*Date declarations as month, date and year
*Ubuntu style version
*Svn revision check
*Change log generator.

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot: 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:03:20Z

Jgm: /* Settings */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++
*Generates and auto increment version variables
*Software status editor
*Integrated scheme editor for changing the behavior of the auto incrementation of version values
*Date declarations as month, date and year
*Ubuntu style version
*Svn revision check
*Change log generator.

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme. If not marked only the Build Number and Revision will increment.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:02:41Z

Jgm: /* Version Values */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++
*Generates and auto increment version variables
*Software status editor
*Integrated scheme editor for changing the behavior of the auto incrementation of version values
*Date declarations as month, date and year
*Ubuntu style version
*Svn revision check
*Change log generator.

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them for you.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T01:00:14Z

Jgm: /* Features */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Supports C and C++
*Generates and auto increment version variables
*Software status editor
*Integrated scheme editor for changing the behavior of the auto incrementation of version values
*Date declarations as month, date and year
*Ubuntu style version
*Svn revision check
*Change log generator.

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them by himself.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T00:53:06Z

Jgm: Structure reorganization

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Generates and auto increment version variables
*Software status editor
*Integrated scheme editor for changing the behavior of the auto incrementation of version values
*Date declarations as month, date and year
*Ubuntu style version
*Svn revision check
*Change log generator.
*Option to generate C header (without namespace) instead of C++ header (with namespace AutoVersion)

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

==Dialog notebook tabs==

===Version Values===

Here you just enter the corresponding version values or let the autoversioning plugin increment them by himself.

*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

===Status===

Some fields to keep track of your software status with a list of predefined values for convenience.

*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

===Scheme===

Lets you edit how the plugin will increment the version values.

*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

===Settings===

Here you can set some settings of the auto versioning behavior.

*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

===Changes Log===

This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.

*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

==Including in your code==
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>

AutoVersioning plugin

2007-09-17T00:48:44Z

Jgm: /* First time use */

[[Category: Code::Blocks Contrib Plugins]]
{{Infobox_Plugin|
name = AutoVersioning |
logo = [[Image:AutoVersioningLogo.png]] |
developer = [[User:jgm|JGM]] |
maintainer = JGM |
version = 0.8
}}

An application versioning plug in that increments the version and build number of your application every time a change has been made and stores it in version.h with easy to use variable declarations. Also have a feature for committing changes a la SVN style, a version scheme editor, a change log generator and more...

==Introduction==
The idea of the Auto Versioning plugin was made during the development of a pre-alpha software that required the version info and status. Been to busy coding, without time to maintain the version number, just decided to develop a plugin that could do the job with little intervention as possible, and made a little contribution to this fabulous OS IDE.

==Features==
Here is the list of features the plugin covers summarized:

*Generates and auto increment version variables
*Software status editor
*Integrated scheme editor for changing the behavior of the auto incrementation of version values
*Date declarations as month, date and year
*Ubuntu style version
*Svn revision check
*Change log generator.
*Option to generate C header (without namespace) instead of C++ header (with namespace AutoVersion)

==Sources==
Usually source and news about new releases are posted on the Code::Blocks forums on the plugins development section. You can access this plugin topic over [/index.php/topic,6294.msg48225.html#msg48225 here], recent sources are attached on the first post (you have to be logged in to download attachments on the forum).

The plugin also have a project page at [http://www.berlios.de www.berlios.de]. The link is [http://developer.berlios.de/projects/autoversioning/ http://developer.berlios.de/projects/autoversioning/]. Submit all features request and bugs on the project page.

Svn check out: '''svn://svn.berlios.de/autoversioning'''

==Usage==

After downloading the sources, compiling them and installing the plugin to Code::Blocks just go to '''Project->Auto Versioning''' menu. A pop up window like this will appear: 
[[Image:AvAskConfigure.png]] 

When hitting yes on the ask to configure message box, the main autoversioning configuration dialog will open, to let you configure the version info of your project. Each editable control has a tool tip with information that explains you its features, so if you put the mouse on the control the tool tip will pop up. Below is a screenshot showing all the tabs: 
[[Image:AvDialog.png]] 

After configuring your project for auto versioning, a version.ini (for the settings that you entered on the configuration dialog) and version.h files will be created next to your project file. For now, everytime that you hit the '''Project->Auto Versioning''' menu the configuration dialog will popup to let you edit your project version and settings, unless you delete the version.ini that has all the configurations.

===Dialog notebook tabs===

'''Version Values: ''' 
Here you just enter the corresponding version values or let the autoversioning plugin increment them by himself.
*Major - Increments by 1 when the minor version reaches its maximum
*Minor - Increments by 1 when the build number pass the barrier of build times, the value is reset to 0 when it reach its maximum value.
*Build Number (also equivalent to Release) - Increments by 1 every time that the revision number is incremented.
*Revision - Increments randomly when the project has been modified and then compiled.

'''Status: ''' 
Some fields to keep track of your software status with a list of predefined values for convenience.
*Software Status - The typical example should be v1.0 Alpha
*Abbreviation - Same as software status but like this: v1.0a

'''Scheme: ''' 
Lets you edit how the plugin will increment the version values.
*Minor maximum - The maximum number that the Minor value can reach, after this value is reached the Major is incremented by 1 and next time project is compiled the Minor is set to 0.
*Build Number maximum - When the value is reached, the next time the project is compiled is set to 0.
*Revision maximum - Same as Build Number maximum.
*Revision random maximum - The revision increments by random numbers that you decide, if you put here 1, the revision obviously will increment by 1.
*Build times before incrementing Minor - After successful changes to code and compilation the build history will increment, and when it reaches this value the Minor will increment.

'''Settings: ''' 
Here you can set some settings of the auto versioning behavior.
*Autoincrement Major and Minor - lets the plugin increments this values by you using the scheme.
*Create date declarations - create entries in the version.h file with dates and ubuntu style version.
*Commit Changes - to increment the changes using the scheme when you feel that is the right moment, just using the menu '''Project->Commit Changes'''. This will increment the version values.
*Header language - select the language output of version.h
*Ask to commit changes - if marked ''Commit Changes'', it ask you before compilation (if changes has been made) to increment the version values.
*svn enabled - search for the svn revision and date in the current folder and generates the correct entries in version.h

'''Changes Log: ''' 
This lets you enter every change made to the project to generate a CHANGES.txt next to your project file.
*Generate changes log - Enables this feature.
*Title Format - a format able title with a list of predefined values.

===Including in your code===
To use the variables generated by the plugin just ''#include <version.h>''. An example code would be like the following:
<pre>
#include <iostream>
#include "version.h"

void main(){
std::cout<<AutoVersion::Major<<endl;
}
</pre>

===Output of version.h===
The header '''version.h''' is generated next to your project file. Here is a sample content of the file on c++ mode: 
<pre>
#ifndef VERSION_H
#define VERSION_H

namespace AutoVersion{

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

}
#endif //VERSION_h
</pre>

On C mode is the same as C++ but without the namespace: 
<pre>
#ifndef VERSION_H
#define VERSION_H

//Date Version Types
static char DATE[] = "15";
static char MONTH[] = "09";
static char YEAR[] = "2007";
static double UBUNTU_VERSION_STYLE = 7.09;

//Software Status
static char STATUS[] = "Pre-alpha";
static char STATUS_SHORT[] = "pa";

//Standard Version Type
static long MAJOR = 0;
static long MINOR = 10;
static long BUILD = 1086;
static long REVISION = 6349;

//Miscellaneous Version Types
static long BUILDS_COUNT = 1984;
#define RC_FILEVERSION 0,10,1086,6349
#define RC_FILEVERSION_STRING "0, 10, 1086, 6349\0"
static char FULLVERSION_STRING[] = "0.10.1086.6349";

#endif //VERSION_h
</pre>

==Change log generator==
After checking the option Generate changes log on the configuration dialog of auto versioning, a window will open to let you enter the list of changes after a modification to the project sources or a Commit Changes event. Below is an example screen shot 

[[Image:AvChangesList.png]] 

Here is an example of the output generated by the plugin to the CHANGES.txt file created next to your project file: 
<pre>
03 September 2007
released version 0.7.34 of AutoVersioning-Linux

Change log:
-Fixed: pointer declaration
-Bug: blah blah

02 September 2007
released version 0.7.32 of AutoVersioning-Linux

Change log:
-Documented some areas of the code
-Reorganized the code for readability

01 September 2007
released version 0.7.30 of AutoVersioning-Linux

Change log:
-Edited the change log window
-If the change log windows is leave blank no changes.txt is modified
</pre>