WINTERMUTE: Convert CRLF to LF

8 files changed, 1085 insertions, 1085 deletions

diff --git a/engines/wintermute/utils/crc.cpp b/engines/wintermute/utils/crc.cpp
index 8f608600f3..e7ec45511b 100644
--- a/engines/wintermute/utils/crc.cpp
+++ b/engines/wintermute/utils/crc.cpp
@@ -1,237 +1,237 @@
-/**********************************************************************

- *

- * Filename:    crc.c

- *

- * Description: Slow and fast implementations of the CRC standards.

- *

- * Notes:       The parameters for each supported CRC standard are

- *              defined in the header file crc.h.  The implementations

- *              here should stand up to further additions to that list.

- *

- *

- * Copyright (c) 2000 by Michael Barr.  This software is placed into

- * the public domain and may be used for any purpose.  However, this

- * notice must not be changed or removed and no warranty is either

- * expressed or implied by its publication or distribution.

- **********************************************************************/

-

-#include "engines/wintermute/utils/crc.h"

-

-namespace Wintermute {

-

-/*

- * Derive parameters from the standard-specific parameters in crc.h.

- */

-#define WIDTH    (8 * sizeof(crc))

-#define TOPBIT   (1 << (WIDTH - 1))

-

-#if (REFLECT_DATA == TRUE)

-#undef  REFLECT_DATA

-#define REFLECT_DATA(X)         ((unsigned char) reflect((X), 8))

-#else

-#undef  REFLECT_DATA

-#define REFLECT_DATA(X)         (X)

-#endif

-

-#if (REFLECT_REMAINDER == TRUE)

-#undef  REFLECT_REMAINDER

-#define REFLECT_REMAINDER(X)    ((crc) reflect((X), WIDTH))

-#else

-#undef  REFLECT_REMAINDER

-#define REFLECT_REMAINDER(X)    (X)

-#endif

-

-

-/*********************************************************************

- *

- * Function:    reflect()

- *

- * Description: Reorder the bits of a binary sequence, by reflecting

- *              them about the middle position.

- *

- * Notes:       No checking is done that nBits <= 32.

- *

- * Returns:     The reflection of the original data.

- *

- *********************************************************************/

-static unsigned long

-reflect(unsigned long data, unsigned char nBits) {

-	unsigned long  reflection = 0x00000000;

-	unsigned char  bit;

-

-	/*

-	 * Reflect the data about the center bit.

-	 */

-	for (bit = 0; bit < nBits; ++bit) {

-		/*

-		 * If the LSB bit is set, set the reflection of it.

-		 */

-		if (data & 0x01) {

-			reflection |= (1 << ((nBits - 1) - bit));

-		}

-

-		data = (data >> 1);

-	}

-

-	return (reflection);

-

-}   /* reflect() */

-

-

-/*********************************************************************

- *

- * Function:    crcSlow()

- *

- * Description: Compute the CRC of a given message.

- *

- * Notes:

- *

- * Returns:     The CRC of the message.

- *

- *********************************************************************/

-crc

-crcSlow(unsigned char const message[], int nBytes) {

-	crc            remainder = INITIAL_REMAINDER;

-	int            byte;

-	unsigned char  bit;

-

-

-	/*

-	 * Perform modulo-2 division, a byte at a time.

-	 */

-	for (byte  = 0; byte < nBytes; ++byte) {

-		/*

-		 * Bring the next byte into the remainder.

-		 */

-		remainder ^= (REFLECT_DATA(message[byte]) << (WIDTH - 8));

-

-		/*

-		 * Perform modulo-2 division, a bit at a time.

-		 */

-		for (bit = 8; bit > 0; --bit) {

-			/*

-			 * Try to divide the current data bit.

-			 */

-			if (remainder & TOPBIT) {

-				remainder = (remainder << 1) ^ POLYNOMIAL;

-			} else {

-				remainder = (remainder << 1);

-			}

-		}

-	}

-

-	/*

-	 * The final remainder is the CRC result.

-	 */

-	return (REFLECT_REMAINDER(remainder) ^ FINAL_XOR_VALUE);

-

-}   /* crcSlow() */

-

-

-crc  crcTable[256];

-

-

-/*********************************************************************

- *

- * Function:    crcInit()

- *

- * Description: Populate the partial CRC lookup table.

- *

- * Notes:       This function must be rerun any time the CRC standard

- *              is changed.  If desired, it can be run "offline" and

- *              the table results stored in an embedded system's ROM.

- *

- * Returns:     None defined.

- *

- *********************************************************************/

-void

-crcInit(void) {

-	crc            remainder;

-	int            dividend;

-	unsigned char  bit;

-

-

-	/*

-	 * Compute the remainder of each possible dividend.

-	 */

-	for (dividend = 0; dividend < 256; ++dividend) {

-		/*

-		 * Start with the dividend followed by zeros.

-		 */

-		remainder = dividend << (WIDTH - 8);

-

-		/*

-		 * Perform modulo-2 division, a bit at a time.

-		 */

-		for (bit = 8; bit > 0; --bit) {

-			/*

-			 * Try to divide the current data bit.

-			 */

-			if (remainder & TOPBIT) {

-				remainder = (remainder << 1) ^ POLYNOMIAL;

-			} else {

-				remainder = (remainder << 1);

-			}

-		}

-

-		/*

-		 * Store the result into the table.

-		 */

-		crcTable[dividend] = remainder;

-	}

-

-}   /* crcInit() */

-

-

-/*********************************************************************

- *

- * Function:    crcFast()

- *

- * Description: Compute the CRC of a given message.

- *

- * Notes:       crcInit() must be called first.

- *

- * Returns:     The CRC of the message.

- *

- *********************************************************************/

-crc

-crcFast(unsigned char const message[], int nBytes) {

-	crc            remainder = INITIAL_REMAINDER;

-	unsigned char  data;

-	int            byte;

-

-

-	/*

-	 * Divide the message by the polynomial, a byte at a time.

-	 */

-	for (byte  = 0; byte < nBytes; ++byte) {

-		data = (unsigned char)(REFLECT_DATA(message[byte]) ^ (remainder >> (WIDTH - 8)));

-		remainder = crcTable[data] ^ (remainder << 8);

-	}

-

-	/*

-	 * The final remainder is the CRC.

-	 */

-	return (REFLECT_REMAINDER(remainder) ^ FINAL_XOR_VALUE);

-

-}   /* crcFast() */

-

-

-

-crc crc_initialize(void) {

-	crcInit();

-	return INITIAL_REMAINDER;

-}

-

-crc crc_process_byte(unsigned char byteVal, crc remainder) {

-	unsigned char  data;

-	data = (unsigned char)(REFLECT_DATA(byteVal) ^ (remainder >> (WIDTH - 8)));

-	remainder = crcTable[data] ^ (remainder << 8);

-	return remainder;

-}

-

-crc crc_finalize(crc remainder) {

-	return (REFLECT_REMAINDER(remainder) ^ FINAL_XOR_VALUE);

-}

-

-} // end of namespace Wintermute

