Contents

Preliminaries:

The Marble project uses CMake to manage the building process depending of your needs : operating system, build options. So, first of all, you need to download the latest CMake binary for windows. Install it and don't forget during the installation to check "define cmake path in environment variables" or something like that.

Marble is a Qt dependent application ("No way!?" "Way!!" :) ) so you also need Qt. Download the latest Qt sdk for windows and install it.

From hereon, there are two ways to compile Marble - both are currently working (as of 1st of july 2010):

Added the steps to compile on a x64 environment with VS2008 Professional, getting the sources from Git and compiling Qt 4.8.4 x64 if needed.

Compiling Marble using MingW

You have to add mingw's path and qmake's path in the environment variable. (use C:\Qt\20xx.xx.x\MinGW\bin and C:\Qt\20xx.xx.x\qt\bin )(follow those instructions if needed). To check that cmake.exe, gcc.exe and qmake.exe are in your %PATH% :

open a commandline-window (start->run program->cmd)

run "cmake" , it should give you a help message and show you what compilation options it found

run "gcc -v" , it should give you version info

run "qmake" , it should give you help output

(Hint: make sure not to add the directory %QT-installation-dir%/bin but rather %QT-installation-dir%/qt/bin, there are for some reason incompatible dll's that might lead to crashes)

If one of those command are not known then something is wrong.

Then check out marble's svn :

svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdeedu/marble

(Note: this is for the development version. You may want a more stable version. So look for the appropriate url)

now you can compile marble :

open the cmd-window

cd to the marble dir

create a build directory (mkdir build)

cd build

cmake -G"MinGW Makefiles"-DQTONLY=ON -DCMAKE_BUILD_TYPE=Release ..

(add -DWITH_DESIGNER_PLUGIN=ON if you want the MarbleWidget Plugin )(note that the "-DCMAKE_BUILD_TYPE=Release" is important because without it you will have trouble like no downloading tiles etc)

mingw32-make

(you can add "-j2" if you have a 2 cores cpu)

mingw32-make install

(Note: if you are under Windows seven you must be root to install marble in the standard place. See this )

Now if all went well you should find marble.exe in Program Files>marble> directory.

Test it... Yeah!

Compiling Marble using Microsoft Visual C++

The Windows version of Marble distributed on the KDE website is compiled using the Microsoft VC++ compiler. For Marble to work right, you'll need the MSVC+ compiled version of QT.

Once you got these installed, make sure that you add the bin Path of the framework to your PATH variable. E.g. "C:\Qt\4.6.3\bin". This will point the system to the DLLs of the framework eventually needed.

Get the Marble sources from SVN into a fresh directory (see above for steps). Then you can open a command line window (with administrator privileges - on Vista and Windows 7, you need to hold down SHIFT and Control when executing "CMD.exe" from the start button menu). You need to make sure that you got those privileges, otherwise the build will fail due to missing rights to write files later on during linking and installing.

Once issued, you will get the build kicked off. First, the cmake cross-compiler will make the MakeFile, and Nmake will then compile it, while nmake install will install the application at the path specified at CMAKE_IMSTALL_PATH Prefix.

Once you got your version of Marble "installed", you need to manually copy the missing Qt Framework DLLs as well as the missing imageformat DLL for importing tiles.The following DLLs go from the Qt/bin directory right next to the marble.exe file in the installation directory:

QtCore4.dllQtGui4.dllQtNetwork4.dllQtSvg4.dllQtWebKit4.dllQtXml4.dll

Additionally, you need to create a directory in the "plugins" folder named "imageformats". This is the plugin for different image formats. In Marble 0.8.0, there was just one DLL in there, namely "qjpeg4.dll", which is the support for JPEG file tiles in Marble.[NOTE: what about PNG support? Would that be "qmng4.dll" to be added?]

The "qjpeg4.dll" is not build yet after downloading and installing the MSVC version of the Qt Framework, yet you will find a MS VC Project file in your Qt source directory (e.g. "C:\Qt\4.6.3\src\plugins\imageformats\imageformats.dsw"). Open that up, set the release configuration in the compiler and compile the project.

Note that the output files will be found in another place! Namely in the plugins folder of Qt (e.g. "C:\Qt\4.6.3\plugins\imageformats"). From there, you can copy the qjpeg4.dll needed, and you should be all set - you now got a fresh Marble version compiled with MSVC.

Compiling Marble using Microsoft Visual C++ x86/x64

For Marble to work right, you'll need the MSVC++ compiled version of QT. If needed and no x64 version of Qt is available, you can compile it from source in a few easy steps.

Git Client

The sources are on a Git Server. Install a Git client to download the sources. Tortoise Git offers a simple windows interface and is easy to use and install. It offers an interface to Git for Windows that must also be installed.

CMAKE

Install CMake, addind it to the system path. Note, it may be necessary to adjust the permissions on the rules folder if you get "access denied" error messages later during compilation. (on Win 7 at least)

Preparing the workplace

The following steps and congfiguration/compilation commands assume source in one directory, Visual Studio generated files (config and objects in a second directory, and then prepared binaries in a third. This way the source directory is kept clean, the final binaries are easy to find, and debug/release versions of each file kept in separate directories. It is very inconvenient to have these mixed.

Example of directories tree:

Marble-Src

Marble-Build

Debug

Release

Marble-Bin

Debug

Release

Getting the sources

When Tortose Git is properly installed and integrated with windows file explorer, you should be able to right click on a directory where you whant to download the sources to ex. Marble-Src, and select "Clone Git repository", pointing to the address of the source code, from the official Marble page. (todo, screenshot here)

Configuring and Compiling

Like mentioned before, it is desirable to keep the sources clean on a large project like this. Visual Studio will create a lot of files and it is also much easier to work on. You'll be able to change files and configurations more easily if you keep sources and built objects separate.

In the directory to use to build in debug mode for example, open a command prompt. No need of elevated priviledges or setting of VS specific variables. Run cmake with ONE (in case its being presented on multiple lines) command similar to this:

-DCMAKE_BUILD_TYPE=Debug specifies in advance to link/build in debug mode in the generated vcproj/sln files

-DCMAKE_INSTALL_PREFIX=..\..\Marble-Bin\Debug specifies where the final binaries should be placed. It will only be populated by the "INSTALL project target part of the complete solution. You can specify a relative or absolute path.

..\..\Marble-Src points to the root directory containing the marble files, where you cloned the Git repository. (It contains the top-level CMakeLists.txt file.) Not the "src" directory within.

If all options and paths are correct, the current directory should now be populated with Visual Studio project files, a lot of them, and one single solution file. Double click/open in VS Studio. No further command line work necessary.

Repeat the above steps in another directory for a release build if desired.