JANITORIAL: Fix whitespace

9 files changed, 93 insertions, 93 deletions

diff --git a/graphics/VectorRenderer.h b/graphics/VectorRenderer.h
index 2b84c21894..2abe0e0759 100644
--- a/graphics/VectorRenderer.h
+++ b/graphics/VectorRenderer.h
@@ -437,7 +437,7 @@ public:
 	void drawCallback_ALPHABITMAP(const Common::Rect &area, const DrawStep &step, const Common::Rect &clip) {
 		uint16 x, y, w, h;
 		stepGetPositions(step, area, x, y, w, h);
-		blitAlphaBitmap(step.blitAlphaSrc, Common::Rect(x, y, x + w, y + h), step.autoscale, step.xAlign, step.yAlign); //TODO
+		blitAlphaBitmap(step.blitAlphaSrc, Common::Rect(x, y, x + w, y + h), step.autoscale, step.xAlign, step.yAlign); // TODO
 	}
 
 	void drawCallback_CROSS(const Common::Rect &area, const DrawStep &step, const Common::Rect &clip) {
diff --git a/graphics/VectorRendererSpec.cpp b/graphics/VectorRendererSpec.cpp
index c66bb2e9af..e308dde821 100644
--- a/graphics/VectorRendererSpec.cpp
+++ b/graphics/VectorRendererSpec.cpp
@@ -419,7 +419,7 @@ inline frac_t fp_sqroot(uint32 x) {
 		x--; px -= pitch; \
 	} \
 	a2 = (T >> 8); \
-	a1 = ~a2;   \
+	a1 = ~a2; \
 } while (0)
 
 