+/**********************************************************************
+ *
+ * Filename:    crc.c
+ *
+ * Description: Slow and fast implementations of the CRC standards.
+ *
+ * Notes:       The parameters for each supported CRC standard are
+ *              defined in the header file crc.h.  The implementations
+ *              here should stand up to further additions to that list.
+ *
+ *
+ * Copyright (c) 2000 by Michael Barr.  This software is placed into
+ * the public domain and may be used for any purpose.  However, this
+ * notice must not be changed or removed and no warranty is either
+ * expressed or implied by its publication or distribution.
+ **********************************************************************/
+
+#include "engines/wintermute/utils/crc.h"
+
+namespace Wintermute {
+
+/*
+ * Derive parameters from the standard-specific parameters in crc.h.
+ */
+#define WIDTH    (8 * sizeof(crc))
+#define TOPBIT   (1 << (WIDTH - 1))
+
+#if (REFLECT_DATA == TRUE)
+#undef  REFLECT_DATA
+#define REFLECT_DATA(X)         ((unsigned char) reflect((X), 8))
+#else
+#undef  REFLECT_DATA
+#define REFLECT_DATA(X)         (X)
+#endif
+
+#if (REFLECT_REMAINDER == TRUE)
+#undef  REFLECT_REMAINDER
+#define REFLECT_REMAINDER(X)    ((crc) reflect((X), WIDTH))
+#else
+#undef  REFLECT_REMAINDER
+#define REFLECT_REMAINDER(X)    (X)
+#endif
+
+
+/*********************************************************************
+ *
+ * Function:    reflect()
+ *
+ * Description: Reorder the bits of a binary sequence, by reflecting
+ *              them about the middle position.
+ *
+ * Notes:       No checking is done that nBits <= 32.
+ *
+ * Returns:     The reflection of the original data.
+ *
+ *********************************************************************/
+static unsigned long
+reflect(unsigned long data, unsigned char nBits) {
+	unsigned long  reflection = 0x00000000;
+	unsigned char  bit;
+
+	/*
+	 * Reflect the data about the center bit.
+	 */
+	for (bit = 0; bit < nBits; ++bit) {
+		/*
+		 * If the LSB bit is set, set the reflection of it.
+		 */
+		if (data & 0x01) {
+			reflection |= (1 << ((nBits - 1) - bit));
+		}
+
+		data = (data >> 1);
+	}
+
+	return (reflection);
+
+}   /* reflect() */
+
+
+/*********************************************************************
+ *
+ * Function:    crcSlow()
+ *
+ * Description: Compute the CRC of a given message.
+ *
+ * Notes:
+ *
+ * Returns:     The CRC of the message.
+ *
+ *********************************************************************/
+crc
+crcSlow(unsigned char const message[], int nBytes) {
+	crc            remainder = INITIAL_REMAINDER;
+	int            byte;
+	unsigned char  bit;
+
+
+	/*
+	 * Perform modulo-2 division, a byte at a time.
+	 */
+	for (byte  = 0; byte < nBytes; ++byte) {
+		/*
+		 * Bring the next byte into the remainder.
+		 */
+		remainder ^= (REFLECT_DATA(message[byte]) << (WIDTH - 8));
+
+		/*
+		 * Perform modulo-2 division, a bit at a time.
+		 */
+		for (bit = 8; bit > 0; --bit) {
+			/*
+			 * Try to divide the current data bit.
+			 */
+			if (remainder & TOPBIT) {
+				remainder = (remainder << 1) ^ POLYNOMIAL;
+			} else {
+				remainder = (remainder << 1);
+			}
+		}
+	}
+
+	/*
+	 * The final remainder is the CRC result.
+	 */
+	return (REFLECT_REMAINDER(remainder) ^ FINAL_XOR_VALUE);
+
+}   /* crcSlow() */
+
+
+crc  crcTable[256];
+
+
+/*********************************************************************
+ *
+ * Function:    crcInit()
+ *
+ * Description: Populate the partial CRC lookup table.
+ *
+ * Notes:       This function must be rerun any time the CRC standard
+ *              is changed.  If desired, it can be run "offline" and
+ *              the table results stored in an embedded system's ROM.
+ *
+ * Returns:     None defined.
+ *
+ *********************************************************************/
+void
+crcInit(void) {
+	crc            remainder;
+	int            dividend;
+	unsigned char  bit;
+
+
+	/*
+	 * Compute the remainder of each possible dividend.
+	 */
+	for (dividend = 0; dividend < 256; ++dividend) {
+		/*
+		 * Start with the dividend followed by zeros.
+		 */
+		remainder = dividend << (WIDTH - 8);
+
+		/*
+		 * Perform modulo-2 division, a bit at a time.
+		 */
+		for (bit = 8; bit > 0; --bit) {
+			/*
+			 * Try to divide the current data bit.
+			 */
+			if (remainder & TOPBIT) {
+				remainder = (remainder << 1) ^ POLYNOMIAL;
+			} else {
+				remainder = (remainder << 1);
+			}
+		}
+
+		/*
+		 * Store the result into the table.
+		 */
+		crcTable[dividend] = remainder;
+	}
+
+}   /* crcInit() */
+
+
+/*********************************************************************
+ *
+ * Function:    crcFast()
+ *
+ * Description: Compute the CRC of a given message.
+ *
+ * Notes:       crcInit() must be called first.
+ *
+ * Returns:     The CRC of the message.
+ *
+ *********************************************************************/
+crc
+crcFast(unsigned char const message[], int nBytes) {
+	crc            remainder = INITIAL_REMAINDER;
+	unsigned char  data;
+	int            byte;
+
+
+	/*
+	 * Divide the message by the polynomial, a byte at a time.
+	 */
+	for (byte  = 0; byte < nBytes; ++byte) {
+		data = (unsigned char)(REFLECT_DATA(message[byte]) ^ (remainder >> (WIDTH - 8)));
+		remainder = crcTable[data] ^ (remainder << 8);
+	}
+
+	/*
+	 * The final remainder is the CRC.
+	 */
+	return (REFLECT_REMAINDER(remainder) ^ FINAL_XOR_VALUE);
+
+}   /* crcFast() */
+
+
+
+crc crc_initialize(void) {
+	crcInit();
+	return INITIAL_REMAINDER;
+}
+
+crc crc_process_byte(unsigned char byteVal, crc remainder) {
+	unsigned char  data;
+	data = (unsigned char)(REFLECT_DATA(byteVal) ^ (remainder >> (WIDTH - 8)));
+	remainder = crcTable[data] ^ (remainder << 8);
+	return remainder;
+}
+
+crc crc_finalize(crc remainder) {
+	return (REFLECT_REMAINDER(remainder) ^ FINAL_XOR_VALUE);
+}
+
+} // end of namespace Wintermute
diff --git a/engines/wintermute/utils/crc.h b/engines/wintermute/utils/crc.h
index 9b9446ce57..77c2ea267f 100644
--- a/engines/wintermute/utils/crc.h
+++ b/engines/wintermute/utils/crc.h
@@ -1,85 +1,85 @@
-/**********************************************************************

- *

- * Filename:    crc.h

- *

- * Description: A header file describing the various CRC standards.

- *

- * Notes:

- *

- *

- * Copyright (c) 2000 by Michael Barr.  This software is placed into

- * the public domain and may be used for any purpose.  However, this

- * notice must not be changed or removed and no warranty is either

- * expressed or implied by its publication or distribution.

- **********************************************************************/

-

-#ifndef _crc_h

-#define _crc_h

-

-#include "common/system.h" // For types.

-

-namespace Wintermute {

-

-#ifndef TRUE

-#define FALSE   0

-#define TRUE    !FALSE

-#endif

-

-/*

- * Select the CRC standard from the list that follows.

- */

-#define CRC32

-

-#if defined(CRC_CCITT)

-

-typedef uint16  crc;

-

-#define CRC_NAME            "CRC-CCITT"

-#define POLYNOMIAL          0x1021

-#define INITIAL_REMAINDER   0xFFFF

-#define FINAL_XOR_VALUE     0x0000

-#define REFLECT_DATA        FALSE

-#define REFLECT_REMAINDER   FALSE

-#define CHECK_VALUE         0x29B1

-

-#elif defined(CRC16)

-

-typedef uint16  crc;

-

-#define CRC_NAME            "CRC-16"

-#define POLYNOMIAL          0x8005

-#define INITIAL_REMAINDER   0x0000

-#define FINAL_XOR_VALUE     0x0000

-#define REFLECT_DATA        TRUE

-#define REFLECT_REMAINDER   TRUE

-#define CHECK_VALUE         0xBB3D

-

-#elif defined(CRC32)

-

-typedef uint32  crc;

-

-#define CRC_NAME            "CRC-32"

-#define POLYNOMIAL          0x04C11DB7

-#define INITIAL_REMAINDER   0xFFFFFFFF

-#define FINAL_XOR_VALUE     0xFFFFFFFF

-#define REFLECT_DATA        TRUE

-#define REFLECT_REMAINDER   TRUE

-#define CHECK_VALUE         0xCBF43926

-

-#else

-

-#error "One of CRC_CCITT, CRC16, or CRC32 must be #define'd."

-

-#endif

-

-void  crcInit(void);

-crc   crcSlow(unsigned char const message[], int nBytes);

-crc   crcFast(unsigned char const message[], int nBytes);

-

-extern "C" crc crc_initialize(void);

-extern "C" crc crc_process_byte(unsigned char byteVal, crc remainder);

-extern "C" crc crc_finalize(crc remainder);

-

-} // End of namespace Wintermute

