=== LICENSE ===
This software is open source software licensed under GPL3, as found in
the COPYING file.

=== CONTRIBUTORS ===
A  list  of  known  contributors  can be  found  in  the  CONTRIBUTORS
file.  New maintainers  should  list  themselves there  as  it is  not
automatically updated.

=== BUILDING ===
This  project  requires  CMake  to  be built.  It  also  requires  the
following libraries:

* OpenGL
* Qt (5.*, Core, Gui, OpenGL)
* storm (stormlib by Ladislav Zezula)
* Boost

Build in the following way. You may customize parameters to cmake. (for windows see next section)
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install

==== WINDOWS ====

* install msvc++
* install cmake
* install boost via https://sourceforge.net/projects/boost/files/boost-binaries/ (be sure to use the right version and compiler version. cmake may not support the latest version) to <boost-install>
* install Qt via https://www.qt.io/download-open-source/#section-2 to <Qt-install>
* download stormlib from https://github.com/ladislav-zezula/StormLib
 * open CMake GUI
 * configure, generate (save the cache entry CMAKE_INSTALL_PREFIX path somewhere, set it to a empty folder if not present)
 * open solution with visual studio
 * build ALL_BUILD, then INSTALL
* open CMake GUI
 * set cache entry CMAKE_PREFIX_PATH (path) to <Qt-install>;<stormlib-build>, e.g. C:/Qt/5.6/msvc2015;<Stormlib's CMAKE_INSTALL_PREFIX path>
 * set cache entry BOOST_ROOT (path) to <boost-install>, e.g. C:/local/boost_1_60_0
 * set cache entry CMAKE_INSTALL_PREFIX (path) to a empty destination, e.g. C:/Users/loerwald/Documents/noggitinstall
 * configure, generate
 * open solution with visual studio
 * build ALL_BUILD

=== DEVELOPMENT ===
Feel   free   to   ask   the   owner  of   the   official   repository
(https://bitbucket.org/berndloerwald/noggit3/)  for  write  access  or
fork and post a pull request.

=== CODING GUIDELINES ===
Following is  an example for file  src/noggit/ui/foo_ban.h. .cpp files
are similar.

   // This file is part of Noggit3, licensed under GNU General Public License (version 3).

   //! \note Include guard shall use pragma once.
   #pragma once

   //! \note   Use  fully   qualified  paths.   Standard   >  external
   //! dependencies > own.
   #include <noggit/bar.h>

   //! \note Namespaces equal directories. (java style packages.)
   namespace noggit
   {
     namespace ui
     {
       //! \note Lower case,  underscore separated. Classes might have
       //! a _type suffix (even though being against the standard)
       class foo_ban : public QWidget
       {
       Q_OBJECT

       public:
         //! \note  Long  parameter  list.   Would  be  more  than  80
         //! chars.  Break  with comma  in  front.  Use  spaces to  be
         //! aligned below the braces.
         foo_ban ( const type& name
                 , const type_2& name_2
                 , const type& name3
                 )
           : QWidget (nullptr)
         //! \note Prefer initialization lists over assignment.
           , _var (name)
         {}

         //! \note Use const where possible. No space between name and
         //! braces when no arguments are given.
         void render() const;

         //! \note If you really need getters and setters, your design
         //! might be broken.
         const type& var() const
         {
           return _var;
         }
         //! \note One  might use setter chaining.  (just as operator=
         //! returns the assigned value)
         const type& var (const type& var_)
         {
           return _var = var_;
         }

         //! \note Prefer const (references) where possible.
         bazs_type count_some_numbers ( const size_t& begin
                                      , const size_t& end
                                      ) const
         {
           bazs_type bazs;

           //! \note  Prefer   construction  over  assignment.  Prefer
           //! preincrement.
           for (size_t it (begin); it < end; ++it)
           {
             bazs.push_back (it);
           }

           //! \note Prefer stl algorithms over hand written code.
           const bazs_type::const_iterator smallest
             (std::min_element (bazs.begin(), bazs.end()));

           return *smallest;
         }

       private:
         //! \note Member variables are prefixed with an underscore.
         type _var;
         //! \note  Typedef when  using complex  types.  Fully qualify
         //! types.
         typedef type_2 baz_type;
         typedef std::vector<baz_type> bazs_type;
         bazs_type _bazs;
       }
     }
   }