SWORD25: Mass-astyle.

svn-id: r53222

1 files changed, 272 insertions, 449 deletions

diff --git a/engines/sword25/gfx/graphicengine_script.cpp b/engines/sword25/gfx/graphicengine_script.cpp
index 74a008d1fc..d009916f32 100644
--- a/engines/sword25/gfx/graphicengine_script.cpp
+++ b/engines/sword25/gfx/graphicengine_script.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-/* 
+/*
  * This code is based on Broken Sword 2.5 engine
  *
  * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
@@ -68,40 +68,35 @@ static bool AnimationDeleteCallback(unsigned int Data);
 static bool AnimationActionCallback(unsigned int Data);
 static bool AnimationLoopPointCallback(unsigned int Data);
 
-namespace
-{
-	// -------------------------------------------------------------------------
+namespace {
+// -------------------------------------------------------------------------
 
-	class ActionCallback : public BS_LuaCallback
-	{
-	public:
-		ActionCallback(lua_State * L) : BS_LuaCallback(L) {};
+class ActionCallback : public BS_LuaCallback {
+public:
+	ActionCallback(lua_State *L) : BS_LuaCallback(L) {};
 
-		Common::String Action;
+	Common::String Action;
 
-	protected:
-		virtual int PreFunctionInvokation(lua_State * L)
-		{
-			lua_pushstring(L, Action.c_str());
-			return 1;
-		}
-	};
+protected:
+	virtual int PreFunctionInvokation(lua_State *L) {
+		lua_pushstring(L, Action.c_str());
+		return 1;
+	}
+};
 
-	std::auto_ptr<BS_LuaCallback> LoopPointCallbackPtr;
-	std::auto_ptr<ActionCallback> ActionCallbackPtr;
+std::auto_ptr<BS_LuaCallback> LoopPointCallbackPtr;
+std::auto_ptr<ActionCallback> ActionCallbackPtr;
 
-	// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 
-	struct CallbackfunctionRegisterer
-	{
-		CallbackfunctionRegisterer()
-		{
-			BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaLoopPointCB", (void (*)(int))AnimationLoopPointCallback);
-			BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaActionCB", (void (*)(int))AnimationActionCallback);
-			BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaDeleteCB", (void (*)(int))AnimationDeleteCallback);
-		}
-	};
-	static CallbackfunctionRegisterer Instance;
+struct CallbackfunctionRegisterer {
+	CallbackfunctionRegisterer() {
+		BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaLoopPointCB", (void ( *)(int))AnimationLoopPointCallback);
+		BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaActionCB", (void ( *)(int))AnimationActionCallback);
+		BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaDeleteCB", (void ( *)(int))AnimationDeleteCallback);
+	}
+};
+static CallbackfunctionRegisterer Instance;
 }
 
 // -----------------------------------------------------------------------------
@@ -115,24 +110,20 @@ namespace
 #define TEXT_CLASS_NAME "Gfx.Text"
 #define ANIMATION_CLASS_NAME "Gfx.Animation"
 #define ANIMATION_TEMPLATE_CLASS_NAME "Gfx.AnimationTemplate"
-static const char * GFX_LIBRARY_NAME = "Gfx";
+static const char *GFX_LIBRARY_NAME = "Gfx";
 
 // -----------------------------------------------------------------------------
 
 // Wie luaL_checkudata, nur ohne dass kein Fehler erzeugt wird.
-static void * my_checkudata (lua_State *L, int ud, const char *tname)
-{
+static void *my_checkudata(lua_State *L, int ud, const char *tname) {
 	int top = lua_gettop(L);
 
-	void * p = lua_touserdata(L, ud);
-	if (p != NULL) /* value is a userdata? */
-	{
-		if (lua_getmetatable(L, ud)) /* does it have a metatable? */
-		{  
+	void *p = lua_touserdata(L, ud);
+	if (p != NULL) { /* value is a userdata? */
+		if (lua_getmetatable(L, ud)) { /* does it have a metatable? */
 			// lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
 			BS_LuaBindhelper::GetMetatable(L, tname);
-			if (lua_rawequal(L, -1, -2)) /* does it have the correct mt? */
-			{
+			if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */
 				lua_settop(L, top);
 				return p;
 			}
@@ -145,27 +136,22 @@ static void * my_checkudata (lua_State *L, int ud, const char *tname)
 
 // -----------------------------------------------------------------------------
 
-static void NewUintUserData(lua_State * L, unsigned int Value)
-{
-	void * UserData = lua_newuserdata(L, sizeof(Value));
+static void NewUintUserData(lua_State *L, unsigned int Value) {
+	void *UserData = lua_newuserdata(L, sizeof(Value));
 	memcpy(UserData, &Value, sizeof(Value));
 }
 
 // -----------------------------------------------------------------------------
 
-static BS_AnimationTemplate * CheckAnimationTemplate(lua_State * L, int idx = 1)
-{
+static BS_AnimationTemplate *CheckAnimationTemplate(lua_State *L, int idx = 1) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.AnimationTemplate
 	unsigned int AnimationTemplateHandle;
-	if ((AnimationTemplateHandle = *reinterpret_cast<unsigned int *>(my_checkudata(L, idx, ANIMATION_TEMPLATE_CLASS_NAME))) != 0)
-	{
-		BS_AnimationTemplate * AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
+	if ((AnimationTemplateHandle = *reinterpret_cast<unsigned int *>(my_checkudata(L, idx, ANIMATION_TEMPLATE_CLASS_NAME))) != 0) {
+		BS_AnimationTemplate *AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
 		if (!AnimationTemplatePtr)
 			luaL_error(L, "The animation template with the handle %d does no longer exist.", AnimationTemplateHandle);
 		return AnimationTemplatePtr;
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, idx, "'" ANIMATION_TEMPLATE_CLASS_NAME "' expected");
 		return 0;
 	}
@@ -174,20 +160,16 @@ static BS_AnimationTemplate * CheckAnimationTemplate(lua_State * L, int idx = 1)
 
 // -----------------------------------------------------------------------------
 
-static int NewAnimationTemplate(lua_State * L)
-{
+static int NewAnimationTemplate(lua_State *L) {
 	unsigned int AnimationTemplateHandle = BS_AnimationTemplate::Create(luaL_checkstring(L, 1));
-	BS_AnimationTemplate * AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
-	if (AnimationTemplatePtr && AnimationTemplatePtr->IsValid())
-	{
+	BS_AnimationTemplate *AnimationTemplatePtr = BS_AnimationTemplateRegistry::GetInstance().ResolveHandle(AnimationTemplateHandle);
+	if (AnimationTemplatePtr && AnimationTemplatePtr->IsValid()) {
 		NewUintUserData(L, AnimationTemplateHandle);
 		//luaL_getmetatable(L, ANIMATION_TEMPLATE_CLASS_NAME);
 		BS_LuaBindhelper::GetMetatable(L, ANIMATION_TEMPLATE_CLASS_NAME);
 		BS_ASSERT(!lua_isnil(L, -1));
 		lua_setmetatable(L, -2);
-	}
-	else
-	{
+	} else {
 		lua_pushnil(L);
 	}
 
@@ -196,85 +178,69 @@ static int NewAnimationTemplate(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int AT_AddFrame(lua_State * L)
-{
-	BS_AnimationTemplate * pAT = CheckAnimationTemplate(L);
+static int AT_AddFrame(lua_State *L) {
+	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	pAT->AddFrame(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int AT_SetFrame(lua_State * L)
-{
-	BS_AnimationTemplate * pAT = CheckAnimationTemplate(L);
+static int AT_SetFrame(lua_State *L) {
+	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	pAT->SetFrame(static_cast<int>(luaL_checknumber(L, 2)), static_cast<int>(luaL_checknumber(L, 3)));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static bool AnimationTypeStringToNumber(const char * TypeString, BS_Animation::ANIMATION_TYPES & Result)
-{
-	if (strcmp(TypeString, "jojo") == 0)
-	{
+static bool AnimationTypeStringToNumber(const char *TypeString, BS_Animation::ANIMATION_TYPES &Result) {
+	if (strcmp(TypeString, "jojo") == 0) {
 		Result = BS_Animation::AT_JOJO;
 		return true;
-	}
-	else if (strcmp(TypeString, "loop") == 0)
-	{
+	} else if (strcmp(TypeString, "loop") == 0) {
 		Result = BS_Animation::AT_LOOP;
 		return true;
-	}
-	else if (strcmp(TypeString, "oneshot") == 0)
-	{
+	} else if (strcmp(TypeString, "oneshot") == 0) {
 		Result = BS_Animation::AT_ONESHOT;
 		return true;
-	}
-	else
+	} else
 		return false;
 }
 
 // -----------------------------------------------------------------------------
 
-static int AT_SetAnimationType(lua_State * L)
-{
-	BS_AnimationTemplate * pAT = CheckAnimationTemplate(L);
+static int AT_SetAnimationType(lua_State *L) {
+	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	BS_Animation::ANIMATION_TYPES AnimationType;
-	if (AnimationTypeStringToNumber(luaL_checkstring(L, 2), AnimationType))
-	{
+	if (AnimationTypeStringToNumber(luaL_checkstring(L, 2), AnimationType)) {
 		pAT->SetAnimationType(AnimationType);
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 2, "Invalid animation type");
 	}
-	
+
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int AT_SetFPS(lua_State * L)
-{
-	BS_AnimationTemplate * pAT = CheckAnimationTemplate(L);
+static int AT_SetFPS(lua_State *L) {
+	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	pAT->SetFPS(static_cast<int>(luaL_checknumber(L, 2)));
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int AT_Finalize(lua_State * L)
-{
-	BS_AnimationTemplate * pAT = CheckAnimationTemplate(L);
+static int AT_Finalize(lua_State *L) {
+	BS_AnimationTemplate *pAT = CheckAnimationTemplate(L);
 	delete pAT;
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg ANIMATION_TEMPLATE_METHODS[] =
-{
+static const luaL_reg ANIMATION_TEMPLATE_METHODS[] = {
 	{"AddFrame", AT_AddFrame},
 	{"SetFrame", AT_SetFrame},
 	{"SetAnimationType", AT_SetAnimationType},
@@ -285,47 +251,44 @@ static const luaL_reg ANIMATION_TEMPLATE_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_GraphicEngine * GetGE()
-{
-	BS_Kernel * pKernel = BS_Kernel::GetInstance();
+static BS_GraphicEngine *GetGE() {
+	BS_Kernel *pKernel = BS_Kernel::GetInstance();
 	BS_ASSERT(pKernel);
-	BS_GraphicEngine * pGE = static_cast<BS_GraphicEngine *>(pKernel->GetService("gfx"));
+	BS_GraphicEngine *pGE = static_cast<BS_GraphicEngine *>(pKernel->GetService("gfx"));
 	BS_ASSERT(pGE);
 	return pGE;
 }
 
 // -----------------------------------------------------------------------------
 
-static int Init(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
-
-	switch (lua_gettop(L))
-	{
-		case 0:
-			lua_pushbooleancpp(L, pGE->Init());
-			break;
-		case 1:
-			lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L, 1))));
-			break;
-		case 2:
-			lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L,1)), static_cast<int>(luaL_checknumber(L, 2))));
-			break;
-		case 3:
-			lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L,1)), static_cast<int>(luaL_checknumber(L, 2)),
-											static_cast<int>(luaL_checknumber(L, 3))));
-			break;
-		case 4:
-			lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L,1)), static_cast<int>(luaL_checknumber(L, 2)),
-											static_cast<int>(luaL_checknumber(L, 3)), static_cast<int>(luaL_checknumber(L, 4))));
-			break;
-		default:
-			lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L,1)), static_cast<int>(luaL_checknumber(L, 2)),
-											static_cast<int>(luaL_checknumber(L, 3)), static_cast<int>(luaL_checknumber(L, 4)),
-											lua_tobooleancpp(L, 5)));
+static int Init(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
+
+	switch (lua_gettop(L)) {
+	case 0:
+		lua_pushbooleancpp(L, pGE->Init());
+		break;
+	case 1:
+		lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L, 1))));
+		break;
+	case 2:
+		lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L, 1)), static_cast<int>(luaL_checknumber(L, 2))));
+		break;
+	case 3:
+		lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L, 1)), static_cast<int>(luaL_checknumber(L, 2)),
+		                                static_cast<int>(luaL_checknumber(L, 3))));
+		break;
+	case 4:
+		lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L, 1)), static_cast<int>(luaL_checknumber(L, 2)),
+		                                static_cast<int>(luaL_checknumber(L, 3)), static_cast<int>(luaL_checknumber(L, 4))));
+		break;
+	default:
+		lua_pushbooleancpp(L, pGE->Init(static_cast<int>(luaL_checknumber(L, 1)), static_cast<int>(luaL_checknumber(L, 2)),
+		                                static_cast<int>(luaL_checknumber(L, 3)), static_cast<int>(luaL_checknumber(L, 4)),
+		                                lua_tobooleancpp(L, 5)));
 	}
 