-

-#endif /* _crc_h */

+/**********************************************************************
+ *
+ * Filename:    crc.h
+ *
+ * Description: A header file describing the various CRC standards.
+ *
+ * Notes:
+ *
+ *
+ * Copyright (c) 2000 by Michael Barr.  This software is placed into
+ * the public domain and may be used for any purpose.  However, this
+ * notice must not be changed or removed and no warranty is either
+ * expressed or implied by its publication or distribution.
+ **********************************************************************/
+
+#ifndef _crc_h
+#define _crc_h
+
+#include "common/system.h" // For types.
+
+namespace Wintermute {
+
+#ifndef TRUE
+#define FALSE   0
+#define TRUE    !FALSE
+#endif
+
+/*
+ * Select the CRC standard from the list that follows.
+ */
+#define CRC32
+
+#if defined(CRC_CCITT)
+
+typedef uint16  crc;
+
+#define CRC_NAME            "CRC-CCITT"
+#define POLYNOMIAL          0x1021
+#define INITIAL_REMAINDER   0xFFFF
+#define FINAL_XOR_VALUE     0x0000
+#define REFLECT_DATA        FALSE
+#define REFLECT_REMAINDER   FALSE
+#define CHECK_VALUE         0x29B1
+
+#elif defined(CRC16)
+
+typedef uint16  crc;
+
+#define CRC_NAME            "CRC-16"
+#define POLYNOMIAL          0x8005
+#define INITIAL_REMAINDER   0x0000
+#define FINAL_XOR_VALUE     0x0000
+#define REFLECT_DATA        TRUE
+#define REFLECT_REMAINDER   TRUE
+#define CHECK_VALUE         0xBB3D
+
+#elif defined(CRC32)
+
+typedef uint32  crc;
+
+#define CRC_NAME            "CRC-32"
+#define POLYNOMIAL          0x04C11DB7
+#define INITIAL_REMAINDER   0xFFFFFFFF
+#define FINAL_XOR_VALUE     0xFFFFFFFF
+#define REFLECT_DATA        TRUE
+#define REFLECT_REMAINDER   TRUE
+#define CHECK_VALUE         0xCBF43926
+
+#else
+
+#error "One of CRC_CCITT, CRC16, or CRC32 must be #define'd."
+
+#endif
+
+void  crcInit(void);
+crc   crcSlow(unsigned char const message[], int nBytes);
+crc   crcFast(unsigned char const message[], int nBytes);
+
+extern "C" crc crc_initialize(void);
+extern "C" crc crc_process_byte(unsigned char byteVal, crc remainder);
+extern "C" crc crc_finalize(crc remainder);
+
+} // End of namespace Wintermute
+
+#endif /* _crc_h */
diff --git a/engines/wintermute/utils/path_util.cpp b/engines/wintermute/utils/path_util.cpp
index 55bf776848..298f0c268f 100644
--- a/engines/wintermute/utils/path_util.cpp
+++ b/engines/wintermute/utils/path_util.cpp
@@ -1,101 +1,101 @@
-/* ScummVM - Graphic Adventure Engine

- *

- * ScummVM is the legal property of its developers, whose names

- * are too numerous to list here. Please refer to the COPYRIGHT

- * file distributed with this source distribution.

- *

- * This program is free software; you can redistribute it and/or

- * modify it under the terms of the GNU General Public License

- * as published by the Free Software Foundation; either version 2

- * of the License, or (at your option) any later version.

-

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

-

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

- *

- */

-

-/*

- * This file is based on WME Lite.

- * http://dead-code.org/redir.php?target=wmelite

- * Copyright (c) 2011 Jan Nedoma

- */

-

-#include "common/file.h"

-#include "engines/wintermute/utils/path_util.h"

-

