SWORD25: brought CallBackRegisry class to our naming standards

svn-id: r53257

6 files changed, 50 insertions, 50 deletions

diff --git a/engines/sword25/gfx/animation.cpp b/engines/sword25/gfx/animation.cpp
index 1790e24c03..5101a8b732 100644
--- a/engines/sword25/gfx/animation.cpp
+++ b/engines/sword25/gfx/animation.cpp
@@ -673,7 +673,7 @@ void BS_Animation::PersistCallbackVector(BS_OutputPersistenceBlock &Writer, cons
 	// Alle Callbacks einzeln persistieren.
 	Common::Array<ANIMATION_CALLBACK_DATA>::const_iterator It = Vector.begin();
 	while (It != Vector.end()) {
-		Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer((void (*)(int))It->Callback));
+		Writer.Write(CallbackRegistry::getInstance().resolveCallbackPointer((void (*)(int))It->Callback));
 		Writer.Write(It->Data);
 
 		++It;
@@ -696,7 +696,7 @@ void BS_Animation::UnpersistCallbackVector(BS_InputPersistenceBlock &Reader, Com
 
 		Common::String CallbackFunctionName;
 		Reader.Read(CallbackFunctionName);
-		CallbackData.Callback = reinterpret_cast<ANIMATION_CALLBACK>(BS_CallbackRegistry::GetInstance().ResolveCallbackFunction(CallbackFunctionName));
+		CallbackData.Callback = reinterpret_cast<ANIMATION_CALLBACK>(CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName));
 
 		Reader.Read(CallbackData.Data);
 
diff --git a/engines/sword25/gfx/graphicengine_script.cpp b/engines/sword25/gfx/graphicengine_script.cpp
index af558e6578..07a867bf6c 100644
--- a/engines/sword25/gfx/graphicengine_script.cpp
+++ b/engines/sword25/gfx/graphicengine_script.cpp
@@ -91,9 +91,9 @@ 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);
+		CallbackRegistry::getInstance().registerCallbackFunction("LuaLoopPointCB", (void ( *)(int))AnimationLoopPointCallback);
+		CallbackRegistry::getInstance().registerCallbackFunction("LuaActionCB", (void ( *)(int))AnimationActionCallback);
+		CallbackRegistry::getInstance().registerCallbackFunction("LuaDeleteCB", (void ( *)(int))AnimationDeleteCallback);
 	}
 };
 static CallbackfunctionRegisterer Instance;
diff --git a/engines/sword25/input/inputengine_script.cpp b/engines/sword25/input/inputengine_script.cpp
index d373cdac19..5827e88414 100644
--- a/engines/sword25/input/inputengine_script.cpp
+++ b/engines/sword25/input/inputengine_script.cpp
@@ -97,8 +97,8 @@ Common::SharedPtr<CommandCallbackClass> CommandCallbackPtr;
 
 struct CallbackfunctionRegisterer {
 	CallbackfunctionRegisterer() {
-		BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaCommandCB", TheCommandCallback);
-		BS_CallbackRegistry::GetInstance().RegisterCallbackFunction("LuaCharacterCB", TheCharacterCallback);
+		CallbackRegistry::getInstance().registerCallbackFunction("LuaCommandCB", TheCommandCallback);
+		CallbackRegistry::getInstance().registerCallbackFunction("LuaCharacterCB", TheCharacterCallback);
 	}
 };
 static CallbackfunctionRegisterer Instance;
diff --git a/engines/sword25/input/scummvminput.cpp b/engines/sword25/input/scummvminput.cpp
index 30d2940d73..97273dc8d5 100644
--- a/engines/sword25/input/scummvminput.cpp
+++ b/engines/sword25/input/scummvminput.cpp
@@ -343,7 +343,7 @@ bool ScummVMInput::Persist(BS_OutputPersistenceBlock &Writer) {
 	{
 		Common::List<CommandCallback>::const_iterator It = m_CommandCallbacks.begin();
 		while (It != m_CommandCallbacks.end()) {
-			Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer(*It));
+			Writer.Write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
 			++It;
 		}
 	}
