SWORD25: Mass-astyle.

svn-id: r53222

12 files changed, 734 insertions, 831 deletions

diff --git a/engines/sword25/gfx/image/b25sloader.cpp b/engines/sword25/gfx/image/b25sloader.cpp
index ea1e933edd..e45a4cddcb 100644
--- a/engines/sword25/gfx/image/b25sloader.cpp
+++ b/engines/sword25/gfx/image/b25sloader.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -50,38 +50,33 @@ namespace Sword25 {
 
 // -----------------------------------------------------------------------------
 
-namespace
-{
-	unsigned int FindEmbeddedPNG(const char * FileDataPtr, unsigned int FileSize)
-	{
-		// Einen Stringstream mit dem Anfang der Datei intialisieren. 512 Byte sollten hierfür genügen.
-		istringstream StringStream(string(FileDataPtr, FileDataPtr + min(static_cast<unsigned int>(512), FileSize)));
-
-		// Headerinformationen der Spielstandes einlesen.
-		string Marker, VersionID;
-		unsigned int CompressedGamedataSize, UncompressedGamedataSize;
-		StringStream >> Marker >> VersionID >> CompressedGamedataSize >> UncompressedGamedataSize;
-		if (!StringStream.good()) return 0;
-
-		// Testen, ob wir tatsächlich einen Spielstand haben.
-		if (Marker == "BS25SAVEGAME")
-		{
-			// Offset zum PNG innerhalb des Spielstandes berechnen und zurückgeben.
-			return static_cast<unsigned int>(StringStream.tellg()) + CompressedGamedataSize + 1;
-		}
-
-		return 0;
+namespace {
+unsigned int FindEmbeddedPNG(const char *FileDataPtr, unsigned int FileSize) {
+	// Einen Stringstream mit dem Anfang der Datei intialisieren. 512 Byte sollten hierfür genügen.
+	istringstream StringStream(string(FileDataPtr, FileDataPtr + min(static_cast<unsigned int>(512), FileSize)));
+
+	// Headerinformationen der Spielstandes einlesen.
+	string Marker, VersionID;
+	unsigned int CompressedGamedataSize, UncompressedGamedataSize;
+	StringStream >> Marker >> VersionID >> CompressedGamedataSize >> UncompressedGamedataSize;
+	if (!StringStream.good()) return 0;
+
+	// Testen, ob wir tatsächlich einen Spielstand haben.
+	if (Marker == "BS25SAVEGAME") {
+		// Offset zum PNG innerhalb des Spielstandes berechnen und zurückgeben.
+		return static_cast<unsigned int>(StringStream.tellg()) + CompressedGamedataSize + 1;
 	}
+
+	return 0;
+}
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_B25SLoader::IsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize)
-{
+bool BS_B25SLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) {
 	// PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen.
 	unsigned int PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize);
-	if (PNGOffset > 0)
-	{
+	if (PNGOffset > 0) {
 		return BS_PNGLoader::DoIsCorrectImageFormat(FileDataPtr + PNGOffset, FileSize - PNGOffset);
 	}
 
@@ -90,13 +85,11 @@ bool BS_B25SLoader::IsCorrectImageFormat(const char * FileDataPtr, unsigned int
 
 // -----------------------------------------------------------------------------
 
-bool BS_B25SLoader::DecodeImage(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
-								int & Width, int & Height, int & Pitch)
-{
+bool BS_B25SLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
+                                int &Width, int &Height, int &Pitch) {
 	// PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen.
 	unsigned int PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize);
-	if (PNGOffset > 0)
-	{
+	if (PNGOffset > 0) {
 		return BS_PNGLoader::DoDecodeImage(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, UncompressedDataPtr, Width, Height, Pitch);
 	}
 
@@ -105,12 +98,10 @@ bool BS_B25SLoader::DecodeImage(const char * FileDataPtr, unsigned int FileSize,
 
 // -----------------------------------------------------------------------------
 
-bool BS_B25SLoader::ImageProperties(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height)
-{
+bool BS_B25SLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
 	// PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen.
 	unsigned int PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize);
-	if (PNGOffset > 0)
-	{
+	if (PNGOffset > 0) {
 		return BS_PNGLoader::DoImageProperties(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, Width, Height);
 	}
 
diff --git a/engines/sword25/gfx/image/b25sloader.h b/engines/sword25/gfx/image/b25sloader.h
index be28b646c8..4a2cf3b841 100644
--- a/engines/sword25/gfx/image/b25sloader.h
+++ b/engines/sword25/gfx/image/b25sloader.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -48,21 +48,19 @@ namespace Sword25 {
 // Klassendeklaration
 // -----------------------------------------------------------------------------
 
-class BS_B25SLoader : public BS_ImageLoader
-{
+class BS_B25SLoader : public BS_ImageLoader {
 public:
-	static BS_ImageLoader * CreateInstance() 
-	{ 
-		#include "sword25/kernel/memlog_off.h"
+	static BS_ImageLoader *CreateInstance() {
+#include "sword25/kernel/memlog_off.h"
 		return static_cast<BS_ImageLoader *>(new BS_B25SLoader());
-		#include "sword25/kernel/memlog_on.h"
+#include "sword25/kernel/memlog_on.h"
 	}
 
 protected:
-	virtual bool IsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize);
-	virtual bool DecodeImage(const char * FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
-							 int & Width, int & Height, int & Pitch);
-	virtual bool ImageProperties(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height);
+	virtual bool IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize);
+	virtual bool DecodeImage(const char *FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
+	                         int &Width, int &Height, int &Pitch);
+	virtual bool ImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height);
 
 };
 
diff --git a/engines/sword25/gfx/image/image.h b/engines/sword25/gfx/image/image.h
index 2f9d49f695..1489af97b3 100644
--- a/engines/sword25/gfx/image/image.h
+++ b/engines/sword25/gfx/image/image.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -33,10 +33,10 @@
  */
 
 /*
-	BS_Image
-	--------
+    BS_Image
+    --------
 
-	Autor: Malte Thiesen
+    Autor: Malte Thiesen
 */
 
 #ifndef SWORD25_IMAGE_H
@@ -52,17 +52,15 @@
 
 namespace Sword25 {
 
-class BS_Image
-{
+class BS_Image {
 public:
 	virtual ~BS_Image() {};
 
 	// Enums
 	/**
-		@brief Die möglichen Flippingparameter für die Blit-Methode.
+	    @brief Die möglichen Flippingparameter für die Blit-Methode.
 	*/
-	enum FLIP_FLAGS
-	{
+	enum FLIP_FLAGS {
 		/// Das Bild wird nicht gespiegelt.
 		FLIP_NONE = 0,
 		/// Das Bild wird an der horizontalen Achse gespiegelt.
@@ -74,22 +72,22 @@ public:
 		/// Das Bild wird an der horizontalen und vertikalen Achse gespiegelt.
 		FLIP_VH = FLIP_H | FLIP_V
 	};
-	
+
 	//@{
 	/** @name Accessor-Methoden */
 
 	/**
-		@brief Gibt die Breite des Bildes in Pixeln zurück
+	    @brief Gibt die Breite des Bildes in Pixeln zurück
 	*/
 	virtual int GetWidth() const = 0;
 
 	/**
-		@brief Gibt die Höhe des Bildes in Pixeln zurück
+	    @brief Gibt die Höhe des Bildes in Pixeln zurück
 	*/
 	virtual int GetHeight() const = 0;
 
 	/**
-		@brief Gibt das Farbformat des Bildes zurück
+	    @brief Gibt das Farbformat des Bildes zurück
 	*/
 	virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const = 0;
 
@@ -99,83 +97,83 @@ public:
 	/** @name Render-Methoden */
 
 	/**
-		@brief Rendert das Bild in den Framebuffer.
-		@param pDest ein Pointer auf das Zielbild. In den meisten Fällen ist dies der Framebuffer.
-		@param PosX die Position auf der X-Achse im Zielbild in Pixeln, an der das Bild gerendert werden soll.<br>
-					Der Standardwert ist 0.
-		@param PosY die Position auf der Y-Achse im Zielbild in Pixeln, an der das Bild gerendert werden soll.<br>
-					Der Standardwert ist 0.
-		@param Flipping gibt an, wie das Bild gespiegelt werden soll.<br>
-						Der Standardwert ist BS_Image::FLIP_NONE (keine Spiegelung)
-		@param pSrcPartRect Pointer auf ein BS_Rect, welches den Ausschnitt des Quellbildes spezifiziert, der gerendert
-							werden soll oder NULL, falls das gesamte Bild gerendert werden soll.<br>
-							Dieser Ausschnitt bezieht sich auf das ungespiegelte und unskalierte Bild.<br>
-							Der Standardwert ist NULL.
-		@param Color ein ARGB Farbwert, der die Parameter für die Farbmodulation und fürs Alphablending festlegt.<br>
-					 Die Alpha-Komponente der Farbe bestimmt den Alphablending Parameter (0 = keine Deckung, 255 = volle Deckung).<br>
-					 Die Farbkomponenten geben die Farbe für die Farbmodulation an.<br>
-					 Der Standardwert is BS_ARGB(255, 255, 255, 255) (volle Deckung, keine Farbmodulation).
-					 Zum Erzeugen des Farbwertes können die Makros BS_RGB und BS_ARGB benutzt werden.
-		@param Width gibt die Ausgabebreite des Bildausschnittes an. 
-					 Falls diese von der Breite des Bildausschnittes abweicht wird
-					 das Bild entsprechend Skaliert.<br>
-					 Der Wert -1 gibt an, dass das Bild nicht Skaliert werden soll.<br>
-					 Der Standardwert ist -1.
-		@param Width gibt die Ausgabehöhe des Bildausschnittes an. 
-					 Falls diese von der Höhe des Bildauschnittes abweicht, wird
-					 das Bild entsprechend Skaliert.<br>
-					 Der Wert -1 gibt an, dass das Bild nicht Skaliert werden soll.<br>
-					 Der Standardwert ist -1.
-		@return Gibt false zurück, falls das Rendern fehlgeschlagen ist.
-		@remark Er werden nicht alle Blitting-Operationen von allen BS_Image-Klassen unterstützt.<br>
-				Mehr Informationen gibt es in der Klassenbeschreibung von BS_Image und durch folgende Methoden:
-				- IsBlitTarget()
-				- IsScalingAllowed()
-				- IsFillingAllowed()
-				- IsAlphaAllowed()
-				- IsColorModulationAllowed()
-				- IsSetContentAllowed()
+	    @brief Rendert das Bild in den Framebuffer.
+	    @param pDest ein Pointer auf das Zielbild. In den meisten Fällen ist dies der Framebuffer.
+	    @param PosX die Position auf der X-Achse im Zielbild in Pixeln, an der das Bild gerendert werden soll.<br>
+	                Der Standardwert ist 0.
+	    @param PosY die Position auf der Y-Achse im Zielbild in Pixeln, an der das Bild gerendert werden soll.<br>
+	                Der Standardwert ist 0.
+	    @param Flipping gibt an, wie das Bild gespiegelt werden soll.<br>
+	                    Der Standardwert ist BS_Image::FLIP_NONE (keine Spiegelung)
+	    @param pSrcPartRect Pointer auf ein BS_Rect, welches den Ausschnitt des Quellbildes spezifiziert, der gerendert
+	                        werden soll oder NULL, falls das gesamte Bild gerendert werden soll.<br>
+	                        Dieser Ausschnitt bezieht sich auf das ungespiegelte und unskalierte Bild.<br>
+	                        Der Standardwert ist NULL.
+	    @param Color ein ARGB Farbwert, der die Parameter für die Farbmodulation und fürs Alphablending festlegt.<br>
+	                 Die Alpha-Komponente der Farbe bestimmt den Alphablending Parameter (0 = keine Deckung, 255 = volle Deckung).<br>
+	                 Die Farbkomponenten geben die Farbe für die Farbmodulation an.<br>
+	                 Der Standardwert is BS_ARGB(255, 255, 255, 255) (volle Deckung, keine Farbmodulation).
+	                 Zum Erzeugen des Farbwertes können die Makros BS_RGB und BS_ARGB benutzt werden.
+	    @param Width gibt die Ausgabebreite des Bildausschnittes an.
+	                 Falls diese von der Breite des Bildausschnittes abweicht wird
+	                 das Bild entsprechend Skaliert.<br>
+	                 Der Wert -1 gibt an, dass das Bild nicht Skaliert werden soll.<br>
+	                 Der Standardwert ist -1.
+	    @param Width gibt die Ausgabehöhe des Bildausschnittes an.
+	                 Falls diese von der Höhe des Bildauschnittes abweicht, wird
+	                 das Bild entsprechend Skaliert.<br>
+	                 Der Wert -1 gibt an, dass das Bild nicht Skaliert werden soll.<br>
+	                 Der Standardwert ist -1.
+	    @return Gibt false zurück, falls das Rendern fehlgeschlagen ist.
+	    @remark Er werden nicht alle Blitting-Operationen von allen BS_Image-Klassen unterstützt.<br>
+	            Mehr Informationen gibt es in der Klassenbeschreibung von BS_Image und durch folgende Methoden:
+	            - IsBlitTarget()
+	            - IsScalingAllowed()
+	            - IsFillingAllowed()
+	            - IsAlphaAllowed()
+	            - IsColorModulationAllowed()
+	            - IsSetContentAllowed()
 	*/
-	virtual bool Blit(int PosX = 0, int PosY = 0, 
-					  int Flipping = FLIP_NONE, 
-					  BS_Rect* pPartRect = NULL,
-					  unsigned int Color = BS_ARGB(255, 255, 255, 255),
-					  int Width = -1, int Height = -1) = 0;
+	virtual bool Blit(int PosX = 0, int PosY = 0,
+	                  int Flipping = FLIP_NONE,
+	                  BS_Rect *pPartRect = NULL,
+	                  unsigned int Color = BS_ARGB(255, 255, 255, 255),
+	                  int Width = -1, int Height = -1) = 0;
 
 	/**
-		@brief Füllt einen Rechteckigen Bereich des Bildes mit einer Farbe.
-		@param pFillRect Pointer auf ein BS_Rect, welches den Ausschnitt des Bildes spezifiziert, der gefüllt
-						  werden soll oder NULL, falls das gesamte Bild gefüllt werden soll.<br>
-						  Der Standardwert ist NULL.
-		@param Color der 32 Bit Farbwert mit dem der Bildbereich gefüllt werden soll.
-		@remark Es ist möglich über die Methode transparente Rechtecke darzustellen, indem man eine Farbe mit einem Alphawert ungleich
-				255 angibt.
-		@remark Unabhängig vom Farbformat des Bildes muss ein 32 Bit Farbwert angegeben werden. Zur Erzeugung, können die Makros
-				BS_RGB und BS_ARGB benutzt werden.
-		@remark Falls das Rechteck nicht völlig innerhalb des Bildschirms ist, wird es automatisch zurechtgestutzt.
+	    @brief Füllt einen Rechteckigen Bereich des Bildes mit einer Farbe.
+	    @param pFillRect Pointer auf ein BS_Rect, welches den Ausschnitt des Bildes spezifiziert, der gefüllt
+	                      werden soll oder NULL, falls das gesamte Bild gefüllt werden soll.<br>
+	                      Der Standardwert ist NULL.
+	    @param Color der 32 Bit Farbwert mit dem der Bildbereich gefüllt werden soll.
+	    @remark Es ist möglich über die Methode transparente Rechtecke darzustellen, indem man eine Farbe mit einem Alphawert ungleich
+	            255 angibt.
+	    @remark Unabhängig vom Farbformat des Bildes muss ein 32 Bit Farbwert angegeben werden. Zur Erzeugung, können die Makros
+	            BS_RGB und BS_ARGB benutzt werden.
+	    @remark Falls das Rechteck nicht völlig innerhalb des Bildschirms ist, wird es automatisch zurechtgestutzt.
 	*/
-	virtual bool Fill(const BS_Rect* pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)) = 0;
+	virtual bool Fill(const BS_Rect *pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0)) = 0;
 
 	/**
-		@brief Füllt den Inhalt des Bildes mit Pixeldaten.
-		@param Pixeldata ein Vector der die Pixeldaten enthält. Sie müssen in dem Farbformat des Bildes vorliegen und es müssen genügend Daten
-			   vorhanden sein, um das ganze Bild zu füllen.
-		@param Offset der Offset in Byte im Pixeldata-Vector an dem sich der erste zu schreibende Pixel befindet.<br>
-			   Der Standardwert ist 0.
-		@param Stride der Abstand in Byte zwischen dem Zeilenende und dem Beginn einer neuen Zeile im Pixeldata-Vector.<br>
-			   Der Standardwert ist 0.
-		@return Gibt false zurück, falls der Aufruf fehlgeschlagen ist.
-		@remark Ein Aufruf dieser Methode ist nur erlaubt, wenn IsSetContentAllowed() true zurückgibt.
+	    @brief Füllt den Inhalt des Bildes mit Pixeldaten.
+	    @param Pixeldata ein Vector der die Pixeldaten enthält. Sie müssen in dem Farbformat des Bildes vorliegen und es müssen genügend Daten
+	           vorhanden sein, um das ganze Bild zu füllen.
+	    @param Offset der Offset in Byte im Pixeldata-Vector an dem sich der erste zu schreibende Pixel befindet.<br>
+	           Der Standardwert ist 0.
+	    @param Stride der Abstand in Byte zwischen dem Zeilenende und dem Beginn einer neuen Zeile im Pixeldata-Vector.<br>
+	           Der Standardwert ist 0.
+	    @return Gibt false zurück, falls der Aufruf fehlgeschlagen ist.
+	    @remark Ein Aufruf dieser Methode ist nur erlaubt, wenn IsSetContentAllowed() true zurückgibt.
 	*/
 	virtual bool SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride) = 0;
 
 	/**
-		@brief Liest einen Pixel des Bildes.
-		@param X die X-Koordinate des Pixels.
-		@param Y die Y-Koordinate des Pixels
-		@return Gibt den 32-Bit Farbwert des Pixels an der übergebenen Koordinate zurück.
-		@remark Diese Methode sollte auf keine Fall benutzt werden um größere Teile des Bildes zu lesen, da sie sehr langsam ist. Sie ist
-				eher dafür gedacht einzelne Pixel des Bildes auszulesen.
+	    @brief Liest einen Pixel des Bildes.
+	    @param X die X-Koordinate des Pixels.
+	    @param Y die Y-Koordinate des Pixels
+	    @return Gibt den 32-Bit Farbwert des Pixels an der übergebenen Koordinate zurück.
+	    @remark Diese Methode sollte auf keine Fall benutzt werden um größere Teile des Bildes zu lesen, da sie sehr langsam ist. Sie ist
+	            eher dafür gedacht einzelne Pixel des Bildes auszulesen.
 	*/
 	virtual unsigned int GetPixel(int X, int Y) = 0;
 
@@ -183,39 +181,39 @@ public:
 	/** @name Auskunfts-Methoden */
 
 	/**
-		@brief Überprüft, ob an dem BS_Image Blit() aufgerufen werden darf.
-		@return Gibt false zurück, falls ein Blit()-Aufruf an diesem Objekt nicht gestattet ist.
+	    @brief Überprüft, ob an dem BS_Image Blit() aufgerufen werden darf.
+	    @return Gibt false zurück, falls ein Blit()-Aufruf an diesem Objekt nicht gestattet ist.
 	*/
 	virtual bool IsBlitSource() const = 0;
 
 	/**
-		@brief Überprüft, ob das BS_Image ein Zielbild für einen Blit-Aufruf sein kann.
-		@return Gibt false zurück, falls ein Blit-Aufruf mit diesem Objekt als Ziel nicht gestattet ist.
+	    @brief Überprüft, ob das BS_Image ein Zielbild für einen Blit-Aufruf sein kann.
+	    @return Gibt false zurück, falls ein Blit-Aufruf mit diesem Objekt als Ziel nicht gestattet ist.
 	*/
 	virtual bool IsBlitTarget() const = 0;
 
 	/**
-		@brief Gibt true zurück, falls das BS_Image bei einem Aufruf von Blit() skaliert dargestellt werden kann.
+	    @brief Gibt true zurück, falls das BS_Image bei einem Aufruf von Blit() skaliert dargestellt werden kann.
 	*/
 	virtual bool IsScalingAllowed() const = 0;
 
 	/**
-		@brief Gibt true zurück, wenn das BS_Image mit einem Aufruf von Fill() gefüllt werden kann.
+	    @brief Gibt true zurück, wenn das BS_Image mit einem Aufruf von Fill() gefüllt werden kann.
 	*/
 	virtual bool IsFillingAllowed() const = 0;
 
 	/**
-		@brief Gibt true zurück, wenn das BS_Image bei einem Aufruf von Blit() mit einem Alphawert dargestellt werden kann.
+	    @brief Gibt true zurück, wenn das BS_Image bei einem Aufruf von Blit() mit einem Alphawert dargestellt werden kann.
 	*/
 	virtual bool IsAlphaAllowed() const = 0;
 
 	/**
-		@brief Gibt true zurück, wenn das BS_Image bei einem Aufruf von Blit() mit Farbmodulation dargestellt werden kann.
+	    @brief Gibt true zurück, wenn das BS_Image bei einem Aufruf von Blit() mit Farbmodulation dargestellt werden kann.
 	*/
 	virtual bool IsColorModulationAllowed() const = 0;
 
 	/**
-		@brief Gibt true zurück, wenn der Inhalt des BS_Image durch eine Aufruf von SetContent() ausgetauscht werden kann.
+	    @brief Gibt true zurück, wenn der Inhalt des BS_Image durch eine Aufruf von SetContent() ausgetauscht werden kann.
 	*/
 	virtual bool IsSetContentAllowed() const = 0;
 
diff --git a/engines/sword25/gfx/image/imageloader.cpp b/engines/sword25/gfx/image/imageloader.cpp
index 1bf7508ee5..02eea59f56 100644
--- a/engines/sword25/gfx/image/imageloader.cpp
+++ b/engines/sword25/gfx/image/imageloader.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -40,31 +40,29 @@ namespace Sword25 {
 #define BS_LOG_PREFIX "IMAGELOADER"
 
 // Statische Elemente der Klasse BS_ImageLoader intialisieren.
-std::list<BS_ImageLoader*> BS_ImageLoader::_ImageLoaderList;
+std::list<BS_ImageLoader *> BS_ImageLoader::_ImageLoaderList;
 bool BS_ImageLoader::_ImageLoaderListInitialized = false;
 
 // Lade Methode
 // ------------
 
-bool BS_ImageLoader::LoadImage(const char* pFileData, unsigned int FileSize, 
-							   BS_GraphicEngine::COLOR_FORMATS ColorFormat, 
-							   char*& pUncompressedData, 
-							   int& Width, int& Height, 
-							   int& Pitch)
-{
+bool BS_ImageLoader::LoadImage(const char *pFileData, unsigned int FileSize,
+                               BS_GraphicEngine::COLOR_FORMATS ColorFormat,
+                               char*& pUncompressedData,
+                               int &Width, int &Height,
+                               int &Pitch) {
 	// Falls die Liste der BS_ImageLoader noch nicht initialisiert wurde, wird dies getan.
 	if (!_ImageLoaderListInitialized)
 		_InitializeLoaderList();
 
 	// Passenden BS_ImageLoader finden und Bild dekodieren
-	BS_ImageLoader* pLoader = _FindSuitableImageLoader(pFileData, FileSize);
-	if (pLoader)
-	{
+	BS_ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize);
+	if (pLoader) {
 		return pLoader->DecodeImage(pFileData, FileSize,
-									ColorFormat,
-									pUncompressedData,
-									Width, Height,
-									Pitch);
+		                            ColorFormat,
+		                            pUncompressedData,
+		                            Width, Height,
+		                            Pitch);
 	}
 
 	return false;
@@ -73,21 +71,19 @@ bool BS_ImageLoader::LoadImage(const char* pFileData, unsigned int FileSize,
 // Info Methode
 // ------------
 
-bool BS_ImageLoader::ExtractImageProperties(const char* pFileData, unsigned int FileSize,
-											BS_GraphicEngine::COLOR_FORMATS& ColorFormat,
-											int& Width, int& Height)
-{
+bool BS_ImageLoader::ExtractImageProperties(const char *pFileData, unsigned int FileSize,
+        BS_GraphicEngine::COLOR_FORMATS &ColorFormat,
+        int &Width, int &Height) {
 	// Falls die Liste der BS_ImageLoader noch nicht initialisiert wurde, wird dies getan.
 	if (!_ImageLoaderListInitialized)
 		_InitializeLoaderList();
 
 	// Passenden BS_ImageLoader finden und Bildeigenschaften auslesen.
-	BS_ImageLoader* pLoader = _FindSuitableImageLoader(pFileData, FileSize);
-	if (pLoader)
-	{
+	BS_ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize);
+	if (pLoader) {
 		return pLoader->ImageProperties(pFileData, FileSize,
-										ColorFormat,
-										Width, Height);
+		                                ColorFormat,
+		                                Width, Height);
 	}
 
 	return false;
@@ -96,8 +92,7 @@ bool BS_ImageLoader::ExtractImageProperties(const char* pFileData, unsigned int
 // Verwaltungs Methoden
 // --------------------
 
-void BS_ImageLoader::_InitializeLoaderList()
-{
+void BS_ImageLoader::_InitializeLoaderList() {
 	// Von jedem BS_ImageLoader wird eine Instanz erzeugt, diese fügen sich selbständig in die BS_ImageLoader-Liste ein.
 	for (int i = 0; i < BS_IMAGELOADER_COUNT; i++)
 		BS_IMAGELOADER_IDS[i]();
@@ -109,24 +104,19 @@ void BS_ImageLoader::_InitializeLoaderList()
 	atexit(BS_ImageLoader::_DeinitializeLoaderList);
 }
 
-void BS_ImageLoader::_DeinitializeLoaderList()
-{
-	while (!_ImageLoaderList.empty())
-	{
+void BS_ImageLoader::_DeinitializeLoaderList() {
+	while (!_ImageLoaderList.empty()) {
 		delete _ImageLoaderList.back();
 		_ImageLoaderList.pop_back();
 	}
 }
 
-BS_ImageLoader* BS_ImageLoader::_FindSuitableImageLoader(const char* pFileData, unsigned int FileSize)
-{
+BS_ImageLoader *BS_ImageLoader::_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize) {
 	// Alle BS_ImageLoader-Objekte durchgehen, bis eins gefunden wurde, dass das Bild laden kann
-	std::list<BS_ImageLoader*>::iterator Iter = _ImageLoaderList.begin();
-	for (; Iter != _ImageLoaderList.end(); ++Iter)
-	{
+	std::list<BS_ImageLoader *>::iterator Iter = _ImageLoaderList.begin();
+	for (; Iter != _ImageLoaderList.end(); ++Iter) {
 		// Falls ein geeigneter BS-ImageLoader gefunden wurde, wird er zurückgegeben.
-		if ((*Iter)->IsCorrectImageFormat(pFileData, FileSize))
-		{
+		if ((*Iter)->IsCorrectImageFormat(pFileData, FileSize)) {
 			return (*Iter);
 		}
 	}
diff --git a/engines/sword25/gfx/image/imageloader.h b/engines/sword25/gfx/image/imageloader.h
index 15c4e20606..204a56b144 100644
--- a/engines/sword25/gfx/image/imageloader.h
+++ b/engines/sword25/gfx/image/imageloader.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -33,10 +33,10 @@
  */
 
 /*
-	BS_ImageLoader
-	--------------
+    BS_ImageLoader
+    --------------
 
-	Autor: Malte Thiesen
+    Autor: Malte Thiesen
 */
 
 #ifndef SWORD25_IMAGELOADER_H
@@ -55,90 +55,88 @@
 namespace Sword25 {
 
 /**
-	@brief Über die statischen Methoden dieser Klasse werden alle unterstützten Bildformate geladen.
-
-	Zum Laden von Bildern wird die #LoadImage-Methode benutzt.
-
-	Außerdem stellt diese Klasse das Interface da, das alle Klassen implementieren müssen, die Bildformate einlesen.<br>
-	Zur Unterstützung eines neuen Bildformates muss folgendermaßen vorgegangen werden:
-	- Erzeugen einer neuen von #BS_ImageLoader abgeleiteten Klasse, die die Methoden #IsCorrectImageFormat und #DecodeImage impelementiert.
-	- Die Klasse muss eine statische Methode haben, die eine Instanz von ihr erzeugt und einen Pointer darauf zurückgibt.
-	- Diese Methode muss in der Liste in der Datei imageloader_ids.h eingetragen werden.
-	- Die Klasse muss JEDES Eingabebild seines Bildformates in die folgenden Farbformate konvertieren können:
-		- BS_GraphicEngine::CF_RGB16
-		- BS_GraphicEngine::CF_RGB15
-		- BS_GraphicEngine::CF_RGB16_INTERLEAVED
-		- BS_GraphicEngine::CF_RGB15_INTERLEAVED
-		- BS_GraphicEngine::CF_ARGB32
-		- BS_GraphicEngine::CF_BGRA32
-	- Zum Konvertieren der Bilddaten können die Hilfsmethoden dieser Klasse benutzt werden, die ARGB Bilddaten in alle benötigten
-	  Farbformate konvertieren.
+    @brief Über die statischen Methoden dieser Klasse werden alle unterstützten Bildformate geladen.
+
+    Zum Laden von Bildern wird die #LoadImage-Methode benutzt.
+
+    Außerdem stellt diese Klasse das Interface da, das alle Klassen implementieren müssen, die Bildformate einlesen.<br>
+    Zur Unterstützung eines neuen Bildformates muss folgendermaßen vorgegangen werden:
+    - Erzeugen einer neuen von #BS_ImageLoader abgeleiteten Klasse, die die Methoden #IsCorrectImageFormat und #DecodeImage impelementiert.
+    - Die Klasse muss eine statische Methode haben, die eine Instanz von ihr erzeugt und einen Pointer darauf zurückgibt.
+    - Diese Methode muss in der Liste in der Datei imageloader_ids.h eingetragen werden.
+    - Die Klasse muss JEDES Eingabebild seines Bildformates in die folgenden Farbformate konvertieren können:
+        - BS_GraphicEngine::CF_RGB16
+        - BS_GraphicEngine::CF_RGB15
+        - BS_GraphicEngine::CF_RGB16_INTERLEAVED
+        - BS_GraphicEngine::CF_RGB15_INTERLEAVED
+        - BS_GraphicEngine::CF_ARGB32
+        - BS_GraphicEngine::CF_BGRA32
+    - Zum Konvertieren der Bilddaten können die Hilfsmethoden dieser Klasse benutzt werden, die ARGB Bilddaten in alle benötigten
+      Farbformate konvertieren.
 */
-class BS_ImageLoader
-{
+class BS_ImageLoader {
 public:
 
 	//@{
 	/** @name Lade Methoden */
 
 	/**
-		@brief Lädt eine Bilddatei.
-
-		Diese Methode kann sämtliche unterstütztem Bildformate lesen. Die Methode erkennt selbstständing um welches Dateiformat es sich
-		bei der vorliegenden Datei handelt.<br>
-		Bisher wird nur PNG unterstützt.
-
-		@param pFileData ein Pointer auf die Bilddaten.
-		@param FileSize die Größe der Bilddaten in Byte.
-		@param ColorFormat gibt das gewünschte Farbformat an, in das die Bilddaten konvertiert werden sollen.<br>
-						   Folgende Farbformate werden unterstützt:
-						   - BS_GraphicEngine::CF_RGB16
-						   - BS_GraphicEngine::CF_RGB15
-						   - BS_GraphicEngine::CF_RGB16_INTERLEAVED
-						   - BS_GraphicEngine::CF_RGB15_INTERLEAVED
-						   - BS_GraphicEngine::CF_ARGB32
-		@param pUncompressedData nach erfolgreichen Laden zeigt dieser Pointer auf die enpackten und konvertierten Bilddaten.
-		@param Width gibt nach erfolgreichen Laden die Breite des geladenen Bildes an.
-		@param Height gibt nach erfolgreichen Laden die Höhe des geladenen Bildes an.
-		@param Pitch gibt nach erfolgreichen Laden die Länge einer Bildzeile in Byte an.
-		@return Gibt false zurück, falls das Laden fehlgeschlagen ist.
-		@remark Die Größe der Ausgabedaten in Bytes kann wie folgt berechnet werden: Pitch * Height.
-		@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
+	    @brief Lädt eine Bilddatei.
+
+	    Diese Methode kann sämtliche unterstütztem Bildformate lesen. Die Methode erkennt selbstständing um welches Dateiformat es sich
+	    bei der vorliegenden Datei handelt.<br>
+	    Bisher wird nur PNG unterstützt.
+
+	    @param pFileData ein Pointer auf die Bilddaten.
+	    @param FileSize die Größe der Bilddaten in Byte.
+	    @param ColorFormat gibt das gewünschte Farbformat an, in das die Bilddaten konvertiert werden sollen.<br>
+	                       Folgende Farbformate werden unterstützt:
+	                       - BS_GraphicEngine::CF_RGB16
+	                       - BS_GraphicEngine::CF_RGB15
+	                       - BS_GraphicEngine::CF_RGB16_INTERLEAVED
+	                       - BS_GraphicEngine::CF_RGB15_INTERLEAVED
+	                       - BS_GraphicEngine::CF_ARGB32
+	    @param pUncompressedData nach erfolgreichen Laden zeigt dieser Pointer auf die enpackten und konvertierten Bilddaten.
+	    @param Width gibt nach erfolgreichen Laden die Breite des geladenen Bildes an.
+	    @param Height gibt nach erfolgreichen Laden die Höhe des geladenen Bildes an.
+	    @param Pitch gibt nach erfolgreichen Laden die Länge einer Bildzeile in Byte an.
+	    @return Gibt false zurück, falls das Laden fehlgeschlagen ist.
+	    @remark Die Größe der Ausgabedaten in Bytes kann wie folgt berechnet werden: Pitch * Height.
+	    @remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
 	*/
-	static bool LoadImage(const char* pFileData, unsigned int FileSize,
-						  BS_GraphicEngine::COLOR_FORMATS ColorFormat,
-						  char*& pUncompressedData,
-						  int& Width, int& Height,
-						  int& Pitch);
+	static bool LoadImage(const char *pFileData, unsigned int FileSize,
+	                      BS_GraphicEngine::COLOR_FORMATS ColorFormat,
+	                      char*& pUncompressedData,
+	                      int &Width, int &Height,
+	                      int &Pitch);
 
 	/**
-		@brief Liest die Bildeigenschaften eines Bildes aus.
-
-		@param pFileData ein Pointer auf die Bilddaten.
-		@param FileSize die Größe des Bilddaten in Byte.
-		@param ColorFormat enthält nach einem erfolgreichem Aufruf das Farbformat des Bildes.
-		@param Width enthält nach einem erfolgreichem Aufruf die Breite des Bildes in Pixeln.
-		@param Height enthält nach einem erfolgreichem Aufruf die Höhe des Bildes in Pixeln.
-		@return Gibt false zurück, wenn die Bildeigenschaften nicht ausgelesen werden konnten.
-		@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
+	    @brief Liest die Bildeigenschaften eines Bildes aus.
+
+	    @param pFileData ein Pointer auf die Bilddaten.
+	    @param FileSize die Größe des Bilddaten in Byte.
+	    @param ColorFormat enthält nach einem erfolgreichem Aufruf das Farbformat des Bildes.
+	    @param Width enthält nach einem erfolgreichem Aufruf die Breite des Bildes in Pixeln.
+	    @param Height enthält nach einem erfolgreichem Aufruf die Höhe des Bildes in Pixeln.
+	    @return Gibt false zurück, wenn die Bildeigenschaften nicht ausgelesen werden konnten.
+	    @remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
 	*/
-	static bool ExtractImageProperties(const char* pFileData, unsigned int FileSize,
-									   BS_GraphicEngine::COLOR_FORMATS& ColorFormat,
-									   int& Width, int& Height);
+	static bool ExtractImageProperties(const char *pFileData, unsigned int FileSize,
+	                                   BS_GraphicEngine::COLOR_FORMATS &ColorFormat,
+	                                   int &Width, int &Height);
 	//@}
 
 protected:
 
 	// Protected Konstruktor, damit Instanzen dieser Klasse nur von BS_ImageLoader-Objekten erstellt werden können
 	/**
-		@brief Der Standardkonstruktor.
+	    @brief Der Standardkonstruktor.
 
-		Dieser Konstruktor registriert alle Instanzen von #BS_ImageLoader-Klassen in einer Liste.<br>
-		Diese Liste enthält jeweils eine Instanz jedes #BS_ImageLoader und wird benutzt um beliebige Bilddateien einem Loader zuzuordnen.
-		@remark Dieser Konstruktor ist protected damit nur #BS_ImageLoader-Objekte diese Klasse instanziieren können.
+	    Dieser Konstruktor registriert alle Instanzen von #BS_ImageLoader-Klassen in einer Liste.<br>
+	    Diese Liste enthält jeweils eine Instanz jedes #BS_ImageLoader und wird benutzt um beliebige Bilddateien einem Loader zuzuordnen.
+	    @remark Dieser Konstruktor ist protected damit nur #BS_ImageLoader-Objekte diese Klasse instanziieren können.
 	*/
-	BS_ImageLoader()
-	{
+	BS_ImageLoader() {
 		// Klasse registrieren
 		_ImageLoaderList.push_front(this);
 	}
@@ -147,54 +145,54 @@ protected:
 	/** @name Abstrakte Methoden */
 
 	/**
-		@brief Gibt an, ob der #BS_ImageLoader ein Bild lesen kann.
-		@param pFileData ein Pointer auf die kompletten Daten des Bildes.
-		@param FileSize die Größe der Daten in Byte.
-		@return Gibt true zurück, wenn der #BS_ImageLoader das Bild lesen kann, ansonsten false.
-		@remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
+	    @brief Gibt an, ob der #BS_ImageLoader ein Bild lesen kann.
+	    @param pFileData ein Pointer auf die kompletten Daten des Bildes.
+	    @param FileSize die Größe der Daten in Byte.
+	    @return Gibt true zurück, wenn der #BS_ImageLoader das Bild lesen kann, ansonsten false.
+	    @remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
 	*/
-	virtual bool IsCorrectImageFormat(const char* pFileData, unsigned int FileSize) = 0;
+	virtual bool IsCorrectImageFormat(const char *pFileData, unsigned int FileSize) = 0;
 
 	/**
-		@brief Lädt eine Bilddatei.
-		@param pFileData ein Pointer auf die Bilddaten.
-		@param FileSize die Größe der Bilddaten in Byte.
-		@param ColorFormat gibt das gewünschte Farbformat an, in das die Bilddaten konvertiert werden sollen.<br>
-						   Folgende Farbformate werden unterstützt:
-						   - BS_GraphicEngine::CF_RGB16
-						   - BS_GraphicEngine::CF_RGB15
-						   - BS_GraphicEngine::CF_RGB16_INTERLEAVED
-						   - BS_GraphicEngine::CF_RGB15_INTERLEAVED
-						   - BS_GraphicEngine::CF_ARGB32
-		@param pUncompressedData nach erfolgreichen Laden zeigt dieser Pointer auf die enpackten und konvertierten Bilddaten.
-		@param Width gibt nach erfolgreichen Laden die Breite des geladenen Bildes an.
-		@param Height gibt nach erfolgreichen Laden die Höhe des geladenen Bildes an.
-		@param Pitch gibt nach erfolgreichen Laden die Länge einer Bildzeile in Byte an.
-		@return Gibt false zurück, falls das Laden fehlgeschlagen ist.
-		@remark Die Größe der Ausgabedaten in Bytes kann wie folgt berechnet werden: Pitch * Height.
-		@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
-		@remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
+	    @brief Lädt eine Bilddatei.
+	    @param pFileData ein Pointer auf die Bilddaten.
+	    @param FileSize die Größe der Bilddaten in Byte.
+	    @param ColorFormat gibt das gewünschte Farbformat an, in das die Bilddaten konvertiert werden sollen.<br>
+	                       Folgende Farbformate werden unterstützt:
+	                       - BS_GraphicEngine::CF_RGB16
+	                       - BS_GraphicEngine::CF_RGB15
+	                       - BS_GraphicEngine::CF_RGB16_INTERLEAVED
+	                       - BS_GraphicEngine::CF_RGB15_INTERLEAVED
+	                       - BS_GraphicEngine::CF_ARGB32
+	    @param pUncompressedData nach erfolgreichen Laden zeigt dieser Pointer auf die enpackten und konvertierten Bilddaten.
+	    @param Width gibt nach erfolgreichen Laden die Breite des geladenen Bildes an.
+	    @param Height gibt nach erfolgreichen Laden die Höhe des geladenen Bildes an.
+	    @param Pitch gibt nach erfolgreichen Laden die Länge einer Bildzeile in Byte an.
+	    @return Gibt false zurück, falls das Laden fehlgeschlagen ist.
+	    @remark Die Größe der Ausgabedaten in Bytes kann wie folgt berechnet werden: Pitch * Height.
+	    @remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
+	    @remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
 	*/
-	virtual bool DecodeImage(const char* pFileData, unsigned int FileSize, 
-							 BS_GraphicEngine::COLOR_FORMATS ColorFormat,
-							 char*& pUncompressedData,
-							 int& Width, int& Height,
-							 int& Pitch) = 0;
+	virtual bool DecodeImage(const char *pFileData, unsigned int FileSize,
+	                         BS_GraphicEngine::COLOR_FORMATS ColorFormat,
+	                         char*& pUncompressedData,
+	                         int &Width, int &Height,
+	                         int &Pitch) = 0;
 
 	/**
-		@brief Liest die Bildeigenschaften aus.
-		@param pFileData ein Pointer auf die Bilddaten.
-		@param FileSize die Größe des Bilddaten in Byte.
-		@param ColorFormat enthält nach einem erfolgreichem Aufruf das Farbformat des Bildes.
-		@param Width enthält nach einem erfolgreichem Aufruf die Breite des Bildes in Pixeln.
-		@param Height enthält nach einem erfolgreichem Aufruf die Höhe des Bildes in Pixeln.
-		@return Gibt false zurück, wenn die Bildeigenschaften nicht ausgelesen werden konnten.
-		@remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
-		@remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
+	    @brief Liest die Bildeigenschaften aus.
+	    @param pFileData ein Pointer auf die Bilddaten.
+	    @param FileSize die Größe des Bilddaten in Byte.
+	    @param ColorFormat enthält nach einem erfolgreichem Aufruf das Farbformat des Bildes.
+	    @param Width enthält nach einem erfolgreichem Aufruf die Breite des Bildes in Pixeln.
+	    @param Height enthält nach einem erfolgreichem Aufruf die Höhe des Bildes in Pixeln.
+	    @return Gibt false zurück, wenn die Bildeigenschaften nicht ausgelesen werden konnten.
+	    @remark Es darf nicht vergessen werden, die Ausgabedaten nach erfolgter Benutzung mit delete freizugeben.
+	    @remark Diese Methode muss von allen BS_ImageLoader Klassen implementiert werden.
 	*/
-	virtual bool ImageProperties(const char* pFileData, unsigned int FileSize,
-								 BS_GraphicEngine::COLOR_FORMATS& ColorFormat,
-								 int& Width, int& Height) = 0;
+	virtual bool ImageProperties(const char *pFileData, unsigned int FileSize,
+	                             BS_GraphicEngine::COLOR_FORMATS &ColorFormat,
+	                             int &Width, int &Height) = 0;
 
 	//@}
 
@@ -202,69 +200,62 @@ protected:
 	/** @name Konvertierungsmethoden */
 
 	/**
-		@brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB16 Farbformat.
-		@param pSrcData ein Pointer auf die Quelldaten.
-		@param pDestData ein Pointer auf den Zielpuffern.
-		@param Width die Anzahl der Pixel in der Bildzeile.
-		@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
-				Es sind mindestens Width * 2 Byte notwendig.
+	    @brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB16 Farbformat.
+	    @param pSrcData ein Pointer auf die Quelldaten.
+	    @param pDestData ein Pointer auf den Zielpuffern.
+	    @param Width die Anzahl der Pixel in der Bildzeile.
+	    @remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
+	            Es sind mindestens Width * 2 Byte notwendig.
 	*/
-	static void RowARGB32ToRGB16(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
-	{
-		for (unsigned int i = 0; i < Width; i++)
-		{
-			((uint16_t*)pDestData)[i] = ((pSrcData[2] >> 3) << 11) | ((pSrcData[1] >> 2) << 5) | (pSrcData[0] >> 3);
+	static void RowARGB32ToRGB16(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
+		for (unsigned int i = 0; i < Width; i++) {
+			((uint16_t *)pDestData)[i] = ((pSrcData[2] >> 3) << 11) | ((pSrcData[1] >> 2) << 5) | (pSrcData[0] >> 3);
 			pSrcData += 4;
 		}
 	}
-	
+
 	/**
-		@brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB15 Farbformat.
-		@param pSrcData ein Pointer auf die Quelldaten.
-		@param pDestData ein Pointer auf den Zielpuffern.
-		@param Width die Anzahl der Pixel in der Bildzeile.
-		@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
-				Es sind mindestens Width * 2 Byte notwendig.
+	    @brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB15 Farbformat.
+	    @param pSrcData ein Pointer auf die Quelldaten.
+	    @param pDestData ein Pointer auf den Zielpuffern.
+	    @param Width die Anzahl der Pixel in der Bildzeile.
+	    @remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
+	            Es sind mindestens Width * 2 Byte notwendig.
 	*/
-	static void RowARGB32ToRGB15(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
-	{
-		for (unsigned int i = 0; i < Width; i++)
-		{
-			((uint16_t*)pDestData)[i] = ((pSrcData[2] >> 3) << 10) | ((pSrcData[1] >> 3) << 5) | (pSrcData[0] >> 3);
+	static void RowARGB32ToRGB15(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
+		for (unsigned int i = 0; i < Width; i++) {
+			((uint16_t *)pDestData)[i] = ((pSrcData[2] >> 3) << 10) | ((pSrcData[1] >> 3) << 5) | (pSrcData[0] >> 3);
 			pSrcData += 4;
 		}
 	}
 
 	/**
-		@brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB16_INTERLEAVED Farbformat.
-		@param pSrcData ein Pointer auf die Quelldaten.
-		@param pDestData ein Pointer auf den Zielpuffern.
-		@param Width die Anzahl der Pixel in der Bildzeile.
-		@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß sein muss.<br>
-				Es sind mindestens ((Width + 3) / 4) * 12 Byte notwendig.
+	    @brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB16_INTERLEAVED Farbformat.
+	    @param pSrcData ein Pointer auf die Quelldaten.
+	    @param pDestData ein Pointer auf den Zielpuffern.
+	    @param Width die Anzahl der Pixel in der Bildzeile.
+	    @remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß sein muss.<br>
+	            Es sind mindestens ((Width + 3) / 4) * 12 Byte notwendig.
 	*/
-	static void RowARGB32ToRGB16_INTERLEAVED(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
-	{
+	static void RowARGB32ToRGB16_INTERLEAVED(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
 		// Die Pixelblöcke erstellen, dabei werden immer jeweils 4 Pixel zu einem Block zusammengefasst
 		unsigned int BlockFillCount = 0;
 		unsigned int AlphaBlock = 0;
-		for (unsigned int i = 0; i < Width; i++)
-		{
+		for (unsigned int i = 0; i < Width; i++) {
 			// Alphawert in den Alphablock schreiben
 			AlphaBlock = (AlphaBlock >> 8) | (pSrcData[BlockFillCount * 4 + 3] << 24);
-			
+
 			// Füllstand der Pixelblockes aktualisieren
 			BlockFillCount++;
 
 			// Sobald 4 Alphawerte gesammelt wurden, oder die Zeile zu Ende ist wird der Pixelblock in den Zielpuffer geschrieben
-			if (BlockFillCount == 4 || i == (Width - 1))
-			{
+			if (BlockFillCount == 4 || i == (Width - 1)) {
 				// Falls der AlphaBlock nicht ganz gefüllt ist muss geshiftet werden um sicherzustellen, dass die Alphawerte
 				// "left aligned" sind.
 				AlphaBlock >>= (4 - BlockFillCount) * 8;
 
 				// Alphablock schreiben
-				*((unsigned int*)pDestData) = AlphaBlock;
+				*((unsigned int *)pDestData) = AlphaBlock;
 				pDestData += 4;
 
 				// Pixel konvertieren und schreiben
@@ -283,35 +274,32 @@ protected:
 	}
 
 	/**
-		@brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB15_INTERLEAVED Farbformat.
-		@param pSrcData ein Pointer auf die Quelldaten.
-		@param pDestData ein Pointer auf den Zielpuffern.
-		@param Width die Anzahl der Pixel in der Bildzeile.
-		@remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
-				Es sind mindestens (Width / 4 + Width % 4) * 3 Byte notwendig.
+	    @brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_RGB15_INTERLEAVED Farbformat.
+	    @param pSrcData ein Pointer auf die Quelldaten.
+	    @param pDestData ein Pointer auf den Zielpuffern.
+	    @param Width die Anzahl der Pixel in der Bildzeile.
+	    @remark Es gilt zu beachten, dass der Zielpuffer ausreichend groß ist.<br>
+	            Es sind mindestens (Width / 4 + Width % 4) * 3 Byte notwendig.
 	*/
-	static void RowARGB32ToRGB15_INTERLEAVED(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
-	{
+	static void RowARGB32ToRGB15_INTERLEAVED(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
 		// Die Pixelblöcke erstellen, dabei werden immer jeweils 4 Pixel zu einem Block zusammengefasst
 		unsigned int BlockFillCount = 0;
 		unsigned int AlphaBlock = 0;
-		for (unsigned int i = 0; i < Width; i++)
-		{
+		for (unsigned int i = 0; i < Width; i++) {
 			// Alphawert in den Alphablock schreiben
 			AlphaBlock = (AlphaBlock >> 8) | (pSrcData[BlockFillCount * 4 + 3] << 24);
-			
+
 			// Füllstand der Pixelblockes aktualisieren
 			BlockFillCount++;
 
 			// Sobald 4 Alphawerte gesammelt wurden, oder die Zeile zu Ende ist wird der Pixelblock in den Zielpuffer geschrieben
-			if (BlockFillCount == 4 || i == (Width - 1))
-			{
+			if (BlockFillCount == 4 || i == (Width - 1)) {
 				// Falls der AlphaBlock nicht ganz gefüllt ist muss geshiftet werden um sicherzustellen, dass die Alphawerte
 				// "left aligned" sind.
 				AlphaBlock >>= (4 - BlockFillCount) * 8;
 
 				// Alphablock schreiben
-				*((unsigned int*)pDestData) = AlphaBlock;
+				*((unsigned int *)pDestData) = AlphaBlock;
 				pDestData += 4;
 
 				// Pixel konvertieren und schreiben
@@ -330,15 +318,13 @@ protected:
 	}
 
 	/**
-		@brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_BGRA32 Farbformat.
-		@param pSrcData ein Pointer auf die Quelldaten.
-		@param pDestData ein Pointer auf den Zielpuffern.
-		@param Width die Anzahl der Pixel in der Bildzeile.
+	    @brief Konvertiert eine Bildzeile mit ARGB Pixeldaten in das BS_GraphicEngine::CF_BGRA32 Farbformat.
+	    @param pSrcData ein Pointer auf die Quelldaten.
+	    @param pDestData ein Pointer auf den Zielpuffern.
+	    @param Width die Anzahl der Pixel in der Bildzeile.
 	*/
-	static void RowARGB32ToABGR32(unsigned char* pSrcData, unsigned char* pDestData, unsigned int Width)
-	{
-		for (unsigned int i = 0; i < Width; ++i)
-		{
+	static void RowARGB32ToABGR32(unsigned char *pSrcData, unsigned char *pDestData, unsigned int Width) {
+		for (unsigned int i = 0; i < Width; ++i) {
 			*pDestData++ = pSrcData[2];
 			*pDestData++ = pSrcData[1];
 			*pDestData++ = pSrcData[0];
@@ -351,25 +337,25 @@ protected:
 private:
 
 	/**
-		@brief Erzeugt je eine Instanz aller BS_ImageLoader Klassen und fügt diese in eine interne Liste ein. Diese werden dann beim
-			   Laden von Bildern benutzt.
-		@remark Die Klassen müssen in der Datei imageloader_ids.h eingetragen sein, damit sie an dieser Stelle berücksichtigt werden.
+	    @brief Erzeugt je eine Instanz aller BS_ImageLoader Klassen und fügt diese in eine interne Liste ein. Diese werden dann beim
+	           Laden von Bildern benutzt.
+	    @remark Die Klassen müssen in der Datei imageloader_ids.h eingetragen sein, damit sie an dieser Stelle berücksichtigt werden.
 	*/
 	static void _InitializeLoaderList();
 
 	/**
-		@brief Zerstört alle Instanzen von BS_ImageLoader Klassen, die in dieser Klasse registriert sind.
+	    @brief Zerstört alle Instanzen von BS_ImageLoader Klassen, die in dieser Klasse registriert sind.
 	*/
 	static void _DeinitializeLoaderList();
 
 	/**
-		@brief Sucht zu Bilddaten ein BS_ImageLoader Objekt, dass die Bilddaten dekodieren kann.
-		@return Gibt einen Pointer auf ein passendes BS_ImageLoader Objekt zurück, oder NULL, wenn kein passendes Objekt gefunden wurde.
+	    @brief Sucht zu Bilddaten ein BS_ImageLoader Objekt, dass die Bilddaten dekodieren kann.
+	    @return Gibt einen Pointer auf ein passendes BS_ImageLoader Objekt zurück, oder NULL, wenn kein passendes Objekt gefunden wurde.
 	*/
-	static BS_ImageLoader* _FindSuitableImageLoader(const char* pFileData, unsigned int FileSize);
+	static BS_ImageLoader *_FindSuitableImageLoader(const char *pFileData, unsigned int FileSize);
 
-	static std::list<BS_ImageLoader*>	_ImageLoaderList;				// Die Liste aller BS_ImageLoader-Objekte
-	static bool							_ImageLoaderListInitialized;	// Gibt an, ob die Liste schon intialisiert wurde
+	static std::list<BS_ImageLoader *>   _ImageLoaderList;              // Die Liste aller BS_ImageLoader-Objekte
+	static bool                         _ImageLoaderListInitialized;    // Gibt an, ob die Liste schon intialisiert wurde
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/image/imageloader_ids.h b/engines/sword25/gfx/image/imageloader_ids.h
index 74c5c3429a..bde6293f50 100644
--- a/engines/sword25/gfx/image/imageloader_ids.h
+++ b/engines/sword25/gfx/image/imageloader_ids.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -33,12 +33,12 @@
  */
 
 /*
-	imageloader_ids.h
-	-----------------
-	In dieser Datei sind alle ImageLoader verzeichnet.
-	JEDER neuer ImageLoader muss hier eingetragen werden, ansonsten wird er beim Laden eines Bildes nicht berücksichtigt.
+    imageloader_ids.h
+    -----------------
+    In dieser Datei sind alle ImageLoader verzeichnet.
+    JEDER neuer ImageLoader muss hier eingetragen werden, ansonsten wird er beim Laden eines Bildes nicht berücksichtigt.
 
-	Autor: Malte Thiesen
+    Autor: Malte Thiesen
 */
 
 #include "sword25/gfx/image/imageloader.h"
@@ -51,9 +51,8 @@ namespace Sword25 {
 
 // Die Tabelle enthält Pointer auf statische Member-Funktionen innerhalb der Klassen, die eine Instanz der Klasse
 // erzeugen
-typedef BS_ImageLoader* (*BS_IMAGELOADER_NEW)();
-const BS_IMAGELOADER_NEW BS_IMAGELOADER_IDS[] =
-{
+typedef BS_ImageLoader*(*BS_IMAGELOADER_NEW)();
+const BS_IMAGELOADER_NEW BS_IMAGELOADER_IDS[] = {
 	BS_PNGLoader::CreateInstance,
 	BS_B25SLoader::CreateInstance,
 };
diff --git a/engines/sword25/gfx/image/pngloader.cpp b/engines/sword25/gfx/image/pngloader.cpp
index 693874314f..1c896a7675 100644
--- a/engines/sword25/gfx/image/pngloader.cpp
+++ b/engines/sword25/gfx/image/pngloader.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -48,66 +48,58 @@ namespace Sword25 {
 // Konstruktor / Destruktor
 // -----------------------------------------------------------------------------
 
-BS_PNGLoader::BS_PNGLoader()
-{
+BS_PNGLoader::BS_PNGLoader() {
 }
 
 // -----------------------------------------------------------------------------
 // Laden
 // -----------------------------------------------------------------------------
 
-static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
-{
-	memcpy(data, (char*)png_ptr->io_ptr, length);
-	png_ptr->io_ptr = (void*)((png_size_t)png_ptr->io_ptr + length);
+static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length) {
+	memcpy(data, (char *)png_ptr->io_ptr, length);
+	png_ptr->io_ptr = (void *)((png_size_t)png_ptr->io_ptr + length);
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
-								 int & Width, int & Height, int & Pitch)
-{
+bool BS_PNGLoader::DoDecodeImage(const char *FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
+                                 int &Width, int &Height, int &Pitch) {
 	png_structp png_ptr = NULL;
 	png_infop   info_ptr = NULL;
-	png_bytep	RawDataBuffer = NULL;
-	png_bytep*	pRowPtr = NULL;
+	png_bytep   RawDataBuffer = NULL;
+	png_bytep  *pRowPtr = NULL;
 
-	int			BitDepth;
-	int			ColorType;
-	int			InterlaceType;
-	int			i;
+	int         BitDepth;
+	int         ColorType;
+	int         InterlaceType;
+	int         i;
 
 	// Zielfarbformat überprüfen
 	if (ColorFormat != BS_GraphicEngine::CF_RGB16 &&
-		ColorFormat != BS_GraphicEngine::CF_RGB15 &&
-		ColorFormat != BS_GraphicEngine::CF_RGB16_INTERLEAVED &&
-		ColorFormat != BS_GraphicEngine::CF_RGB15_INTERLEAVED &&
-		ColorFormat != BS_GraphicEngine::CF_ARGB32 &&
-		ColorFormat != BS_GraphicEngine::CF_ABGR32)
-	{
+	        ColorFormat != BS_GraphicEngine::CF_RGB15 &&
+	        ColorFormat != BS_GraphicEngine::CF_RGB16_INTERLEAVED &&
+	        ColorFormat != BS_GraphicEngine::CF_RGB15_INTERLEAVED &&
+	        ColorFormat != BS_GraphicEngine::CF_ARGB32 &&
+	        ColorFormat != BS_GraphicEngine::CF_ABGR32) {
 		BS_LOG_ERRORLN("Illegal or unsupported color format.");
 		return false;
 	}
 
-	try
-	{
+	try {
 		// PNG Signatur überprüfen
-		if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<char *>(FileDataPtr)), 8))
-		{
+		if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<char *>(FileDataPtr)), 8)) {
 			throw(0);
 		}
 
 		// Die beiden PNG Strukturen erstellen
 		png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-		if (!png_ptr)
-		{
+		if (!png_ptr) {
 			BS_LOG_ERRORLN("Could not create libpng read struct.");
 			throw(0);
 		}
 
 		info_ptr = png_create_info_struct(png_ptr);
-		if (!info_ptr)
-		{
+		if (!info_ptr) {
 			BS_LOG_ERRORLN("Could not create libpng info struct.");
 			throw(0);
 		}
@@ -116,13 +108,13 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 		if (setjmp(png_jmpbuf(png_ptr))) throw(0);
 
 		// Alternative Lesefunktion benutzen
-		png_set_read_fn(png_ptr, (void*)FileDataPtr, png_user_read_data);
+		png_set_read_fn(png_ptr, (void *)FileDataPtr, png_user_read_data);
 
 		// PNG Header einlesen
 		png_read_info(png_ptr, info_ptr);
 
 		// PNG Informationen auslesen
-		png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL);
+		png_get_IHDR(png_ptr, info_ptr, (unsigned long *)&Width, (unsigned long *)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL);
 
 		// Pitch des Ausgabebildes berechnen
 		Pitch = BS_GraphicEngine::CalcPitch(ColorFormat, Width);
@@ -130,8 +122,7 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 		// Speicher für die endgültigen Bilddaten reservieren
 		// Dieses geschieht vor dem reservieren von Speicher für temporäre Bilddaten um die Fragmentierung des Speichers gering zu halten
 		UncompressedDataPtr = new char[Pitch * Height];
-		if (!UncompressedDataPtr)
-		{
+		if (!UncompressedDataPtr) {
 			BS_LOG_ERRORLN("Could not allocate memory for output image.");
 			throw(0);
 		}
@@ -146,7 +137,7 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 		if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 			png_set_expand(png_ptr);
 		if (ColorType == PNG_COLOR_TYPE_GRAY ||
-			ColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
+		        ColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
 			png_set_gray_to_rgb(png_ptr);
 
 		png_set_bgr(png_ptr);
@@ -156,62 +147,58 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 
 		// Nachdem die Transformationen registriert wurden, werden die Bilddaten erneut eingelesen
 		png_read_update_info(png_ptr, info_ptr);
-		png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
+		png_get_IHDR(png_ptr, info_ptr, (unsigned long *)&Width, (unsigned long *)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
 
 		// PNGs ohne Interlacing werden Zeilenweise eingelesen
-		if (InterlaceType == PNG_INTERLACE_NONE)
-		{
+		if (InterlaceType == PNG_INTERLACE_NONE) {
 			// Speicher für eine Bildzeile reservieren
 			RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr)];
-			if (!RawDataBuffer)
-			{
+			if (!RawDataBuffer) {
 				BS_LOG_ERRORLN("Could not allocate memory for row buffer.");
 				throw(0);
 			}
 
 			// Bilddaten zeilenweise einlesen und in das gewünschte Zielformat konvertieren
-			for (i = 0; i < Height; i++)
-			{
+			for (i = 0; i < Height; i++) {
 				// Zeile einlesen
 				png_read_row(png_ptr, RawDataBuffer, NULL);
 
 				// Zeile konvertieren
-				switch (ColorFormat)
-				{
+				switch (ColorFormat) {
 				case BS_GraphicEngine::CF_RGB16:
-					RowARGB32ToRGB16((unsigned char*)RawDataBuffer,
-						(unsigned char*)&UncompressedDataPtr[i * Pitch],
-						Width);
+					RowARGB32ToRGB16((unsigned char *)RawDataBuffer,
+					                 (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                 Width);
 					break;
 
 				case BS_GraphicEngine::CF_RGB15:
-					RowARGB32ToRGB15((unsigned char*)RawDataBuffer,
-						(unsigned char*)&UncompressedDataPtr[i * Pitch],
-						Width);
+					RowARGB32ToRGB15((unsigned char *)RawDataBuffer,
+					                 (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                 Width);
 					break;
 
 				case BS_GraphicEngine::CF_RGB16_INTERLEAVED:
-					RowARGB32ToRGB16_INTERLEAVED((unsigned char*)RawDataBuffer,
-						(unsigned char*)&UncompressedDataPtr[i * Pitch],
-						Width);
+					RowARGB32ToRGB16_INTERLEAVED((unsigned char *)RawDataBuffer,
+					                             (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                             Width);
 					break;
 
 				case BS_GraphicEngine::CF_RGB15_INTERLEAVED:
-					RowARGB32ToRGB15_INTERLEAVED((unsigned char*)RawDataBuffer,
-						(unsigned char*)&UncompressedDataPtr[i * Pitch],
-						Width);
+					RowARGB32ToRGB15_INTERLEAVED((unsigned char *)RawDataBuffer,
+					                             (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                             Width);
 					break;
 
 				case BS_GraphicEngine::CF_ARGB32:
 					memcpy(&UncompressedDataPtr[i * Pitch],
-						RawDataBuffer,
-						Pitch);
+					       RawDataBuffer,
+					       Pitch);
 					break;
 
 				case BS_GraphicEngine::CF_ABGR32:
-					RowARGB32ToABGR32((unsigned char*)RawDataBuffer,
-						(unsigned char*)&UncompressedDataPtr[i * Pitch],
-						Width);
+					RowARGB32ToABGR32((unsigned char *)RawDataBuffer,
+					                  (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                  Width);
 					break;
 
 				default:
@@ -220,20 +207,17 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 			}
 		}
 		// PNGs mit Interlacing werden an einem Stück eingelesen
-		else
-		{
+		else {
 			// Speicher für das komplette Bild reservieren
 			RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr) * Height];
-			if (!RawDataBuffer)
-			{
+			if (!RawDataBuffer) {
 				BS_LOG_ERRORLN("Could not allocate memory for raw image buffer.");
 				throw(0);
 			}
 
 			// Speicher für die Rowpointer reservieren
 			pRowPtr = new png_bytep[Height];
-			if (!pRowPtr)
-			{
+			if (!pRowPtr) {
 				BS_LOG_ERRORLN("Could not allocate memory for row pointers.");
 				throw(0);
 			}
@@ -246,41 +230,40 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 			png_read_image(png_ptr, pRowPtr);
 
 			// Bilddaten zeilenweise in das gewünschte Ausgabeformat konvertieren
-			switch (ColorFormat)
-			{
+			switch (ColorFormat) {
 			case BS_GraphicEngine::CF_RGB16:
 				for (i = 0; i < Height; i++)
-					RowARGB32ToRGB16((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
-					(unsigned char*)&UncompressedDataPtr[i * Pitch],
-					Width);
+					RowARGB32ToRGB16((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
+					                 (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                 Width);
 				break;
 
 			case BS_GraphicEngine::CF_RGB15:
 				for (i = 0; i < Height; i++)
-					RowARGB32ToRGB15((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
-					(unsigned char*)&UncompressedDataPtr[i * Pitch],
-					Width);
+					RowARGB32ToRGB15((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
+					                 (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                 Width);
 				break;
 
 			case BS_GraphicEngine::CF_RGB16_INTERLEAVED:
 				for (i = 0; i < Height; i++)
-					RowARGB32ToRGB16_INTERLEAVED((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
-					(unsigned char*)&UncompressedDataPtr[i * Pitch],
-					Width);
+					RowARGB32ToRGB16_INTERLEAVED((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
+					                             (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                             Width);
 				break;
 
 			case BS_GraphicEngine::CF_RGB15_INTERLEAVED:
 				for (i = 0; i < Height; i++)
-					RowARGB32ToRGB15_INTERLEAVED((unsigned char*)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
-					(unsigned char*)&UncompressedDataPtr[i * Pitch],
-					Width);
+					RowARGB32ToRGB15_INTERLEAVED((unsigned char *)(&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)]),
+					                             (unsigned char *)&UncompressedDataPtr[i * Pitch],
+					                             Width);
 				break;
 
 			case BS_GraphicEngine::CF_ARGB32:
 				for (i = 0; i < Height; i++)
 					memcpy(&UncompressedDataPtr[i * Pitch],
-					&RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)],
-					Pitch);
+					       &RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)],
+					       Pitch);
 				break;
 			}
 		}
@@ -296,8 +279,7 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 		delete[] RawDataBuffer;
 	}
 
-	catch(int)
-	{
+	catch (int) {
 		delete[] pRowPtr;
 		delete[] RawDataBuffer;
 		if (png_ptr) png_destroy_read_struct(&png_ptr, NULL, NULL);
@@ -313,40 +295,35 @@ bool BS_PNGLoader::DoDecodeImage(const char * FileDataPtr, unsigned int FileSize
 
 // -----------------------------------------------------------------------------
 
-bool BS_PNGLoader::DecodeImage(const char * FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
-							   int & Width, int & Height, int & Pitch)
-{
+bool BS_PNGLoader::DecodeImage(const char *FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
+                               int &Width, int &Height, int &Pitch) {
 	return DoDecodeImage(FileDataPtr, FileSize, ColorFormat, UncompressedDataPtr, Width, Height, Pitch);
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height)
-{
+bool BS_PNGLoader::DoImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
 	// PNG Signatur überprüfen
 	if (!DoIsCorrectImageFormat(FileDataPtr, FileSize)) return false;
 
 	png_structp png_ptr = NULL;
 	png_infop info_ptr = NULL;
-	try
-	{
+	try {
 		// Die beiden PNG Strukturen erstellen
 		png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-		if (!png_ptr)
-		{
+		if (!png_ptr) {
 			BS_LOG_ERRORLN("Could not create libpng read struct.");
 			throw(0);
 		}
 
 		info_ptr = png_create_info_struct(png_ptr);
-		if (!info_ptr)
-		{
+		if (!info_ptr) {
 			BS_LOG_ERRORLN("Could not create libpng info struct.");
 			throw(0);
 		}
 
 		// Alternative Lesefunktion benutzen
-		png_set_read_fn(png_ptr, (void*)FileDataPtr, png_user_read_data);
+		png_set_read_fn(png_ptr, (void *)FileDataPtr, png_user_read_data);
 
 		// PNG Header einlesen
 		png_read_info(png_ptr, info_ptr);
@@ -354,7 +331,7 @@ bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int File
 		// PNG Informationen auslesen
 		int BitDepth;
 		int ColorType;
-		png_get_IHDR(png_ptr, info_ptr, (unsigned long*)&Width, (unsigned long*)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
+		png_get_IHDR(png_ptr, info_ptr, (unsigned long *)&Width, (unsigned long *)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
 
 		// PNG-ColorType in BS ColorFormat konvertieren.
 		if (ColorType & PNG_COLOR_MASK_ALPHA || png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
@@ -366,8 +343,7 @@ bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int File
 		png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 	}
 
-	catch (int)
-	{
+	catch (int) {
 		if (png_ptr) png_destroy_read_struct(&png_ptr, NULL, NULL);
 		if (info_ptr) png_destroy_read_struct(NULL, &info_ptr, NULL);
 
@@ -381,8 +357,7 @@ bool BS_PNGLoader::DoImageProperties(const char * FileDataPtr, unsigned int File
 
 // -----------------------------------------------------------------------------
 
-bool BS_PNGLoader::ImageProperties(const char* FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height)
-{
+bool BS_PNGLoader::ImageProperties(const char *FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
 	return DoImageProperties(FileDataPtr, FileSize, ColorFormat, Width, Height);
 }
 
@@ -390,18 +365,16 @@ bool BS_PNGLoader::ImageProperties(const char* FileDataPtr, unsigned int FileSiz
 // Header überprüfen
 // -----------------------------------------------------------------------------
 
-bool BS_PNGLoader::DoIsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize)
-{
+bool BS_PNGLoader::DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) {
 	if (FileSize > 8)
-		return png_check_sig((unsigned char*)FileDataPtr, 8) ? true : false;
+		return png_check_sig((unsigned char *)FileDataPtr, 8) ? true : false;
 	else
 		return false;
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_PNGLoader::IsCorrectImageFormat(const char* FileDataPtr, unsigned int FileSize)
-{
+bool BS_PNGLoader::IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize) {
 	return DoIsCorrectImageFormat(FileDataPtr, FileSize);
 }
 
diff --git a/engines/sword25/gfx/image/pngloader.h b/engines/sword25/gfx/image/pngloader.h
index a4ce28fbe5..85d12a7a94 100644
--- a/engines/sword25/gfx/image/pngloader.h
+++ b/engines/sword25/gfx/image/pngloader.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -33,11 +33,11 @@
  */
 
 /*
-	BS_PNGLoader
-	------------
-	BS_ImageLoader-Klasse zum Laden von PNG-Dateien
+    BS_PNGLoader
+    ------------
+    BS_ImageLoader-Klasse zum Laden von PNG-Dateien
 
-	Autor: Malte Thiesen
+    Autor: Malte Thiesen
 */
 
 #ifndef SWORD25_PNGLOADER2_H
@@ -50,32 +50,30 @@
 namespace Sword25 {
 
 // Klassendefinition
-class BS_PNGLoader : public BS_ImageLoader
-{
+class BS_PNGLoader : public BS_ImageLoader {
 public:
-	static BS_ImageLoader* CreateInstance() 
-	{ 
-		#include "sword25/kernel/memlog_off.h"
-		return (BS_ImageLoader*) new BS_PNGLoader();
-		#include "sword25/kernel/memlog_on.h"
+	static BS_ImageLoader *CreateInstance() {
+#include "sword25/kernel/memlog_off.h"
+		return (BS_ImageLoader *) new BS_PNGLoader();
+#include "sword25/kernel/memlog_on.h"
 	}
 
 	// Alle virtuellen Methoden von BS_ImageLoader sind hier als static-Methode implementiert, damit sie von BS_B25SLoader aufgerufen werden können.
 	// Die virtuellen Methoden rufen diese Methoden auf.
-	static bool DoIsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize);
-	static bool	DoDecodeImage(const char * FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
-							  int & Width, int & Height, int & Pitch);
-	static bool DoImageProperties(const char * FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height);
+	static bool DoIsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize);
+	static bool DoDecodeImage(const char *FileDataPtr, unsigned int FileSize,  BS_GraphicEngine::COLOR_FORMATS ColorFormat, char * & UncompressedDataPtr,
+	                          int &Width, int &Height, int &Pitch);
+	static bool DoImageProperties(const char *FileDataPtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height);
 
 protected:
 	BS_PNGLoader();
-	bool DecodeImage(const char * pFileData, unsigned int FileSize, 
-					 BS_GraphicEngine::COLOR_FORMATS ColorFormat,
-					 char * & pUncompressedData,
-					 int & Width, int & Height,
-					 int & Pitch);
-	bool IsCorrectImageFormat(const char * FileDataPtr, unsigned int FileSize);
-	bool ImageProperties(const char * FileDatePtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS & ColorFormat, int & Width, int & Height);
+	bool DecodeImage(const char *pFileData, unsigned int FileSize,
+	                 BS_GraphicEngine::COLOR_FORMATS ColorFormat,
+	                 char * & pUncompressedData,
+	                 int &Width, int &Height,
+	                 int &Pitch);
+	bool IsCorrectImageFormat(const char *FileDataPtr, unsigned int FileSize);
+	bool ImageProperties(const char *FileDatePtr, unsigned int FileSize, BS_GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height);
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/image/vectorimage.cpp b/engines/sword25/gfx/image/vectorimage.cpp
index 5c7a5231a8..a8c84ee6b3 100644
--- a/engines/sword25/gfx/image/vectorimage.cpp
+++ b/engines/sword25/gfx/image/vectorimage.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -68,111 +68,94 @@ typedef int16_t s32;
 // Diese Klasse ist speziell dafür ausgestattet.
 // -----------------------------------------------------------------------------
 
-class BS_VectorImage::SWFBitStream
-{
+class BS_VectorImage::SWFBitStream {
 public:
-	SWFBitStream(const unsigned char * pData, unsigned int DataSize) :
-	  m_Pos(pData), m_End(pData + DataSize), m_WordMask(0)
-	  {}
-
-	  inline u32 GetBits(unsigned int BitCount)
-	  {
-		  if (BitCount == 0 || BitCount > 32)
-		  {
-			  throw(runtime_error("SWFBitStream::GetBits() must read at least 1 and at most 32 bits at a time"));
-		  }
-
-		  u32 value = 0;
-		  while (BitCount)
-		  {
-			  if (m_WordMask == 0) FlushByte();
-
-			  value <<= 1;
-			  value |= ((m_Word & m_WordMask) != 0) ? 1 : 0;
-			  m_WordMask >>= 1;
-
-			  --BitCount;
-		  }
-
-		  return value;
-	  }
-
-	  inline s32 GetSignedBits(unsigned int BitCount)
-	  {
-		  // Bits einlesen
-		  u32 Temp = GetBits(BitCount);
-
-		  // Falls das Sign-Bit gesetzt ist, den Rest des Rückgabewertes mit 1-Bits auffüllen (Sign Extension)
-		  if (Temp & 1 << (BitCount - 1))
-			  return (0xffffffff << BitCount) | Temp;
-		  else
-			  return Temp;
-	  }
-
-	  inline u32 GetU32()
-	  {
-		  u32 Byte1 = GetU8();
-		  u32 Byte2 = GetU8();
-		  u32 Byte3 = GetU8();
-		  u32 Byte4 = GetU8();
-
-		  return Byte1 | (Byte2 << 8) | (Byte3 << 16) | (Byte4 << 24);
-	  }
-
-	  inline u16 GetU16()
-	  {
-		  u32 Byte1 = GetU8();
-		  u32 Byte2 = GetU8();
-
-		  return Byte1 | (Byte2 << 8);
-	  }
-
-	  inline u8 GetU8()
-	  {
-		  FlushByte();
-		  u8 Value = m_Word;
-		  m_WordMask = 0;
-		  FlushByte();
-
-		  return Value;
-	  }
-
-	  inline void FlushByte()
-	  {
-		  if (m_WordMask != 128)
-		  {
-			  if (m_Pos >= m_End)
-			  {
-				  throw(runtime_error("Attempted to read past end of file"));
-			  }
-			  else
-			  {
-				  m_Word = *m_Pos++;
-				  m_WordMask = 128;
-			  }
-		  }
-	  }
-
-	  inline void SkipBytes(unsigned int SkipLength)
-	  {
-		  FlushByte();
-		  if (m_Pos + SkipLength >= m_End)
-		  {
-			  throw(runtime_error("Attempted to read past end of file"));
-		  }
-		  else
-		  {
-			  m_Pos += SkipLength;
-			  m_Word = *(m_Pos - 1);
-		  }
-	  }
+	SWFBitStream(const unsigned char *pData, unsigned int DataSize) :
+		m_Pos(pData), m_End(pData + DataSize), m_WordMask(0)
+	{}
+
+	inline u32 GetBits(unsigned int BitCount) {
+		if (BitCount == 0 || BitCount > 32) {
+			throw(runtime_error("SWFBitStream::GetBits() must read at least 1 and at most 32 bits at a time"));
+		}
+
+		u32 value = 0;
+		while (BitCount) {
+			if (m_WordMask == 0) FlushByte();
+
+			value <<= 1;
+			value |= ((m_Word & m_WordMask) != 0) ? 1 : 0;
+			m_WordMask >>= 1;
+
+			--BitCount;
+		}
+
+		return value;
+	}
+
+	inline s32 GetSignedBits(unsigned int BitCount) {
+		// Bits einlesen
+		u32 Temp = GetBits(BitCount);
+
+		// Falls das Sign-Bit gesetzt ist, den Rest des Rückgabewertes mit 1-Bits auffüllen (Sign Extension)
+		if (Temp & 1 << (BitCount - 1))
+			return (0xffffffff << BitCount) | Temp;
+		else
+			return Temp;
+	}
+
+	inline u32 GetU32() {
+		u32 Byte1 = GetU8();
+		u32 Byte2 = GetU8();
+		u32 Byte3 = GetU8();
+		u32 Byte4 = GetU8();
+
+		return Byte1 | (Byte2 << 8) | (Byte3 << 16) | (Byte4 << 24);
+	}
+
+	inline u16 GetU16() {
+		u32 Byte1 = GetU8();
+		u32 Byte2 = GetU8();
+
+		return Byte1 | (Byte2 << 8);
+	}
+
+	inline u8 GetU8() {
+		FlushByte();
+		u8 Value = m_Word;
+		m_WordMask = 0;
+		FlushByte();
+
+		return Value;
+	}
+
+	inline void FlushByte() {
+		if (m_WordMask != 128) {
+			if (m_Pos >= m_End) {
+				throw(runtime_error("Attempted to read past end of file"));
+			} else {
+				m_Word = *m_Pos++;
+				m_WordMask = 128;
+			}
+		}
+	}
+
+	inline void SkipBytes(unsigned int SkipLength) {
+		FlushByte();
+		if (m_Pos + SkipLength >= m_End) {
+			throw(runtime_error("Attempted to read past end of file"));
+		} else {
+			m_Pos += SkipLength;
+			m_Word = *(m_Pos - 1);
+		}
+	}
 
 private:
-	const unsigned char *	m_Pos;
-	const unsigned char *	m_End;
+	const unsigned char    *m_Pos;
+	const unsigned char    *m_End;
 
-	u8						m_Word;
-	unsigned int			m_WordMask;
+	u8                      m_Word;
+	unsigned int            m_WordMask;
 };
 
 
@@ -180,69 +163,66 @@ private:
 // Konstanten und Hilfsfunktionen
 // -----------------------------------------------------------------------------
 
-namespace
-{
-	// -----------------------------------------------------------------------------
-	// Konstanten
-	// -----------------------------------------------------------------------------
+namespace {
+// -----------------------------------------------------------------------------
+// Konstanten
+// -----------------------------------------------------------------------------
 
-	const u32 MAX_ACCEPTED_FLASH_VERSION = 3;	// Die höchste Flash-Dateiversion, die vom Lader akzeptiert wird
+const u32 MAX_ACCEPTED_FLASH_VERSION = 3;   // Die höchste Flash-Dateiversion, die vom Lader akzeptiert wird
 
 
-	// -----------------------------------------------------------------------------
-	// Konvertiert SWF-Rechteckdaten in einem Bitstrom in BS_Rect-Objekte
-	// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Konvertiert SWF-Rechteckdaten in einem Bitstrom in BS_Rect-Objekte
+// -----------------------------------------------------------------------------
 
-	BS_Rect FlashRectToBSRect(BS_VectorImage::SWFBitStream & bs)
-	{
-		bs.FlushByte();
+BS_Rect FlashRectToBSRect(BS_VectorImage::SWFBitStream &bs) {
+	bs.FlushByte();
 
-		// Feststellen mit wie vielen Bits die einzelnen Komponenten kodiert sind
-		u32 BitsPerValue = bs.GetBits(5);
+	// Feststellen mit wie vielen Bits die einzelnen Komponenten kodiert sind
+	u32 BitsPerValue = bs.GetBits(5);
 
-		// Die einzelnen Komponenten einlesen
-		s32 XMin = bs.GetSignedBits(BitsPerValue);
-		s32 XMax = bs.GetSignedBits(BitsPerValue);
-		s32 YMin = bs.GetSignedBits(BitsPerValue);
-		s32 YMax = bs.GetSignedBits(BitsPerValue);
+	// Die einzelnen Komponenten einlesen
+	s32 XMin = bs.GetSignedBits(BitsPerValue);
+	s32 XMax = bs.GetSignedBits(BitsPerValue);
+	s32 YMin = bs.GetSignedBits(BitsPerValue);
+	s32 YMax = bs.GetSignedBits(BitsPerValue);
 
-		return BS_Rect(XMin, YMin, XMax + 1, YMax + 1);
-	}
+	return BS_Rect(XMin, YMin, XMax + 1, YMax + 1);
+}
 
 
-	// -----------------------------------------------------------------------------
-	// Konvertiert SWF-Farben in AntiGrain Farben
-	// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Konvertiert SWF-Farben in AntiGrain Farben
+// -----------------------------------------------------------------------------
 
-	agg::rgba8 FlashColorToAGGRGBA8(unsigned int FlashColor)
-	{
-		agg::rgba8 ResultColor((FlashColor >> 16) & 0xff, (FlashColor >> 8) & 0xff, FlashColor & 0xff, FlashColor >> 24);
-		ResultColor.premultiply();
-		return ResultColor;
-	}
+agg::rgba8 FlashColorToAGGRGBA8(unsigned int FlashColor) {
+	agg::rgba8 ResultColor((FlashColor >> 16) & 0xff, (FlashColor >> 8) & 0xff, FlashColor & 0xff, FlashColor >> 24);
+	ResultColor.premultiply();
+	return ResultColor;
+}
 
 
-	// -----------------------------------------------------------------------------
-	// Berechnet die Bounding-Box eines BS_VectorImageElement
-	// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Berechnet die Bounding-Box eines BS_VectorImageElement
+// -----------------------------------------------------------------------------
+
+struct CBBGetId {
+	CBBGetId(const BS_VectorImageElement &VectorImageElement_) : VectorImageElement(VectorImageElement_) {}
+	unsigned operator [](unsigned i) const {
+		return VectorImageElement.GetPathInfo(i).GetID();
+	}
+	const BS_VectorImageElement &VectorImageElement;
+};
 
-	struct CBBGetId
-	{
-		CBBGetId(const BS_VectorImageElement & VectorImageElement_) : VectorImageElement(VectorImageElement_) {}
-		unsigned operator [] (unsigned i) const { return VectorImageElement.GetPathInfo(i).GetID(); }
-		const BS_VectorImageElement & VectorImageElement;
-	};
+BS_Rect CalculateBoundingBox(const BS_VectorImageElement &VectorImageElement) {
+	agg::path_storage Path = VectorImageElement.GetPaths();
+	CBBGetId IdSource(VectorImageElement);
 
-	BS_Rect CalculateBoundingBox(const BS_VectorImageElement & VectorImageElement)
-	{
-		agg::path_storage Path = VectorImageElement.GetPaths();
-		CBBGetId IdSource(VectorImageElement);
+	double x1, x2, y1, y2;
+	agg::bounding_rect(Path, IdSource, 0, VectorImageElement.GetPathCount(), &x1, &y1, &x2, &y2);
 
-		double x1, x2, y1, y2;
-		agg::bounding_rect(Path, IdSource, 0, VectorImageElement.GetPathCount(), &x1, &y1, &x2, &y2);
-		
-		return BS_Rect(static_cast<int>(x1), static_cast<int>(y1), static_cast<int>(x2) + 1, static_cast<int>(y2) + 1);
-	}
+	return BS_Rect(static_cast<int>(x1), static_cast<int>(y1), static_cast<int>(x2) + 1, static_cast<int>(y2) + 1);
+}
 }
 
 
@@ -250,41 +230,36 @@ namespace
 // Konstruktion
 // -----------------------------------------------------------------------------
 
-BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int FileSize, bool & Success)
-{
+BS_VectorImage::BS_VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success) {
 	Success = false;
 
 	// Bitstream-Objekt erzeugen
 	// Im Folgenden werden die Dateidaten aus diesem ausgelesen.
 	SWFBitStream bs(pFileData, FileSize);
 
-	try
-	{
+	try {
 		// SWF-Signatur überprüfen
 		u32 Signature[3];
 		Signature[0] = bs.GetU8();
 		Signature[1] = bs.GetU8();
 		Signature[2] = bs.GetU8();
 		if (Signature[0] != 'F' ||
-			Signature[1] != 'W' ||
-			Signature[2] != 'S')
-		{
+		        Signature[1] != 'W' ||
+		        Signature[2] != 'S') {
 			BS_LOG_ERRORLN("File is not a valid SWF-file");
 			return;
 		}
 
 		// Versionsangabe überprüfen
 		u32 Version = bs.GetU8();
-		if (Version > MAX_ACCEPTED_FLASH_VERSION)
-		{
+		if (Version > MAX_ACCEPTED_FLASH_VERSION) {
 			BS_LOG_ERRORLN("File is of version %d. Highest accepted version is %d.", Version, MAX_ACCEPTED_FLASH_VERSION);
 			return;
 		}
 
 		// Dateigröße auslesen und mit der tatsächlichen Größe vergleichen
 		u32 StoredFileSize = bs.GetU32();
-		if (StoredFileSize != FileSize)
-		{
+		if (StoredFileSize != FileSize) {
 			BS_LOG_ERRORLN("File is not a valid SWF-file");
 			return;
 		}
@@ -299,8 +274,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
 		// Tags parsen
 		// Da wir uns nur für das erste DefineShape-Tag interessieren
 		bool KeepParsing = true;
-		while (KeepParsing)
-		{
+		while (KeepParsing) {
 			// Tags beginnen immer an Bytegrenzen
 			bs.FlushByte();
 
@@ -310,8 +284,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
 			u32 TagLength = TagTypeAndLength & 0x3f;
 			if (TagLength == 0x3f) TagLength = bs.GetU32();
 
-			switch (TagType)
-			{
+			switch (TagType) {
 			case 2:
 				// DefineShape
 				Success = ParseDefineShape(2, bs);
@@ -330,8 +303,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
 		}
 	}
 
-	catch (runtime_error & e)
-	{
+	catch (runtime_error &e) {
 		// Fehler loggen und Funktion verlassen
 		// Success ist somit "false" und signalisiert dem Programmierer, dass die Konstruktion fehlgeschlagen ist.
 		BS_LOG_ERRORLN("The following exception occured while parsing a SWF-file: %s", e.what());
@@ -345,8 +317,7 @@ BS_VectorImage::BS_VectorImage(const unsigned char * pFileData, unsigned int Fil
 
 // -----------------------------------------------------------------------------
 
-bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
-{
+bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs) {
 	u32 ShapeID = bs.GetU16();
 
 	// Bounding Box auslesen
@@ -368,13 +339,11 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
 	// ------------------
 
 	bool EndOfShapeDiscovered = false;
-	while (!EndOfShapeDiscovered)
-	{
+	while (!EndOfShapeDiscovered) {
 		u32 TypeFlag = bs.GetBits(1);
 
 		// Non-Edge Record
-		if (TypeFlag == 0)
-		{
+		if (TypeFlag == 0) {
 			// Feststellen welche Parameter gesetzt werden
 			u32 StateNewStyles = bs.GetBits(1);
 			u32 StateLineStyle = bs.GetBits(1);
@@ -386,43 +355,37 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
 			if (!StateNewStyles && !StateLineStyle && !StateFillStyle0 && !StateFillStyle1 && !StateMoveTo)
 				EndOfShapeDiscovered = true;
 			// Parameter dekodieren
-			else
-			{
+			else {
 				s32 MoveDeltaX = 0;
 				s32 MoveDeltaY = 0;
-				if (StateMoveTo)
-				{
+				if (StateMoveTo) {
 					u32 MoveToBits = bs.GetBits(5);
 					MoveDeltaX = bs.GetSignedBits(MoveToBits);
 					MoveDeltaY = bs.GetSignedBits(MoveToBits);
 				}
 
-				if (StateFillStyle0)
-				{
+				if (StateFillStyle0) {
 					if (NumFillBits > 0)
 						FillStyle0 = bs.GetBits(NumFillBits);
 					else
 						FillStyle0 = 0;
 				}
 
-				if (StateFillStyle1)
-				{
+				if (StateFillStyle1) {
 					if (NumFillBits > 0)
 						FillStyle1 = bs.GetBits(NumFillBits);
 					else
 						FillStyle1 = 0;
 				}
 
-				if (StateLineStyle)
-				{
+				if (StateLineStyle) {
 					if (NumLineBits)
 						LineStyle = bs.GetBits(NumLineBits);
 					else
 						NumLineBits = 0;
 				}
 
-				if (StateNewStyles)
-				{
+				if (StateNewStyles) {
 					// An dieser Stelle werden in Flash die alten Style-Definitionen verworfen und mit den neuen überschrieben.
 					// Es wird ein neues Element begonnen.
 					m_Elements.resize(m_Elements.size() + 1);
@@ -430,8 +393,7 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
 				}
 
 				// Ein neuen Pfad erzeugen, es sei denn, es wurden nur neue Styles definiert
-				if (StateLineStyle || StateFillStyle0 || StateFillStyle1 || StateMoveTo)
-				{
+				if (StateLineStyle || StateFillStyle0 || StateFillStyle1 || StateMoveTo) {
 					// Letzte Zeichenposition merken, beim Aufruf von start_new_path() wird die Zeichenpostionen auf 0, 0 zurückgesetzt
 					double LastX = m_Elements.back().m_Paths.last_x();
 					double LastY = m_Elements.back().m_Paths.last_y();
@@ -449,14 +411,12 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
 			}
 		}
 		// Edge Record
-		else
-		{
+		else {
 			u32 EdgeFlag = bs.GetBits(1);
 			u32 NumBits = bs.GetBits(4) + 2;
 
 			// Curved edge
-			if (EdgeFlag == 0)
-			{
+			if (EdgeFlag == 0) {
 				s32 ControlDeltaX = bs.GetSignedBits(NumBits);
 				s32 ControlDeltaY = bs.GetSignedBits(NumBits);
 				s32 AnchorDeltaX = bs.GetSignedBits(NumBits);
@@ -469,19 +429,15 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
 				m_Elements.back().m_Paths.curve3(ControlX, ControlY, AnchorX, AnchorY);
 			}
 			// Staight edge
-			else
-			{
+			else {
 				s32 DeltaX = 0;
 				s32 DeltaY = 0;
 
 				u32 GeneralLineFlag = bs.GetBits(1);
-				if (GeneralLineFlag)
-				{
+				if (GeneralLineFlag) {
 					DeltaX = bs.GetSignedBits(NumBits);
 					DeltaY = bs.GetSignedBits(NumBits);
-				}
-				else
-				{
+				} else {
 					u32 VertLineFlag = bs.GetBits(1);
 					if (VertLineFlag)
 						DeltaY = bs.GetSignedBits(NumBits);
@@ -504,8 +460,7 @@ bool BS_VectorImage::ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs)
 
 // -----------------------------------------------------------------------------
 
-bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsigned int & NumFillBits, unsigned int & NumLineBits)
-{
+bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsigned int &NumFillBits, unsigned int &NumLineBits) {
 	bs.FlushByte();
 
 	// Fillstyles parsen
@@ -518,15 +473,12 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsi
 	// Alle Fillstyles einlesen, falls ein Fillstyle mit Typ != 0 gefunden wird, wird das Parsen abgebrochen.
 	// Es wird nur "solid fill" (Typ 0) unterstützt.
 	m_Elements.back().m_FillStyles.reserve(FillStyleCount);
-	for (unsigned int i = 0; i < FillStyleCount; ++i)
-	{
+	for (unsigned int i = 0; i < FillStyleCount; ++i) {
 		u8 Type = bs.GetU8();
 		u32 Color;
-		if (ShapeType == 3)
-		{
+		if (ShapeType == 3) {
 			Color = (bs.GetU8() << 16) | (bs.GetU8() << 8) | bs.GetU8() | (bs.GetU8() << 24);
-		}
-		else
+		} else
 			Color = bs.GetBits(24) | (0xff << 24);
 		if (Type != 0) return false;
 
@@ -542,8 +494,7 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsi
 
 	// Alle Linestyles einlesen
 	m_Elements.back().m_LineStyles.reserve(LineStyleCount);
-	for (unsigned int i = 0; i < LineStyleCount; ++i)
-	{
+	for (unsigned int i = 0; i < LineStyleCount; ++i) {
 		double Width = bs.GetU16();
 		u32 Color;
 		if (ShapeType == 3)
@@ -564,8 +515,7 @@ bool BS_VectorImage::ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsi
 
 // -----------------------------------------------------------------------------
 
-bool BS_VectorImage::Fill(const BS_Rect* pFillRect, unsigned int Color)
-{
+bool BS_VectorImage::Fill(const BS_Rect *pFillRect, unsigned int Color) {
 	BS_LOG_ERRORLN("Fill() is not supported.");
 	return false;
 }
@@ -573,16 +523,14 @@ bool BS_VectorImage::Fill(const BS_Rect* pFillRect, unsigned int Color)
 
 // -----------------------------------------------------------------------------
 
-unsigned int BS_VectorImage::GetPixel(int X, int Y)
-{
+unsigned int BS_VectorImage::GetPixel(int X, int Y) {
 	BS_LOG_ERRORLN("GetPixel() is not supported. Returning black.");
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_VectorImage::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride)
-{
+bool BS_VectorImage::SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride) {
 	BS_LOG_ERRORLN("SetContent() is not supported.");
 	return 0;
 }
diff --git a/engines/sword25/gfx/image/vectorimage.h b/engines/sword25/gfx/image/vectorimage.h
index 85685121f2..f791a36f03 100644
--- a/engines/sword25/gfx/image/vectorimage.h
+++ b/engines/sword25/gfx/image/vectorimage.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -53,22 +53,29 @@ namespace Sword25 {
 class BS_VectorImage;
 
 /**
-	@brief Pfadinformationen zu BS_VectorImageElement Objekten
+    @brief Pfadinformationen zu BS_VectorImageElement Objekten
 
-	Jedes BS_VectorImageElement besteht aus Kantenzügen, oder auch Pfaden. Jeder dieser Pfad hat Eigenschaften, die in Objekten diesen Typs
-	gespeichert werden.
+    Jedes BS_VectorImageElement besteht aus Kantenzügen, oder auch Pfaden. Jeder dieser Pfad hat Eigenschaften, die in Objekten diesen Typs
+    gespeichert werden.
 */
 
-class BS_VectorPathInfo
-{
+class BS_VectorPathInfo {
 public:
 	BS_VectorPathInfo(unsigned int ID, unsigned int LineStyle, unsigned int FillStyle0, unsigned int FillStyle1) :
-	  m_ID(ID), m_LineStyle(LineStyle), m_FillStyle0(FillStyle0), m_FillStyle1(FillStyle1) {};
+		m_ID(ID), m_LineStyle(LineStyle), m_FillStyle0(FillStyle0), m_FillStyle1(FillStyle1) {};
 
-	unsigned int GetID() const { return m_ID; }
-	unsigned int GetLineStyle() const { return m_LineStyle; }
-	unsigned int GetFillStyle0() const { return m_FillStyle0; }
-	unsigned int GetFillStyle1() const { return m_FillStyle1; }
+	unsigned int GetID() const {
+		return m_ID;
+	}
+	unsigned int GetLineStyle() const {
+		return m_LineStyle;
+	}
+	unsigned int GetFillStyle0() const {
+		return m_FillStyle0;
+	}
+	unsigned int GetFillStyle1() const {
+		return m_FillStyle1;
+	}
 
 private:
 	unsigned int m_ID;
@@ -79,106 +86,136 @@ private:
 
 
 /**
-	@brief Ein Element eines Vektorbild. Ein BS_VectorImage besteht aus diesen Elementen, die jeweils einen Teil der Graphik definieren.
-		   Werden alle Elemente eines Vektorbildes übereinandergelegt, ergibt sich das komplette Bild.
+    @brief Ein Element eines Vektorbild. Ein BS_VectorImage besteht aus diesen Elementen, die jeweils einen Teil der Graphik definieren.
+           Werden alle Elemente eines Vektorbildes übereinandergelegt, ergibt sich das komplette Bild.
 */
-class BS_VectorImageElement
-{
-friend BS_VectorImage;
+class BS_VectorImageElement {
+	friend BS_VectorImage;
 public:
-	const agg::path_storage &	GetPaths() const { return m_Paths; }
-	unsigned int				GetPathCount() const { return m_PathInfos.size(); }
-	const BS_VectorPathInfo &	GetPathInfo(unsigned int PathNr) const { BS_ASSERT(PathNr < GetPathCount()); return m_PathInfos[PathNr]; }
+	const agg::path_storage    &GetPaths() const {
+		return m_Paths;
+	}
+	unsigned int                GetPathCount() const {
+		return m_PathInfos.size();
+	}
+	const BS_VectorPathInfo    &GetPathInfo(unsigned int PathNr) const {
+		BS_ASSERT(PathNr < GetPathCount());
+		return m_PathInfos[PathNr];
+	}
 
-	double GetLineStyleWidth(unsigned int LineStyle) const
-	{
+	double GetLineStyleWidth(unsigned int LineStyle) const {
 		BS_ASSERT(LineStyle < m_LineStyles.size());
 		return m_LineStyles[LineStyle].Width;
 	}
 
-	unsigned int GetLineStyleCount() const { return m_LineStyles.size(); }
+	unsigned int GetLineStyleCount() const {
+		return m_LineStyles.size();
+	}
 
-	const agg::rgba8 & GetLineStyleColor(unsigned int LineStyle) const
-	{
+	const agg::rgba8 &GetLineStyleColor(unsigned int LineStyle) const {
 		BS_ASSERT(LineStyle < m_LineStyles.size());
 		return m_LineStyles[LineStyle].Color;
 	}
 
-	unsigned int GetFillStyleCount() const { return m_FillStyles.size(); }
+	unsigned int GetFillStyleCount() const {
+		return m_FillStyles.size();
+	}
 
-	const agg::rgba8 & GetFillStyleColor(unsigned int FillStyle) const
-	{
+	const agg::rgba8 &GetFillStyleColor(unsigned int FillStyle) const {
 		BS_ASSERT(FillStyle < m_FillStyles.size());
 		return m_FillStyles[FillStyle];
 	}
 
-	const BS_Rect & GetBoundingBox() const { return m_BoundingBox; }	
+	const BS_Rect &GetBoundingBox() const {
+		return m_BoundingBox;
+	}
 
 private:
-	struct LineStyleType
-	{
-		LineStyleType(double Width_, const agg::rgba8 & Color_) : Width(Width_), Color(Color_) {};
-		double		Width;
-		agg::rgba8	Color;
+	struct LineStyleType {
+		LineStyleType(double Width_, const agg::rgba8 &Color_) : Width(Width_), Color(Color_) {};
+		double      Width;
+		agg::rgba8  Color;
 	};
 
-	agg::path_storage				m_Paths;
-	Common::Array<BS_VectorPathInfo>	m_PathInfos;
-	Common::Array<LineStyleType>		m_LineStyles;
-	Common::Array<agg::rgba8>			m_FillStyles;
-	BS_Rect							m_BoundingBox;
+	agg::path_storage               m_Paths;
+	Common::Array<BS_VectorPathInfo>    m_PathInfos;
+	Common::Array<LineStyleType>        m_LineStyles;
+	Common::Array<agg::rgba8>           m_FillStyles;
+	BS_Rect                         m_BoundingBox;
 };
 
 
 /**
-	@brief Eine Vektorgraphik
+    @brief Eine Vektorgraphik
 
-	Objekte dieser Klasse enthalten die Informationen eines SWF-Shapes.
+    Objekte dieser Klasse enthalten die Informationen eines SWF-Shapes.
 */
 
-class BS_VectorImage : public BS_Image
-{
+class BS_VectorImage : public BS_Image {
 public:
-	BS_VectorImage(const unsigned char * pFileData, unsigned int FileSize, bool & Success);
+	BS_VectorImage(const unsigned char *pFileData, unsigned int FileSize, bool &Success);
 
-	unsigned int GetElementCount() const { return m_Elements.size(); }
-	const BS_VectorImageElement & GetElement(unsigned int ElementNr) const
-	{
+	unsigned int GetElementCount() const {
+		return m_Elements.size();
+	}
+	const BS_VectorImageElement &GetElement(unsigned int ElementNr) const {
 		BS_ASSERT(ElementNr < m_Elements.size());
 		return m_Elements[ElementNr];
 	}
-	const BS_Rect & GetBoundingBox() const { return m_BoundingBox; }
+	const BS_Rect &GetBoundingBox() const {
+		return m_BoundingBox;
+	}
 
 	//
 	// Die abstrakten Methoden von BS_Image
 	//
-	virtual int GetWidth() const { return m_BoundingBox.GetWidth(); }
-	virtual int GetHeight() const { return m_BoundingBox.GetHeight(); }
-	virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const { return BS_GraphicEngine::CF_ARGB32; }
-	virtual bool Fill(const BS_Rect* pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0));
+	virtual int GetWidth() const {
+		return m_BoundingBox.GetWidth();
+	}
+	virtual int GetHeight() const {
+		return m_BoundingBox.GetHeight();
+	}
+	virtual BS_GraphicEngine::COLOR_FORMATS GetColorFormat() const {
+		return BS_GraphicEngine::CF_ARGB32;
+	}
+	virtual bool Fill(const BS_Rect *pFillRect = 0, unsigned int Color = BS_RGB(0, 0, 0));
 	virtual unsigned int GetPixel(int X, int Y);
-	virtual bool IsBlitSource() const { return true; }
-	virtual bool IsBlitTarget() const { return false; }
-	virtual bool IsScalingAllowed() const { return true; }
-	virtual bool IsFillingAllowed() const { return false; }
-	virtual bool IsAlphaAllowed() const { return true; }
-	virtual bool IsColorModulationAllowed() const { return true; }
-	virtual bool IsSetContentAllowed() const { return false; }
+	virtual bool IsBlitSource() const {
+		return true;
+	}
+	virtual bool IsBlitTarget() const {
+		return false;
+	}
+	virtual bool IsScalingAllowed() const {
+		return true;
+	}
+	virtual bool IsFillingAllowed() const {
+		return false;
+	}
+	virtual bool IsAlphaAllowed() const {
+		return true;
+	}
+	virtual bool IsColorModulationAllowed() const {
+		return true;
+	}
+	virtual bool IsSetContentAllowed() const {
+		return false;
+	}
 	virtual bool SetContent(const byte *Pixeldata, unsigned int Offset, unsigned int Stride);
 	virtual bool Blit(int PosX = 0, int PosY = 0,
-					  int Flipping = FLIP_NONE,
-					  BS_Rect* pPartRect = NULL,
-					  unsigned int Color = BS_ARGB(255, 255, 255, 255),
-					  int Width = -1, int Height = -1);
+	                  int Flipping = FLIP_NONE,
+	                  BS_Rect *pPartRect = NULL,
+	                  unsigned int Color = BS_ARGB(255, 255, 255, 255),
+	                  int Width = -1, int Height = -1);
 
 	class SWFBitStream;
 
 private:
-	bool ParseDefineShape(unsigned int ShapeType, SWFBitStream & bs);
-	bool ParseStyles(unsigned int ShapeType, SWFBitStream & bs, unsigned int & NumFillBits, unsigned int & NumLineBits);
+	bool ParseDefineShape(unsigned int ShapeType, SWFBitStream &bs);
+	bool ParseStyles(unsigned int ShapeType, SWFBitStream &bs, unsigned int &NumFillBits, unsigned int &NumLineBits);
 
-	Common::Array<BS_VectorImageElement>	m_Elements;
-	BS_Rect								m_BoundingBox;
+	Common::Array<BS_VectorImageElement>    m_Elements;
+	BS_Rect                             m_BoundingBox;
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/image/vectorimagerenderer.cpp b/engines/sword25/gfx/image/vectorimagerenderer.cpp
index fa776578e3..0c7f93c130 100644
--- a/engines/sword25/gfx/image/vectorimagerenderer.cpp
+++ b/engines/sword25/gfx/image/vectorimagerenderer.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -49,10 +49,9 @@ namespace Sword25 {
 // CompoundShape
 // -----------------------------------------------------------------------------
 
-class CompoundShape
-{
+class CompoundShape {
 public:
-	CompoundShape(const BS_VectorImageElement & VectorImageElement) :
+	CompoundShape(const BS_VectorImageElement &VectorImageElement) :
 		m_ImageElement(VectorImageElement),
 		m_Path(VectorImageElement.GetPaths()),
 		m_Affine(),
@@ -60,29 +59,28 @@ public:
 		m_Trans(m_Curve, m_Affine)
 	{}
 
-	unsigned operator [] (unsigned i) const 
-	{
+	unsigned operator [](unsigned i) const {
 		return m_ImageElement.GetPathInfo(i).GetID();
 	}
 
-	unsigned paths() const { return m_ImageElement.GetPathCount(); }
+	unsigned paths() const {
+		return m_ImageElement.GetPathCount();
+	}
 
-	void rewind(unsigned path_id)
-	{
+	void rewind(unsigned path_id) {
 		m_Trans.rewind(path_id);
 	}
 
-	unsigned vertex(double* x, double* y)
-	{
+	unsigned vertex(double *x, double *y) {
 		return m_Trans.vertex(x, y);
 	}
 
 private:
-	const BS_VectorImageElement &								m_ImageElement;
-	agg::path_storage											m_Path;
-	agg::trans_affine											m_Affine;
-	agg::conv_curve<agg::path_storage>							m_Curve;
-	agg::conv_transform< agg::conv_curve<agg::path_storage> >	m_Trans;
+	const BS_VectorImageElement                                &m_ImageElement;
+	agg::path_storage                                           m_Path;
+	agg::trans_affine                                           m_Affine;
+	agg::conv_curve<agg::path_storage>                          m_Curve;
+	agg::conv_transform< agg::conv_curve<agg::path_storage> >   m_Trans;
 };
 
 
@@ -90,29 +88,25 @@ private:
 // StyleHandler
 // -----------------------------------------------------------------------------
 
-class StyleHandler
-{
+class StyleHandler {
 public:
-	StyleHandler(const BS_VectorImageElement & VectorImageElement) : m_ImageElement(VectorImageElement) {}
+	StyleHandler(const BS_VectorImageElement &VectorImageElement) : m_ImageElement(VectorImageElement) {}
 
-	bool is_solid(unsigned int style) const
-	{
+	bool is_solid(unsigned int style) const {
 		return true;
 	}
 
-	const agg::rgba8 & color(unsigned style) const 
-	{
+	const agg::rgba8 &color(unsigned style) const {
 		return m_ImageElement.GetFillStyleColor(style);
 	}
 
-	void generate_span(agg::rgba8 * span, int x, int y, unsigned len, unsigned style)
-	{
+	void generate_span(agg::rgba8 *span, int x, int y, unsigned len, unsigned style) {
 		// Wird nicht benutzt
 		return;
 	}
 
 private:
-	const BS_VectorImageElement & m_ImageElement;
+	const BS_VectorImageElement &m_ImageElement;
 };
 
 
@@ -121,21 +115,19 @@ private:
 // -----------------------------------------------------------------------------
 
 BS_VectorImageRenderer::BS_VectorImageRenderer() :
-	PixelFormat(rbuf)
-{
+	PixelFormat(rbuf) {
 
 }
 
 
 // -----------------------------------------------------------------------------
 
-bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
-									float ScaleFactorX, float ScaleFactorY,
-									unsigned int & Width, unsigned int & Height,
-									Common::Array<char> & ImageData,
-									float LineScaleFactor,
-									bool NoAlphaShapes)
-{
+bool BS_VectorImageRenderer::Render(const BS_VectorImage &VectorImage,
+                                    float ScaleFactorX, float ScaleFactorY,
+                                    unsigned int &Width, unsigned int &Height,
+                                    Common::Array<char> & ImageData,
+                                    float LineScaleFactor,
+                                    bool NoAlphaShapes) {
 	Width = static_cast<unsigned int>(VectorImage.GetWidth() * ScaleFactorX);
 	Height = static_cast<unsigned int>(VectorImage.GetHeight() * ScaleFactorY);
 
@@ -151,9 +143,8 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
 	Scale = agg::trans_affine_translation(- VectorImage.GetBoundingBox().left, - VectorImage.GetBoundingBox().top);
 	Scale *= agg::trans_affine_scaling(ScaleFactorX, ScaleFactorY);
 
-	for (unsigned int element = 0; element < VectorImage.GetElementCount(); ++element)
-	{
-		const BS_VectorImageElement & CurImageElement = VectorImage.GetElement(element);
+	for (unsigned int element = 0; element < VectorImage.GetElementCount(); ++element) {
+		const BS_VectorImageElement &CurImageElement = VectorImage.GetElement(element);
 
 		CompoundShape ImageCompoundShape(CurImageElement);
 		StyleHandler ImageStyleHandler(CurImageElement);
@@ -164,19 +155,16 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
 		//----------------------
 		CompoundRasterizer.clip_box(0, 0, Width, Height);
 		CompoundRasterizer.reset();
-		for(unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i)
-		{
+		for (unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i) {
 			unsigned int FillStyle0 = CurImageElement.GetPathInfo(i).GetFillStyle0();
 			unsigned int FillStyle1 = CurImageElement.GetPathInfo(i).GetFillStyle1();
 
-			if (NoAlphaShapes)
-			{
+			if (NoAlphaShapes) {
 				if (FillStyle0 != 0 && CurImageElement.GetFillStyleColor(FillStyle0 - 1).a != 255) FillStyle0 = 0;
 				if (FillStyle1 != 0 && CurImageElement.GetFillStyleColor(FillStyle1 - 1).a != 255) FillStyle1 = 0;
 			}
 
-			if(FillStyle0 != 0 || FillStyle1 != 0)
-			{
+			if (FillStyle0 != 0 || FillStyle1 != 0) {
 				CompoundRasterizer.styles(FillStyle0 - 1, FillStyle1 - 1);
 				CompoundRasterizer.add_path(Shape, CurImageElement.GetPathInfo(i).GetID());
 			}
@@ -189,13 +177,11 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
 		Rasterizer.clip_box(0, 0, Width, Height);
 		Stroke.line_join(agg::round_join);
 		Stroke.line_cap(agg::round_cap);
-		for(unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i)
-		{
+		for (unsigned int i = 0; i < CurImageElement.GetPathCount(); ++i) {
 			Rasterizer.reset();
-			
+
 			unsigned int CurrentLineStyle = CurImageElement.GetPathInfo(i).GetLineStyle();
-			if (CurrentLineStyle != 0)
-			{
+			if (CurrentLineStyle != 0) {
 				Stroke.width(ScaleFactorX * CurImageElement.GetLineStyleWidth(CurrentLineStyle - 1) * LineScaleFactor);
 				Rasterizer.add_path(Stroke, CurImageElement.GetPathInfo(i).GetID());
 				ScanlineRenderer.color(CurImageElement.GetLineStyleColor(CurrentLineStyle - 1));
@@ -203,9 +189,9 @@ bool BS_VectorImageRenderer::Render(const BS_VectorImage & VectorImage,
 				// Die SWF-Frames enthalten zum Teil Reste von grünen Linien, die wohl von Bernd als Umriss benutzt wurden.
 				// Damit diese Reste nicht störend auffallen werden grüne Linien schlichtweg ignoriert.
 				if (!(CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).a == 255 &&
-					CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).r == 0 &&
-					CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).g == 255 &&
-					CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).b == 0))
+				        CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).r == 0 &&
+				        CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).g == 255 &&
+				        CurImageElement.GetLineStyleColor(CurrentLineStyle - 1).b == 0))
 					agg::render_scanlines(Rasterizer, Scanline, ScanlineRenderer);
 			}
 		}
diff --git a/engines/sword25/gfx/image/vectorimagerenderer.h b/engines/sword25/gfx/image/vectorimagerenderer.h
index 2712728b1f..ed073abb56 100644
--- a/engines/sword25/gfx/image/vectorimagerenderer.h
+++ b/engines/sword25/gfx/image/vectorimagerenderer.h
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -58,20 +58,19 @@ class BS_VectorImage;
 
 
 /**
-	@brief Rendert BS_VectorImage Objekte
+    @brief Rendert BS_VectorImage Objekte
 */
 
-class BS_VectorImageRenderer
-{
+class BS_VectorImageRenderer {
 public:
 	BS_VectorImageRenderer();
 
-	bool Render(const BS_VectorImage & VectorImage,
-				float ScaleFactorX, float ScaleFactorY, 
-				unsigned int & Width, unsigned int & Height,
-				Common::Array<char> & ImageData,
-				float LineScaleFactor = 1.0f,
-				bool NoAlphaShapes = false);
+	bool Render(const BS_VectorImage &VectorImage,
+	            float ScaleFactorX, float ScaleFactorY,
+	            unsigned int &Width, unsigned int &Height,
+	            Common::Array<char> & ImageData,
+	            float LineScaleFactor = 1.0f,
+	            bool NoAlphaShapes = false);
 
 private:
 	typedef agg::pixfmt_rgba32_pre PixelFormatType;