-namespace Wintermute {

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::unifySeparators(const AnsiString &path) {

-	AnsiString newPath = path;

-

-	for (uint32 i = 0; i < newPath.size(); i++) {

-		if (newPath[i] == '\\') {

-			newPath.setChar('/', i);

-		}

-	}

-

-	return newPath;

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::normalizeFileName(const AnsiString &path) {

-	AnsiString newPath = unifySeparators(path);

-	newPath.toLowercase();

-	return newPath;

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::combine(const AnsiString &path1, const AnsiString &path2) {

-	AnsiString newPath1 = unifySeparators(path1);

-	AnsiString newPath2 = unifySeparators(path2);

-

-	if (!newPath1.hasSuffix("/") && !newPath2.hasPrefix("/")) {

-		newPath1 += "/";

-	}

-

-	return newPath1 + newPath2;

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::getDirectoryName(const AnsiString &path) {

-	AnsiString newPath = unifySeparators(path);

-	Common::String filename = getFileName(path);

-	return Common::String(path.c_str(), path.size() - filename.size());

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::getFileName(const AnsiString &path) {

-	AnsiString newPath = unifySeparators(path);

-	Common::String lastPart = Common::lastPathComponent(newPath, '/');

-	if (lastPart[lastPart.size() - 1 ] != '/') {

-		return lastPart;

-	} else {

-		return path;

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::getFileNameWithoutExtension(const AnsiString &path) {

-	AnsiString fileName = getFileName(path);

-	// TODO: Prettify this.

-	AnsiString extension = Common::lastPathComponent(fileName, '.');

-	for (uint32 i = 0; i < extension.size() + 1; i++) {

-		fileName.deleteLastChar();

-	}

-	return fileName;

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::getExtension(const AnsiString &path) {

-	AnsiString fileName = getFileName(path);

-	return Common::lastPathComponent(path, '.');

-}

-

-} // end of namespace Wintermute

+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#include "common/file.h"
+#include "engines/wintermute/utils/path_util.h"
+
+namespace Wintermute {
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::unifySeparators(const AnsiString &path) {
+	AnsiString newPath = path;
+
+	for (uint32 i = 0; i < newPath.size(); i++) {
+		if (newPath[i] == '\\') {
+			newPath.setChar('/', i);
+		}
+	}
+
+	return newPath;
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::normalizeFileName(const AnsiString &path) {
+	AnsiString newPath = unifySeparators(path);
+	newPath.toLowercase();
+	return newPath;
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::combine(const AnsiString &path1, const AnsiString &path2) {
+	AnsiString newPath1 = unifySeparators(path1);
+	AnsiString newPath2 = unifySeparators(path2);
+
+	if (!newPath1.hasSuffix("/") && !newPath2.hasPrefix("/")) {
+		newPath1 += "/";
+	}
+
+	return newPath1 + newPath2;
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::getDirectoryName(const AnsiString &path) {
+	AnsiString newPath = unifySeparators(path);
+	Common::String filename = getFileName(path);
+	return Common::String(path.c_str(), path.size() - filename.size());
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::getFileName(const AnsiString &path) {
+	AnsiString newPath = unifySeparators(path);
+	Common::String lastPart = Common::lastPathComponent(newPath, '/');
+	if (lastPart[lastPart.size() - 1 ] != '/') {
+		return lastPart;
+	} else {
+		return path;
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::getFileNameWithoutExtension(const AnsiString &path) {
+	AnsiString fileName = getFileName(path);
+	// TODO: Prettify this.
+	AnsiString extension = Common::lastPathComponent(fileName, '.');
+	for (uint32 i = 0; i < extension.size() + 1; i++) {
+		fileName.deleteLastChar();
+	}
+	return fileName;
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString PathUtil::getExtension(const AnsiString &path) {
+	AnsiString fileName = getFileName(path);
+	return Common::lastPathComponent(path, '.');
+}
+
+} // end of namespace Wintermute
diff --git a/engines/wintermute/utils/path_util.h b/engines/wintermute/utils/path_util.h
index 92adfd91b8..7358c2aba0 100644
--- a/engines/wintermute/utils/path_util.h
+++ b/engines/wintermute/utils/path_util.h
@@ -1,49 +1,49 @@
-/* ScummVM - Graphic Adventure Engine

- *

- * ScummVM is the legal property of its developers, whose names

- * are too numerous to list here. Please refer to the COPYRIGHT

- * file distributed with this source distribution.

- *

- * This program is free software; you can redistribute it and/or

- * modify it under the terms of the GNU General Public License

- * as published by the Free Software Foundation; either version 2

- * of the License, or (at your option) any later version.

-

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

-

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

- *

- */

-

-/*

- * This file is based on WME Lite.

- * http://dead-code.org/redir.php?target=wmelite

- * Copyright (c) 2011 Jan Nedoma

- */

-

-#ifndef WINTERMUTE_PATHUTILS_H

-#define WINTERMUTE_PATHUTILS_H

-

-#include "engines/wintermute/dctypes.h"

-

-namespace Wintermute {

-

-class PathUtil {

-public:

-	static AnsiString unifySeparators(const AnsiString &path);

-	static AnsiString normalizeFileName(const AnsiString &path);

-	static AnsiString combine(const AnsiString &path1, const AnsiString &path2);

-	static AnsiString getDirectoryName(const AnsiString &path);

-	static AnsiString getFileName(const AnsiString &path);

-	static AnsiString getFileNameWithoutExtension(const AnsiString &path);

-	static AnsiString getExtension(const AnsiString &path);

-};

-

-} // end of namespace Wintermute

-

-#endif

+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#ifndef WINTERMUTE_PATHUTILS_H
+#define WINTERMUTE_PATHUTILS_H
+
+#include "engines/wintermute/dctypes.h"
+
+namespace Wintermute {
+
+class PathUtil {
+public:
+	static AnsiString unifySeparators(const AnsiString &path);
+	static AnsiString normalizeFileName(const AnsiString &path);
+	static AnsiString combine(const AnsiString &path1, const AnsiString &path2);
+	static AnsiString getDirectoryName(const AnsiString &path);
+	static AnsiString getFileName(const AnsiString &path);
+	static AnsiString getFileNameWithoutExtension(const AnsiString &path);
+	static AnsiString getExtension(const AnsiString &path);
+};
+
+} // end of namespace Wintermute
+
+#endif
diff --git a/engines/wintermute/utils/string_util.cpp b/engines/wintermute/utils/string_util.cpp
index 63793f7d0b..2c3be8c2f5 100644
--- a/engines/wintermute/utils/string_util.cpp
+++ b/engines/wintermute/utils/string_util.cpp
@@ -1,232 +1,232 @@
-/* ScummVM - Graphic Adventure Engine

- *

- * ScummVM is the legal property of its developers, whose names

- * are too numerous to list here. Please refer to the COPYRIGHT

- * file distributed with this source distribution.

- *

- * This program is free software; you can redistribute it and/or

- * modify it under the terms of the GNU General Public License

- * as published by the Free Software Foundation; either version 2

- * of the License, or (at your option) any later version.

-

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

-

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

- *

- */

-

-/*

- * This file is based on WME Lite.

- * http://dead-code.org/redir.php?target=wmelite

- * Copyright (c) 2011 Jan Nedoma

- */

-

-#include "common/tokenizer.h"

-#include "engines/wintermute/utils/string_util.h"

-#include "engines/wintermute/utils/convert_utf.h"

-

-namespace Wintermute {

-

-//////////////////////////////////////////////////////////////////////////

-bool StringUtil::compareNoCase(const AnsiString &str1, const AnsiString &str2) {

-	return (str1.compareToIgnoreCase(str2) == 0);

-}

-

-//////////////////////////////////////////////////////////////////////////

-/*bool StringUtil::CompareNoCase(const WideString &str1, const WideString &str2) {

-    WideString str1lc = str1;

-    WideString str2lc = str2;

-

-    ToLowerCase(str1lc);

-    ToLowerCase(str2lc);

-

-    return (str1lc == str2lc);

-}*/

-

-//////////////////////////////////////////////////////////////////////////

-WideString StringUtil::utf8ToWide(const Utf8String &Utf8Str) {

-	error("StringUtil::Utf8ToWide - WideString not supported yet");

-	/*  size_t WideSize = Utf8Str.size();

-

-	    if (sizeof(wchar_t) == 2) {

-	        wchar_t *WideStringNative = new wchar_t[WideSize + 1];

-

-	        const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(Utf8Str.c_str());

-	        const UTF8 *SourceEnd = SourceStart + WideSize;

-

-	        UTF16 *TargetStart = reinterpret_cast<UTF16 *>(WideStringNative);

-	        UTF16 *TargetEnd = TargetStart + WideSize + 1;

-

-	        ConversionResult res = ConvertUTF8toUTF16(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);

-	        if (res != conversionOK) {

-	            delete[] WideStringNative;

-	            return L"";

-	        }

-	        *TargetStart = 0;

-	        WideString ResultString(WideStringNative);

-	        delete[] WideStringNative;

-

-	        return ResultString;

-	    } else if (sizeof(wchar_t) == 4) {

-	        wchar_t *WideStringNative = new wchar_t[WideSize + 1];

-

-	        const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(Utf8Str.c_str());

-	        const UTF8 *SourceEnd = SourceStart + WideSize;

-

-	        UTF32 *TargetStart = reinterpret_cast<UTF32 *>(WideStringNative);

-	        UTF32 *TargetEnd = TargetStart + WideSize;

-

-	        ConversionResult res = ConvertUTF8toUTF32(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);

-	        if (res != conversionOK) {

-	            delete[] WideStringNative;

-	            return L"";

-	        }

-	        *TargetStart = 0;

-	        WideString ResultString(WideStringNative);

-	        delete[] WideStringNative;

-

-	        return ResultString;

-	    } else {

-	        return L"";

-	    }*/

-	return "";

-}

-

-//////////////////////////////////////////////////////////////////////////

-Utf8String StringUtil::wideToUtf8(const WideString &WideStr) {

-	error("StringUtil::wideToUtf8 - Widestring not supported yet");

-	/*  size_t WideSize = WideStr.length();

-

-	    if (sizeof(wchar_t) == 2) {

-	        size_t utf8Size = 3 * WideSize + 1;

-	        char *utf8StringNative = new char[Utf8Size];

-

-	        const UTF16 *SourceStart = reinterpret_cast<const UTF16 *>(WideStr.c_str());

-	        const UTF16 *SourceEnd = SourceStart + WideSize;

-

-	        UTF8 *TargetStart = reinterpret_cast<UTF8 *>(Utf8StringNative);

-	        UTF8 *TargetEnd = TargetStart + Utf8Size;

-

-	        ConversionResult res = ConvertUTF16toUTF8(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);

-	        if (res != conversionOK) {

-	            delete[] Utf8StringNative;

-	            return (Utf8String)"";

-	        }

-	        *TargetStart = 0;

-	        Utf8String ResultString(Utf8StringNative);

-	        delete[] Utf8StringNative;

-	        return ResultString;

-	    } else if (sizeof(wchar_t) == 4) {

-	        size_t utf8Size = 4 * WideSize + 1;

-	        char *utf8StringNative = new char[Utf8Size];

-

-	        const UTF32 *SourceStart = reinterpret_cast<const UTF32 *>(WideStr.c_str());

-	        const UTF32 *SourceEnd = SourceStart + WideSize;

-

-	        UTF8 *TargetStart = reinterpret_cast<UTF8 *>(Utf8StringNative);

-	        UTF8 *TargetEnd = TargetStart + Utf8Size;

-

-	        ConversionResult res = ConvertUTF32toUTF8(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);

-	        if (res != conversionOK) {

-	            delete[] Utf8StringNative;

-	            return (Utf8String)"";

-	        }

-	        *TargetStart = 0;

-	        Utf8String ResultString(Utf8StringNative);

-	        delete[] Utf8StringNative;

-	        return ResultString;

-	    } else {

-	        return (Utf8String)"";

-	    }*/

-	return "";

-}

-

-// Currently this only does Ansi->ISO 8859, and only for carets.

-char simpleAnsiToWide(const AnsiString &str, uint32 &offset) {

-	char c = str[offset];

-

-	if (c == 92) {

-		offset++;

-		return '\'';

-	} else {

-		offset++;

-		return c;

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////

-WideString StringUtil::ansiToWide(const AnsiString &str) {

-	// TODO: This function gets called a lot, so warnings like these drown out the usefull information

-	/*Common::String converted = "";

-	uint32 index = 0;

-	while (index != str.size()) {

-	    converted += simpleAnsiToWide(str, index);

-	}*/

-	// using default os locale!

-

-	/*  setlocale(LC_CTYPE, "");

-	    size_t wideSize = mbstowcs(NULL, str.c_str(), 0) + 1;

-	    wchar_t *wstr = new wchar_t[WideSize];

-	    mbstowcs(wstr, str.c_str(), WideSize);

-	    WideString ResultString(wstr);

-	    delete[] wstr;

-	    return ResultString;*/

-	return WideString(str);

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::wideToAnsi(const WideString &wstr) {

-	// using default os locale!

-	// TODO: This function gets called a lot, so warnings like these drown out the usefull information

-	/*  setlocale(LC_CTYPE, "");

-	    size_t wideSize = wcstombs(NULL, wstr.c_str(), 0) + 1;

-	    char *str = new char[WideSize];

-	    wcstombs(str, wstr.c_str(), WideSize);

-	    AnsiString ResultString(str);

-	    delete[] str;

-	    return ResultString;*/

-	return AnsiString(wstr);

-}

-

-//////////////////////////////////////////////////////////////////////////

-bool StringUtil::isUtf8BOM(const byte *buffer, uint32 bufferSize) {

-	if (bufferSize > 3 && buffer[0] == 0xEF && buffer[1] == 0xBB && buffer[2] == 0xBF) {

-		return true;

-	} else {

-		return false;

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////

-int StringUtil::indexOf(const WideString &str, const WideString &toFind, size_t startFrom) {

-	const char *index = strstr(str.c_str(), toFind.c_str());

-	if (index == NULL) {

-		return -1;

-	} else {

-		return index - str.c_str();

-	}

-}

-

-Common::String StringUtil::encodeSetting(const Common::String &str) {

-	if (str.contains('=')) {

-		error("Setting contains '='");

-	}

-	return str;

-}

-

-Common::String StringUtil::decodeSetting(const Common::String &str) {

-	return str;

-}

-

-//////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::toString(int val) {

-	return Common::String::format("%d", val);

-}

-

-

-} // end of namespace Wintermute

+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#include "common/tokenizer.h"
+#include "engines/wintermute/utils/string_util.h"
+#include "engines/wintermute/utils/convert_utf.h"
+
+namespace Wintermute {
+
+//////////////////////////////////////////////////////////////////////////
+bool StringUtil::compareNoCase(const AnsiString &str1, const AnsiString &str2) {
+	return (str1.compareToIgnoreCase(str2) == 0);
+}
+
+//////////////////////////////////////////////////////////////////////////
+/*bool StringUtil::CompareNoCase(const WideString &str1, const WideString &str2) {
+    WideString str1lc = str1;
+    WideString str2lc = str2;
+
+    ToLowerCase(str1lc);
+    ToLowerCase(str2lc);
+
+    return (str1lc == str2lc);
+}*/
+
+//////////////////////////////////////////////////////////////////////////
+WideString StringUtil::utf8ToWide(const Utf8String &Utf8Str) {
+	error("StringUtil::Utf8ToWide - WideString not supported yet");
+	/*  size_t WideSize = Utf8Str.size();
+
+	    if (sizeof(wchar_t) == 2) {
+	        wchar_t *WideStringNative = new wchar_t[WideSize + 1];
+
+	        const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(Utf8Str.c_str());
+	        const UTF8 *SourceEnd = SourceStart + WideSize;
+
+	        UTF16 *TargetStart = reinterpret_cast<UTF16 *>(WideStringNative);
+	        UTF16 *TargetEnd = TargetStart + WideSize + 1;
+
+	        ConversionResult res = ConvertUTF8toUTF16(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);
+	        if (res != conversionOK) {
+	            delete[] WideStringNative;
+	            return L"";
+	        }
+	        *TargetStart = 0;
+	        WideString ResultString(WideStringNative);
+	        delete[] WideStringNative;
+
+	        return ResultString;
+	    } else if (sizeof(wchar_t) == 4) {
+	        wchar_t *WideStringNative = new wchar_t[WideSize + 1];
+
+	        const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(Utf8Str.c_str());
+	        const UTF8 *SourceEnd = SourceStart + WideSize;
+
+	        UTF32 *TargetStart = reinterpret_cast<UTF32 *>(WideStringNative);
+	        UTF32 *TargetEnd = TargetStart + WideSize;
+
+	        ConversionResult res = ConvertUTF8toUTF32(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);
+	        if (res != conversionOK) {
+	            delete[] WideStringNative;
+	            return L"";
+	        }
+	        *TargetStart = 0;
+	        WideString ResultString(WideStringNative);
+	        delete[] WideStringNative;
+
+	        return ResultString;
+	    } else {
+	        return L"";
+	    }*/
+	return "";
+}
+
+//////////////////////////////////////////////////////////////////////////
+Utf8String StringUtil::wideToUtf8(const WideString &WideStr) {
+	error("StringUtil::wideToUtf8 - Widestring not supported yet");
+	/*  size_t WideSize = WideStr.length();
+
+	    if (sizeof(wchar_t) == 2) {
+	        size_t utf8Size = 3 * WideSize + 1;
+	        char *utf8StringNative = new char[Utf8Size];
+
+	        const UTF16 *SourceStart = reinterpret_cast<const UTF16 *>(WideStr.c_str());
+	        const UTF16 *SourceEnd = SourceStart + WideSize;
+
+	        UTF8 *TargetStart = reinterpret_cast<UTF8 *>(Utf8StringNative);
+	        UTF8 *TargetEnd = TargetStart + Utf8Size;
+
+	        ConversionResult res = ConvertUTF16toUTF8(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);
+	        if (res != conversionOK) {
+	            delete[] Utf8StringNative;
+	            return (Utf8String)"";
+	        }
+	        *TargetStart = 0;
+	        Utf8String ResultString(Utf8StringNative);
+	        delete[] Utf8StringNative;
+	        return ResultString;
+	    } else if (sizeof(wchar_t) == 4) {
+	        size_t utf8Size = 4 * WideSize + 1;
+	        char *utf8StringNative = new char[Utf8Size];
+
+	        const UTF32 *SourceStart = reinterpret_cast<const UTF32 *>(WideStr.c_str());
+	        const UTF32 *SourceEnd = SourceStart + WideSize;
+
+	        UTF8 *TargetStart = reinterpret_cast<UTF8 *>(Utf8StringNative);
+	        UTF8 *TargetEnd = TargetStart + Utf8Size;
+
+	        ConversionResult res = ConvertUTF32toUTF8(&SourceStart, SourceEnd, &TargetStart, TargetEnd, strictConversion);
+	        if (res != conversionOK) {
+	            delete[] Utf8StringNative;
+	            return (Utf8String)"";
+	        }
+	        *TargetStart = 0;
+	        Utf8String ResultString(Utf8StringNative);
+	        delete[] Utf8StringNative;
+	        return ResultString;
+	    } else {
+	        return (Utf8String)"";
+	    }*/
+	return "";
+}
+
+// Currently this only does Ansi->ISO 8859, and only for carets.
+char simpleAnsiToWide(const AnsiString &str, uint32 &offset) {
+	char c = str[offset];
+
+	if (c == 92) {
+		offset++;
+		return '\'';
+	} else {
+		offset++;
+		return c;
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+WideString StringUtil::ansiToWide(const AnsiString &str) {
+	// TODO: This function gets called a lot, so warnings like these drown out the usefull information
+	/*Common::String converted = "";
+	uint32 index = 0;
+	while (index != str.size()) {
+	    converted += simpleAnsiToWide(str, index);
+	}*/
+	// using default os locale!
+
+	/*  setlocale(LC_CTYPE, "");
+	    size_t wideSize = mbstowcs(NULL, str.c_str(), 0) + 1;
+	    wchar_t *wstr = new wchar_t[WideSize];
+	    mbstowcs(wstr, str.c_str(), WideSize);
+	    WideString ResultString(wstr);
+	    delete[] wstr;
+	    return ResultString;*/
+	return WideString(str);
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString StringUtil::wideToAnsi(const WideString &wstr) {
+	// using default os locale!
+	// TODO: This function gets called a lot, so warnings like these drown out the usefull information
+	/*  setlocale(LC_CTYPE, "");
+	    size_t wideSize = wcstombs(NULL, wstr.c_str(), 0) + 1;
+	    char *str = new char[WideSize];
+	    wcstombs(str, wstr.c_str(), WideSize);
+	    AnsiString ResultString(str);
+	    delete[] str;
+	    return ResultString;*/
+	return AnsiString(wstr);
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool StringUtil::isUtf8BOM(const byte *buffer, uint32 bufferSize) {
+	if (bufferSize > 3 && buffer[0] == 0xEF && buffer[1] == 0xBB && buffer[2] == 0xBF) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+int StringUtil::indexOf(const WideString &str, const WideString &toFind, size_t startFrom) {
+	const char *index = strstr(str.c_str(), toFind.c_str());
+	if (index == NULL) {
+		return -1;
+	} else {
+		return index - str.c_str();
+	}
+}
+
+Common::String StringUtil::encodeSetting(const Common::String &str) {
+	if (str.contains('=')) {
+		error("Setting contains '='");
+	}
+	return str;
+}
+
+Common::String StringUtil::decodeSetting(const Common::String &str) {
+	return str;
+}
+
+//////////////////////////////////////////////////////////////////////////
+AnsiString StringUtil::toString(int val) {
+	return Common::String::format("%d", val);
+}
+
+
+} // end of namespace Wintermute
diff --git a/engines/wintermute/utils/string_util.h b/engines/wintermute/utils/string_util.h
index 87760971a8..e419e2bca8 100644
--- a/engines/wintermute/utils/string_util.h
+++ b/engines/wintermute/utils/string_util.h
@@ -1,56 +1,56 @@
-/* ScummVM - Graphic Adventure Engine

- *

- * ScummVM is the legal property of its developers, whose names

- * are too numerous to list here. Please refer to the COPYRIGHT

- * file distributed with this source distribution.

- *

- * This program is free software; you can redistribute it and/or

- * modify it under the terms of the GNU General Public License

- * as published by the Free Software Foundation; either version 2

- * of the License, or (at your option) any later version.

-

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

-

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

- *

- */

-

-/*

- * This file is based on WME Lite.

- * http://dead-code.org/redir.php?target=wmelite

- * Copyright (c) 2011 Jan Nedoma

- */

-

-#ifndef WINTERMUTE_STRINGUTIL_H

-#define WINTERMUTE_STRINGUTIL_H

-

-#include "engines/wintermute/dctypes.h"

-

-namespace Wintermute {

-

-class StringUtil {

-public:

-	static bool compareNoCase(const AnsiString &str1, const AnsiString &str2);

-	//static bool compareNoCase(const WideString &str1, const WideString &str2);

-	static WideString utf8ToWide(const Utf8String &Utf8Str);

-	static Utf8String wideToUtf8(const WideString &WideStr);

-	static WideString ansiToWide(const AnsiString &str);

-	static AnsiString wideToAnsi(const WideString &str);

-

-	static bool isUtf8BOM(const byte *buffer, uint32 bufferSize);

-	static int indexOf(const WideString &str, const WideString &toFind, size_t startFrom);

-

-	static Common::String encodeSetting(const Common::String &str);

-	static Common::String decodeSetting(const Common::String &str);

-

-	static AnsiString toString(int val);

-};

-

-} // end of namespace Wintermute

-

-#endif

+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#ifndef WINTERMUTE_STRINGUTIL_H
+#define WINTERMUTE_STRINGUTIL_H
+
+#include "engines/wintermute/dctypes.h"
+
+namespace Wintermute {
+
+class StringUtil {
+public:
+	static bool compareNoCase(const AnsiString &str1, const AnsiString &str2);
+	//static bool compareNoCase(const WideString &str1, const WideString &str2);
+	static WideString utf8ToWide(const Utf8String &Utf8Str);
+	static Utf8String wideToUtf8(const WideString &WideStr);
+	static WideString ansiToWide(const AnsiString &str);
+	static AnsiString wideToAnsi(const WideString &str);
+
+	static bool isUtf8BOM(const byte *buffer, uint32 bufferSize);
+	static int indexOf(const WideString &str, const WideString &toFind, size_t startFrom);
+
+	static Common::String encodeSetting(const Common::String &str);
+	static Common::String decodeSetting(const Common::String &str);
+
+	static AnsiString toString(int val);
+};
+
+} // end of namespace Wintermute
+
+#endif
diff --git a/engines/wintermute/utils/utils.cpp b/engines/wintermute/utils/utils.cpp
index f26d60b7cf..824b16ccdb 100644
--- a/engines/wintermute/utils/utils.cpp
+++ b/engines/wintermute/utils/utils.cpp
@@ -1,261 +1,261 @@
-/* ScummVM - Graphic Adventure Engine

- *

- * ScummVM is the legal property of its developers, whose names

- * are too numerous to list here. Please refer to the COPYRIGHT

- * file distributed with this source distribution.

- *

- * This program is free software; you can redistribute it and/or

- * modify it under the terms of the GNU General Public License

- * as published by the Free Software Foundation; either version 2

- * of the License, or (at your option) any later version.

-

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

-

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

- *

- */

-

-/*

- * This file is based on WME Lite.

- * http://dead-code.org/redir.php?target=wmelite

- * Copyright (c) 2011 Jan Nedoma

- */

-

-#include "engines/wintermute/utils/utils.h"

-#include "engines/wintermute/wintermute.h"

-#include "engines/wintermute/base/base_engine.h"

-

-namespace Wintermute {

-

-//////////////////////////////////////////////////////////////////////

-static inline unsigned Sqr(int x) {

-	return (x * x);

-}

-

-//////////////////////////////////////////////////////////////////////////////////

-// Swap - swaps two integers

-//////////////////////////////////////////////////////////////////////////////////

-void BaseUtils::swap(int *a, int *b) {

-	int temp = *a;

-	*a = *b;

-	*b = temp;

-}

-

-

-//////////////////////////////////////////////////////////////////////////

-float BaseUtils::normalizeAngle(float angle) {

-	while (angle > 360) {

-		angle -= 360;

-	}

-	while (angle < 0) {

-		angle += 360;

-	}

-

-	return angle;

-}

-

-

-////////////////////////////////////////////////////////////////////////////////

-void BaseUtils::createPath(const char *path, bool pathOnly) {

-	/*  AnsiString pathStr;

-

-	    if (!pathOnly) pathStr = PathUtil::getDirectoryName(path);

-	    else pathStr = path;

-	*/

-//	try {

-	warning("BaseUtils::CreatePath - not implemented: %s", path);

-//		boost::filesystem::create_directories(path);

-//	} catch (...) {

-	return;

-//	}

-}

-

-

-//////////////////////////////////////////////////////////////////////////

-void BaseUtils::debugMessage(const char *text) {

-	//MessageBox(hWnd, Text, "WME", MB_OK|MB_ICONINFORMATION);

-}

-

-

-//////////////////////////////////////////////////////////////////////////

-char *BaseUtils::setString(char **string, const char *value) {

-	delete[] *string;

-	*string = new char[strlen(value) + 1];

-	if (*string) {

-		strcpy(*string, value);

-	}

-	return *string;

-}

-

-//////////////////////////////////////////////////////////////////////////

-char *BaseUtils::strEntry(int entry, const char *str, const char delim) {

-	int numEntries = 0;

-

-	const char *start = NULL;

-	int len = 0;

-

-	for (uint32 i = 0; i <= strlen(str); i++) {

-		if (numEntries == entry) {

-			if (!start) {

-				start = str + i;

-			} else {

-				len++;

-			}

-		}

-		if (str[i] == delim || str[i] == '\0') {

-			numEntries++;

-			if (start) {

-				char *ret = new char[len + 1];

-				memset(ret, 0, len + 1);

-				Common::strlcpy(ret, start, len + 1);

-				return ret;

-			}

-		}

-	}

-	return NULL;

-}

-

-//////////////////////////////////////////////////////////////////////////

-int BaseUtils::randomInt(int from, int to) {

-	if (to < from) {

-		int i = to;

-		to = from;

-		from = i;

-	}

-	return BaseEngine::instance().randInt(from, to);

-//	return (rand() % (to - from + 1)) + from;

-}

-

-//////////////////////////////////////////////////////////////////////////

-float BaseUtils::randomFloat(float from, float to) {

-	const uint32 randMax = RAND_MAX;

-	float randNum = (float)BaseEngine::instance().randInt(0, randMax) / (float)randMax;

-	return from + (to - from) * randNum;

-}

-

-//////////////////////////////////////////////////////////////////////////

-float BaseUtils::randomAngle(float from, float to) {

-	while (to < from) {

-		to += 360;

-	}

-	return normalizeAngle(randomFloat(from, to));

-}

-

-//////////////////////////////////////////////////////////////////////////

-void BaseUtils::RGBtoHSL(uint32 rgbColor, byte *outH, byte *outS, byte *outL) {

-	float varR = (RGBCOLGetR(rgbColor) / 255.0f);

-	float varG = (RGBCOLGetG(rgbColor) / 255.0f);

-	float varB = (RGBCOLGetB(rgbColor) / 255.0f);

-

-	//Min. value of RGB

-	float varMin = MIN(varR, varG);

-	varMin = MIN(varMin, varB);

-

-	//Max. value of RGB

-	float varMax = MAX(varR, varG);

-	varMax = MAX(varMax, varB);

-

-	//Delta RGB value

-	float delMax = varMax - varMin;

-

-	float H = 0.0f, S = 0.0f, L = 0.0f;

-

-	L = (varMax + varMin) / 2.0f;

-

-	//This is a gray, no chroma...

-	if (delMax == 0) {

-		H = 0;

-		S = 0;

-	}

-	//Chromatic data...

-	else {

-		if (L < 0.5f) {

-			S = delMax / (varMax + varMin);

-		} else {

-			S = delMax / (2.0f - varMax - varMin);

-		}

-

-		float delR = (((varMax - varR) / 6.0f) + (delMax / 2.0f)) / delMax;

-		float delG = (((varMax - varG) / 6.0f) + (delMax / 2.0f)) / delMax;

-		float delB = (((varMax - varB) / 6.0f) + (delMax / 2.0f)) / delMax;

-

-		if (varR == varMax) {

-			H = delB - delG;

-		} else if (varG == varMax) {

-			H = (1.0f / 3.0f) + delR - delB;

-		} else if (varB == varMax) {

-			H = (2.0f / 3.0f) + delG - delR;

-		}

-

-		if (H < 0) {

-			H += 1;

-		}

-		if (H > 1) {

-			H -= 1;

-		}

-	}

-

-	*outH = (byte)(H * 255);

-	*outS = (byte)(S * 255);

-	*outL = (byte)(L * 255);

-}

-

-

-//////////////////////////////////////////////////////////////////////////

-uint32 BaseUtils::HSLtoRGB(byte  InH, byte InS, byte InL) {

-	float H = InH / 255.0f;

-	float S = InS / 255.0f;

-	float L = InL / 255.0f;

-

-	byte R, G, B;

-

-

-	if (S == 0) {

-		R = (byte)(L * 255);

-		G = (byte)(L * 255);

-		B = (byte)(L * 255);

-	} else {

-		float var1, var2;

-

-		if (L < 0.5) {

-			var2 = L * (1.0 + S);

-		} else {

-			var2 = (L + S) - (S * L);

-		}

-

-		var1 = 2.0f * L - var2;

-

-		R = (byte)(255 * Hue2RGB(var1, var2, H + (1.0f / 3.0f)));

-		G = (byte)(255 * Hue2RGB(var1, var2, H));

-		B = (byte)(255 * Hue2RGB(var1, var2, H - (1.0f / 3.0f)));

-	}

-	return BYTETORGBA(255, R, G, B);

-}

-

-

-//////////////////////////////////////////////////////////////////////////

-float BaseUtils::Hue2RGB(float v1, float v2, float vH) {

-	if (vH < 0.0f) {

-		vH += 1.0f;

-	}

-	if (vH > 1.0f) {

-		vH -= 1.0f;

-	}

-	if ((6.0f * vH) < 1.0f) {

-		return (v1 + (v2 - v1) * 6.0f * vH);

-	}

-	if ((2.0f * vH) < 1.0f) {

-		return (v2);

-	}

-	if ((3.0f * vH) < 2.0f) {

-		return (v1 + (v2 - v1) * ((2.0f / 3.0f) - vH) * 6.0f);

-	}

-	return (v1);

-}

-

-} // end of namespace Wintermute

+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/base/base_engine.h"
+
+namespace Wintermute {
+
+//////////////////////////////////////////////////////////////////////
+static inline unsigned Sqr(int x) {
+	return (x * x);
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+// Swap - swaps two integers
+//////////////////////////////////////////////////////////////////////////////////
+void BaseUtils::swap(int *a, int *b) {
+	int temp = *a;
+	*a = *b;
+	*b = temp;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+float BaseUtils::normalizeAngle(float angle) {
+	while (angle > 360) {
+		angle -= 360;
+	}
+	while (angle < 0) {
+		angle += 360;
+	}
+
+	return angle;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+void BaseUtils::createPath(const char *path, bool pathOnly) {
+	/*  AnsiString pathStr;
+
+	    if (!pathOnly) pathStr = PathUtil::getDirectoryName(path);
+	    else pathStr = path;
+	*/
+//	try {
+	warning("BaseUtils::CreatePath - not implemented: %s", path);
+//		boost::filesystem::create_directories(path);
+//	} catch (...) {
+	return;
+//	}
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void BaseUtils::debugMessage(const char *text) {
+	//MessageBox(hWnd, Text, "WME", MB_OK|MB_ICONINFORMATION);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+char *BaseUtils::setString(char **string, const char *value) {
+	delete[] *string;
+	*string = new char[strlen(value) + 1];
+	if (*string) {
+		strcpy(*string, value);
+	}
+	return *string;
+}
+
+//////////////////////////////////////////////////////////////////////////
+char *BaseUtils::strEntry(int entry, const char *str, const char delim) {
+	int numEntries = 0;
+
+	const char *start = NULL;
+	int len = 0;
+
+	for (uint32 i = 0; i <= strlen(str); i++) {
+		if (numEntries == entry) {
+			if (!start) {
+				start = str + i;
+			} else {
+				len++;
+			}
+		}
+		if (str[i] == delim || str[i] == '\0') {
+			numEntries++;
+			if (start) {
+				char *ret = new char[len + 1];
+				memset(ret, 0, len + 1);
+				Common::strlcpy(ret, start, len + 1);
+				return ret;
+			}
+		}
+	}
+	return NULL;
+}
+
+//////////////////////////////////////////////////////////////////////////
+int BaseUtils::randomInt(int from, int to) {
+	if (to < from) {
+		int i = to;
+		to = from;
+		from = i;
+	}
+	return BaseEngine::instance().randInt(from, to);
+//	return (rand() % (to - from + 1)) + from;
+}
+
+//////////////////////////////////////////////////////////////////////////
+float BaseUtils::randomFloat(float from, float to) {
+	const uint32 randMax = RAND_MAX;
+	float randNum = (float)BaseEngine::instance().randInt(0, randMax) / (float)randMax;
+	return from + (to - from) * randNum;
+}
+
+//////////////////////////////////////////////////////////////////////////
+float BaseUtils::randomAngle(float from, float to) {
+	while (to < from) {
+		to += 360;
+	}
+	return normalizeAngle(randomFloat(from, to));
+}
+
+//////////////////////////////////////////////////////////////////////////
+void BaseUtils::RGBtoHSL(uint32 rgbColor, byte *outH, byte *outS, byte *outL) {
+	float varR = (RGBCOLGetR(rgbColor) / 255.0f);
+	float varG = (RGBCOLGetG(rgbColor) / 255.0f);
+	float varB = (RGBCOLGetB(rgbColor) / 255.0f);
+
+	//Min. value of RGB
+	float varMin = MIN(varR, varG);
+	varMin = MIN(varMin, varB);
+
+	//Max. value of RGB
+	float varMax = MAX(varR, varG);
+	varMax = MAX(varMax, varB);
+
+	//Delta RGB value
+	float delMax = varMax - varMin;
+
+	float H = 0.0f, S = 0.0f, L = 0.0f;
+
+	L = (varMax + varMin) / 2.0f;
+
+	//This is a gray, no chroma...
+	if (delMax == 0) {
+		H = 0;
+		S = 0;
+	}
+	//Chromatic data...
+	else {
+		if (L < 0.5f) {
+			S = delMax / (varMax + varMin);
+		} else {
+			S = delMax / (2.0f - varMax - varMin);
+		}
+
+		float delR = (((varMax - varR) / 6.0f) + (delMax / 2.0f)) / delMax;
+		float delG = (((varMax - varG) / 6.0f) + (delMax / 2.0f)) / delMax;
+		float delB = (((varMax - varB) / 6.0f) + (delMax / 2.0f)) / delMax;
+
+		if (varR == varMax) {
+			H = delB - delG;
+		} else if (varG == varMax) {
+			H = (1.0f / 3.0f) + delR - delB;
+		} else if (varB == varMax) {
+			H = (2.0f / 3.0f) + delG - delR;
+		}
+
+		if (H < 0) {
+			H += 1;
+		}
+		if (H > 1) {
+			H -= 1;
+		}
+	}
+
+	*outH = (byte)(H * 255);
+	*outS = (byte)(S * 255);
+	*outL = (byte)(L * 255);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+uint32 BaseUtils::HSLtoRGB(byte  InH, byte InS, byte InL) {
+	float H = InH / 255.0f;
+	float S = InS / 255.0f;
+	float L = InL / 255.0f;
+
+	byte R, G, B;
+
+
+	if (S == 0) {
+		R = (byte)(L * 255);
+		G = (byte)(L * 255);
+		B = (byte)(L * 255);
+	} else {
+		float var1, var2;
+
+		if (L < 0.5) {
+			var2 = L * (1.0 + S);
+		} else {
+			var2 = (L + S) - (S * L);
+		}
+
+		var1 = 2.0f * L - var2;
+
+		R = (byte)(255 * Hue2RGB(var1, var2, H + (1.0f / 3.0f)));
+		G = (byte)(255 * Hue2RGB(var1, var2, H));
+		B = (byte)(255 * Hue2RGB(var1, var2, H - (1.0f / 3.0f)));
+	}
+	return BYTETORGBA(255, R, G, B);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+float BaseUtils::Hue2RGB(float v1, float v2, float vH) {
+	if (vH < 0.0f) {
+		vH += 1.0f;
+	}
+	if (vH > 1.0f) {
+		vH -= 1.0f;
+	}
+	if ((6.0f * vH) < 1.0f) {
+		return (v1 + (v2 - v1) * 6.0f * vH);
+	}
+	if ((2.0f * vH) < 1.0f) {
+		return (v2);
+	}
+	if ((3.0f * vH) < 2.0f) {
+		return (v1 + (v2 - v1) * ((2.0f / 3.0f) - vH) * 6.0f);
+	}
+	return (v1);
+}
+
+} // end of namespace Wintermute
diff --git a/engines/wintermute/utils/utils.h b/engines/wintermute/utils/utils.h
index af69bd4523..d6a603ec72 100644
--- a/engines/wintermute/utils/utils.h
+++ b/engines/wintermute/utils/utils.h
@@ -1,64 +1,64 @@
-/* ScummVM - Graphic Adventure Engine

- *

- * ScummVM is the legal property of its developers, whose names

- * are too numerous to list here. Please refer to the COPYRIGHT

- * file distributed with this source distribution.

- *

- * This program is free software; you can redistribute it and/or

- * modify it under the terms of the GNU General Public License

- * as published by the Free Software Foundation; either version 2

- * of the License, or (at your option) any later version.

-

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

-

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

- *

- */

-

-/*

- * This file is based on WME Lite.

- * http://dead-code.org/redir.php?target=wmelite

- * Copyright (c) 2011 Jan Nedoma

- */

-

-#ifndef WINTERMUTE_UTILS_H

-#define WINTERMUTE_UTILS_H

-

-#include "engines/wintermute/wintypes.h"

-#include "engines/wintermute/math/rect32.h"

-

-namespace Wintermute {

-

-class BaseGame;

-

-class BaseUtils {

-public:

-	static void swap(int *a, int *b);

-	static float normalizeAngle(float angle);

-

-	static void createPath(const char *path, bool pathOnly = false);

-

-	static void debugMessage(const char *text);

-	static char *setString(char **string, const char *value);

-

-	static char *strEntry(int entry, const char *str, const char delim = ',');

-

-	static int randomInt(int from, int to);

-	static float randomFloat(float from, float to);

-	static float randomAngle(float from, float to);

-

-	static void RGBtoHSL(uint32 rgbColor, byte *outH, byte *outS, byte *outL);

-	static uint32 HSLtoRGB(byte H, byte S, byte L);

-

-private:

-	static float Hue2RGB(float v1, float v2, float vH);

-};

-

-} // end of namespace Wintermute

-

-#endif

+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+/*
+ * This file is based on WME Lite.
+ * http://dead-code.org/redir.php?target=wmelite
+ * Copyright (c) 2011 Jan Nedoma
+ */
+
+#ifndef WINTERMUTE_UTILS_H
+#define WINTERMUTE_UTILS_H
+
+#include "engines/wintermute/wintypes.h"
+#include "engines/wintermute/math/rect32.h"
+
+namespace Wintermute {
+
+class BaseGame;
+
+class BaseUtils {
+public:
+	static void swap(int *a, int *b);
+	static float normalizeAngle(float angle);
+
+	static void createPath(const char *path, bool pathOnly = false);
+
+	static void debugMessage(const char *text);
+	static char *setString(char **string, const char *value);
+
+	static char *strEntry(int entry, const char *str, const char delim = ',');
+
+	static int randomInt(int from, int to);
+	static float randomFloat(float from, float to);
+	static float randomAngle(float from, float to);
+
+	static void RGBtoHSL(uint32 rgbColor, byte *outH, byte *outS, byte *outL);
+	static uint32 HSLtoRGB(byte H, byte S, byte L);
+
+private:
+	static float Hue2RGB(float v1, float v2, float vH);
+};
+
+} // end of namespace Wintermute
+
+#endif