@@ -2680,7 +2680,7 @@ drawTriangleVertAlg(int x1, int y1, int w, int h, bool inverted, PixelType color
 		int gradient = (dx << 8) / (dy + 0x100);
 		int interx = (x1 << 8) + gradient;
 #else
-		double gradient = dx / (dy+1);
+		double gradient = dx / (dy + 1);
 		double interx = x1 + gradient;
 #endif
 
@@ -2846,7 +2846,7 @@ drawTriangleVertAlgClip(int x1, int y1, int w, int h, bool inverted, PixelType c
 				break;
 			case kFillForeground:
 			case kFillBackground:
-				colorFillClip<PixelType>(ptr_right + 1, ptr_left, color, x_right+1, y_right, _clippingArea);
+				colorFillClip<PixelType>(ptr_right + 1, ptr_left, color, x_right + 1, y_right, _clippingArea);
 				blendPixelPtrClip(ptr_right, color, rfpart(intery), x_right, y_right);
 				blendPixelPtrClip(ptr_left, color, rfpart(intery), x_left, y_left);
 				break;
@@ -2905,7 +2905,7 @@ drawTriangleVertAlgClip(int x1, int y1, int w, int h, bool inverted, PixelType c
 				break;
 			case kFillForeground:
 			case kFillBackground:
-				colorFillClip<PixelType>(ptr_right + 1, ptr_left, color, x_right+1, y_right, _clippingArea);
+				colorFillClip<PixelType>(ptr_right + 1, ptr_left, color, x_right + 1, y_right, _clippingArea);
 				blendPixelPtrClip(ptr_right, color, rfpart(interx), x_right, y_right);
 				blendPixelPtrClip(ptr_left, color, rfpart(interx), x_left, y_left);
 				break;
@@ -2953,7 +2953,7 @@ drawTriangleVertAlgClip(int x1, int y1, int w, int h, bool inverted, PixelType c
 			break;
 		case kFillForeground:
 		case kFillBackground:
-			colorFillClip<PixelType>(ptr_right + 1, ptr_left, color, x_right+1, y_right, _clippingArea);
+			colorFillClip<PixelType>(ptr_right + 1, ptr_left, color, x_right + 1, y_right, _clippingArea);
 			blendPixelPtrClip(ptr_right, color, rfpart(interx), x_right, y_right);
 			blendPixelPtrClip(ptr_left, color, rfpart(interx), x_left, y_left);
 			break;
@@ -3061,10 +3061,10 @@ drawBorderRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color,
 		BE_RESET();
 		r--;
 
-		int alphaStep_tr = ((alpha_t - alpha_r)/(y+1));
-		int alphaStep_br = ((alpha_r - alpha_b)/(y+1));
-		int alphaStep_bl = ((alpha_b - alpha_l)/(y+1));
-		int alphaStep_tl = ((alpha_l - alpha_t)/(y+1));
+		int alphaStep_tr = ((alpha_t - alpha_r) / (y + 1));
+		int alphaStep_br = ((alpha_r - alpha_b) / (y + 1));
+		int alphaStep_bl = ((alpha_b - alpha_l) / (y + 1));
+		int alphaStep_tl = ((alpha_l - alpha_t) / (y + 1));
 
 		// Avoid blending the last pixels twice, since we have an alpha
 		while (x++ < (y - 2)) {
@@ -3970,10 +3970,10 @@ drawBorderRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color,
 		px = pitch * x;
 		py = 0;
 
-		int alphaStep_tr = ((alpha_t - alpha_r)/(x+1));
-		int alphaStep_br = ((alpha_r - alpha_b)/(x+1));
-		int alphaStep_bl = ((alpha_b - alpha_l)/(x+1));
-		int alphaStep_tl = ((alpha_l - alpha_t)/(x+1));
+		int alphaStep_tr = ((alpha_t - alpha_r) / (x + 1));
+		int alphaStep_br = ((alpha_r - alpha_b) / (x + 1));
+		int alphaStep_bl = ((alpha_b - alpha_l) / (x + 1));
+		int alphaStep_tl = ((alpha_l - alpha_t) / (x + 1));
 
 		while (x > y++) {
 			WU_ALGORITHM();
diff --git a/graphics/fonts/bdf.h b/graphics/fonts/bdf.h
index d99b5fd401..c903d52c55 100644
--- a/graphics/fonts/bdf.h
+++ b/graphics/fonts/bdf.h
@@ -85,9 +85,9 @@ private:
 };
 
 #define DEFINE_FONT(n) \
-	const BdfFont *n = 0;   \
+	const BdfFont *n = 0; \
 	void create_##n() { \
-		n = new BdfFont(desc, DisposeAfterUse::NO);  \
+		n = new BdfFont(desc, DisposeAfterUse::NO); \
 	}
 
 #define FORWARD_DECLARE_FONT(n) \
diff --git a/graphics/nine_patch.cpp b/graphics/nine_patch.cpp
index 56e1202be3..ce82fff61e 100644
--- a/graphics/nine_patch.cpp
+++ b/graphics/nine_patch.cpp
@@ -156,7 +156,7 @@ NinePatchBitmap::NinePatchBitmap(Graphics::TransparentSurface *bmp, bool owns_bi
 	bmp->format.colorToARGB(*(uint32 *)bmp->getBasePtr(x, y), a, r, g, b); \
 	if (a != 0 && r + g + b + a != 4) goto bad_bitmap;
 
-	_check_pixel(0,0);
+	_check_pixel(0, 0);
 	_check_pixel(bmp->w - 1, 0);
 	_check_pixel(0, bmp->h - 1);
 	_check_pixel(bmp->w - 1, bmp->h - 1);
diff --git a/graphics/primitives.cpp b/graphics/primitives.cpp
index 8663a61606..76c44b650d 100644
--- a/graphics/primitives.cpp
+++ b/graphics/primitives.cpp
@@ -262,13 +262,13 @@ void drawRoundRect(Common::Rect &rect, int arc, int color, bool filled, void (*p
 
 		do {
 			if (filled) {
-				drawHLine(rect.left+x+r, rect.right-x-r, rect.top-y+r-stop, color, plotProc, data);
-				drawHLine(rect.left+x+r, rect.right-x-r, rect.bottom+y-r+stop, color, plotProc, data);
+				drawHLine(rect.left + x + r, rect.right - x - r, rect.top    - y + r - stop, color, plotProc, data);
+				drawHLine(rect.left + x + r, rect.right - x - r, rect.bottom + y - r + stop, color, plotProc, data);
 			} else {
-				(*plotProc)(rect.left+x+r, rect.top-y+r-stop, color, data);
-				(*plotProc)(rect.right-x-r, rect.top-y+r-stop, color, data);
-				(*plotProc)(rect.left+x+r, rect.bottom+y-r+stop, color, data);
-				(*plotProc)(rect.right-x-r, rect.bottom+y-r+stop, color, data);
+				(*plotProc)(rect.left  + x + r, rect.top    - y + r - stop, color, data);
+				(*plotProc)(rect.right - x - r, rect.top    - y + r - stop, color, data);
+				(*plotProc)(rect.left  + x + r, rect.bottom + y - r + stop, color, data);
+				(*plotProc)(rect.right - x - r, rect.bottom + y - r + stop, color, data);
 
 				lastx = x;
 				lasty = y;
@@ -284,15 +284,15 @@ void drawRoundRect(Common::Rect &rect, int arc, int color, bool filled, void (*p
 			x = lastx;
 			y = lasty;
 
-			drawHLine(rect.left+x+r, rect.right-x-r, rect.top-y+r-stop, color, plotProc, data);
-			drawHLine(rect.left+x+r, rect.right-x-r, rect.bottom+y-r+stop, color, plotProc, data);
+			drawHLine(rect.left + x + r, rect.right - x - r, rect.top    - y + r - stop, color, plotProc, data);
+			drawHLine(rect.left + x + r, rect.right - x - r, rect.bottom + y - r + stop, color, plotProc, data);
 		}
 
 		for (int i = 0; i < dy; i++) {
 			if (filled) {
 				drawHLine(rect.left, rect.right, rect.top + r + i, color, plotProc, data);
 			} else {
-				(*plotProc)(rect.left, rect.top + r + i, color, data);
+				(*plotProc)(rect.left,  rect.top + r + i, color, data);
 				(*plotProc)(rect.right, rect.top + r + i, color, data);
 			}
 		}
@@ -307,13 +307,13 @@ void drawRoundRect(Common::Rect &rect, int arc, int color, bool filled, void (*p
 
 		do {
 			if (filled) {
-				drawVLine(rect.left-x+r-stop, rect.top+y+r, rect.bottom-y-r, color, plotProc, data);
-				drawVLine(rect.right+x-r+stop, rect.top+y+r, rect.bottom-y-r, color, plotProc, data);
+				drawVLine(rect.left  - x + r - stop, rect.top + y + r, rect.bottom - y - r, color, plotProc, data);
+				drawVLine(rect.right + x - r + stop, rect.top + y + r, rect.bottom - y - r, color, plotProc, data);
 			} else {
-				(*plotProc)(rect.left-x+r-stop, rect.top+y+r, color, data);
-				(*plotProc)(rect.left-x+r-stop, rect.bottom-y-r, color, data);
-				(*plotProc)(rect.right+x-r+stop, rect.top+y+r, color, data);
-				(*plotProc)(rect.right+x-r+stop, rect.bottom-y-r, color, data);
+				(*plotProc)(rect.left  - x + r - stop, rect.top    + y + r, color, data);
+				(*plotProc)(rect.left  - x + r - stop, rect.bottom - y - r, color, data);
+				(*plotProc)(rect.right + x - r + stop, rect.top    + y + r, color, data);
+				(*plotProc)(rect.right + x - r + stop, rect.bottom - y - r, color, data);
 
 				lastx = x;
 				lasty = y;
@@ -329,15 +329,15 @@ void drawRoundRect(Common::Rect &rect, int arc, int color, bool filled, void (*p
 		if (!filled) {
 			x = lastx;
 			y = lasty;
-			drawVLine(rect.left-x+r-stop, rect.top+y+r, rect.bottom-y-r, color, plotProc, data);
-			drawVLine(rect.right+x-r+stop, rect.top+y+r, rect.bottom-y-r, color, plotProc, data);
+			drawVLine(rect.left  - x + r - stop, rect.top + y + r, rect.bottom - y - r, color, plotProc, data);
+			drawVLine(rect.right + x - r + stop, rect.top + y + r, rect.bottom - y - r, color, plotProc, data);
 		}
 
 		for (int i = 0; i < dx; i++) {
 			if (filled) {
 				drawVLine(rect.left + r + i, rect.top, rect.bottom, color, plotProc, data);
 			} else {
-				(*plotProc)(rect.left + r + i, rect.top, color, data);
+				(*plotProc)(rect.left + r + i, rect.top,    color, data);
 				(*plotProc)(rect.left + r + i, rect.bottom, color, data);
 			}
 		}
@@ -385,14 +385,14 @@ void drawPolygonScan(int *polyX, int *polyY, int npoints, Common::Rect &bbox, in
 
 // http://members.chello.at/easyfilter/bresenham.html
 void drawEllipse(int x0, int y0, int x1, int y1, int color, bool filled, void (*plotProc)(int, int, int, void *), void *data) {
-	int a = abs(x1-x0), b = abs(y1-y0), b1 = b&1; /* values of diameter */
-	long dx = 4*(1-a)*b*b, dy = 4*(b1+1)*a*a; /* error increment */
-	long err = dx+dy+b1*a*a, e2; /* error of 1.step */
+	int a = abs(x1 - x0), b = abs(y1 - y0), b1 = b & 1; /* values of diameter */
+	long dx = 4 * (1 - a) * b * b, dy = 4 * (b1 + 1) * a * a; /* error increment */
+	long err = dx + dy + b1 * a * a, e2; /* error of 1.step */
 
 	if (x0 > x1) { x0 = x1; x1 += a; } /* if called with swapped points */
 	if (y0 > y1) y0 = y1; /* .. exchange them */
-	y0 += (b+1)/2; y1 = y0-b1;   /* starting pixel */
-	a *= 8*a; b1 = 8*b*b;
+	y0 += (b + 1) / 2; y1 = y0 - b1;   /* starting pixel */
+	a *= 8 * a; b1 = 8 * b * b;
 
 	do {
 		if (filled) {
@@ -411,15 +411,15 @@ void drawEllipse(int x0, int y0, int x1, int y1, int color, bool filled, void (*
 
 	while (y0-y1 < b) {  /* too early stop of flat ellipses a=1 */
 		if (filled) {
-			drawHLine(x0-1, x0-1, y0, color, plotProc, data); /* -> finish tip of ellipse */
-			drawHLine(x1+1, x1+1, y0, color, plotProc, data);
-			drawHLine(x0-1, x0-1, y1, color, plotProc, data);
-			drawHLine(x1+1, x1+1, y1, color, plotProc, data);
+			drawHLine(x0 - 1, x0 - 1, y0, color, plotProc, data); /* -> finish tip of ellipse */
+			drawHLine(x1 + 1, x1 + 1, y0, color, plotProc, data);
+			drawHLine(x0 - 1, x0 - 1, y1, color, plotProc, data);
+			drawHLine(x1 + 1, x1 + 1, y1, color, plotProc, data);
 		} else {
-			(*plotProc)(x0-1, y0, color, data); /* -> finish tip of ellipse */
-			(*plotProc)(x1+1, y0, color, data);
-			(*plotProc)(x0-1, y1, color, data);
-			(*plotProc)(x1+1, y1, color, data);
+			(*plotProc)(x0 - 1, y0, color, data); /* -> finish tip of ellipse */
+			(*plotProc)(x1 + 1, y0, color, data);
+			(*plotProc)(x0 - 1, y1, color, data);
+			(*plotProc)(x1 + 1, y1, color, data);
 		}
 		y0++;
 		y1--;
diff --git a/graphics/scaler.cpp b/graphics/scaler.cpp
index 745988cbd9..a3ac7fc107 100644
--- a/graphics/scaler.cpp
+++ b/graphics/scaler.cpp
@@ -107,12 +107,12 @@ void InitLUT(Graphics::PixelFormat format) {
 	hqx_low2bits = (3 << format.rShift) | (3 << format.gShift) | (3 << format.bShift),
 	hqx_low3bits = (7 << format.rShift) | (7 << format.gShift) | (7 << format.bShift),
 
-	hqx_highbits = format.RGBToColor(255,255,255) ^ hqx_lowbits;
+	hqx_highbits = format.RGBToColor(255, 255, 255) ^ hqx_lowbits;
 
 	// FIXME: The following code only does the right thing
 	// if the color order is RGB or BGR, i.e., green is in the middle.
-	hqx_greenMask = format.RGBToColor(0,255,0);
-	hqx_redBlueMask = format.RGBToColor(255,0,255);
+	hqx_greenMask   = format.RGBToColor(  0, 255,   0);
+	hqx_redBlueMask = format.RGBToColor(255,   0, 255);
 
 	hqx_green_redBlue_Mask = (hqx_greenMask << 16) | hqx_redBlueMask;
 #endif
@@ -145,10 +145,10 @@ void InitScalers(uint32 BitFormat) {
 #endif
 
 	// Build dotmatrix lookup table for the DotMatrix scaler.
-	g_dotmatrix[0] = g_dotmatrix[10] = format.RGBToColor(0, 63, 0);
-	g_dotmatrix[1] = g_dotmatrix[11] = format.RGBToColor(0, 0, 63);
-	g_dotmatrix[2] = g_dotmatrix[8] = format.RGBToColor(63, 0, 0);
-	g_dotmatrix[4] = g_dotmatrix[6] =
+	g_dotmatrix[0] = g_dotmatrix[10] = format.RGBToColor( 0, 63,  0);
+	g_dotmatrix[1] = g_dotmatrix[11] = format.RGBToColor( 0,  0, 63);
+	g_dotmatrix[2] = g_dotmatrix[ 8] = format.RGBToColor(63,  0,  0);
+	g_dotmatrix[4] = g_dotmatrix[ 6] =
 		g_dotmatrix[12] = g_dotmatrix[14] = format.RGBToColor(63, 63, 63);
 }
 
diff --git a/graphics/scaler/intern.h b/graphics/scaler/intern.h
index eddc3c7f3d..213b69b049 100644
--- a/graphics/scaler/intern.h
+++ b/graphics/scaler/intern.h
@@ -195,18 +195,18 @@ static inline bool diffYUV(int yuv1, int yuv2) {
 	int mask;
 
 	diff = ((yuv1 & Umask) - (yuv2 & Umask));
-	mask = diff >> 31; // -1 if value < 0, 0 otherwise
-	diff = (diff ^ mask) - mask; //-1: ~value + 1; 0: value
+	mask = diff >> 31;           // -1 if value < 0, 0 otherwise
+	diff = (diff ^ mask) - mask; // -1: ~value + 1; 0: value
 	if (diff > trU) return true;
 
 	diff = ((yuv1 & Vmask) - (yuv2 & Vmask));
-	mask = diff >> 31; // -1 if value < 0, 0 otherwise
-	diff = (diff ^ mask) - mask; //-1: ~value + 1; 0: value
+	mask = diff >> 31;           // -1 if value < 0, 0 otherwise
+	diff = (diff ^ mask) - mask; // -1: ~value + 1; 0: value
 	if (diff > trV) return true;
 
 	diff = ((yuv1 & Ymask) - (yuv2 & Ymask));
-	mask = diff >> 31; // -1 if value < 0, 0 otherwise
-	diff = (diff ^ mask) - mask; //-1: ~value + 1; 0: value
+	mask = diff >> 31;           // -1 if value < 0, 0 otherwise
+	diff = (diff ^ mask) - mask; // -1: ~value + 1; 0: value
 	if (diff > trY) return true;
 
 	return false;
diff --git a/graphics/scaler/scalebit.cpp b/graphics/scaler/scalebit.cpp
index c8b54f4b25..bcba5793e2 100644
--- a/graphics/scaler/scalebit.cpp
+++ b/graphics/scaler/scalebit.cpp
@@ -47,17 +47,17 @@
 static inline void stage_scale2x(void* dst0, void* dst1, const void* src0, const void* src1, const void* src2, unsigned pixel, unsigned pixel_per_row) {
 	switch (pixel) {
 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-	case 1 : scale2x_8_mmx(DST(8,0), DST(8,1), SRC(8,0), SRC(8,1), SRC(8,2), pixel_per_row); break;
-	case 2 : scale2x_16_mmx(DST(16,0), DST(16,1), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
-	case 4 : scale2x_32_mmx(DST(32,0), DST(32,1), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
+	case 1: scale2x_8_mmx( DST( 8,0), DST( 8,1), SRC( 8,0), SRC( 8,1), SRC( 8,2), pixel_per_row); break;
+	case 2: scale2x_16_mmx(DST(16,0), DST(16,1), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
+	case 4: scale2x_32_mmx(DST(32,0), DST(32,1), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
 #elif defined(USE_ARM_SCALER_ASM)
-	case 1 : scale2x_8_arm(DST(8,0), DST(8,1), SRC(8,0), SRC(8,1), SRC(8,2), pixel_per_row); break;
-	case 2 : scale2x_16_arm(DST(16,0), DST(16,1), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
-	case 4 : scale2x_32_arm(DST(32,0), DST(32,1), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
+	case 1: scale2x_8_arm( DST( 8,0), DST( 8,1), SRC( 8,0), SRC( 8,1), SRC( 8,2), pixel_per_row); break;
+	case 2: scale2x_16_arm(DST(16,0), DST(16,1), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
+	case 4: scale2x_32_arm(DST(32,0), DST(32,1), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
 #else
-	case 1 : scale2x_8_def(DST(8,0), DST(8,1), SRC(8,0), SRC(8,1), SRC(8,2), pixel_per_row); break;
-	case 2 : scale2x_16_def(DST(16,0), DST(16,1), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
-	case 4 : scale2x_32_def(DST(32,0), DST(32,1), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
+	case 1: scale2x_8_def( DST( 8,0), DST( 8,1), SRC( 8,0), SRC( 8,1), SRC( 8,2), pixel_per_row); break;
+	case 2: scale2x_16_def(DST(16,0), DST(16,1), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
+	case 4: scale2x_32_def(DST(32,0), DST(32,1), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
 #endif
 	}
 }
@@ -67,9 +67,9 @@ static inline void stage_scale2x(void* dst0, void* dst1, const void* src0, const
  */
 static inline void stage_scale3x(void* dst0, void* dst1, void* dst2, const void* src0, const void* src1, const void* src2, unsigned pixel, unsigned pixel_per_row) {
 	switch (pixel) {
-	case 1 : scale3x_8_def(DST(8,0), DST(8,1), DST(8,2), SRC(8,0), SRC(8,1), SRC(8,2), pixel_per_row); break;
-	case 2 : scale3x_16_def(DST(16,0), DST(16,1), DST(16,2), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
-	case 4 : scale3x_32_def(DST(32,0), DST(32,1), DST(32,2), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
+	case 1: scale3x_8_def( DST( 8,0), DST( 8,1), DST( 8,2), SRC( 8,0), SRC( 8,1), SRC( 8,2), pixel_per_row); break;
+	case 2: scale3x_16_def(DST(16,0), DST(16,1), DST(16,2), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;
+	case 4: scale3x_32_def(DST(32,0), DST(32,1), DST(32,2), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;
 	}
 }
 
@@ -281,12 +281,12 @@ int scale_precondition(unsigned scale, unsigned pixel, unsigned width, unsigned
 		return -1;
 
 	switch (scale) {
-	case 2 :
-	case 3 :
+	case 2:
+	case 3:
 		if (height < 2)
 			return -1;
 		break;
-	case 4 :
+	case 4:
 		if (height < 4)
 			return -1;
 		break;
@@ -294,14 +294,14 @@ int scale_precondition(unsigned scale, unsigned pixel, unsigned width, unsigned
 
 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 	switch (scale) {
-	case 2 :
-	case 4 :
+	case 2:
+	case 4:
 		if (width < (16 / pixel))
 			return -1;
 		if (width % (8 / pixel) != 0)
 			return -1;
 		break;
-	case 3 :
+	case 3:
 		if (width < 2)
 			return -1;
 		break;
@@ -329,13 +329,13 @@ int scale_precondition(unsigned scale, unsigned pixel, unsigned width, unsigned
 void scale(unsigned scale, void* void_dst, unsigned dst_slice, const void* void_src, unsigned src_slice, unsigned pixel, unsigned width, unsigned height)
 {
 	switch (scale) {
-	case 2 :
+	case 2:
 		scale2x(void_dst, dst_slice, void_src, src_slice, pixel, width, height);
 		break;
-	case 3 :
+	case 3:
 		scale3x(void_dst, dst_slice, void_src, src_slice, pixel, width, height);
 		break;
-	case 4 :
+	case 4:
 		scale4x(void_dst, dst_slice, void_src, src_slice, pixel, width, height);
 		break;
 	}
diff --git a/graphics/sjis.cpp b/graphics/sjis.cpp
index 45cf1cee90..877f314c69 100644
--- a/graphics/sjis.cpp
+++ b/graphics/sjis.cpp
@@ -334,16 +334,16 @@ const uint8 *FontTowns::getCharData(uint16 ch) const {
 		if (f >= 0xe0 && f <= 0xea) kanjiType = EKANJI;
 
 		if ((f > 0xe8 || (f == 0xe8 && base >= 0x9f)) || (f > 0x90 || (f == 0x90 && base >= 0x9f))) {
-			c = 48; //correction
-			p = -8; //correction
+			c = 48; // correction
+			p = -8; // correction
 		}
 
-		if (kanjiType == KANA) {//Kana
+		if (kanjiType == KANA) {
 			chunk_f = (f - 0x81) * 2;
-		} else if (kanjiType == KANJI) {//Standard Kanji
+		} else if (kanjiType == KANJI) { // Standard Kanji
 			p += f - 0x88;
 			chunk_f = c + 2 * p;
-		} else if (kanjiType == EKANJI) {//Enhanced Kanji
+		} else if (kanjiType == EKANJI) { // Enhanced Kanji
 			p += f - 0xe0;
 			chunk_f = c + 2 * p;
 		}
@@ -360,37 +360,37 @@ const uint8 *FontTowns::getCharData(uint16 ch) const {
 
 		switch (base) {
 		case 0x3f:
-			cr = 0; //3f
+			cr = 0; // 3f
 			if (kanjiType == KANA) chunk = 1;
 			else if (kanjiType == KANJI) chunk = 31;
 			else if (kanjiType == EKANJI) chunk = 111;
 			break;
 		case 0x5f:
-			cr = 0; //5f
+			cr = 0; // 5f
 			if (kanjiType == KANA) chunk = 17;
 			else if (kanjiType == KANJI) chunk = 47;
 			else if (kanjiType == EKANJI) chunk = 127;
 			break;
 		case 0x7f:
-			cr = -1; //80
+			cr = -1; // 80
 			if (kanjiType == KANA) chunk = 9;
 			else if (kanjiType == KANJI) chunk = 63;
 			else if (kanjiType == EKANJI) chunk = 143;
 			break;
 		case 0x9f:
-			cr = 1; //9e
+			cr = 1; // 9e
 			if (kanjiType == KANA) chunk = 2;
 			else if (kanjiType == KANJI) chunk = 32;
 			else if (kanjiType == EKANJI) chunk = 112;
 			break;
 		case 0xbf:
-			cr = 1; //be
+			cr = 1; // be
 			if (kanjiType == KANA) chunk = 18;
 			else if (kanjiType == KANJI) chunk = 48;
 			else if (kanjiType == EKANJI) chunk = 128;
 			break;
 		case 0xdf:
-			cr = 1; //de
+			cr = 1; // de
 			if (kanjiType == KANA) chunk = 10;
 			else if (kanjiType == KANJI) chunk = 64;
 			else if (kanjiType == EKANJI) chunk = 144;