-	
+
 #ifdef DEBUG
 	int __startStackDepth = lua_gettop(L);
 #endif
@@ -345,7 +308,7 @@ static int Init(lua_State * L)
 	BS_ASSERT(!lua_isnil(L, -1));
 	lua_setmetatable(L, -2);
 
-	lua_pushstring(L, "MainPanel");	
+	lua_pushstring(L, "MainPanel");
 	lua_insert(L, -2);
 	lua_settable(L, -3);
 
@@ -360,9 +323,8 @@ static int Init(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int StartFrame(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int StartFrame(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	if (lua_gettop(L) == 0)
 		lua_pushbooleancpp(L, pGE->StartFrame());
@@ -374,9 +336,8 @@ static int StartFrame(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int EndFrame(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int EndFrame(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushbooleancpp(L, pGE->EndFrame());
 
@@ -385,9 +346,8 @@ static int EndFrame(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int DrawDebugLine(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int DrawDebugLine(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	BS_Vertex Start;
 	BS_Vertex End;
@@ -400,9 +360,8 @@ static int DrawDebugLine(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int GetDisplayWidth(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetDisplayWidth(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetDisplayWidth());
 
@@ -411,9 +370,8 @@ static int GetDisplayWidth(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int GetDisplayHeight(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetDisplayHeight(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetDisplayHeight());
 
@@ -422,9 +380,8 @@ static int GetDisplayHeight(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int GetBitDepth(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetBitDepth(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetBitDepth());
 
@@ -433,9 +390,8 @@ static int GetBitDepth(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int SetVsync(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int SetVsync(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	pGE->SetVsync(lua_tobooleancpp(L, 1));
 
@@ -444,9 +400,8 @@ static int SetVsync(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int IsVsync(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int IsVsync(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushbooleancpp(L, pGE->GetVsync());
 
@@ -455,9 +410,8 @@ static int IsVsync(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int IsWindowed(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int IsWindowed(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushbooleancpp(L, pGE->IsWindowed());
 
@@ -466,9 +420,8 @@ static int IsWindowed(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int GetFPSCount(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetFPSCount(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetFPSCount());
 
@@ -477,9 +430,8 @@ static int GetFPSCount(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int GetLastFrameDuration(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetLastFrameDuration(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetLastFrameDuration());
 
@@ -488,27 +440,24 @@ static int GetLastFrameDuration(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int StopMainTimer(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int StopMainTimer(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 	pGE->StopMainTimer();
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int ResumeMainTimer(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int ResumeMainTimer(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 	pGE->ResumeMainTimer();
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int GetSecondaryFrameDuration(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetSecondaryFrameDuration(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 
 	lua_pushnumber(L, pGE->GetSecondaryFrameDuration());
 
@@ -517,35 +466,31 @@ static int GetSecondaryFrameDuration(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int SaveScreenshot(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int SaveScreenshot(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 	lua_pushbooleancpp(L, pGE->SaveScreenshot(luaL_checkstring(L, 1)));
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int SaveThumbnailScreenshot(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int SaveThumbnailScreenshot(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 	lua_pushbooleancpp(L, pGE->SaveThumbnailScreenshot(luaL_checkstring(L, 1)));
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int GetRepaintedPixels(lua_State * L)
-{
-	BS_GraphicEngine * pGE = GetGE();
+static int GetRepaintedPixels(lua_State *L) {
+	BS_GraphicEngine *pGE = GetGE();
 	lua_pushnumber(L, static_cast<lua_Number>(pGE->GetRepaintedPixels()));
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg GFX_FUNCTIONS[] =
-{
+static const luaL_reg GFX_FUNCTIONS[] = {
 	{"Init", Init},
 	{"StartFrame", StartFrame},
 	{"EndFrame", EndFrame},
@@ -570,26 +515,21 @@ static const luaL_reg GFX_FUNCTIONS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State * L, bool ErrorIfRemoved = true)
-{
+static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State *L, bool ErrorIfRemoved = true) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable einer Klasse haben, die von Gfx.RenderObject "erbt".
-	unsigned int * UserDataPtr;
+	unsigned int *UserDataPtr;
 	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0 ||
-		(UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0 ||
-		(UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0 ||
-		(UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0)
-	{
+	        (UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0 ||
+	        (UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0 ||
+	        (UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0) {
 		BS_RenderObjectPtr<BS_RenderObject> ROPtr(* UserDataPtr);
 		if (ROPtr.IsValid())
 			return ROPtr;
-		else
-		{
+		else {
 			if (ErrorIfRemoved)
 				luaL_error(L, "The renderobject with the handle %d does no longer exist.", * UserDataPtr);
 		}
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" RENDEROBJECT_CLASS_NAME "' expected");
 	}
 
@@ -598,8 +538,7 @@ static BS_RenderObjectPtr<BS_RenderObject> CheckRenderObject(lua_State * L, bool
 
 // -----------------------------------------------------------------------------
 
-static int RO_SetPos(lua_State * L)
-{
+static int RO_SetPos(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	BS_Vertex Pos;
@@ -610,8 +549,7 @@ static int RO_SetPos(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_SetX(lua_State * L)
-{
+static int RO_SetX(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetX(static_cast<int>(luaL_checknumber(L, 2)));
@@ -620,8 +558,7 @@ static int RO_SetX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_SetY(lua_State * L)
-{
+static int RO_SetY(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetY(static_cast<int>(luaL_checknumber(L, 2)));
@@ -630,8 +567,7 @@ static int RO_SetY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_SetZ(lua_State * L)
-{
+static int RO_SetZ(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetZ(static_cast<int>(luaL_checknumber(L, 2)));
@@ -640,8 +576,7 @@ static int RO_SetZ(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_SetVisible(lua_State * L)
-{
+static int RO_SetVisible(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr->SetVisible(lua_tobooleancpp(L, 2));
@@ -650,8 +585,7 @@ static int RO_SetVisible(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetX(lua_State * L)
-{
+static int RO_GetX(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetX());
@@ -661,8 +595,7 @@ static int RO_GetX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetY(lua_State * L)
-{
+static int RO_GetY(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetY());
@@ -672,8 +605,7 @@ static int RO_GetY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetZ(lua_State * L)
-{
+static int RO_GetZ(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetZ());
@@ -683,8 +615,7 @@ static int RO_GetZ(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetAbsoluteX(lua_State * L)
-{
+static int RO_GetAbsoluteX(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetAbsoluteX());
@@ -694,66 +625,59 @@ static int RO_GetAbsoluteX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetAbsoluteY(lua_State * L)
-{
+static int RO_GetAbsoluteY(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetAbsoluteY());
-	
+
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetWidth(lua_State * L)
-{
+static int RO_GetWidth(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetWidth());
-	
+
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int RO_GetHeight(lua_State * L)
-{
+static int RO_GetHeight(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushnumber(L, ROPtr->GetHeight());
-	
+
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int RO_IsVisible(lua_State * L)
-{
+static int RO_IsVisible(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	lua_pushbooleancpp(L, ROPtr->IsVisible());
-	
+
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int RO_AddPanel(lua_State * L)
-{
+static int RO_AddPanel(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	BS_RenderObjectPtr<BS_Panel> PanelPtr = ROPtr->AddPanel(static_cast<int>(luaL_checknumber(L, 2)),
-															static_cast<int>(luaL_checknumber(L, 3)),
-															BS_GraphicEngine::LuaColorToARGBColor(L, 4));
-	if (PanelPtr.IsValid())
-	{
+	                                        static_cast<int>(luaL_checknumber(L, 3)),
+	                                        BS_GraphicEngine::LuaColorToARGBColor(L, 4));
+	if (PanelPtr.IsValid()) {
 		NewUintUserData(L, PanelPtr->GetHandle());
 		// luaL_getmetatable(L, PANEL_CLASS_NAME);
 		BS_LuaBindhelper::GetMetatable(L, PANEL_CLASS_NAME);
 		BS_ASSERT(!lua_isnil(L, -1));
 		lua_setmetatable(L, -2);
-	}
-	else
+	} else
 		lua_pushnil(L);
 
 	return 1;
@@ -761,20 +685,17 @@ static int RO_AddPanel(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_AddBitmap(lua_State * L)
-{
+static int RO_AddBitmap(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	BS_RenderObjectPtr<BS_Bitmap> BitmaPtr = ROPtr->AddBitmap(luaL_checkstring(L, 2));
-	if (BitmaPtr.IsValid())
-	{
+	if (BitmaPtr.IsValid()) {
 		NewUintUserData(L, BitmaPtr->GetHandle());
 		// luaL_getmetatable(L, BITMAP_CLASS_NAME);
 		BS_LuaBindhelper::GetMetatable(L, BITMAP_CLASS_NAME);
 		BS_ASSERT(!lua_isnil(L, -1));
 		lua_setmetatable(L, -2);
-	}
-	else
+	} else
 		lua_pushnil(L);
 
 	return 1;
@@ -782,8 +703,7 @@ static int RO_AddBitmap(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_AddText(lua_State * L)
-{
+static int RO_AddText(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 
@@ -791,15 +711,13 @@ static int RO_AddText(lua_State * L)
 	if (lua_gettop(L) >= 3) TextPtr = ROPtr->AddText(luaL_checkstring(L, 2), luaL_checkstring(L, 3));
 	else TextPtr = ROPtr->AddText(luaL_checkstring(L, 2));
 
-	if (TextPtr.IsValid())
-	{
+	if (TextPtr.IsValid()) {
 		NewUintUserData(L, TextPtr->GetHandle());
 		// luaL_getmetatable(L, TEXT_CLASS_NAME);
 		BS_LuaBindhelper::GetMetatable(L, TEXT_CLASS_NAME);
 		BS_ASSERT(!lua_isnil(L, -1));
 		lua_setmetatable(L, -2);
-	}
-	else
+	} else
 		lua_pushnil(L);
 
 	return 1;
@@ -807,8 +725,7 @@ static int RO_AddText(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_AddAnimation(lua_State * L)
-{
+static int RO_AddAnimation(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 
@@ -818,8 +735,7 @@ static int RO_AddAnimation(lua_State * L)
 	else
 		AnimationPtr = ROPtr->AddAnimation(luaL_checkstring(L, 2));
 
-	if (AnimationPtr.IsValid())
-	{
+	if (AnimationPtr.IsValid()) {
 		NewUintUserData(L, AnimationPtr->GetHandle());
 		// luaL_getmetatable(L, ANIMATION_CLASS_NAME);
 		BS_LuaBindhelper::GetMetatable(L, ANIMATION_CLASS_NAME);
@@ -830,8 +746,7 @@ static int RO_AddAnimation(lua_State * L)
 		AnimationPtr->RegisterDeleteCallback(AnimationDeleteCallback, AnimationPtr->GetHandle());
 		AnimationPtr->RegisterLoopPointCallback(AnimationLoopPointCallback, AnimationPtr->GetHandle());
 		AnimationPtr->RegisterActionCallback(AnimationActionCallback, AnimationPtr->GetHandle());
-	}
-	else
+	} else
 		lua_pushnil(L);
 
 	return 1;
@@ -839,8 +754,7 @@ static int RO_AddAnimation(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int RO_Remove(lua_State * L)
-{
+static int RO_Remove(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	ROPtr.Erase();
 	return 0;
@@ -848,8 +762,7 @@ static int RO_Remove(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg RENDEROBJECT_METHODS[] =
-{
+static const luaL_reg RENDEROBJECT_METHODS[] = {
 	{"AddAnimation", RO_AddAnimation},
 	{"AddText", RO_AddText},
 	{"AddBitmap", RO_AddBitmap},
@@ -872,22 +785,16 @@ static const luaL_reg RENDEROBJECT_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State * L)
-{
+static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Panel
-	unsigned int * UserDataPtr;
-	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0)
-	{
+	unsigned int *UserDataPtr;
+	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, PANEL_CLASS_NAME)) != 0) {
 		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
-		if (ROPtr.IsValid())
-		{
+		if (ROPtr.IsValid()) {
 			return ROPtr->ToPanel();
-		}
-		else
+		} else
 			luaL_error(L, "The panel with the handle %d does no longer exist.", *UserDataPtr);
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" PANEL_CLASS_NAME "' expected");
 	}
 
@@ -896,19 +803,17 @@ static BS_RenderObjectPtr<BS_Panel> CheckPanel(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int P_GetColor(lua_State * L)
-{
+static int P_GetColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Panel> PanelPtr = CheckPanel(L);
 	BS_ASSERT(PanelPtr.IsValid());
 	BS_GraphicEngine::ARGBColorToLuaColor(L, PanelPtr->GetColor());
-	
+
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int P_SetColor(lua_State * L)
-{
+static int P_SetColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Panel> PanelPtr = CheckPanel(L);
 	BS_ASSERT(PanelPtr.IsValid());
 	PanelPtr->SetColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
@@ -917,8 +822,7 @@ static int P_SetColor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int P_Remove(lua_State * L)
-{
+static int P_Remove(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr.Erase();
@@ -927,8 +831,7 @@ static int P_Remove(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg PANEL_METHODS[] =
-{
+static const luaL_reg PANEL_METHODS[] = {
 	{"GetColor", P_GetColor},
 	{"SetColor", P_SetColor},
 	{"Remove", P_Remove},
@@ -937,22 +840,16 @@ static const luaL_reg PANEL_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State * L)
-{
+static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Bitmap
-	unsigned int * UserDataPtr;
-	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0)
-	{
+	unsigned int *UserDataPtr;
+	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, BITMAP_CLASS_NAME)) != 0) {
 		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
-		if (ROPtr.IsValid())
-		{
+		if (ROPtr.IsValid()) {
 			return ROPtr->ToBitmap();
-		}
-		else
+		} else
 			luaL_error(L, "The bitmap with the handle %d does no longer exist.", *UserDataPtr);
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" BITMAP_CLASS_NAME "' expected");
 	}
 
@@ -961,8 +858,7 @@ static BS_RenderObjectPtr<BS_Bitmap> CheckBitmap(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetAlpha(lua_State * L)
-{
+static int B_SetAlpha(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetAlpha(static_cast<unsigned int>(luaL_checknumber(L, 2)));
@@ -971,8 +867,7 @@ static int B_SetAlpha(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetTintColor(lua_State * L)
-{
+static int B_SetTintColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetModulationColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
@@ -981,8 +876,7 @@ static int B_SetTintColor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetScaleFactor(lua_State * L)
-{
+static int B_SetScaleFactor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 2)));
@@ -991,8 +885,7 @@ static int B_SetScaleFactor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetScaleFactorX(lua_State * L)
-{
+static int B_SetScaleFactorX(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetScaleFactorX(static_cast<float>(luaL_checknumber(L, 2)));
@@ -1001,8 +894,7 @@ static int B_SetScaleFactorX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetScaleFactorY(lua_State * L)
-{
+static int B_SetScaleFactorY(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetScaleFactorY(static_cast<float>(luaL_checknumber(L, 2)));
@@ -1011,8 +903,7 @@ static int B_SetScaleFactorY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetFlipH(lua_State * L)
-{
+static int B_SetFlipH(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetFlipH(lua_tobooleancpp(L, 2));
@@ -1021,8 +912,7 @@ static int B_SetFlipH(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_SetFlipV(lua_State * L)
-{
+static int B_SetFlipV(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BitmapPtr->SetFlipV(lua_tobooleancpp(L, 2));
@@ -1031,8 +921,7 @@ static int B_SetFlipV(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_GetAlpha(lua_State * L)
-{
+static int B_GetAlpha(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushnumber(L, BitmapPtr->GetAlpha());
@@ -1041,8 +930,7 @@ static int B_GetAlpha(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_GetTintColor(lua_State * L)
-{
+static int B_GetTintColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BS_GraphicEngine::ARGBColorToLuaColor(L, BitmapPtr->GetModulationColor());
@@ -1051,8 +939,7 @@ static int B_GetTintColor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_GetScaleFactorX(lua_State * L)
-{
+static int B_GetScaleFactorX(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushnumber(L, BitmapPtr->GetScaleFactorX());
@@ -1061,8 +948,7 @@ static int B_GetScaleFactorX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_GetScaleFactorY(lua_State * L)
-{
+static int B_GetScaleFactorY(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushnumber(L, BitmapPtr->GetScaleFactorY());
@@ -1071,8 +957,7 @@ static int B_GetScaleFactorY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_IsFlipH(lua_State * L)
-{
+static int B_IsFlipH(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsFlipH());
@@ -1081,8 +966,7 @@ static int B_IsFlipH(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_IsFlipV(lua_State * L)
-{
+static int B_IsFlipV(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsFlipV());
@@ -1091,8 +975,7 @@ static int B_IsFlipV(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_GetPixel(lua_State * L)
-{
+static int B_GetPixel(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	BS_Vertex Pos;
@@ -1103,8 +986,7 @@ static int B_GetPixel(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_IsScalingAllowed(lua_State * L)
-{
+static int B_IsScalingAllowed(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsScalingAllowed());
@@ -1113,8 +995,7 @@ static int B_IsScalingAllowed(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_IsAlphaAllowed(lua_State * L)
-{
+static int B_IsAlphaAllowed(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsAlphaAllowed());
@@ -1123,8 +1004,7 @@ static int B_IsAlphaAllowed(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int B_IsTintingAllowed(lua_State * L)
-{
+static int B_IsTintingAllowed(lua_State *L) {
 	BS_RenderObjectPtr<BS_Bitmap> BitmapPtr = CheckBitmap(L);
 	BS_ASSERT(BitmapPtr.IsValid());
 	lua_pushbooleancpp(L, BitmapPtr->IsColorModulationAllowed());
@@ -1132,8 +1012,7 @@ static int B_IsTintingAllowed(lua_State * L)
 }
 // -----------------------------------------------------------------------------
 
-static int B_Remove(lua_State * L)
-{
+static int B_Remove(lua_State *L) {
 	BS_RenderObjectPtr<BS_RenderObject> ROPtr = CheckRenderObject(L);
 	BS_ASSERT(ROPtr.IsValid());
 	ROPtr.Erase();
@@ -1142,8 +1021,7 @@ static int B_Remove(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg BITMAP_METHODS[] =
-{
+static const luaL_reg BITMAP_METHODS[] = {
 	{"SetAlpha", B_SetAlpha},
 	{"SetTintColor", B_SetTintColor},
 	{"SetScaleFactor", B_SetScaleFactor},
@@ -1167,22 +1045,17 @@ static const luaL_reg BITMAP_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State * L)
-{
+static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Animation
-	unsigned int * UserDataPtr;
-	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0)
-	{
+	unsigned int *UserDataPtr;
+	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, ANIMATION_CLASS_NAME)) != 0) {
 		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
 		if (ROPtr.IsValid())
 			return ROPtr->ToAnimation();
-		else
-		{
+		else {
 			luaL_error(L, "The animation with the handle %d does no longer exist.", *UserDataPtr);
 		}
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" ANIMATION_CLASS_NAME "' expected");
 	}
 
@@ -1191,8 +1064,7 @@ static BS_RenderObjectPtr<BS_Animation> CheckAnimation(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_Play(lua_State * L)
-{
+static int A_Play(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->Play();
@@ -1201,8 +1073,7 @@ static int A_Play(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_Pause(lua_State * L)
-{
+static int A_Pause(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->Pause();
@@ -1211,8 +1082,7 @@ static int A_Pause(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_Stop(lua_State * L)
-{
+static int A_Stop(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->Stop();
@@ -1221,8 +1091,7 @@ static int A_Stop(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_SetFrame(lua_State * L)
-{
+static int A_SetFrame(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetFrame(static_cast<unsigned int>(luaL_checknumber(L, 2)));
@@ -1231,8 +1100,7 @@ static int A_SetFrame(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_SetAlpha(lua_State * L)
-{
+static int A_SetAlpha(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetAlpha(static_cast<int>(luaL_checknumber(L, 2)));
@@ -1240,8 +1108,7 @@ static int A_SetAlpha(lua_State * L)
 }
 // -----------------------------------------------------------------------------
 
-static int A_SetTintColor(lua_State * L)
-{
+static int A_SetTintColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetModulationColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
@@ -1250,8 +1117,7 @@ static int A_SetTintColor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_SetScaleFactor(lua_State * L)
-{
+static int A_SetScaleFactor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetScaleFactor(static_cast<float>(luaL_checknumber(L, 2)));
@@ -1260,8 +1126,7 @@ static int A_SetScaleFactor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_SetScaleFactorX(lua_State * L)
-{
+static int A_SetScaleFactorX(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetScaleFactorX(static_cast<float>(luaL_checknumber(L, 2)));
@@ -1270,8 +1135,7 @@ static int A_SetScaleFactorX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_SetScaleFactorY(lua_State * L)
-{
+static int A_SetScaleFactorY(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr->SetScaleFactorY(static_cast<float>(luaL_checknumber(L, 2)));
@@ -1280,8 +1144,7 @@ static int A_SetScaleFactorY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_GetScaleFactorX(lua_State * L)
-{
+static int A_GetScaleFactorX(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetScaleFactorX());
@@ -1290,8 +1153,7 @@ static int A_GetScaleFactorX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_GetScaleFactorY(lua_State * L)
-{
+static int A_GetScaleFactorY(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetScaleFactorY());
@@ -1300,31 +1162,28 @@ static int A_GetScaleFactorY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_GetAnimationType(lua_State * L)
-{
+static int A_GetAnimationType(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
-	switch (AnimationPtr->GetAnimationType())
-	{
-		case BS_Animation::AT_JOJO:
-			lua_pushstring(L, "jojo");
-			break;
-		case BS_Animation::AT_LOOP:
-			lua_pushstring(L, "loop");
-			break;
-		case BS_Animation::AT_ONESHOT:
-			lua_pushstring(L, "oneshot");
-			break;
-		default:
-			BS_ASSERT(false);
+	switch (AnimationPtr->GetAnimationType()) {
+	case BS_Animation::AT_JOJO:
+		lua_pushstring(L, "jojo");
+		break;
+	case BS_Animation::AT_LOOP:
+		lua_pushstring(L, "loop");
+		break;
+	case BS_Animation::AT_ONESHOT:
+		lua_pushstring(L, "oneshot");
+		break;
+	default:
+		BS_ASSERT(false);
 	}
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int A_GetFPS(lua_State * L)
-{
+static int A_GetFPS(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetFPS());
@@ -1334,8 +1193,7 @@ static int A_GetFPS(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_GetFrameCount(lua_State * L)
-{
+static int A_GetFrameCount(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetFrameCount());
@@ -1344,8 +1202,7 @@ static int A_GetFrameCount(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_IsScalingAllowed(lua_State * L)
-{
+static int A_IsScalingAllowed(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsScalingAllowed());
@@ -1354,8 +1211,7 @@ static int A_IsScalingAllowed(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_IsAlphaAllowed(lua_State * L)
-{
+static int A_IsAlphaAllowed(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsAlphaAllowed());
@@ -1364,8 +1220,7 @@ static int A_IsAlphaAllowed(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_IsTintingAllowed(lua_State * L)
-{
+static int A_IsTintingAllowed(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsColorModulationAllowed());
@@ -1374,8 +1229,7 @@ static int A_IsTintingAllowed(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_GetCurrentFrame(lua_State * L)
-{
+static int A_GetCurrentFrame(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushnumber(L, AnimationPtr->GetCurrentFrame());
@@ -1384,8 +1238,7 @@ static int A_GetCurrentFrame(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_GetCurrentAction(lua_State * L)
-{
+static int A_GetCurrentAction(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushstring(L, AnimationPtr->GetCurrentAction().c_str());
@@ -1394,8 +1247,7 @@ static int A_GetCurrentAction(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_IsPlaying(lua_State * L)
-{
+static int A_IsPlaying(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	lua_pushbooleancpp(L, AnimationPtr->IsRunning());
@@ -1404,9 +1256,8 @@ static int A_IsPlaying(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static bool AnimationLoopPointCallback(unsigned int Handle)
-{
-	lua_State * L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
+static bool AnimationLoopPointCallback(unsigned int Handle) {
+	lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
 	LoopPointCallbackPtr->InvokeCallbackFunctions(L, Handle);
 
 	return true;
@@ -1414,8 +1265,7 @@ static bool AnimationLoopPointCallback(unsigned int Handle)
 
 // -----------------------------------------------------------------------------
 
-static int A_RegisterLoopPointCallback(lua_State * L)
-{
+static int A_RegisterLoopPointCallback(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
@@ -1428,8 +1278,7 @@ static int A_RegisterLoopPointCallback(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_UnregisterLoopPointCallback(lua_State * L)
-{
+static int A_UnregisterLoopPointCallback(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
@@ -1442,13 +1291,11 @@ static int A_UnregisterLoopPointCallback(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static bool AnimationActionCallback(unsigned int Handle)
-{
+static bool AnimationActionCallback(unsigned int Handle) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr(Handle);
-	if (AnimationPtr.IsValid())
-	{
+	if (AnimationPtr.IsValid()) {
 		ActionCallbackPtr->Action = AnimationPtr->GetCurrentAction();
-		lua_State * L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
+		lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
 		ActionCallbackPtr->InvokeCallbackFunctions(L, AnimationPtr->GetHandle());
 	}
 
@@ -1457,8 +1304,7 @@ static bool AnimationActionCallback(unsigned int Handle)
 
 // -----------------------------------------------------------------------------
 
-static int A_RegisterActionCallback(lua_State * L)
-{
+static int A_RegisterActionCallback(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
@@ -1471,8 +1317,7 @@ static int A_RegisterActionCallback(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int A_UnregisterActionCallback(lua_State * L)
-{
+static int A_UnregisterActionCallback(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	luaL_checktype(L, 2, LUA_TFUNCTION);
@@ -1485,9 +1330,8 @@ static int A_UnregisterActionCallback(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static bool AnimationDeleteCallback(unsigned int Handle)
-{
-	lua_State * L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
+static bool AnimationDeleteCallback(unsigned int Handle) {
+	lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
 	LoopPointCallbackPtr->RemoveAllObjectCallbacks(L, Handle);
 
 	return true;
@@ -1495,8 +1339,7 @@ static bool AnimationDeleteCallback(unsigned int Handle)
 
 // -----------------------------------------------------------------------------
 
-static int A_Remove(lua_State * L)
-{
+static int A_Remove(lua_State *L) {
 	BS_RenderObjectPtr<BS_Animation> AnimationPtr = CheckAnimation(L);
 	BS_ASSERT(AnimationPtr.IsValid());
 	AnimationPtr.Erase();
@@ -1505,8 +1348,7 @@ static int A_Remove(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg ANIMATION_METHODS[] =
-{
+static const luaL_reg ANIMATION_METHODS[] = {
 	{"Play", A_Play},
 	{"Pause", A_Pause},
 	{"Stop", A_Stop},
@@ -1537,20 +1379,16 @@ static const luaL_reg ANIMATION_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_RenderObjectPtr<BS_Text> CheckText(lua_State * L)
-{
+static BS_RenderObjectPtr<BS_Text> CheckText(lua_State *L) {
 	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Gfx.Text
-	unsigned int * UserDataPtr;
-	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0)
-	{
+	unsigned int *UserDataPtr;
+	if ((UserDataPtr = (unsigned int *) my_checkudata(L, 1, TEXT_CLASS_NAME)) != 0) {
 		BS_RenderObjectPtr<BS_RenderObject> ROPtr(*UserDataPtr);
 		if (ROPtr.IsValid())
 			return ROPtr->ToText();
 		else
 			luaL_error(L, "The text with the handle %d does no longer exist.", *UserDataPtr);
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" TEXT_CLASS_NAME "' expected");
 	}
 
@@ -1559,8 +1397,7 @@ static BS_RenderObjectPtr<BS_Text> CheckText(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_SetFont(lua_State * L)
-{
+static int T_SetFont(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetFont(luaL_checkstring(L, 2));
@@ -1569,8 +1406,7 @@ static int T_SetFont(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_SetText(lua_State * L)
-{
+static int T_SetText(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetText(luaL_checkstring(L, 2));
@@ -1579,8 +1415,7 @@ static int T_SetText(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_SetAlpha(lua_State * L)
-{
+static int T_SetAlpha(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetAlpha(static_cast<int>(luaL_checknumber(L, 2)));
@@ -1589,8 +1424,7 @@ static int T_SetAlpha(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_SetColor(lua_State * L)
-{
+static int T_SetColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetColor(BS_GraphicEngine::LuaColorToARGBColor(L, 2));
@@ -1599,8 +1433,7 @@ static int T_SetColor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_SetAutoWrap(lua_State * L)
-{
+static int T_SetAutoWrap(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetAutoWrap(lua_tobooleancpp(L, 2));
@@ -1609,8 +1442,7 @@ static int T_SetAutoWrap(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_SetAutoWrapThreshold(lua_State * L)
-{
+static int T_SetAutoWrapThreshold(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr->SetAutoWrapThreshold(static_cast<unsigned int>(luaL_checknumber(L, 2)));
@@ -1619,8 +1451,7 @@ static int T_SetAutoWrapThreshold(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_GetText(lua_State * L)
-{
+static int T_GetText(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushstring(L, TextPtr->GetText().c_str());
@@ -1629,8 +1460,7 @@ static int T_GetText(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_GetFont(lua_State * L)
-{
+static int T_GetFont(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushstring(L, TextPtr->GetFont().c_str());
@@ -1639,8 +1469,7 @@ static int T_GetFont(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_GetAlpha(lua_State * L)
-{
+static int T_GetAlpha(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushnumber(L, TextPtr->GetAlpha());
@@ -1649,8 +1478,7 @@ static int T_GetAlpha(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_GetColor(lua_State * L)
-{
+static int T_GetColor(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushnumber(L, TextPtr->GetColor());
@@ -1659,8 +1487,7 @@ static int T_GetColor(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_IsAutoWrap(lua_State * L)
-{
+static int T_IsAutoWrap(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushbooleancpp(L, TextPtr->IsAutoWrapActive());
@@ -1669,8 +1496,7 @@ static int T_IsAutoWrap(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_GetAutoWrapThreshold(lua_State * L)
-{
+static int T_GetAutoWrapThreshold(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	lua_pushnumber(L, TextPtr->GetAutoWrapThreshold());
@@ -1679,8 +1505,7 @@ static int T_GetAutoWrapThreshold(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int T_Remove(lua_State * L)
-{
+static int T_Remove(lua_State *L) {
 	BS_RenderObjectPtr<BS_Text> TextPtr = CheckText(L);
 	BS_ASSERT(TextPtr.IsValid());
 	TextPtr.Erase();
@@ -1689,8 +1514,7 @@ static int T_Remove(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg TEXT_METHODS[] =
-{
+static const luaL_reg TEXT_METHODS[] = {
 	{"SetFont", T_SetFont},
 	{"SetText", T_SetText},
 	{"SetAlpha", T_SetAlpha},
@@ -1709,13 +1533,12 @@ static const luaL_reg TEXT_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-bool BS_GraphicEngine::RegisterScriptBindings()
-{
-	BS_Kernel * pKernel = BS_Kernel::GetInstance();
+bool BS_GraphicEngine::RegisterScriptBindings() {
+	BS_Kernel *pKernel = BS_Kernel::GetInstance();
 	BS_ASSERT(pKernel);
-	BS_ScriptEngine * pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
+	BS_ScriptEngine *pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
 	BS_ASSERT(pScript);
-	lua_State * L = static_cast<lua_State *>(pScript->GetScriptObject());
+	lua_State *L = static_cast<lua_State *>(pScript->GetScriptObject());
 	BS_ASSERT(L);
 
 	if (!BS_LuaBindhelper::AddMethodsToClass(L, BITMAP_CLASS_NAME, RENDEROBJECT_METHODS)) return false;