@@ -355,7 +355,7 @@ bool ScummVMInput::Persist(BS_OutputPersistenceBlock &Writer) {
 	{
 		Common::List<CharacterCallback>::const_iterator It = m_CharacterCallbacks.begin();
 		while (It != m_CharacterCallbacks.end()) {
-			Writer.Write(BS_CallbackRegistry::GetInstance().ResolveCallbackPointer(*It));
+			Writer.Write(CallbackRegistry::getInstance().resolveCallbackPointer(*It));
 			++It;
 		}
 	}
@@ -379,7 +379,7 @@ bool ScummVMInput::Unpersist(BS_InputPersistenceBlock &Reader) {
 		Reader.Read(CallbackFunctionName);
 
 		m_CommandCallbacks.push_back(reinterpret_cast<CommandCallback>(
-		                                 BS_CallbackRegistry::GetInstance().ResolveCallbackFunction(CallbackFunctionName)));
+		                                 CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
 	}
 
 	// Character-Callbackliste leeren.
@@ -394,7 +394,7 @@ bool ScummVMInput::Unpersist(BS_InputPersistenceBlock &Reader) {
 		Common::String CallbackFunctionName;
 		Reader.Read(CallbackFunctionName);
 
-		m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(BS_CallbackRegistry::GetInstance().ResolveCallbackFunction(CallbackFunctionName)));
+		m_CharacterCallbacks.push_back(reinterpret_cast<CharacterCallback>(CallbackRegistry::getInstance().resolveCallbackFunction(CallbackFunctionName)));
 	}
 
 	return Reader.IsGood();
