SWORD25: Enforce code naming conventions in gfx/image/imageloader*

svn-id: r53623

10 files changed, 175 insertions, 260 deletions

diff --git a/engines/sword25/gfx/image/b25sloader.cpp b/engines/sword25/gfx/image/b25sloader.cpp
index 393d0e2d80..693b616e01 100644
--- a/engines/sword25/gfx/image/b25sloader.cpp
+++ b/engines/sword25/gfx/image/b25sloader.cpp
@@ -32,10 +32,6 @@
  *
  */
 
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
 #include "sword25/gfx/image/b25sloader.h"
 #include "sword25/gfx/image/pngloader.h"
 
@@ -43,77 +39,68 @@ namespace Sword25 {
 
 #define BS_LOG_PREFIX "B25SLOADER"
 
-// -----------------------------------------------------------------------------
-
 namespace {
-static Common::String LoadString(Common::ReadStream &In, uint MaxSize = 999) {
-	Common::String Result;
+static Common::String loadString(Common::ReadStream &in, uint maxSize = 999) {
+	Common::String result;
 
-	while (!In.eos() && (Result.size() < MaxSize)) {
-		char ch = (char)In.readByte();
+	while (!in.eos() && (result.size() < maxSize)) {
+		char ch = (char)in.readByte();
 		if ((ch == '\0') || (ch == ' '))
 			break;
 
-		Result += ch;
+		result += ch;
 	}
 
-	return Result;
+	return result;
 }
 
-uint FindEmbeddedPNG(const byte *FileDataPtr, uint FileSize) {
-	assert(FileSize >= 100);
-	if (memcmp(FileDataPtr, "BS25SAVEGAME", 12))
+uint findEmbeddedPNG(const byte *fileDataPtr, uint fileSize) {
+	assert(fileSize >= 100);
+	if (memcmp(fileDataPtr, "BS25SAVEGAME", 12))
 		return 0;
 
 	// Read in the header
-	Common::MemoryReadStream stream(FileDataPtr, FileSize);
+	Common::MemoryReadStream stream(fileDataPtr, fileSize);
 	stream.seek(0, SEEK_SET);
 
 	// Headerinformationen der Spielstandes einlesen.
 	uint compressedGamedataSize;
-	LoadString(stream);
-	LoadString(stream);
-	Common::String gameSize = LoadString(stream);
+	loadString(stream);
+	loadString(stream);
+	Common::String gameSize = loadString(stream);
 	compressedGamedataSize = atoi(gameSize.c_str());
-	LoadString(stream);
+	loadString(stream);
 
 	// Return the offset of where the thumbnail starts
 	return static_cast<uint>(stream.pos() + compressedGamedataSize);
 }
 }
 
-// -----------------------------------------------------------------------------
-
-bool B25SLoader::IsCorrectImageFormat(const byte *FileDataPtr, uint FileSize) {
+bool B25SLoader::isCorrectImageFormat(const byte *fileDataPtr, uint fileSize) {
 	// PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen.
-	uint PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize);
-	if (PNGOffset > 0) {
-		return PNGLoader::DoIsCorrectImageFormat(FileDataPtr + PNGOffset, FileSize - PNGOffset);
+	uint pngOffset = findEmbeddedPNG(fileDataPtr, fileSize);
+	if (pngOffset > 0) {
+		return PNGLoader::doIsCorrectImageFormat(fileDataPtr + pngOffset, fileSize - pngOffset);
 	}
 
 	return false;
 }
 
-// -----------------------------------------------------------------------------
-
-bool B25SLoader::DecodeImage(const byte *FileDataPtr, uint FileSize, GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr,
-                             int &Width, int &Height, int &Pitch) {
+bool B25SLoader::decodeImage(const byte *fileDataPtr, uint fileSize, GraphicEngine::COLOR_FORMATS colorFormat, byte *&uncompressedDataPtr, int &width, int &height, int &pitch) {
 	// PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen.
-	uint PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize);
-	if (PNGOffset > 0) {
-		return PNGLoader::DoDecodeImage(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, UncompressedDataPtr, Width, Height, Pitch);
+	uint pngOffset = findEmbeddedPNG(fileDataPtr, fileSize);
+	if (pngOffset > 0) {
+		return PNGLoader::doDecodeImage(fileDataPtr + pngOffset, fileSize - pngOffset, colorFormat, uncompressedDataPtr, width, height, pitch);
 	}
 
 	return false;
 }
 
-// -----------------------------------------------------------------------------
-
-bool B25SLoader::ImageProperties(const byte *FileDataPtr, uint FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
+bool B25SLoader::imageProperties(const byte *fileDataPtr, uint fileSize, GraphicEngine::COLOR_FORMATS &colorFormat, int &width, int &height) {
 	// PNG innerhalb des Spielstandes finden und den Methodenaufruf zu BS_PNGLoader weiterreichen.
-	uint PNGOffset = FindEmbeddedPNG(FileDataPtr, FileSize);
-	if (PNGOffset > 0) {
-		return PNGLoader::DoImageProperties(FileDataPtr + PNGOffset, FileSize - PNGOffset, ColorFormat, Width, Height);
+	uint pngOffset = findEmbeddedPNG(fileDataPtr, fileSize);
+	if (pngOffset > 0) {
+		return PNGLoader::doImageProperties(fileDataPtr + pngOffset, fileSize - pngOffset, colorFormat, width, height);
 	}
 
 	return false;
diff --git a/engines/sword25/gfx/image/b25sloader.h b/engines/sword25/gfx/image/b25sloader.h
index fbfaf87194..5beba07e53 100644
--- a/engines/sword25/gfx/image/b25sloader.h
+++ b/engines/sword25/gfx/image/b25sloader.h
@@ -35,30 +35,21 @@
 #ifndef SWORD25_B25SLOADER_H
 #define SWORD25_B25SLOADER_H
 
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
 #include "sword25/kernel/common.h"
 #include "sword25/gfx/image/imageloader.h"
 
 namespace Sword25 {
 
-// -----------------------------------------------------------------------------
-// Klassendeklaration
-// -----------------------------------------------------------------------------
-
 class B25SLoader : public ImageLoader {
 public:
-	static ImageLoader *CreateInstance() {
+	static ImageLoader *createInstance() {
 		return static_cast<ImageLoader *>(new B25SLoader());
 	}
 
 protected:
-	virtual bool IsCorrectImageFormat(const byte *FileDataPtr, uint FileSize);
-	virtual bool DecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr,
-	                         int &Width, int &Height, int &Pitch);
-	virtual bool ImageProperties(const byte *FileDataPtr, uint FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height);
+	virtual bool isCorrectImageFormat(const byte *fileDataPtr, uint fileSize);
+	virtual bool decodeImage(const byte *fileDataPtr, uint fileSize,  GraphicEngine::COLOR_FORMATS colorFormat, byte *&uncompressedDataPtr, int &width, int &height, int &pitch);
+	virtual bool imageProperties(const byte *fileDataPtr, uint fileSize, GraphicEngine::COLOR_FORMATS &colorFormat, int &width, int &height);
 
 };
 
diff --git a/engines/sword25/gfx/image/imageloader.cpp b/engines/sword25/gfx/image/imageloader.cpp
index 55ce833cc9..9838e8f0b6 100644
--- a/engines/sword25/gfx/image/imageloader.cpp
+++ b/engines/sword25/gfx/image/imageloader.cpp
@@ -40,84 +40,75 @@ namespace Sword25 {
 #define BS_LOG_PREFIX "IMAGELOADER"
 
 // Statische Elemente der Klasse BS_ImageLoader intialisieren.
-Common::List<ImageLoader *> ImageLoader::_ImageLoaderList;
-bool ImageLoader::_ImageLoaderListInitialized = false;
+Common::List<ImageLoader *> ImageLoader::_imageLoaderList;
+bool ImageLoader::_imageLoaderListInitialized = false;
 
-// Lade Methode
-// ------------
-
-bool ImageLoader::LoadImage(const byte *pFileData, uint FileSize,
-                            GraphicEngine::COLOR_FORMATS ColorFormat,
+bool ImageLoader::loadImage(const byte *pFileData, uint fileSize,
+                            GraphicEngine::COLOR_FORMATS colorFormat,
                             byte *&pUncompressedData,
-                            int &Width, int &Height,
-                            int &Pitch) {
+                            int &width, int &height,
+                            int &pitch) {
 	// Falls die Liste der BS_ImageLoader noch nicht initialisiert wurde, wird dies getan.
-	if (!_ImageLoaderListInitialized)
-		_InitializeLoaderList();
+	if (!_imageLoaderListInitialized)
+		initializeLoaderList();
 
 	// Passenden BS_ImageLoader finden und Bild dekodieren
-	ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize);
+	ImageLoader *pLoader = findSuitableImageLoader(pFileData, fileSize);
 	if (pLoader) {
-		return pLoader->DecodeImage(pFileData, FileSize,
-		                            ColorFormat,
+		return pLoader->decodeImage(pFileData, fileSize,
+		                            colorFormat,
 		                            pUncompressedData,
-		                            Width, Height,
-		                            Pitch);
+		                            width, height,
+		                            pitch);
 	}
 
 	return false;
 }
 
-// Info Methode
-// ------------
-
-bool ImageLoader::ExtractImageProperties(const byte *pFileData, uint FileSize,
-        GraphicEngine::COLOR_FORMATS &ColorFormat,
-        int &Width, int &Height) {
+bool ImageLoader::extractImageProperties(const byte *pFileData, uint fileSize,
+        GraphicEngine::COLOR_FORMATS &colorFormat,
+        int &width, int &height) {
 	// Falls die Liste der BS_ImageLoader noch nicht initialisiert wurde, wird dies getan.
-	if (!_ImageLoaderListInitialized)
-		_InitializeLoaderList();
+	if (!_imageLoaderListInitialized)
+		initializeLoaderList();
 
 	// Passenden BS_ImageLoader finden und Bildeigenschaften auslesen.
-	ImageLoader *pLoader = _FindSuitableImageLoader(pFileData, FileSize);
+	ImageLoader *pLoader = findSuitableImageLoader(pFileData, fileSize);
 	if (pLoader) {
-		return pLoader->ImageProperties(pFileData, FileSize,
-		                                ColorFormat,
-		                                Width, Height);
+		return pLoader->imageProperties(pFileData, fileSize,
+		                                colorFormat,
+		                                width, height);
 	}
 
 	return false;
 }
 
-// Verwaltungs Methoden
-// --------------------
-
-void ImageLoader::_InitializeLoaderList() {
+void 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]();
 
 	// Die Liste als gefüllt markieren.
-	_ImageLoaderListInitialized = true;
+	_imageLoaderListInitialized = true;
 
 	// Sicherstellen, dass beim Beenden alle BS_ImageLoader Instanzen zerstört werden.
-	atexit(ImageLoader::_DeinitializeLoaderList);
+	atexit(ImageLoader::deinitializeLoaderList);
 }
 
-void ImageLoader::_DeinitializeLoaderList() {
-	while (!_ImageLoaderList.empty()) {
-		delete _ImageLoaderList.back();
-		_ImageLoaderList.pop_back();
+void ImageLoader::deinitializeLoaderList() {
+	while (!_imageLoaderList.empty()) {
+		delete _imageLoaderList.back();
+		_imageLoaderList.pop_back();
 	}
 }
 
-ImageLoader *ImageLoader::_FindSuitableImageLoader(const byte *pFileData, uint FileSize) {
+ImageLoader *ImageLoader::findSuitableImageLoader(const byte *pFileData, uint fileSize) {
 	// Alle BS_ImageLoader-Objekte durchgehen, bis eins gefunden wurde, dass das Bild laden kann
-	Common::List<ImageLoader *>::iterator Iter = _ImageLoaderList.begin();
-	for (; Iter != _ImageLoaderList.end(); ++Iter) {
+	Common::List<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)) {
-			return (*Iter);
+		if ((*iter)->isCorrectImageFormat(pFileData, fileSize)) {
+			return (*iter);
 		}
 	}
 
diff --git a/engines/sword25/gfx/image/imageloader.h b/engines/sword25/gfx/image/imageloader.h
index e895f339e6..4d91faabb9 100644
--- a/engines/sword25/gfx/image/imageloader.h
+++ b/engines/sword25/gfx/image/imageloader.h
@@ -33,7 +33,7 @@
  */
 
 /*
-    BS_ImageLoader
+    ImageLoader
     --------------
 
     Autor: Malte Thiesen
@@ -55,11 +55,11 @@ namespace Sword25 {
 
     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.
+    - Erzeugen einer neuen von #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_ARGB32
+        - GraphicEngine::CF_ARGB32
     - Zum Konvertieren der Bilddaten können die Hilfsmethoden dieser Klasse benutzt werden, die ARGB Bilddaten in alle benötigten
       Farbformate konvertieren.
 */
@@ -80,7 +80,7 @@ public:
 	    @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_ARGB32
+	                       - 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.
@@ -89,11 +89,11 @@ public:
 	    @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 byte *pFileData, uint FileSize,
-	                      GraphicEngine::COLOR_FORMATS ColorFormat,
+	static bool loadImage(const byte *pFileData, uint fileSize,
+	                      GraphicEngine::COLOR_FORMATS colorFormat,
 	                      byte *&pUncompressedData,
-	                      int &Width, int &Height,
-	                      int &Pitch);
+	                      int &width, int &height,
+	                      int &pitch);
 
 	/**
 	    @brief Liest die Bildeigenschaften eines Bildes aus.
@@ -106,24 +106,24 @@ public:
 	    @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 byte *pFileData, uint FileSize,
-	                                   GraphicEngine::COLOR_FORMATS &ColorFormat,
-	                                   int &Width, int &Height);
+	static bool extractImageProperties(const byte *pFileData, uint fileSize,
+	                                   GraphicEngine::COLOR_FORMATS &colorFormat,
+	                                   int &width, int &height);
 	//@}
 
 protected:
 
-	// Protected Konstruktor, damit Instanzen dieser Klasse nur von BS_ImageLoader-Objekten erstellt werden können
+	// Protected Konstruktor, damit Instanzen dieser Klasse nur von ImageLoader-Objekten erstellt werden können
 	/**
 	    @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 #ImageLoader-Klassen in einer Liste.<br>
+	    Diese Liste enthält jeweils eine Instanz jedes #ImageLoader und wird benutzt um beliebige Bilddateien einem Loader zuzuordnen.
+	    @remark Dieser Konstruktor ist protected damit nur #ImageLoader-Objekte diese Klasse instanziieren können.
 	*/
 	ImageLoader() {
 		// Klasse registrieren
-		_ImageLoaderList.push_front(this);
+		_imageLoaderList.push_front(this);
 	}
 
 	virtual ~ImageLoader() {}
@@ -132,13 +132,13 @@ protected:
 	/** @name Abstrakte Methoden */
 
 	/**
-	    @brief Gibt an, ob der #BS_ImageLoader ein Bild lesen kann.
+	    @brief Gibt an, ob der #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.
+	    @return Gibt true zurück, wenn der #ImageLoader das Bild lesen kann, ansonsten false.
+	    @remark Diese Methode muss von allen ImageLoader Klassen implementiert werden.
 	*/
-	virtual bool IsCorrectImageFormat(const byte *pFileData, uint FileSize) = 0;
+	virtual bool isCorrectImageFormat(const byte *pFileData, uint fileSize) = 0;
 
 	/**
 	    @brief Lädt eine Bilddatei.
@@ -146,7 +146,7 @@ protected:
 	    @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_ARGB32
+	                       - 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.
@@ -154,13 +154,13 @@ protected:
 	    @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.
+	    @remark Diese Methode muss von allen ImageLoader Klassen implementiert werden.
 	*/
-	virtual bool DecodeImage(const byte *pFileData, uint FileSize,
-	                         GraphicEngine::COLOR_FORMATS ColorFormat,
+	virtual bool decodeImage(const byte *pFileData, uint fileSize,
+	                         GraphicEngine::COLOR_FORMATS colorFormat,
 	                         byte *&pUncompressedData,
-	                         int &Width, int &Height,
-	                         int &Pitch) = 0;
+	                         int &width, int &height,
+	                         int &pitch) = 0;
 
 	/**
 	    @brief Liest die Bildeigenschaften aus.
@@ -171,36 +171,36 @@ protected:
 	    @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.
+	    @remark Diese Methode muss von allen ImageLoader Klassen implementiert werden.
 	*/
-	virtual bool ImageProperties(const byte *pFileData, uint FileSize,
-	                             GraphicEngine::COLOR_FORMATS &ColorFormat,
-	                             int &Width, int &Height) = 0;
+	virtual bool imageProperties(const byte *pFileData, uint fileSize,
+	                             GraphicEngine::COLOR_FORMATS &colorFormat,
+	                             int &width, int &height) = 0;
 
 	//@}
 
 private:
 
 	/**
-	    @brief Erzeugt je eine Instanz aller BS_ImageLoader Klassen und fügt diese in eine interne Liste ein. Diese werden dann beim
+	    @brief Erzeugt je eine Instanz aller 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();
+	static void initializeLoaderList();
 
 	/**
-	    @brief Zerstört alle Instanzen von BS_ImageLoader Klassen, die in dieser Klasse registriert sind.
+	    @brief Zerstört alle Instanzen von ImageLoader Klassen, die in dieser Klasse registriert sind.
 	*/
-	static void _DeinitializeLoaderList();
+	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 ImageLoader Objekt, dass die Bilddaten dekodieren kann.
+	    @return Gibt einen Pointer auf ein passendes ImageLoader Objekt zurück, oder NULL, wenn kein passendes Objekt gefunden wurde.
 	*/
-	static ImageLoader *_FindSuitableImageLoader(const byte *pFileData, uint FileSize);
+	static ImageLoader *findSuitableImageLoader(const byte *pFileData, uint fileSize);
 
-	static Common::List<ImageLoader *>   _ImageLoaderList;              // Die Liste aller BS_ImageLoader-Objekte
-	static bool                         _ImageLoaderListInitialized;    // Gibt an, ob die Liste schon intialisiert wurde
+	static Common::List<ImageLoader *> _imageLoaderList;              // Die Liste aller 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 8fb6872ad7..5e2cb77fef 100644
--- a/engines/sword25/gfx/image/imageloader_ids.h
+++ b/engines/sword25/gfx/image/imageloader_ids.h
@@ -53,8 +53,8 @@ namespace Sword25 {
 // erzeugen
 typedef ImageLoader*(*BS_IMAGELOADER_NEW)();
 const BS_IMAGELOADER_NEW BS_IMAGELOADER_IDS[] = {
-	PNGLoader::CreateInstance,
-	B25SLoader::CreateInstance,
+	PNGLoader::createInstance,
+	B25SLoader::createInstance,
 };
 const int BS_IMAGELOADER_COUNT = sizeof(BS_IMAGELOADER_IDS) / sizeof(BS_IMAGELOADER_NEW);
 
diff --git a/engines/sword25/gfx/image/pngloader.cpp b/engines/sword25/gfx/image/pngloader.cpp
index 1136b94006..a61036311f 100644
--- a/engines/sword25/gfx/image/pngloader.cpp
+++ b/engines/sword25/gfx/image/pngloader.cpp
@@ -32,10 +32,6 @@
  *
  */
 
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
 #include "sword25/gfx/image/image.h"
 #include "sword25/gfx/image/pngloader.h"
 #include <png.h>
@@ -44,45 +40,34 @@ namespace Sword25 {
 
 #define BS_LOG_PREFIX "PNGLOADER"
 
-// -----------------------------------------------------------------------------
-// Konstruktor / Destruktor
-// -----------------------------------------------------------------------------
-
 PNGLoader::PNGLoader() {
 }
 
-// -----------------------------------------------------------------------------
-// Laden
-// -----------------------------------------------------------------------------
-
 static void png_user_read_data(png_structp png_ptr, png_bytep data, png_size_t length) {
 	const byte **ref = (const byte **)png_get_io_ptr(png_ptr);
 	memcpy(data, *ref, length);
 	*ref += length;
 }
 
-// -----------------------------------------------------------------------------
-
-bool PNGLoader::DoDecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr,
-                              int &Width, int &Height, int &Pitch) {
+bool PNGLoader::doDecodeImage(const byte *fileDataPtr, uint fileSize,  GraphicEngine::COLOR_FORMATS colorFormat, byte *&uncompressedDataPtr, int &width, int &height, int &pitch) {
 	png_structp png_ptr = NULL;
 	png_infop   info_ptr = NULL;
-	png_bytep   RawDataBuffer = NULL;
+	png_bytep   rawDataBuffer = NULL;
 	png_bytep  *pRowPtr = NULL;
 
-	int         BitDepth;
-	int         ColorType;
-	int         InterlaceType;
+	int         bitDepth;
+	int         colorType;
+	int         interlaceType;
 	int         i;
 
 	// Zielfarbformat überprüfen
-	if (ColorFormat != GraphicEngine::CF_ARGB32) {
+	if (colorFormat != GraphicEngine::CF_ARGB32) {
 		BS_LOG_ERRORLN("Illegal or unsupported color format.");
 		return false;
 	}
 
 	// PNG Signatur überprüfen
-	if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<byte *>(FileDataPtr)), 8)) {
+	if (!png_check_sig(reinterpret_cast<png_bytep>(const_cast<byte *>(fileDataPtr)), 8)) {
 		error("png_check_sig failed");
 	}
 
@@ -98,64 +83,64 @@ bool PNGLoader::DoDecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEn
 	}
 
 	// Alternative Lesefunktion benutzen
-	const byte **ref = &FileDataPtr;
+	const byte **ref = &fileDataPtr;
 	png_set_read_fn(png_ptr, (void *)ref, png_user_read_data);
 
 	// PNG Header einlesen
 	png_read_info(png_ptr, info_ptr);
 
 	// PNG Informationen auslesen
-	png_get_IHDR(png_ptr, info_ptr, (png_uint_32 *)&Width, (png_uint_32 *)&Height, &BitDepth, &ColorType, &InterlaceType, NULL, NULL);
+	png_get_IHDR(png_ptr, info_ptr, (png_uint_32 *)&width, (png_uint_32 *)&height, &bitDepth, &colorType, &interlaceType, NULL, NULL);
 
 	// Pitch des Ausgabebildes berechnen
-	Pitch = GraphicEngine::calcPitch(ColorFormat, Width);
+	pitch = GraphicEngine::calcPitch(colorFormat, width);
 
 	// 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 byte[Pitch * Height];
-	if (!UncompressedDataPtr) {
+	uncompressedDataPtr = new byte[pitch * height];
+	if (!uncompressedDataPtr) {
 		error("Could not allocate memory for output image.");
 	}
 
 	// Bilder jeglicher Farbformate werden zunächst in ARGB Bilder umgewandelt
-	if (BitDepth == 16)
+	if (bitDepth == 16)
 		png_set_strip_16(png_ptr);
-	if (ColorType == PNG_COLOR_TYPE_PALETTE)
+	if (colorType == PNG_COLOR_TYPE_PALETTE)
 		png_set_expand(png_ptr);
-	if (BitDepth < 8)
+	if (bitDepth < 8)
 		png_set_expand(png_ptr);
 	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)
+	if (colorType == PNG_COLOR_TYPE_GRAY ||
+	        colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
 		png_set_gray_to_rgb(png_ptr);
 
 	png_set_bgr(png_ptr);
 
-	if (ColorType != PNG_COLOR_TYPE_RGB_ALPHA)
+	if (colorType != PNG_COLOR_TYPE_RGB_ALPHA)
 		png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
 
 	// 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, (png_uint_32 *)&Width, (png_uint_32 *)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
+	png_get_IHDR(png_ptr, info_ptr, (png_uint_32 *)&width, (png_uint_32 *)&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) {
+		rawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr)];
+		if (!rawDataBuffer) {
 			error("Could not allocate memory for row buffer.");
 		}
 
 		// 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);
+			png_read_row(png_ptr, rawDataBuffer, NULL);
 
 			// Zeile konvertieren
-			switch (ColorFormat) {
+			switch (colorFormat) {
 			case GraphicEngine::CF_ARGB32:
-				memcpy(&UncompressedDataPtr[i * Pitch], RawDataBuffer, Pitch);
+				memcpy(&uncompressedDataPtr[i * pitch], rawDataBuffer, pitch);
 				break;
 			default:
 				assert(0);
@@ -164,29 +149,29 @@ bool PNGLoader::DoDecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEn
 	} else {
 		// PNGs mit Interlacing werden an einem Stück eingelesen
 		// Speicher für das komplette Bild reservieren
-		RawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr) * Height];
-		if (!RawDataBuffer) {
+		rawDataBuffer = new png_byte[png_get_rowbytes(png_ptr, info_ptr) * height];
+		if (!rawDataBuffer) {
 			error("Could not allocate memory for raw image buffer.");
 		}
 
 		// Speicher für die Rowpointer reservieren
-		pRowPtr = new png_bytep[Height];
+		pRowPtr = new png_bytep[height];
 		if (!pRowPtr) {
 			error("Could not allocate memory for row pointers.");
 		}
 
 		// Alle Rowpointer mit den richtigen Offsets initialisieren
-		for (i = 0; i < Height; i++)
-			pRowPtr[i] = RawDataBuffer + i * png_get_rowbytes(png_ptr, info_ptr);
+		for (i = 0; i < height; i++)
+			pRowPtr[i] = rawDataBuffer + i * png_get_rowbytes(png_ptr, info_ptr);
 
 		// Bild einlesen
 		png_read_image(png_ptr, pRowPtr);
 
 		// Bilddaten zeilenweise in das gewünschte Ausgabeformat konvertieren
-		switch (ColorFormat) {
+		switch (colorFormat) {
 		case GraphicEngine::CF_ARGB32:
-			for (i = 0; i < Height; i++)
-				memcpy(&UncompressedDataPtr[i * Pitch], &RawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)], Pitch);
+			for (i = 0; i < height; i++)
+				memcpy(&uncompressedDataPtr[i * pitch], &rawDataBuffer[i * png_get_rowbytes(png_ptr, info_ptr)], pitch);
 			break;
 		default:
 			error("Unhandled case in DoDecodeImage");
@@ -202,24 +187,20 @@ bool PNGLoader::DoDecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEn
 
 	// Temporäre Buffer freigeben
 	delete[] pRowPtr;
-	delete[] RawDataBuffer;
+	delete[] rawDataBuffer;
 
 	// Der Funktionsaufruf war erfolgreich
 	return true;
 }
 
-// -----------------------------------------------------------------------------
-
-bool PNGLoader::DecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr,
-                            int &Width, int &Height, int &Pitch) {
-	return DoDecodeImage(FileDataPtr, FileSize, ColorFormat, UncompressedDataPtr, Width, Height, Pitch);
+bool PNGLoader::decodeImage(const byte *fileDataPtr, uint fileSize,  GraphicEngine::COLOR_FORMATS colorFormat, byte *&uncompressedDataPtr, int &width, int &height, int &pitch) {
+	return doDecodeImage(fileDataPtr, fileSize, colorFormat, uncompressedDataPtr, width, height, pitch);
 }
 
-// -----------------------------------------------------------------------------
-
-bool PNGLoader::DoImageProperties(const byte *FileDataPtr, uint FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
+bool PNGLoader::doImageProperties(const byte *fileDataPtr, uint fileSize, GraphicEngine::COLOR_FORMATS &colorFormat, int &width, int &height) {
 	// PNG Signatur überprüfen
-	if (!DoIsCorrectImageFormat(FileDataPtr, FileSize)) return false;
+	if (!doIsCorrectImageFormat(fileDataPtr, fileSize))
+		return false;
 
 	png_structp png_ptr = NULL;
 	png_infop info_ptr = NULL;
@@ -236,22 +217,22 @@ bool PNGLoader::DoImageProperties(const byte *FileDataPtr, uint FileSize, Graphi
 	}
 
 	// Alternative Lesefunktion benutzen
-	const byte **ref = &FileDataPtr;
+	const byte **ref = &fileDataPtr;
 	png_set_read_fn(png_ptr, (void *)ref, png_user_read_data);
 
 	// PNG Header einlesen
 	png_read_info(png_ptr, info_ptr);
 
 	// PNG Informationen auslesen
-	int BitDepth;
-	int ColorType;
-	png_get_IHDR(png_ptr, info_ptr, (png_uint_32 *)&Width, (png_uint_32 *)&Height, &BitDepth, &ColorType, NULL, NULL, NULL);
+	int bitDepth;
+	int colorType;
+	png_get_IHDR(png_ptr, info_ptr, (png_uint_32 *)&width, (png_uint_32 *)&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))
-		ColorFormat = GraphicEngine::CF_ARGB32;
+	if (colorType & PNG_COLOR_MASK_ALPHA || png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
+		colorFormat = GraphicEngine::CF_ARGB32;
 	else
-		ColorFormat = GraphicEngine::CF_RGB24;
+		colorFormat = GraphicEngine::CF_RGB24;
 
 	// Die Strukturen freigeben
 	png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
@@ -260,27 +241,19 @@ bool PNGLoader::DoImageProperties(const byte *FileDataPtr, uint FileSize, Graphi
 
 }
 
-// -----------------------------------------------------------------------------
-
-bool PNGLoader::ImageProperties(const byte *FileDataPtr, uint FileSize,  GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height) {
-	return DoImageProperties(FileDataPtr, FileSize, ColorFormat, Width, Height);
+bool PNGLoader::imageProperties(const byte *fileDataPtr, uint fileSize, GraphicEngine::COLOR_FORMATS &colorFormat, int &width, int &height) {
+	return doImageProperties(fileDataPtr, fileSize, colorFormat, width, height);
 }
 
-// -----------------------------------------------------------------------------
-// Header überprüfen
-// -----------------------------------------------------------------------------
-
-bool PNGLoader::DoIsCorrectImageFormat(const byte *FileDataPtr, uint FileSize) {
-	if (FileSize > 8)
-		return png_check_sig(const_cast<byte *>(FileDataPtr), 8) ? true : false;
+bool PNGLoader::doIsCorrectImageFormat(const byte *fileDataPtr, uint fileSize) {
+	if (fileSize > 8)
+		return png_check_sig(const_cast<byte *>(fileDataPtr), 8) ? true : false;
 	else
 		return false;
 }
 
-// -----------------------------------------------------------------------------
-
-bool PNGLoader::IsCorrectImageFormat(const byte *FileDataPtr, uint FileSize) {
-	return DoIsCorrectImageFormat(FileDataPtr, FileSize);
+bool PNGLoader::isCorrectImageFormat(const byte *fileDataPtr, uint fileSize) {
+	return doIsCorrectImageFormat(fileDataPtr, fileSize);
 }
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/image/pngloader.h b/engines/sword25/gfx/image/pngloader.h
index 44c31b267c..aca04e815e 100644
--- a/engines/sword25/gfx/image/pngloader.h
+++ b/engines/sword25/gfx/image/pngloader.h
@@ -33,9 +33,9 @@
  */
 
 /*
-    BS_PNGLoader
+    PNGLoader
     ------------
-    BS_ImageLoader-Klasse zum Laden von PNG-Dateien
+    ImageLoader-Klasse zum Laden von PNG-Dateien
 
     Autor: Malte Thiesen
 */
@@ -52,26 +52,25 @@ namespace Sword25 {
 // Klassendefinition
 class PNGLoader : public ImageLoader {
 public:
-	static ImageLoader *CreateInstance() {
+	static ImageLoader *createInstance() {
 		return (ImageLoader *) new PNGLoader();
 	}
 
 	// 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 byte *FileDataPtr, uint FileSize);
-	static bool DoDecodeImage(const byte *FileDataPtr, uint FileSize,  GraphicEngine::COLOR_FORMATS ColorFormat, byte *&UncompressedDataPtr,
-	                          int &Width, int &Height, int &Pitch);
-	static bool DoImageProperties(const byte *FileDataPtr, uint FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height);
+	static bool doIsCorrectImageFormat(const byte *fileDataPtr, uint fileSize);
+	static bool doDecodeImage(const byte *fileDataPtr, uint fileSize,  GraphicEngine::COLOR_FORMATS colorFormat, byte *&uncompressedDataPtr, int &width, int &height, int &pitch);
+	static bool doImageProperties(const byte *fileDataPtr, uint fileSize, GraphicEngine::COLOR_FORMATS &colorFormat, int &width, int &height);
 
 protected:
 	PNGLoader();
-	bool DecodeImage(const byte *pFileData, uint FileSize,
-	                 GraphicEngine::COLOR_FORMATS ColorFormat,
+	bool decodeImage(const byte *pFileData, uint fileSize,
+	                 GraphicEngine::COLOR_FORMATS colorFormat,
 	                 byte *&pUncompressedData,
-	                 int &Width, int &Height,
-	                 int &Pitch);
-	bool IsCorrectImageFormat(const byte *FileDataPtr, uint FileSize);
-	bool ImageProperties(const byte *FileDatePtr, uint FileSize, GraphicEngine::COLOR_FORMATS &ColorFormat, int &Width, int &Height);
+	                 int &width, int &height,
+	                 int &pitch);
+	bool isCorrectImageFormat(const byte *fileDataPtr, uint fileSize);
+	bool imageProperties(const byte *fileDatePtr, uint fileSize, GraphicEngine::COLOR_FORMATS &colorFormat, int &width, int &height);
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/gfx/image/renderedimage.cpp b/engines/sword25/gfx/image/renderedimage.cpp
index d758e66841..a9ac4e6d26 100644
--- a/engines/sword25/gfx/image/renderedimage.cpp
+++ b/engines/sword25/gfx/image/renderedimage.cpp
@@ -72,14 +72,14 @@ RenderedImage::RenderedImage(const Common::String &filename, bool &result) :
 	// Bildeigenschaften bestimmen
 	GraphicEngine::COLOR_FORMATS colorFormat;
 	int pitch;
-	if (!ImageLoader::ExtractImageProperties(pFileData, fileSize, colorFormat, _width, _height)) {
+	if (!ImageLoader::extractImageProperties(pFileData, fileSize, colorFormat, _width, _height)) {
 		BS_LOG_ERRORLN("Could not read image properties.");
 		delete[] pFileData;
 		return;
 	}
 
 	// Das Bild dekomprimieren
-	if (!ImageLoader::LoadImage(pFileData, fileSize, GraphicEngine::CF_ARGB32, _data, _width, _height, pitch)) {
+	if (!ImageLoader::loadImage(pFileData, fileSize, GraphicEngine::CF_ARGB32, _data, _width, _height, pitch)) {
 		BS_LOG_ERRORLN("Could not decode image.");
 		delete[] pFileData;
 		return;
diff --git a/engines/sword25/gfx/image/swimage.cpp b/engines/sword25/gfx/image/swimage.cpp
index 77ac109e48..04fc8c4bcc 100644
--- a/engines/sword25/gfx/image/swimage.cpp
+++ b/engines/sword25/gfx/image/swimage.cpp
@@ -32,10 +32,6 @@
  *
  */
 
-// -----------------------------------------------------------------------------
-// INCLUDES
-// -----------------------------------------------------------------------------
-
 #include "sword25/package/packagemanager.h"
 #include "sword25/gfx/image/imageloader.h"
 #include "sword25/gfx/image/swimage.h"
@@ -45,10 +41,6 @@ namespace Sword25 {
 #define BS_LOG_PREFIX "SWIMAGE"
 
 
-// -----------------------------------------------------------------------------
-// CONSTRUCTION / DESTRUCTION
-// -----------------------------------------------------------------------------
-
 SWImage::SWImage(const Common::String &filename, bool &result) :
 	_imageDataPtr(0),
 	_width(0),
@@ -69,14 +61,14 @@ SWImage::SWImage(const Common::String &filename, bool &result) :
 	// Bildeigenschaften bestimmen
 	GraphicEngine::COLOR_FORMATS colorFormat;
 	int pitch;
-	if (!ImageLoader::ExtractImageProperties(pFileData, fileSize, colorFormat, _width, _height)) {
+	if (!ImageLoader::extractImageProperties(pFileData, fileSize, colorFormat, _width, _height)) {
 		BS_LOG_ERRORLN("Could not read image properties.");
 		return;
 	}
 
 	// Das Bild dekomprimieren
 	byte *pUncompressedData;
-	if (!ImageLoader::LoadImage(pFileData, fileSize, GraphicEngine::CF_ARGB32, pUncompressedData, _width, _height, pitch)) {
+	if (!ImageLoader::loadImage(pFileData, fileSize, GraphicEngine::CF_ARGB32, pUncompressedData, _width, _height, pitch)) {
 		BS_LOG_ERRORLN("Could not decode image.");
 		return;
 	}
@@ -90,15 +82,11 @@ SWImage::SWImage(const Common::String &filename, bool &result) :
 	return;
 }
 
-// -----------------------------------------------------------------------------
-
 SWImage::~SWImage() {
 	delete[] _imageDataPtr;
 }
 
 
-// -----------------------------------------------------------------------------
-
 bool SWImage::blit(int posX, int posY,
                       int flipping,
                       Common::Rect *pPartRect,
@@ -108,22 +96,16 @@ bool SWImage::blit(int posX, int posY,
 	return false;
 }
 
-// -----------------------------------------------------------------------------
-
 bool SWImage::fill(const Common::Rect *pFillRect, uint color) {
 	BS_LOG_ERRORLN("Fill() is not supported.");
 	return false;
 }
 
-// -----------------------------------------------------------------------------
-
 bool SWImage::setContent(const byte *pixeldata, uint size, uint offset, uint stride) {
 	BS_LOG_ERRORLN("SetContent() is not supported.");
 	return false;
 }
 
-// -----------------------------------------------------------------------------
-
 uint SWImage::getPixel(int x, int y) {
 	BS_ASSERT(x >= 0 && x < _width);
 	BS_ASSERT(y >= 0 && y < _height);
diff --git a/engines/sword25/gfx/image/swimage.h b/engines/sword25/gfx/image/swimage.h
index caf6bdcc71..a914c4f41f 100644
--- a/engines/sword25/gfx/image/swimage.h
+++ b/engines/sword25/gfx/image/swimage.h
@@ -35,10 +35,6 @@
 #ifndef SWORD25_SWIMAGE_H
 #define SWORD25_SWIMAGE_H
 
-// -----------------------------------------------------------------------------
-// INCLUDES
-// -----------------------------------------------------------------------------
-
 #include "sword25/kernel/common.h"
 #include "sword25/gfx/image/image.h"
 #include "sword25/gfx/graphicengine.h"
@@ -46,10 +42,6 @@
 
 namespace Sword25 {
 
-// -----------------------------------------------------------------------------
-// CLASS DEFINITION
-// -----------------------------------------------------------------------------
-
 class SWImage : public Image {
 public:
 	SWImage(const Common::String &filename, bool &result);