undo the code formatting. somehow it got screwed up

HBC/META.XML

@@ -2,8 +2,8 @@
 	<app version="1">
 		<name> USB Loader GX</name>
 		<coder>USB Loader GX Team</coder>
-		<version>1.0 r908</version>
-		<release_date>201002090353</release_date>
+		<version>1.0 r909</version>
+		<release_date>201002091053</release_date>
 		<short_description>Loads games from USB-devices</short_description>
 		<long_description>USB Loader GX is a libwiigui based USB iso loader with a wii-like GUI. You can install games to your HDDs and boot them with shorter loading times.
 The interactive GUI is completely controllable with WiiMote, Classic Controller or GC Controller.

source/FreeTypeGX.cpp

@@ -65,9 +65,10 @@ typedef struct ftgxDataOffset_ {
  * @param vertexIndex	Optional vertex format index (GX_VTXFMT*) of the glyph textures as defined by the libogc gx.h header file. If not specified default value is GX_VTXFMT1.
  */
 FreeTypeGX::FreeTypeGX(uint8_t textureFormat, uint8_t vertexIndex, uint32_t compatibilityMode)
-        :
-        ftFace(NULL),
-        ftFace_fromFile(NULL) {
+:
+ftFace(NULL), 
+ftFace_fromFile(NULL)
+{
     FT_Init_FreeType(&this->ftLibrary);
 
     this->textureFormat = textureFormat;
@@ -95,7 +96,7 @@ FreeTypeGX::~FreeTypeGX() {
 wchar_t* FreeTypeGX::charToWideChar(const char* strChar) {
     wchar_t *strWChar;
 	strWChar = new(std::nothrow) wchar_t[strlen(strChar) + 1];
-    if (!strWChar) return NULL;
+	if(!strWChar) return NULL;
     // UTF-8
     int	bt;
     bt = mbstowcs(strWChar, strChar, strlen(strChar));
@@ -260,24 +261,27 @@ void FreeTypeGX::clearGlyphData() {
     GX_DrawDone();
     GX_Flush();
 
-    for ( std::map<uint16_t, FTGX_Cache>::iterator i = this->fontDatas.begin(); i != this->fontDatas.end(); i++) {
-        for ( FTGX_Cache::iterator j = i->second.begin(); j != i->second.end(); j++) {
+	for ( std::map<uint16_t, FTGX_Cache>::iterator i = this->fontDatas.begin(); i != this->fontDatas.end(); i++) 
+	{
+		for ( FTGX_Cache::iterator j = i->second.begin(); j != i->second.end(); j++) 
+		{
 			free(j->second.glyphDataTexture);
 		}
 		i->second.clear();
     }
-    /*	for ( std::map<wchar_t, ftgxCharData>::iterator i = this->fontData.begin(); i != this->fontData.end(); i++) {
+/*	for ( std::map<wchar_t, ftgxCharData>::iterator i = this->fontData.begin(); i != this->fontData.end(); i++) {
         free(i->second.glyphDataTexture);
     }
-    */
+*/
     this->fontDatas.clear();
 }
 
 void FreeTypeGX::changeSize(FT_UInt vPointSize, FT_UInt hPointSize/*=0*/) {
-    if (hPointSize == 0) hPointSize = vPointSize;
-    if (vPointSize > 255) vPointSize = 255;// limit to 255
-    if (hPointSize > 255) hPointSize = 255;
-    if (this->ftPointSize_v != vPointSize || this->ftPointSize_h != hPointSize) {
+	if(hPointSize == 0) hPointSize = vPointSize;
+	if(vPointSize > 255) vPointSize = 255;// limit to 255
+	if(hPointSize > 255) hPointSize = 255;
+	if(this->ftPointSize_v != vPointSize || this->ftPointSize_h != hPointSize)
+	{
 //		this->clearGlyphData();
 		this->ftPointSize_v = vPointSize;
 		this->ftPointSize_h = hPointSize;
@@ -356,11 +360,13 @@ uint16_t FreeTypeGX::adjustTextureHeight(uint16_t textureHeight, uint8_t texture
  * @param charCode	The requested glyph's character code.
  * @return A pointer to the allocated font structure.
  */
-ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode) {
+ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode)
+{
 	FTGX_Cache &fontData = this->fontDatas[ftPointSize_v | ftPointSize_h << 8];
 	return cacheGlyphData(charCode, fontData);
 }
-ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode, FTGX_Cache &fontData) {
+ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode, FTGX_Cache &fontData)
+{
 	FT_UInt gIndex;
 	uint16_t textureWidth = 0, textureHeight = 0;
 

source/FreeTypeGX.h

@@ -203,7 +203,9 @@ typedef struct ftgxDataOffset_ ftgxDataOffset;
 #define FTGX_COMPATIBILITY_GRRLIB						FTGX_COMPATIBILITY_DEFAULT_TEVOP_GX_PASSCLR | FTGX_COMPATIBILITY_DEFAULT_VTXDESC_GX_NONE
 #define FTGX_COMPATIBILITY_LIBWIISPRITE					FTGX_COMPATIBILITY_DEFAULT_TEVOP_GX_MODULATE | FTGX_COMPATIBILITY_DEFAULT_VTXDESC_GX_DIRECT
 
-const GXColor ftgxWhite = (GXColor) {0xff, 0xff, 0xff, 0xff}
+const GXColor ftgxWhite = (GXColor) {
+    0xff, 0xff, 0xff, 0xff
+}
 ; /**< Constant color value used only to sanitize Doxygen documentation. */
 
 /*! \class FreeTypeGX

source/ZipFile.cpp

@@ -39,22 +39,26 @@
 #include "ZipFile.h"
 #include "language/gettext.h"
 
-ZipFile::ZipFile(const char *filepath) {
+ZipFile::ZipFile(const char *filepath)
+{
     File = unzOpen(filepath);
-    if (File)
+    if(File)
         this->LoadList();
 }
 
-ZipFile::~ZipFile() {
+ZipFile::~ZipFile()
+{
     unzClose(File);
 }
 
-bool ZipFile::LoadList() {
+bool ZipFile::LoadList()
+{
     return true;
 }
 
-bool ZipFile::ExtractAll(const char *dest) {
-    if (!File)
+bool ZipFile::ExtractAll(const char *dest)
+{
+    if(!File)
         return false;
 
     bool Stop = false;
@@ -62,7 +66,7 @@ bool ZipFile::ExtractAll(const char *dest) {
     u32 blocksize = 1024*50;
     u8 *buffer = new u8[blocksize];
 
-    if (!buffer)
+    if(!buffer)
         return false;
 
     char writepath[MAXPATHLEN];
@@ -70,14 +74,16 @@ bool ZipFile::ExtractAll(const char *dest) {
     memset(filename, 0, sizeof(filename));
 
     int ret = unzGoToFirstFile(File);
-    if (ret != UNZ_OK)
+    if(ret != UNZ_OK)
         Stop = true;
 
-    while (!Stop) {
-        if (unzGetCurrentFileInfo(File, &cur_file_info, filename, sizeof(filename), NULL, NULL, NULL, NULL) != UNZ_OK)
+    while(!Stop)
+    {
+        if(unzGetCurrentFileInfo(File, &cur_file_info, filename, sizeof(filename), NULL, NULL, NULL, NULL) != UNZ_OK)
             Stop = true;
 
-        if (!Stop && filename[strlen(filename)-1] != '/') {
+        if(!Stop && filename[strlen(filename)-1] != '/')
+        {
             u32 uncompressed_size = cur_file_info.uncompressed_size;
 
             u32 done = 0;
@@ -95,31 +101,33 @@ bool ZipFile::ExtractAll(const char *dest) {
 
             subfoldercreate(temppath);
 
-            if (ret == UNZ_OK) {
+            if(ret == UNZ_OK)
+            {
                 FILE *pfile = fopen(writepath, "wb");
 
-                do {
+                do
+                {
                     ShowProgress(tr("Extracting files..."), 0, pointer+1, done, uncompressed_size);
 
-                    if (uncompressed_size - done < blocksize)
+                    if(uncompressed_size - done < blocksize)
                         blocksize = uncompressed_size - done;
 
                     ret = unzReadCurrentFile(File, buffer, blocksize);
 
-                    if (ret == 0)
+                    if(ret == 0)
                         break;
 
                     fwrite(buffer, 1, blocksize, pfile);
 
                     done += ret;
 
-                } while (done < uncompressed_size);
+                } while(done < uncompressed_size);
 
                 fclose(pfile);
                 unzCloseCurrentFile(File);
             }
         }
-        if (unzGoToNextFile(File) != UNZ_OK)
+        if(unzGoToNextFile(File) != UNZ_OK)
             Stop = true;
     }
 

source/ZipFile.h

@@ -30,15 +30,17 @@
 
 #include "unzip/unzip.h"
 
-typedef struct {
+typedef struct
+{
 	u64 offset; // ZipFile offset
 	u64 length; // uncompressed file length in 64 bytes for sizes higher than 4GB
 	bool isdir; // 0 - file, 1 - directory
 	char filename[256]; // full filename
 } FileStructure;
 
-class ZipFile {
-public:
+class ZipFile
+{
+    public:
 		//!Constructor
         ZipFile(const char *filepath);
 		//!Destructor
@@ -46,7 +48,7 @@ public:
 		//!Extract all files from a zip file to a directory
 		//!\param dest Destination path to where to extract
 		bool ExtractAll(const char *dest);
-protected:
+    protected:
         bool LoadList();
         unzFile File;
         unz_file_info cur_file_info;

source/banner/MD5.c

@@ -110,22 +110,25 @@
  *          array.  They're divided up into four groups of 16.
  */
 
-static const uint8_t K[3][16] = {
+static const uint8_t K[3][16] =
+  {
     /* Round 1: skipped (since it is simply sequential). */
     {  1,  6, 11,  0,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12 }, /* R2 */
     {  5,  8, 11, 14,  1,  4,  7, 10, 13,  0,  3,  6,  9, 12, 15,  2 }, /* R3 */
     {  0,  7, 14,  5, 12,  3, 10,  1,  8, 15,  6, 13,  4, 11,  2,  9 }  /* R4 */
-};
+  };
 
-static const uint8_t S[4][4] = {
+static const uint8_t S[4][4] =
+  {
     { 7, 12, 17, 22 },  /* Round 1 */
     { 5,  9, 14, 20 },  /* Round 2 */
     { 4, 11, 16, 23 },  /* Round 3 */
     { 6, 10, 15, 21 }   /* Round 4 */
-};
+  };
 
 
-static const uint32_t T[4][16] = {
+static const uint32_t T[4][16] =
+  {
     { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,   /* Round 1 */
       0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
       0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
@@ -145,7 +148,7 @@ static const uint32_t T[4][16] = {
       0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
       0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
       0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 },
-};
+  };
 
 
 /* -------------------------------------------------------------------------- **
@@ -175,7 +178,7 @@ static const uint32_t T[4][16] = {
  */
 
 static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
-/* ------------------------------------------------------------------------ **
+  /* ------------------------------------------------------------------------ **
    * Permute the ABCD "registers" using the 64-byte <block> as a driver.
    *
    *  Input:  ABCD  - Pointer to an array of four unsigned longwords.
@@ -207,7 +210,7 @@ static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
    *
    * ------------------------------------------------------------------------ **
    */
-{
+  {
   int      round;
   int      i, j;
   uint8_t  s;
@@ -217,14 +220,15 @@ static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
 
   /* Store the current ABCD values for later re-use.
    */
-    for ( i = 0; i < 4; i++ )
+  for( i = 0; i < 4; i++ )
     KeepABCD[i] = ABCD[i];
 
   /* Convert the input block into an array of unsigned longs, taking care
    * to read the block in Little Endian order (the algorithm assumes this).
    * The uint32_t values are then handled in host order.
    */
-    for ( i = 0, j = 0; i < 16; i++ ) {
+  for( i = 0, j = 0; i < 16; i++ )
+    {
     X[i]  =  (uint32_t)block[j++];
     X[i] |= ((uint32_t)block[j++] << 8);
     X[i] |= ((uint32_t)block[j++] << 16);
@@ -245,8 +249,10 @@ static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
    * (My implementation appears to be a poor compromise between speed, size,
    * and clarity.  Ugh.  [crh])
    */
-    for ( round = 0; round < 4; round++ ) {
-        for ( i = 0; i < 16; i++ ) {
+  for( round = 0; round < 4; round++ )
+    {
+    for( i = 0; i < 16; i++ )
+      {
       j = (4 - (i % 4)) & 0x3;  /* <j> handles the rotation of ABCD.          */
       s = S[round][i%4];        /* <s> is the bit shift for this iteration.   */
 
@@ -257,7 +263,8 @@ static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
       /* The actual perumation function.
        * This is broken out to minimize the code within the switch().
        */
-            switch ( round ) {
+      switch( round )
+        {
         case 0:
           /* round 1 */
           a = md5F( b, c, d ) + X[i];
@@ -283,10 +290,10 @@ static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
   /* Use the stored original A, B, C, D values to perform
    * one last convolution.
    */
-    for ( i = 0; i < 4; i++ )
+  for( i = 0; i < 4; i++ )
     ABCD[i] = 0xFFFFFFFF & ( ABCD[i] + KeepABCD[i] );
 
-} /* Permute */
+  } /* Permute */
 
 
 /* -------------------------------------------------------------------------- **
@@ -294,7 +301,7 @@ static void Permute( uint32_t ABCD[4], const unsigned char block[64] )
  */
 
 auth_md5Ctx *auth_md5InitCtx( auth_md5Ctx *ctx )
-/* ------------------------------------------------------------------------ **
+  /* ------------------------------------------------------------------------ **
    * Initialize an MD5 context.
    *
    *  Input:  ctx - A pointer to the MD5 context structure to be initialized.
@@ -321,7 +328,7 @@ auth_md5Ctx *auth_md5InitCtx( auth_md5Ctx *ctx )
    *
    * ------------------------------------------------------------------------ **
    */
-{
+  {
   ctx->len     = 0;
   ctx->b_used  = 0;
 
@@ -338,13 +345,13 @@ auth_md5Ctx *auth_md5InitCtx( auth_md5Ctx *ctx )
                 /* here are provided as 32-bit values in C language format,   */
                 /* so they are endian-agnostic.  */
   return( ctx );
-} /* auth_md5InitCtx */
+  } /* auth_md5InitCtx */
 
 
 auth_md5Ctx *auth_md5SumCtx( auth_md5Ctx *ctx,
                              const unsigned char *src,
                              const int    len )
-/* ------------------------------------------------------------------------ **
+  /* ------------------------------------------------------------------------ **
    * Build an MD5 Message Digest within the given context.
    *
    *  Input:  ctx - Pointer to the context in which the MD5 sum is being
@@ -359,7 +366,7 @@ auth_md5Ctx *auth_md5SumCtx( auth_md5Ctx *ctx,
    *
    * ------------------------------------------------------------------------ **
    */
-{
+  {
   int i;
 
   /* Add the new block's length to the total length.
@@ -369,10 +376,12 @@ auth_md5Ctx *auth_md5SumCtx( auth_md5Ctx *ctx,
   /* Copy the new block's data into the context block.
    * Call the Permute() function whenever the context block is full.
    */
-    for ( i = 0; i < len; i++ ) {
+  for( i = 0; i < len; i++ )
+    {
     ctx->block[ ctx->b_used ] = src[i];
     (ctx->b_used)++;
-        if ( 64 == ctx->b_used ) {
+    if( 64 == ctx->b_used )
+      {
       Permute( ctx->ABCD, ctx->block );
       ctx->b_used = 0;
       }
@@ -381,11 +390,11 @@ auth_md5Ctx *auth_md5SumCtx( auth_md5Ctx *ctx,
   /* Return the updated context.
    */
   return( ctx );
-} /* auth_md5SumCtx */
+  } /* auth_md5SumCtx */
 
 
 auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst )
-/* ------------------------------------------------------------------------ **
+  /* ------------------------------------------------------------------------ **
    * Close an MD5 Message Digest context and generate the final MD5 sum.
    *
    *  Input:  ctx - Pointer to the context in which the MD5 sum is being
@@ -403,7 +412,7 @@ auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst )
    *
    * ------------------------------------------------------------------------ **
    */
-{
+  {
   int      i;
   uint32_t l;
 
@@ -417,15 +426,16 @@ auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst )
 
   /* Zero out any remaining free bytes in the context block.
    */
-    for ( i = ctx->b_used; i < 64; i++ )
+  for( i = ctx->b_used; i < 64; i++ )
     ctx->block[i] = 0;
 
   /* We need 8 bytes to store the length field.
    * If we don't have 8, call Permute() and reset the context block.
    */
-    if ( 56 < ctx->b_used ) {
+  if( 56 < ctx->b_used )
+    {
     Permute( ctx->ABCD, ctx->block );
-        for ( i = 0; i < 64; i++ )
+    for( i = 0; i < 64; i++ )
       ctx->block[i] = 0;
     }
 
@@ -435,14 +445,15 @@ auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst )
    *        any MAXINT numeric overflow issues.
    */
   l = ctx->len << 3;
-    for ( i = 0; i < 4; i++ )
+  for( i = 0; i < 4; i++ )
     ctx->block[56+i] |= GetLongByte( l, i );
   ctx->block[60] = ((GetLongByte( ctx->len, 3 ) & 0xE0) >> 5);  /* See Above! */
   Permute( ctx->ABCD, ctx->block );
 
   /* Now copy the result into the output buffer and we're done.
    */
-    for ( i = 0; i < 4; i++ ) {
+  for( i = 0; i < 4; i++ )
+    {
     dst[ 0+i] = GetLongByte( ctx->ABCD[0], i );
     dst[ 4+i] = GetLongByte( ctx->ABCD[1], i );
     dst[ 8+i] = GetLongByte( ctx->ABCD[2], i );
@@ -453,11 +464,11 @@ auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst )
    * This is done for compatibility with the other auth_md5*Ctx() functions.
    */
   return( ctx );
-} /* auth_md5CloseCtx */
+  } /* auth_md5CloseCtx */
 
 
 unsigned char * MD5(unsigned char *dst, const unsigned char *src, const int len )
-/* ------------------------------------------------------------------------ **
+  /* ------------------------------------------------------------------------ **
    * Compute an MD5 message digest.
    *
    *  Input:  dst - Destination buffer into which the result will be written.
@@ -489,7 +500,7 @@ unsigned char * MD5(unsigned char *dst, const unsigned char *src, const int len
    *
    * ------------------------------------------------------------------------ **
    */
-{
+  {
   auth_md5Ctx ctx[1];
 
   (void)auth_md5InitCtx( ctx );             /* Open a context.      */
@@ -497,12 +508,12 @@ unsigned char * MD5(unsigned char *dst, const unsigned char *src, const int len
   (void)auth_md5CloseCtx( ctx, dst );       /* Close the context.   */
 
   return( dst );                            /* Makes life easy.     */
-} /* auth_md5Sum */
+  } /* auth_md5Sum */
 
 
 
 unsigned char * MD5fromFile(unsigned char *dst, const char *src)
-/* ------------------------------------------------------------------------ **
+  /* ------------------------------------------------------------------------ **
    * Compute an MD5 message digest.
    *
    *  Input:  dst - Destination buffer into which the result will be written.
@@ -532,7 +543,7 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src)
    *
    * ------------------------------------------------------------------------ **
    */
-{
+  {
   auth_md5Ctx ctx[1];
 
     FILE * file;
@@ -541,7 +552,7 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src)
 
     file = fopen(src, "rb");
 
-    if (file==NULL) {
+    if (file==NULL){
         return NULL;
     }
 
@@ -551,24 +562,25 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src)
     unsigned long long filesize = ftell(file);
     rewind (file);
 
-    if (filesize < 1048576)                 //1MB cache for files bigger than 1 MB
+    if(filesize < 1048576)                  //1MB cache for files bigger than 1 MB
         blksize = filesize;
     else
         blksize = 1048576;
 
     unsigned char * buffer = malloc(blksize);
 
-    if (buffer == NULL) {
+    if(buffer == NULL){
 	    //no memory
         fclose(file);
 		return NULL;
 	}
 
-    do {
+	do
+	{
 	    read = fread(buffer, 1, blksize, file);
         (void)auth_md5SumCtx( ctx, buffer, read );    /* Pass only one block. */
 
-    } while (read > 0);
+	} while(read > 0);
 
     fclose(file);
     free(buffer);
@@ -576,14 +588,16 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src)
     (void)auth_md5CloseCtx( ctx, dst );       /* Close the context.   */
 
     return( dst );                            /* Makes life easy.     */
-} /* auth_md5Sum */
+  } /* auth_md5Sum */
 
 
-const char * MD5ToString(const unsigned char * hash, char * dst) {
+const char * MD5ToString(const unsigned char * hash, char * dst)
+{
     char hexchar[3];
     short i = 0, n = 0;
 
-    for (i = 0; i < 16; i++) {
+    for (i = 0; i < 16; i++)
+    {
         sprintf(hexchar, "%02X", hash[i]);
 
         dst[n++] = hexchar[0];
@@ -595,11 +609,13 @@ const char * MD5ToString(const unsigned char * hash, char * dst) {
     return dst;
 }
 
-unsigned char * StringToMD5(const char * hash, unsigned char * dst) {
+unsigned char * StringToMD5(const char * hash, unsigned char * dst)
+{
     char hexchar[2];
     short i = 0, n = 0;
 
-    for (i = 0; i < 16; i++) {
+    for (i = 0; i < 16; i++)
+    {
         hexchar[0] = hash[n++];
         hexchar[1] = hash[n++];
 

source/banner/MD5.h

@@ -2,9 +2,10 @@
 #define MD5_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
-    /* ========================================================================== **
+/* ========================================================================== **
  *
  *                                    MD5.h
  *
@@ -80,11 +81,12 @@ extern "C" {
  *
  * ========================================================================== **
  */
-    /* -------------------------------------------------------------------------- **
+/* -------------------------------------------------------------------------- **
  * Typedefs:
  */
 
-    typedef struct {
+typedef struct
+  {
   unsigned int len;
   unsigned int ABCD[4];
   int      b_used;
@@ -92,11 +94,11 @@ extern "C" {
   } auth_md5Ctx;
 
 
-    /* -------------------------------------------------------------------------- **
+/* -------------------------------------------------------------------------- **
  * Functions:
  */
 
-    auth_md5Ctx *auth_md5InitCtx( auth_md5Ctx *ctx );
+auth_md5Ctx *auth_md5InitCtx( auth_md5Ctx *ctx );
   /* ------------------------------------------------------------------------ **
    * Initialize an MD5 context.
    *
@@ -126,7 +128,7 @@ extern "C" {
    */
 
 
-    auth_md5Ctx *auth_md5SumCtx( auth_md5Ctx *ctx,
+auth_md5Ctx *auth_md5SumCtx( auth_md5Ctx *ctx,
                              const unsigned char *src,
                              const int    len );
   /* ------------------------------------------------------------------------ **
@@ -146,7 +148,7 @@ extern "C" {
    */
 
 
-    auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst );
+auth_md5Ctx *auth_md5CloseCtx( auth_md5Ctx *ctx, unsigned char *dst );
   /* ------------------------------------------------------------------------ **
    * Close an MD5 Message Digest context and generate the final MD5 sum.
    *
@@ -167,7 +169,7 @@ extern "C" {
    */
 
 
-    unsigned char * MD5(unsigned char * hash, const unsigned char *src, const int len );
+unsigned char * MD5(unsigned char * hash, const unsigned char *src, const int len );
   /* ------------------------------------------------------------------------ **
    * Compute an MD5 message digest.
    *
@@ -201,7 +203,7 @@ extern "C" {
    * ------------------------------------------------------------------------ **
    */
 
-    unsigned char * MD5fromFile(unsigned char *dst, const char *src);
+unsigned char * MD5fromFile(unsigned char *dst, const char *src);
   /* ------------------------------------------------------------------------ **
    * Compute an MD5 message digest.
    *
@@ -233,10 +235,10 @@ extern "C" {
    * ------------------------------------------------------------------------ **
    */
 
-    const char * MD5ToString(const unsigned char *hash, char *dst);
-    unsigned char * StringToMD5(const char * hash, unsigned char * dst);
+const char * MD5ToString(const unsigned char *hash, char *dst);
+unsigned char * StringToMD5(const char * hash, unsigned char * dst);
 
-    /* ========================================================================== */
+/* ========================================================================== */
 
 #ifdef __cplusplus
 }

source/banner/banner.c

@@ -22,7 +22,8 @@
 #include "patches/fst.h"
 #include "usbloader/fstfile.h"
 
-s32 dump_banner(const u8* discid,const char * dest) {
+s32 dump_banner(const u8* discid,const char * dest)
+{
 	// Mount the disc
 	//Disc_SetWBFS(1, (u8*)discid);
 	Disc_SetUSB(discid);
@@ -46,7 +47,8 @@ s32 dump_banner(const u8* discid,const char * dest) {
 	// Read where to find the fst.bin
 	u32 *buffer = memalign(32, 0x20);
 
-    if (buffer == NULL) {
+	if (buffer == NULL)
+	{
 		//Out of memory
 		return -1;
 	}
@@ -59,7 +61,8 @@ s32 dump_banner(const u8* discid,const char * dest) {
 	void *fstbuffer = memalign(32, buffer[2]*4);
 	FST_ENTRY *fst = (FST_ENTRY *)fstbuffer;
 
-    if (fst == NULL) {
+	if (fst == NULL)
+	{
 		//Out of memory
 		free(buffer);
 		return -1;
@@ -76,13 +79,16 @@ s32 dump_banner(const u8* discid,const char * dest) {
 	int i;
 	u32 index = 0;
 
-    for (i=1;i<count;i++) {
-        if (strstr(fstfiles(fst, i), "opening.bnr") != NULL) {
+	for (i=1;i<count;i++)
+	{
+		if (strstr(fstfiles(fst, i), "opening.bnr") != NULL)
+		{
 			index = i;
 		}
 	}
 
-    if (index == 0) {
+	if (index == 0)
+	{
 		//opening.bnr not found
 		free(fstbuffer);
 		return -1;
@@ -91,7 +97,8 @@ s32 dump_banner(const u8* discid,const char * dest) {
 	// Load the .bnr
 	u8 *banner = memalign(32, fst[index].filelen);
 
-    if (banner == NULL) {
+	if (banner == NULL)
+	{
 		//Out of memory
 		free(fstbuffer);
 		return -1;
@@ -107,7 +114,8 @@ s32 dump_banner(const u8* discid,const char * dest) {
 	//SDCard_Init();
 	WDVD_SetUSBMode(NULL, 0);
 	FILE *fp = fopen(dest, "wb");
-    if (fp) {
+	if(fp)
+	{
 		fwrite(banner, 1, fst[index].filelen, fp);
 		fclose(fp);
 	}

source/banner/banner.h

@@ -9,10 +9,11 @@
 #define BANNER_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-    s32 dump_banner(const u8 *discid,const char * dest);
+s32 dump_banner(const u8 *discid,const char * dest);
 
 #ifdef __cplusplus
 }

source/banner/gui_banner.cpp

@@ -6,7 +6,8 @@
  ***************************************************************************/
 #include "gui_banner.h"
 
-GuiBanner::GuiBanner(const char *tplfilepath) {
+GuiBanner::GuiBanner(const char *tplfilepath)
+{
     memory = NULL;
     tplfilesize = 0;
     width = 0;
@@ -14,7 +15,7 @@ GuiBanner::GuiBanner(const char *tplfilepath) {
 
 	FILE *tplfp = fopen(tplfilepath,"rb");
 
-    if (tplfp !=NULL) {
+	if(tplfp !=NULL) {
 
 		unsigned short heighttemp = 0;
 		unsigned short widthtemp = 0;
@@ -26,7 +27,7 @@ GuiBanner::GuiBanner(const char *tplfilepath) {
         tplfilesize = ftell (tplfp);
         rewind (tplfp);
         memory = memalign(32, tplfilesize);
-        if (!memory) {
+        if(!memory) {
             fclose(tplfp);
             return;
         }
@@ -37,13 +38,13 @@ GuiBanner::GuiBanner(const char *tplfilepath) {
         int ret;
 
         ret = TPL_OpenTPLFromMemory(&tplfile, memory, tplfilesize);
-        if (ret < 0) {
+        if(ret < 0) {
             free(memory);
             memory = NULL;
             return;
         }
         ret = TPL_GetTexture(&tplfile,0,&texObj);
-        if (ret < 0) {
+        if(ret < 0) {
             free(memory);
             memory = NULL;
             return;
@@ -61,8 +62,9 @@ GuiBanner::GuiBanner(const char *tplfilepath) {
     }
 }
 
-GuiBanner::GuiBanner(void *mem, u32 len, int w, int h) {
-    if (!mem || !len)
+GuiBanner::GuiBanner(void *mem, u32 len, int w, int h)
+{
+    if(!mem || !len)
         return;
     memory = mem;
     tplfilesize = len;
@@ -74,13 +76,13 @@ GuiBanner::GuiBanner(void *mem, u32 len, int w, int h) {
     int ret;
 
     ret = TPL_OpenTPLFromMemory(&tplfile, memory, tplfilesize);
-    if (ret < 0) {
+    if(ret < 0) {
         free(memory);
         memory = NULL;
         return;
     }
     ret = TPL_GetTexture(&tplfile,0,&texObj);
-    if (ret < 0) {
+    if(ret < 0) {
         free(memory);
         memory = NULL;
         return;
@@ -90,16 +92,18 @@ GuiBanner::GuiBanner(void *mem, u32 len, int w, int h) {
     filecheck = true;
 }
 
-GuiBanner::~GuiBanner() {
-    if (memory != NULL) {
+GuiBanner::~GuiBanner()
+{
+    if(memory != NULL) {
         free(memory);
         memory = NULL;
     }
 }
 
-void GuiBanner::Draw() {
+void GuiBanner::Draw()
+{
 	LOCK(this);
-    if (!filecheck ||!this->IsVisible())
+	if(!filecheck ||!this->IsVisible())
 		return;
 
 	float currScale = this->GetScale();

source/banner/gui_banner.h

@@ -10,7 +10,8 @@
 
 #include "libwiigui/gui.h"
 
-class GuiBanner  : public GuiImage {
+class GuiBanner  : public GuiImage
+{
 public:
     //!Constructor
     //!\param tplfilepath Path of the tpl file

source/banner/openingbnr.c

@@ -28,38 +28,46 @@
 #include "../ramdisk/ramdisk.h"
 #include "../listfiles.h"
 
-u16 be16(const u8 *p) {
+u16 be16(const u8 *p)
+{
 	return (p[0] << 8) | p[1];
 }
 
-u32 be32(const u8 *p) {
+u32 be32(const u8 *p)
+{
 	return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 }
 
-u64 be64(const u8 *p) {
+u64 be64(const u8 *p)
+{
 	return ((u64)be32(p) << 32) | be32(p + 4);
 }
 
-u64 be34(const u8 *p) {
+u64 be34(const u8 *p)
+{
 	return 4 * (u64)be32(p);
 }
 
-void wbe16(u8 *p, u16 x) {
+void wbe16(u8 *p, u16 x)
+{
 	p[0] = x >> 8;
 	p[1] = x;
 }
 
-void wbe32(u8 *p, u32 x) {
+void wbe32(u8 *p, u32 x)
+{
 	wbe16(p, x >> 16);
 	wbe16(p + 2, x);
 }
 
-void wbe64(u8 *p, u64 x) {
+void wbe64(u8 *p, u64 x)
+{
 	wbe32(p, x >> 32);
 	wbe32(p + 4, x);
 }
 
-void md5(u8 *data, u32 len, u8 *hash) {
+void md5(u8 *data, u32 len, u8 *hash)
+{
 	MD5(hash, data, len);
 }
 
@@ -90,14 +98,16 @@ typedef struct {
       u32 payload_data;
 }  imd5_header_t;
 
-typedef struct {
+typedef struct
+{
   u16 type;
   u16 name_offset;
   u32 data_offset; // == absolut offset från U.8- headerns början
   u32 size; // last included file num for directories
 } U8_node;
 
-typedef struct {
+typedef struct
+{
   u32 tag; // 0x55AA382D "U.8-"
   u32 rootnode_offset; // offset to root_node, always 0x20.
   u32 header_size; // size of header from root_node to end of string table.
@@ -105,18 +115,21 @@ typedef struct {
   u8 zeroes[16];
 } U8_archive_header;
 
-static int write_file(void* data, size_t size, char* name) {
+static int write_file(void* data, size_t size, char* name)
+{
 	size_t written=0;
 	FILE *out;
 	out = fopen(name, "wb");
-    if (out) {
+	if(out)
+	{
 		written = fwrite(data, 1, size, out);
 		fclose(out);
 	}
 	return (written == size) ? 1 : -1;
 }
 
-u8* decompress_lz77(u8 *data, size_t data_size, size_t* decompressed_size) {
+u8* decompress_lz77(u8 *data, size_t data_size, size_t* decompressed_size)
+{
 	u8 *data_end;
 	u8 *decompressed_data;
 	size_t unpacked_size;
@@ -186,7 +199,8 @@ u8* decompress_lz77(u8 *data, size_t data_size, size_t* decompressed_size) {
 	return decompressed_data;
 }
 
-static int write_imd5_lz77(u8* data, size_t size, char* outname) {
+static int write_imd5_lz77(u8* data, size_t size, char* outname)
+{
 	imd5_header_t* header = (imd5_header_t*) data;
 	u32 tag;
 	u32 size_in_imd5;
@@ -213,7 +227,7 @@ static int write_imd5_lz77(u8* data, size_t size, char* outname) {
 	if (tag == 0x4C5A3737) {
 	  // "LZ77" - uncompress
     decompressed_data = decompress_lz77(data + sizeof(imd5_header_t), size - sizeof(imd5_header_t), &decompressed_size);
-        if (decompressed_data == NULL)
+    if(decompressed_data == NULL)
         return -7;
     write_file(decompressed_data, decompressed_size, outname);
     //printf(", uncompressed %d bytes, md5 ok", decompressed_size);
@@ -226,7 +240,8 @@ static int write_imd5_lz77(u8* data, size_t size, char* outname) {
 	return 0;
 }
 
-static int do_U8_archive(FILE *fp) {
+static int do_U8_archive(FILE *fp)
+{
   U8_archive_header header;
   U8_node root_node;
 	u32 tag;
@@ -300,8 +315,8 @@ static int do_U8_archive(FILE *fp) {
       //printf("%*s %s (%d bytes", dir_index, "", name, size);
       int result;
       result = write_imd5_lz77(file_data, size, name);
-            if (result < 0) {
-                free(string_table);
+      if(result < 0)
+		{free(string_table);
         return result;
 		}
       //printf(")\n");
@@ -317,7 +332,8 @@ static int do_U8_archive(FILE *fp) {
 	return 0;
 }
 
-static void do_imet_header(FILE *fp) {
+static void do_imet_header(FILE *fp)
+{
 	imet_data_t header;
 
 	fread(&header, 1, sizeof header, fp);
@@ -325,7 +341,8 @@ static void do_imet_header(FILE *fp) {
 	write_file(&header, sizeof(header), "header.imet");
 }
 
-void do_U8_archivebanner(FILE *fp) {
+void do_U8_archivebanner(FILE *fp)
+{
 	U8_archive_header header;
 	U8_node root_node;
 	u32 tag;
@@ -397,10 +414,12 @@ void do_U8_archivebanner(FILE *fp) {
 	free(string_table);
 }
 
-int extractbnrfile(const char * filepath, const char * destpath) {
+int extractbnrfile(const char * filepath, const char * destpath)
+{
     int ret = -1;
 	FILE *fp = fopen(filepath, "rb");
-    if (fp) {
+	if(fp)
+	{
 		subfoldercreate(destpath);
 		chdir(destpath);
 
@@ -412,9 +431,11 @@ int extractbnrfile(const char * filepath, const char * destpath) {
 	return ret;
 }
 
-int unpackBin(const char * filename,const char * outdir) {
+int unpackBin(const char * filename,const char * outdir)
+{
 	FILE *fp = fopen(filename,"rb");;
-    if (fp) {
+	if(fp)
+	{
 		subfoldercreate(outdir);
 		chdir(outdir);
 
@@ -428,70 +449,81 @@ int unpackBin(const char * filename,const char * outdir) {
 #define TMP_PATH(s) "BANNER:/dump"s
 //#define TMP_PATH(s) "SD:/dump"s
 
-int unpackBanner(const u8 *gameid, int what, const char *outdir) {
+int unpackBanner(const u8 *gameid, int what, const char *outdir)
+{
 
 	char path[256];
-    if (!ramdiskMount("BANNER", NULL)) return -1;
+	if(!ramdiskMount("BANNER", NULL)) return -1;
 
 	subfoldercreate(TMP_PATH("/"));
 	s32 ret = dump_banner(gameid, TMP_PATH("/opening.bnr"));
-    if (ret != 1) {
+	if (ret != 1)
+	{
 		ret = -1;
 		goto error2;
 	}
 
 	ret = extractbnrfile(TMP_PATH("/opening.bnr"), TMP_PATH("/"));
-    if (ret != 0) {
+	if (ret != 0)
+	{
 		ret = -1;
 		goto error2;
 	}
 
-    if (what & UNPACK_BANNER_BIN) {
+	if(what & UNPACK_BANNER_BIN)
+	{
 		snprintf(path, sizeof(path),"%sbanner/", outdir);
 		ret = unpackBin(TMP_PATH("/meta/banner.bin"), path);
-        if (ret != 1) {
+		if (ret != 1)
+		{
 			ret = -1;
 			goto error2;
 		}
 	}
-    if (what & UNPACK_ICON_BIN) {
+	if(what & UNPACK_ICON_BIN)
+	{
 		snprintf(path, sizeof(path),"%sicon/", outdir);
 		ret = unpackBin(TMP_PATH("/meta/icon.bin"), path);
-        if (ret != 1) {
+		if (ret != 1)
+		{
 			ret = -1;
 			goto error2;
 		}
 	}
-    if (what & UNPACK_SOUND_BIN) {
+	if(what & UNPACK_SOUND_BIN)
+	{
 		snprintf(path, sizeof(path),"%ssound.bin", outdir);
 		FILE *fp = fopen(TMP_PATH("/meta/sound.bin"), "rb");
-        if (fp) {
+		if(fp)
+		{
 			size_t size;
 			u8 *data;
 			fseek(fp, 0, SEEK_END);
 			size = ftell(fp);
-            if (!size) {
+			if(!size)
+			{
 				ret = -1;
 				goto error;
 			}
 			fseek(fp, 0, SEEK_SET);
 			data = (u8 *)malloc(size);
-            if (!data) {
+			if(!data)
+			{
 				ret = -1;
 				goto error;
 			}
-            if (fread(data, 1, size, fp) != size) {
+			if(fread(data, 1, size, fp) != size)
+			{
 				ret = -1;
 				goto error;
 			}
 			ret = write_file(data, size, path);
 		}
-error:
-        fclose(fp);
+error:	fclose(fp);
 	}
 	ramdiskUnmount("BANNER");
 error2:
-    if (ret < 0)
+	if(ret < 0)
 		return ret;
 	return 1;
 }

source/banner/openingbnr.h

@@ -9,35 +9,36 @@
 #define _OPENINGBNR_H_
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-    /***********************************************************
-    *    Error description:
-    *     0      Successfully extracted
-    *    -1      No U8 tag
-    *    -2      Unknown type
-    *    -3      Archive inconsistency, too much padding
-    *    -4      No IMD5 tag
-    *    -5      MD5 mismatch
-    *    -6      Size mismatch
-    *    -7      Inconsistency in LZ77 encoding
-    ************************************************************/
+/***********************************************************
+*    Error description:
+*     0      Successfully extracted
+*    -1      No U8 tag
+*    -2      Unknown type
+*    -3      Archive inconsistency, too much padding
+*    -4      No IMD5 tag
+*    -5      MD5 mismatch
+*    -6      Size mismatch
+*    -7      Inconsistency in LZ77 encoding
+************************************************************/
 
 //! Extract opening.bnr from filepath to destpath
 //! Files extracted: banner.bin icon.bin and sound.bin
-    int extractbnrfile(const char * filepath, const char * destpath);
-    int unpackBin(const char * filename,const char * outdir);
+int extractbnrfile(const char * filepath, const char * destpath);
+int unpackBin(const char * filename,const char * outdir);
 #define UNPACK_BANNER_BIN	1 /* extract banner.bin to outdir/banner/   */
 #define UNPACK_ICON_BIN		2 /* extract icon.bin to outdir/icon/   */
 #define UNPACK_SOUND_BIN	4 /* copies sound.bin to outdir/sound.bin   */
 #define UNPACK_ALL (UNPACK_SOUND_BIN | UNPACK_ICON_BIN | UNPACK_BANNER_BIN)
-    int unpackBanner(const u8 * gameid, int what, const char *outdir);
+int unpackBanner(const u8 * gameid, int what, const char *outdir);
 //! Extract the lz77 compressed banner, icon and sound .bin
-    u8* decompress_lz77(u8 *data, size_t data_size, size_t* decompressed_size);
+u8* decompress_lz77(u8 *data, size_t data_size, size_t* decompressed_size);
 
-    u16 be16(const u8 *p);
-    u32 be32(const u8 *p);
+u16 be16(const u8 *p);
+u32 be32(const u8 *p);
 
 #ifdef __cplusplus
 }

source/bannersound.cpp

@@ -11,14 +11,16 @@
 #include "bannersound.h"
 
 
-struct IMD5Header {
+struct IMD5Header
+{
 	u32 fcc;
 	u32 filesize;
 	u8 zeroes[8];
 	u8 crypto[16];
 } __attribute__((packed));
 
-struct IMETHeader {
+struct IMETHeader
+{
 	u8 zeroes[64];
 	u32 fcc;
 	u8 unk[8];
@@ -31,7 +33,8 @@ struct IMETHeader {
 	u8 crypto[16];
 } __attribute__((packed));
 
-struct U8Header {
+struct U8Header
+{
 	u32 fcc;
 	u32 rootNodeOffset;
 	u32 headerSize;
@@ -39,40 +42,44 @@ struct U8Header {
 	u8 zeroes[16];
 } __attribute__((packed));
 
-struct U8Entry {
-    struct {
-u32 fileType :
-        8;
-u32 nameOffset :
-        24;
+struct U8Entry
+{
+	struct
+	{
+		u32 fileType : 8;
+		u32 nameOffset : 24;
 	};
 	u32 fileOffset;
-    union {
+	union
+	{
 		u32 fileLength;
 		u32 numEntries;
 	};
 } __attribute__((packed));
 
-struct LZ77Info {
-u16 length :
-    4;
-u16 offset :
-    12;
+struct LZ77Info
+{
+	u16 length : 4;
+	u16 offset : 12;
 } __attribute__((packed));
 
-static char *u8Filename(const U8Entry *fst, int i) {
+static char *u8Filename(const U8Entry *fst, int i)
+{
 	return (char *)(fst + fst[0].numEntries) + fst[i].nameOffset;
 }
 
-inline u32 le32(u32 i) {
+inline u32 le32(u32 i)
+{
 	return ((i & 0xFF) << 24) | ((i & 0xFF00) << 8) | ((i & 0xFF0000) >> 8) | ((i & 0xFF000000) >> 24);
 }
 
-inline u16 le16(u16 i) {
+inline u16 le16(u16 i)
+{
 	return ((i & 0xFF) << 8) | ((i & 0xFF00) >> 8);
 }
 
-static u8 *uncompressLZ77(const u8 *inBuf, u32 inLength, u32 &size) {
+static u8 *uncompressLZ77(const u8 *inBuf, u32 inLength, u32 &size)
+{
 	u8 *buffer = NULL;
 	if (inLength <= 0x8 || *((const u32 *)inBuf) != 0x4C5A3737 /*"LZ77"*/ || inBuf[4] != 0x10)
 		return NULL;
@@ -87,11 +94,14 @@ static u8 *uncompressLZ77(const u8 *inBuf, u32 inLength, u32 &size) {
 	u8 *bufCur = buffer;
 	u8 *bufEnd = buffer + uncSize;
 
-    while (bufCur < bufEnd && inBuf < inBufEnd) {
+	while (bufCur < bufEnd && inBuf < inBufEnd)
+	{
 		u8 flags = *inBuf;
 		++inBuf;
-        for (int i = 0; i < 8 && bufCur < bufEnd && inBuf < inBufEnd; ++i) {
-            if ((flags & 0x80) != 0) {
+		for (int i = 0; i < 8 && bufCur < bufEnd && inBuf < inBufEnd; ++i)
+		{
+			if ((flags & 0x80) != 0)
+			{
 				const LZ77Info &info = *(const LZ77Info *)inBuf;
 				inBuf += sizeof (LZ77Info);
 				int length = info.length + 3;
@@ -99,7 +109,9 @@ static u8 *uncompressLZ77(const u8 *inBuf, u32 inLength, u32 &size) {
 					return buffer;
 				memcpy(bufCur, bufCur - info.offset - 1, length);
 				bufCur += length;
-            } else {
+			}
+			else
+			{
 				*bufCur = *inBuf;
 				++inBuf;
 				++bufCur;
@@ -111,23 +123,27 @@ static u8 *uncompressLZ77(const u8 *inBuf, u32 inLength, u32 &size) {
 	return buffer;
 }
 
-const u8 *LoadBannerSound(const u8 *discid, u32 *size) {
-    if (!discid)
+const u8 *LoadBannerSound(const u8 *discid, u32 *size)
+{
+    if(!discid)
         return NULL;
 
  	Disc_SetUSB(NULL);
 	wbfs_disc_t *disc = WBFS_OpenDisc((u8 *) discid);
-    if (!disc) {
+	if(!disc)
+	{
        // WindowPrompt(tr("Can't find disc"), 0, tr("OK"));
         return NULL;
 	}
 	wiidisc_t *wdisc = wd_open_disc((int (*)(void *, u32, u32, void *))wbfs_disc_read, disc);
-    if (!wdisc) {
+	if(!wdisc)
+	{
 	//WindowPrompt(tr("Could not open Disc"), 0, tr("OK"));
         return NULL;
 	}
 	u8 * opening_bnr = wd_extract_file(wdisc, ALL_PARTITIONS, (char *) "opening.bnr");
-    if (!opening_bnr) {
+	if(!opening_bnr)
+	{
 		//WindowPrompt(tr("ERROR"), tr("Failed to extract opening.bnr"), tr("OK"));
         return NULL;
 	}
@@ -138,7 +154,8 @@ const u8 *LoadBannerSound(const u8 *discid, u32 *size) {
 	const U8Entry *fst;
 
 	const IMETHeader *imetHdr = (IMETHeader *)opening_bnr;
-    if ( imetHdr->fcc != 0x494D4554 /*"IMET"*/ ) {
+	if ( imetHdr->fcc != 0x494D4554 /*"IMET"*/ )
+	{
 	//	WindowPrompt(tr("IMET Header wrong."), 0, tr("OK"));
 		free(opening_bnr);
         return NULL;
@@ -150,14 +167,16 @@ const u8 *LoadBannerSound(const u8 *discid, u32 *size) {
 	for (i = 1; i < fst[0].numEntries; ++i)
 		if (fst[i].fileType == 0 && strcasecmp(u8Filename(fst, i), "sound.bin") == 0)
 			break;
-    if (i >= fst[0].numEntries) {
+	if (i >= fst[0].numEntries)
+	{
 	    /* Not all games have a sound.bin and this message is annoying **/
 		//WindowPrompt(tr("sound.bin not found."), 0, tr("OK"));
 		free(opening_bnr);
         return NULL;
 	}
 	const u8 *sound_bin = ((const u8 *)bnrArcHdr) + fst[i].fileOffset;
-    if ( ((IMD5Header *)sound_bin)->fcc != 0x494D4435 /*"IMD5"*/ ) {
+	if ( ((IMD5Header *)sound_bin)->fcc != 0x494D4435 /*"IMD5"*/ )
+	{
 	//	WindowPrompt(tr("IMD5 Header not right."), 0, tr("OK"));
 		free(opening_bnr);
         return NULL;
@@ -165,22 +184,25 @@ const u8 *LoadBannerSound(const u8 *discid, u32 *size) {
 	const u8 *soundChunk = sound_bin + sizeof (IMD5Header);;
 	u32 soundChunkSize = fst[i].fileLength - sizeof (IMD5Header);
 
-    if ( *((u32*)soundChunk) == 0x4C5A3737 /*"LZ77"*/ ) {
+	if ( *((u32*)soundChunk) == 0x4C5A3737 /*"LZ77"*/ )
+	{
 		u32 uncSize = NULL;
 		u8 * uncompressed_data = uncompressLZ77(soundChunk, soundChunkSize, uncSize);
-        if (!uncompressed_data) {
+		if (!uncompressed_data)
+		{
 		//	WindowPrompt(tr("Can't decompress LZ77"), 0, tr("OK"));
 			free(opening_bnr);
 			return NULL;
 		}
-        if (size) *size=uncSize;
+		if(size) *size=uncSize;
 		free(opening_bnr);
 		return uncompressed_data;
 	}
 	u8 *out = new(std::nothrow) u8[soundChunkSize];
-    if (out) {
+	if(out)
+	{
 		memcpy(out, soundChunk, soundChunkSize);
-        if (size) *size=soundChunkSize;
+		if(size) *size=soundChunkSize;
 	}
 	free(opening_bnr);
 	return out;

source/cheats/cheatmenu.cpp

@@ -29,7 +29,7 @@ int CheatMenu(const char * gameID) {
 	int ret = 1;
 
 	// because destroy GuiSound must wait while sound playing is finished, we use a global sound
-    if (!btnClick2) btnClick2=new GuiSound(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
+	if(!btnClick2) btnClick2=new GuiSound(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
 	//	GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
 
 	char imgPath[100];
@@ -71,11 +71,13 @@ int CheatMenu(const char * gameID) {
 		break;
 	case 0:
 		download = WindowPrompt(tr("Error"),tr("No Cheatfile found"),tr("Download Now"),tr("Cancel"));
-        if (download==1) {
+		if (download==1)
+		{
 			download = CodeDownload(gameID);
-            if (download < 0 || c.openTxtfile(txtfilename) != 1)
+			if(download < 0 || c.openTxtfile(txtfilename) != 1)
 				break;
-        } else
+		}
+		else
 			break;
 	case 1:
 		int cntcheats = c.getCnt();

source/fatmounter.c

@@ -111,7 +111,7 @@ int isInserted(const char *path) {
 }
 
 int SDCard_Init() {
-    gprintf("\nSDCard_Init()");
+gprintf("\nSDCard_Init()");
 
     //closing all open Files write back the cache and then shutdown em!
     fatUnmount("SD:/");
@@ -121,7 +121,8 @@ int SDCard_Init() {
 		fat_sd_sec = _FAT_startSector;
 		gprintf(":1");
 		return 1;
-    } else if (fatMount("SD", &__io_sdhc, 0, CACHE, SDHC_SECTOR_SIZE)) {
+	}
+	else if (fatMount("SD", &__io_sdhc, 0, CACHE, SDHC_SECTOR_SIZE)) {
 		fat_sd_mount = MOUNT_SDHC;
 		fat_sd_sec = _FAT_startSector;
 		gprintf(":1");
@@ -132,7 +133,7 @@ int SDCard_Init() {
 }
 
 void SDCard_deInit() {
-    gprintf("\nSDCard_deInit()");
+gprintf("\nSDCard_deInit()");
     //closing all open Files write back the cache and then shutdown em!
     fatUnmount("SD:/");
 
@@ -142,7 +143,8 @@ void SDCard_deInit() {
 
 void ntfsInit();
 
-s32 MountNTFS(u32 sector) {
+s32 MountNTFS(u32 sector)
+{
 	s32 ret;
 
 	if (fs_ntfs_mount) return 0;
@@ -190,7 +192,8 @@ s32 MountNTFS(u32 sector) {
 	return 0;
 }
 
-s32 UnmountNTFS(void) {
+s32 UnmountNTFS(void)
+{
 	/* Unmount device */
 	ntfsUnmount("NTFS:/", true);
 
@@ -200,29 +203,36 @@ s32 UnmountNTFS(void) {
 	return 0;
 }
 
-void _FAT_mem_init() {
+void _FAT_mem_init()
+{
 }
 
-void* _FAT_mem_allocate(size_t size) {
+void* _FAT_mem_allocate(size_t size)
+{
 	return malloc(size);
 }
 
-void* _FAT_mem_align(size_t size) {
+void* _FAT_mem_align(size_t size)
+{
 	return memalign(32, size);		
 }
 
-void _FAT_mem_free(void *mem) {
+void _FAT_mem_free(void *mem)
+{
 	free(mem);
 }
 
-void* ntfs_alloc (size_t size) {
+void* ntfs_alloc (size_t size)
+{
 	return _FAT_mem_allocate(size);
 }
 
-void* ntfs_align (size_t size) {
+void* ntfs_align (size_t size)
+{
 	return _FAT_mem_align(size);
 }
 
-void ntfs_free (void* mem) {
+void ntfs_free (void* mem)
+{
 	_FAT_mem_free(mem);
 }

source/gecko.c

@@ -10,7 +10,8 @@ bool textVideoInit = false;
 #include <stdarg.h>
 
 //using the gprintf from crediar because it is smaller than mine
-void gprintf( const char *str, ... ) {
+void gprintf( const char *str, ... )
+{
 	if (!(geckoinit))return;
 
 	char astr[4096];
@@ -25,12 +26,15 @@ void gprintf( const char *str, ... ) {
 	usb_sendbuffer_safe( 1, astr, strlen(astr) );
 } 
 
-bool InitGecko() {
+bool InitGecko()
+{
 	u32 geckoattached = usb_isgeckoalive(EXI_CHANNEL_1);
-    if (geckoattached) {
+	if (geckoattached)
+	{
 		usb_flush(EXI_CHANNEL_1);
 		return true;
-    } else return false;
+	}
+	else return false;
 }
 
 

source/gecko.h

@@ -12,8 +12,8 @@ extern "C" {
 	void gprintf(const char *str, ...);
 	bool InitGecko();
 #else
-#define gprintf(...)
-#define InitGecko()      false
+	#define gprintf(...)
+	#define InitGecko()      false
 #endif /* NO_DEBUG */
 
 

source/homebrewboot/HomebrewBrowse.cpp

@@ -87,7 +87,7 @@ int MenuHomebrewBrowse() {
     /*** Sound Variables ***/
     GuiSound btnSoundOver(button_over_pcm, button_over_pcm_size, Settings.sfxvolume);
 	// because destroy GuiSound must wait while sound playing is finished, we use a global sound
-    if (!btnClick2) btnClick2=new GuiSound(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
+	if(!btnClick2) btnClick2=new GuiSound(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
 	//	GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
     GuiSound btnClick1(button_click_pcm, button_click_pcm_size, Settings.sfxvolume);
 
@@ -219,11 +219,11 @@ int MenuHomebrewBrowse() {
 
     GuiImage MainButton2Img(&MainButtonImgData);
     GuiImage MainButton2ImgOver(&MainButtonImgOverData);
-    GuiText MainButton2Txt(MainButtonText, 18, (GXColor) {0, 0, 0, 255});
+    GuiText MainButton2Txt(MainButtonText, 18, (GXColor) {0, 0, 0, 255 });
     MainButton2Txt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton2Txt.SetPosition(148, -12);
     MainButton2Txt.SetMaxWidth(MainButton2Img.GetWidth()-150, GuiText::DOTTED);
-    GuiText MainButton2DescTxt(MainButtonText, 18, (GXColor) {0, 0, 0, 255});
+    GuiText MainButton2DescTxt(MainButtonText, 18, (GXColor) { 0, 0, 0, 255});
     MainButton2DescTxt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton2DescTxt.SetPosition(148, 15);
     MainButton2DescTxt.SetMaxWidth(MainButton2Img.GetWidth()-150, GuiText::DOTTED);
@@ -250,11 +250,11 @@ int MenuHomebrewBrowse() {
     MainButton3Txt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton3Txt.SetPosition(148, -12);
     MainButton3Txt.SetMaxWidth(MainButton3Img.GetWidth()-150, GuiText::DOTTED);
-    GuiText MainButton3DescTxt(MainButtonText, 18, (GXColor) {0, 0, 0, 255});
+    GuiText MainButton3DescTxt(MainButtonText, 18, (GXColor) { 0, 0, 0, 255});
     MainButton3DescTxt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton3DescTxt.SetPosition(148, 15);
     MainButton3DescTxt.SetMaxWidth(MainButton3Img.GetWidth()-150, GuiText::DOTTED);
-    GuiText MainButton3DescOverTxt(MainButtonText, 18, (GXColor) {0, 0, 0, 255});
+    GuiText MainButton3DescOverTxt(MainButtonText, 18, (GXColor) {0, 0, 0, 255 });
     MainButton3DescOverTxt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton3DescOverTxt.SetPosition(148, 15);
     MainButton3DescOverTxt.SetMaxWidth(MainButton3Img.GetWidth()-150, GuiText::SCROLL);
@@ -273,7 +273,7 @@ int MenuHomebrewBrowse() {
 
     GuiImage MainButton4Img(&MainButtonImgData);
     GuiImage MainButton4ImgOver(&MainButtonImgOverData);
-    GuiText MainButton4Txt(MainButtonText, 18, (GXColor) {0, 0, 0, 255});
+    GuiText MainButton4Txt(MainButtonText, 18, (GXColor) {0, 0, 0, 255} );
     MainButton4Txt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton4Txt.SetPosition(148, -12);
     MainButton4Txt.SetMaxWidth(MainButton4Img.GetWidth()-150, GuiText::DOTTED);
@@ -281,7 +281,7 @@ int MenuHomebrewBrowse() {
     MainButton4DescTxt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton4DescTxt.SetPosition(148, 15);
     MainButton4DescTxt.SetMaxWidth(MainButton4Img.GetWidth()-150, GuiText::DOTTED);
-    GuiText MainButton4DescOverTxt(MainButtonText, 18, (GXColor) {0, 0, 0, 255});
+    GuiText MainButton4DescOverTxt(MainButtonText, 18, (GXColor) { 0, 0, 0, 255});
     MainButton4DescOverTxt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
     MainButton4DescOverTxt.SetPosition(148, 15);
     MainButton4DescOverTxt.SetMaxWidth(MainButton4Img.GetWidth()-150, GuiText::SCROLL);
@@ -852,7 +852,8 @@ int MenuHomebrewBrowse() {
 									sprintf((char *) &zippath, "%s%s", Settings.homebrewapps_path, filename);
 									
 									FILE *fp = fopen(zippath, "wb");
-                                    if (fp != NULL) {
+									if (fp != NULL)
+									{
 										fwrite(temp, 1, infilesize, fp);
 										fclose(fp);