diff --git a/engines/sword25/kernel/callbackregistry.cpp b/engines/sword25/kernel/callbackregistry.cpp
index a530159cd7..32b2597334 100644
--- a/engines/sword25/kernel/callbackregistry.cpp
+++ b/engines/sword25/kernel/callbackregistry.cpp
@@ -60,72 +60,72 @@ namespace Sword25 {
 
 // -----------------------------------------------------------------------------
 
-bool BS_CallbackRegistry::RegisterCallbackFunction(const Common::String &Name, CallbackPtr Ptr) {
-	if (Name == "") {
+bool CallbackRegistry::registerCallbackFunction(const Common::String &name, CallbackPtr ptr) {
+	if (name == "") {
 		BS_LOG_ERRORLN("The empty string is not allowed as a callback function name.");
 		return false;
 	}
 
-	if (FindPtrByName(Name) != 0) {
-		BS_LOG_ERRORLN("There is already a callback function with the name \"%s\".", Name.c_str());
+	if (findPtrByName(name) != 0) {
+		BS_LOG_ERRORLN("There is already a callback function with the name \"%s\".", name.c_str());
 		return false;
 	}
-	if (FindNameByPtr(Ptr) != "") {
-		BS_LOG_ERRORLN("There is already a callback function with the pointer 0x%x.", Ptr);
+	if (findNameByPtr(ptr) != "") {
+		BS_LOG_ERRORLN("There is already a callback function with the pointer 0x%x.", ptr);
 		return false;
 	}
 
-	StoreCallbackFunction(Name, Ptr);
+	storeCallbackFunction(name, ptr);
 
 	return true;
 }
 
 // -----------------------------------------------------------------------------
 
-CallbackPtr BS_CallbackRegistry::ResolveCallbackFunction(const Common::String &Name) const {
-	CallbackPtr Result = FindPtrByName(Name);
+CallbackPtr CallbackRegistry::resolveCallbackFunction(const Common::String &name) const {
+	CallbackPtr result = findPtrByName(name);
 
-	if (!Result) {
-		BS_LOG_ERRORLN("There is no callback function with the name \"%s\".", Name.c_str());
+	if (!result) {
+		BS_LOG_ERRORLN("There is no callback function with the name \"%s\".", name.c_str());
 	}
 
-	return Result;
+	return result;
 }
 
 // -----------------------------------------------------------------------------
 
-Common::String BS_CallbackRegistry::ResolveCallbackPointer(CallbackPtr Ptr) const {
-	const Common::String &Result = FindNameByPtr(Ptr);
+Common::String CallbackRegistry::resolveCallbackPointer(CallbackPtr ptr) const {
+	const Common::String &result = findNameByPtr(ptr);
 
-	if (Result == "") {
-		BS_LOG_ERRORLN("There is no callback function with the pointer 0x%x.", Ptr);
+	if (result == "") {
+		BS_LOG_ERRORLN("There is no callback function with the pointer 0x%x.", ptr);
 	}
 
-	return Result;
+	return result;
 }
 
 // -----------------------------------------------------------------------------
 
-CallbackPtr BS_CallbackRegistry::FindPtrByName(const Common::String &Name) const {
+CallbackPtr CallbackRegistry::findPtrByName(const Common::String &name) const {
 	// Eintrag in der Map finden und den Pointer zurückgeben.
-	NameToPtrMap::const_iterator It = m_NameToPtrMap.find(Name);
-	return It == m_NameToPtrMap.end() ? 0 : It->_value;
+	NameToPtrMap::const_iterator it = _nameToPtrMap.find(name);
+	return it == _nameToPtrMap.end() ? 0 : it->_value;
 }
 
 // -----------------------------------------------------------------------------
 
-Common::String BS_CallbackRegistry::FindNameByPtr(CallbackPtr Ptr) const {
+Common::String CallbackRegistry::findNameByPtr(CallbackPtr ptr) const {
 	// Eintrag in der Map finden und den Namen zurückgeben.
-	PtrToNameMap::const_iterator It = m_PtrToNameMap.find(Ptr);
-	return It == m_PtrToNameMap.end() ? "" : It->_value;
+	PtrToNameMap::const_iterator it = _ptrToNameMap.find(ptr);
+	return it == _ptrToNameMap.end() ? "" : it->_value;
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_CallbackRegistry::StoreCallbackFunction(const Common::String &Name, CallbackPtr Ptr) {
+void CallbackRegistry::storeCallbackFunction(const Common::String &name, CallbackPtr ptr) {
 	// Callback-Funktion in beide Maps eintragen.
-	m_NameToPtrMap[Name] = Ptr;
-	m_PtrToNameMap[Ptr] = Name;
+	_nameToPtrMap[name] = ptr;
+	_ptrToNameMap[ptr] = name;
 }
 
 } // End of namespace Sword25
diff --git a/engines/sword25/kernel/callbackregistry.h b/engines/sword25/kernel/callbackregistry.h
index a4ebd03dba..c5076d22f5 100644
--- a/engines/sword25/kernel/callbackregistry.h
+++ b/engines/sword25/kernel/callbackregistry.h
@@ -52,22 +52,22 @@ namespace Sword25 {
 // Klassendeklaration
 // -----------------------------------------------------------------------------
 
-typedef void (*CallbackPtr)(int Command);
+typedef void (*CallbackPtr)(int command);
 
-class BS_CallbackRegistry {
+class CallbackRegistry {
 public:
-	static BS_CallbackRegistry &GetInstance() {
-		static BS_CallbackRegistry Instance;
-		return Instance;
+	static CallbackRegistry &getInstance() {
+		static CallbackRegistry _instance;
+		return _instance;
 	}
 
-	bool        RegisterCallbackFunction(const Common::String &Name, CallbackPtr Ptr);
-	CallbackPtr     ResolveCallbackFunction(const Common::String &Name) const;
-	Common::String  ResolveCallbackPointer(CallbackPtr Ptr) const;
+	bool        registerCallbackFunction(const Common::String &name, CallbackPtr ptr);
+	CallbackPtr     resolveCallbackFunction(const Common::String &name) const;
+	Common::String  resolveCallbackPointer(CallbackPtr ptr) const;
 
 private:
 	typedef Common::HashMap<Common::String, CallbackPtr, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> NameToPtrMap;
-	NameToPtrMap m_NameToPtrMap;
+	NameToPtrMap _nameToPtrMap;
 
 	struct CallbackPtr_EqualTo {
 		bool operator()(CallbackPtr x, CallbackPtr y) const {
@@ -81,11 +81,11 @@ private:
 	};
 
 	typedef Common::HashMap<CallbackPtr, Common::String, CallbackPtr_Hash, CallbackPtr_EqualTo> PtrToNameMap;
-	PtrToNameMap m_PtrToNameMap;
+	PtrToNameMap _ptrToNameMap;
 
-	CallbackPtr     FindPtrByName(const Common::String &Name) const;
-	Common::String  FindNameByPtr(CallbackPtr Ptr) const;
-	void        StoreCallbackFunction(const Common::String &Name, CallbackPtr Ptr);
+	CallbackPtr     findPtrByName(const Common::String &name) const;
+	Common::String  findNameByPtr(CallbackPtr ptr) const;
+	void        storeCallbackFunction(const Common::String &name, CallbackPtr ptr);
 };
 
 } // End of namespace Sword25