added template rules for modules. thanks to sardanap;

git-svn-id: https://svn.kvirc.de/svn/trunk/kvirc@1456 17fca916-40b9-46aa-a4ea-0a15b648b75c

63 files changed, 123 insertions, 1719 deletions

diff --git a/src/modules/CMakeLists.txt b/src/modules/CMakeLists.txt
index 6e0f5adc2..b5c433c92 100644
--- a/src/modules/CMakeLists.txt
+++ b/src/modules/CMakeLists.txt
@@ -1,6 +1,6 @@
 # CMakeLists.txt for src/modules/
 IF(APPLE)
-	SET(CMAKE_MODULE_LINKER_FLAGS "-single_module -undefined dynamic_lookup -multiply_defined suppress")
+	SET(CMAKE_MODULE_LINKER_FLAGS "-undefined dynamic_lookup")
 ENDIF()
 
 INCLUDE_DIRECTORIES(
diff --git a/src/modules/about/CMakeLists.txt b/src/modules/about/CMakeLists.txt
index e944496a5..9cda568a7 100644
--- a/src/modules/about/CMakeLists.txt
+++ b/src/modules/about/CMakeLists.txt
@@ -11,32 +11,5 @@ SET(kviabout_SRCS
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviabout_MOC_SRCS ${kviabout_MOC_HDRS})
-
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviabout MODULE ${kviabout_SRCS} ${kviabout_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviabout SHARED ${kviabout_SRCS} ${kviabout_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviabout ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviabout kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviabout PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviabout LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviabout PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviabout LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviabout PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviabout LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviabout)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/action/CMakeLists.txt b/src/modules/action/CMakeLists.txt
index 2e177f335..6b1755f4a 100644
--- a/src/modules/action/CMakeLists.txt
+++ b/src/modules/action/CMakeLists.txt
@@ -6,32 +6,5 @@ SET(kviaction_SRCS
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviaction_MOC_SRCS ${kviaction_MOC_HDRS})
-
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviaction MODULE ${kviaction_SRCS} ${kviaction_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviaction SHARED ${kviaction_SRCS} ${kviaction_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviaction ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviaction kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviaction PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviaction LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviaction PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviaction LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviaction PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviaction LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviaction)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/actioneditor/CMakeLists.txt b/src/modules/actioneditor/CMakeLists.txt
index 3db9137f6..a3fb5c56c 100644
--- a/src/modules/actioneditor/CMakeLists.txt
+++ b/src/modules/actioneditor/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kviactioneditor_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviactioneditor_MOC_SRCS ${kviactioneditor_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviactioneditor MODULE ${kviactioneditor_SRCS} ${kviactioneditor_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviactioneditor SHARED ${kviactioneditor_SRCS} ${kviactioneditor_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviactioneditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviactioneditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviactioneditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviactioneditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviactioneditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviactioneditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviactioneditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviactioneditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviactioneditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/addon/CMakeLists.txt b/src/modules/addon/CMakeLists.txt
index 031f76fc0..47aa70145 100644
--- a/src/modules/addon/CMakeLists.txt
+++ b/src/modules/addon/CMakeLists.txt
@@ -12,32 +12,5 @@ SET(kviaddon_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviaddon_MOC_SRCS ${kviaddon_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviaddon MODULE ${kviaddon_SRCS} ${kviaddon_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviaddon SHARED ${kviaddon_SRCS} ${kviaddon_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviaddon ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviaddon kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviaddon PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviaddon LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviaddon PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviaddon LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	# Windows
-	SET_TARGET_PROPERTIES(kviaddon PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviaddon LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviaddon)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/aliaseditor/CMakeLists.txt b/src/modules/aliaseditor/CMakeLists.txt
index 5cf761782..2b0c789a8 100644
--- a/src/modules/aliaseditor/CMakeLists.txt
+++ b/src/modules/aliaseditor/CMakeLists.txt
@@ -11,32 +11,5 @@ SET(kvialiaseditor_SRCS
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvialiaseditor_MOC_SRCS ${kvialiaseditor_MOC_HDRS})
-
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvialiaseditor MODULE ${kvialiaseditor_SRCS} ${kvialiaseditor_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvialiaseditor SHARED ${kvialiaseditor_SRCS} ${kvialiaseditor_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvialiaseditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvialiaseditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvialiaseditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvialiaseditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvialiaseditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvialiaseditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvialiaseditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvialiaseditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvialiaseditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/avatar/CMakeLists.txt b/src/modules/avatar/CMakeLists.txt
index 310254c13..4dbed6abe 100644
--- a/src/modules/avatar/CMakeLists.txt
+++ b/src/modules/avatar/CMakeLists.txt
@@ -11,30 +11,5 @@ SET(kviavatar_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviavatar_MOC_SRCS ${kviavatar_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviavatar MODULE ${kviavatar_SRCS} ${kviavatar_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviavatar SHARED ${kviavatar_SRCS} ${kviavatar_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviavatar ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviavatar kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviavatar PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviavatar LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		SET_TARGET_PROPERTIES(kviavatar PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviavatar LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviavatar PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviavatar LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviavatar)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/chan/CMakeLists.txt b/src/modules/chan/CMakeLists.txt
index ef7fb3722..7fdd3d159 100644
--- a/src/modules/chan/CMakeLists.txt
+++ b/src/modules/chan/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvichan_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvichan_MOC_SRCS ${kvichan_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvichan MODULE ${kvichan_SRCS} ${kvichan_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvichan SHARED ${kvichan_SRCS} ${kvichan_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvichan ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvichan kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvichan PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvichan LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvichan PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvichan LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvichan PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvichan LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvichan)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/channelsjoin/CMakeLists.txt b/src/modules/channelsjoin/CMakeLists.txt
index 57e6dd7ba..06805bacb 100644
--- a/src/modules/channelsjoin/CMakeLists.txt
+++ b/src/modules/channelsjoin/CMakeLists.txt
@@ -10,31 +10,5 @@ SET(kvichannelsjoin_MOC_HDRS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvichannelsjoin_MOC_SRCS ${kvichannelsjoin_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvichannelsjoin MODULE ${kvichannelsjoin_SRCS} ${kvichannelsjoin_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvichannelsjoin SHARED ${kvichannelsjoin_SRCS} ${kvichannelsjoin_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvichannelsjoin ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvichannelsjoin kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvichannelsjoin PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvichannelsjoin LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvichannelsjoin PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvichannelsjoin LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvichannelsjoin PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvichannelsjoin LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvichannelsjoin)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/clock/CMakeLists.txt b/src/modules/clock/CMakeLists.txt
index 750ab39e0..080fa4a30 100644
--- a/src/modules/clock/CMakeLists.txt
+++ b/src/modules/clock/CMakeLists.txt
@@ -11,31 +11,5 @@ SET(kviclock_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviclock_MOC_SRCS ${kviclock_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviclock MODULE ${kviclock_SRCS} ${kviclock_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviclock SHARED ${kviclock_SRCS} ${kviclock_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviclock ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviclock kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviclock PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviclock LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviclock PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviclock LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviclock PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-        #INSTALL(TARGETS kviclock LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviclock)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/codetester/CMakeLists.txt b/src/modules/codetester/CMakeLists.txt
index 6b038a91b..87c4cedca 100644
--- a/src/modules/codetester/CMakeLists.txt
+++ b/src/modules/codetester/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvicodetester_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvicodetester_MOC_SRCS ${kvicodetester_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvicodetester MODULE ${kvicodetester_SRCS} ${kvicodetester_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvicodetester SHARED ${kvicodetester_SRCS} ${kvicodetester_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvicodetester ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvicodetester kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvicodetester PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvicodetester LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvicodetester PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvicodetester LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvicodetester PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvicodetester LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvicodetester)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/config/CMakeLists.txt b/src/modules/config/CMakeLists.txt
index af4cba00d..a97646e5b 100644
--- a/src/modules/config/CMakeLists.txt
+++ b/src/modules/config/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kviconfig_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviconfig_MOC_SRCS ${kviconfig_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviconfig MODULE ${kviconfig_SRCS} ${kviconfig_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviconfig SHARED ${kviconfig_SRCS} ${kviconfig_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviconfig ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviconfig kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviconfig PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviconfig LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviconfig PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviconfig LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviconfig PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviconfig LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviconfig)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/context/CMakeLists.txt b/src/modules/context/CMakeLists.txt
index 05e28f5c5..a5035462f 100644
--- a/src/modules/context/CMakeLists.txt
+++ b/src/modules/context/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvicontext_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvicontext_MOC_SRCS ${kvicontext_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvicontext MODULE ${kvicontext_SRCS} ${kvicontext_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvicontext SHARED ${kvicontext_SRCS} ${kvicontext_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvicontext ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvicontext kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvicontext PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvicontext LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvicontext PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvicontext LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvicontext PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvicontext LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvicontext)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/dcc/CMakeLists.txt b/src/modules/dcc/CMakeLists.txt
index 2d4480b58..b4e23c858 100644
--- a/src/modules/dcc/CMakeLists.txt
+++ b/src/modules/dcc/CMakeLists.txt
@@ -44,32 +44,5 @@ ENDIF()
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvidcc_MOC_SRCS ${kvidcc_MOC_HDRS})
-
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvidcc MODULE ${kvidcc_SRCS} ${kvidcc_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvidcc SHARED ${kvidcc_SRCS} ${kvidcc_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvidcc ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvidcc kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvidcc PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvidcc LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvidcc PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvidcc LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvidcc PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvidcc LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvidcc)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/dialog/CMakeLists.txt b/src/modules/dialog/CMakeLists.txt
index 4d4d26757..8ec4f2b32 100644
--- a/src/modules/dialog/CMakeLists.txt
+++ b/src/modules/dialog/CMakeLists.txt
@@ -11,31 +11,5 @@ SET(kvidialog_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvidialog_MOC_SRCS ${kvidialog_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvidialog MODULE ${kvidialog_SRCS} ${kvidialog_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvidialog SHARED ${kvidialog_SRCS} ${kvidialog_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvidialog ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvidialog kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvidialog PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvidialog LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvidialog PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvidialog LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvidialog PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvidialog LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvidialog)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/editor/CMakeLists.txt b/src/modules/editor/CMakeLists.txt
index 0aab5b647..239a32db6 100644
--- a/src/modules/editor/CMakeLists.txt
+++ b/src/modules/editor/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvieditor_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvieditor_MOC_SRCS ${kvieditor_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvieditor MODULE ${kvieditor_SRCS} ${kvieditor_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvieditor SHARED ${kvieditor_SRCS} ${kvieditor_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvieditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvieditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvieditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvieditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvieditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvieditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvieditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvieditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvieditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/eventeditor/CMakeLists.txt b/src/modules/eventeditor/CMakeLists.txt
index 5b5d9c295..fa063255f 100644
--- a/src/modules/eventeditor/CMakeLists.txt
+++ b/src/modules/eventeditor/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvieventeditor_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvieventeditor_MOC_SRCS ${kvieventeditor_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvieventeditor MODULE ${kvieventeditor_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvieventeditor SHARED ${kvieventeditor_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvieventeditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvieventeditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvieventeditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvieventeditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvieventeditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvieventeditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvieventeditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvieventeditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvieventeditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/file/CMakeLists.txt b/src/modules/file/CMakeLists.txt
index 3dd153686..40aa796f9 100644
--- a/src/modules/file/CMakeLists.txt
+++ b/src/modules/file/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvifile_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvifile_MOC_SRCS ${kvifile_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvifile MODULE ${kvifile_SRCS} ${kvifile_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvifile SHARED ${kvifile_SRCS} ${kvifile_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvifile ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvifile kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvifile PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvifile LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvifile PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvifile LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvifile PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvifile LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvifile)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/filetransferwindow/CMakeLists.txt b/src/modules/filetransferwindow/CMakeLists.txt
index daa63daf2..7f7b3a0cf 100644
--- a/src/modules/filetransferwindow/CMakeLists.txt
+++ b/src/modules/filetransferwindow/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvifiletransferwindow_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvifiletransferwindow_MOC_SRCS ${kvifiletransferwindow_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvifiletransferwindow MODULE ${kvifiletransferwindow_SRCS} ${kvifiletransferwindow_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvifiletransferwindow SHARED ${kvifiletransferwindow_SRCS} ${kvifiletransferwindow_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvifiletransferwindow ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvifiletransferwindow kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvifiletransferwindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvifiletransferwindow LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvifiletransferwindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvifiletransferwindow LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvifiletransferwindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvifiletransferwindow LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvifiletransferwindow)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/help/CMakeLists.txt b/src/modules/help/CMakeLists.txt
index 56726ad9d..ac9d04d02 100644
--- a/src/modules/help/CMakeLists.txt
+++ b/src/modules/help/CMakeLists.txt
@@ -16,31 +16,5 @@ SET(kvihelp_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvihelp_MOC_SRCS ${kvihelp_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvihelp MODULE ${kvihelp_SRCS} ${kvihelp_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvihelp SHARED ${kvihelp_SRCS} ${kvihelp_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvihelp ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvihelp kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvihelp PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvihelp LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvihelp PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvihelp LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvihelp PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvihelp LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvihelp)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/http/CMakeLists.txt b/src/modules/http/CMakeLists.txt
index 2ad715be9..54b05d810 100644
--- a/src/modules/http/CMakeLists.txt
+++ b/src/modules/http/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvihttp_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvihttp_MOC_SRCS ${kvihttp_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvihttp MODULE ${kvihttp_SRCS} ${kvihttp_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvihttp SHARED ${kvihttp_SRCS} ${kvihttp_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvihttp ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvihttp kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvihttp PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvihttp LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvihttp PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvihttp LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvihttp PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvihttp LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvihttp)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/ident/CMakeLists.txt b/src/modules/ident/CMakeLists.txt
index eb1491ebe..8b9c56f43 100644
--- a/src/modules/ident/CMakeLists.txt
+++ b/src/modules/ident/CMakeLists.txt
@@ -15,31 +15,5 @@ ENDIF(WIN32)
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviident_MOC_SRCS ${kviident_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviident MODULE ${kviident_SRCS} ${kviident_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviident SHARED ${kviident_SRCS} ${kviident_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviident ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviident kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviident PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviident LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviident PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviident LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviident PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviident LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviident)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/iograph/CMakeLists.txt b/src/modules/iograph/CMakeLists.txt
index a86e6325f..897cbeac8 100644
--- a/src/modules/iograph/CMakeLists.txt
+++ b/src/modules/iograph/CMakeLists.txt
@@ -11,31 +11,5 @@ SET(kviiograph_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviiograph_MOC_SRCS ${kviiograph_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviiograph MODULE ${kviiograph_SRCS} ${kviiograph_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviiograph SHARED ${kviiograph_SRCS} ${kviiograph_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviiograph ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviiograph kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviiograph PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviiograph LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviiograph PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviiograph LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviiograph PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviiograph LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviiograph)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/lamerizer/CMakeLists.txt b/src/modules/lamerizer/CMakeLists.txt
index b34007191..4a0277410 100644
--- a/src/modules/lamerizer/CMakeLists.txt
+++ b/src/modules/lamerizer/CMakeLists.txt
@@ -11,31 +11,5 @@ SET(kvilamerizer_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvilamerizer_MOC_SRCS ${kvilamerizer_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvilamerizer MODULE ${kvilamerizer_SRCS} ${kvilamerizer_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvilamerizer SHARED ${kvilamerizer_SRCS} ${kvilamerizer_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvilamerizer ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvilamerizer kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvilamerizer PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvilamerizer LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvilamerizer PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvilamerizer LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvilamerizer PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvilamerizer LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvilamerizer)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/links/CMakeLists.txt b/src/modules/links/CMakeLists.txt
index 228bc890a..1ffe5e95d 100644
--- a/src/modules/links/CMakeLists.txt
+++ b/src/modules/links/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvilinks_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvilinks_MOC_SRCS ${kvilinks_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvilinks MODULE ${kvilinks_SRCS} ${kvilinks_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvilinks SHARED ${kvilinks_SRCS} ${kvilinks_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvilinks ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvilinks kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvilinks PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvilinks LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvilinks PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvilinks LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvilinks PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvilinks LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvilinks)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/list/CMakeLists.txt b/src/modules/list/CMakeLists.txt
index 1251266ea..eb0ea0d56 100644
--- a/src/modules/list/CMakeLists.txt
+++ b/src/modules/list/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvilist_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvilist_MOC_SRCS ${kvilist_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvilist MODULE ${kvilist_SRCS} ${kvilist_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvilist SHARED ${kvilist_SRCS} ${kvilist_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvilist ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvilist kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvilist PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvilist LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvilist PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvilist LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvilist PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvilist LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvilist)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/log/CMakeLists.txt b/src/modules/log/CMakeLists.txt
index 82f1b3ac8..777b390f3 100644
--- a/src/modules/log/CMakeLists.txt
+++ b/src/modules/log/CMakeLists.txt
@@ -6,32 +6,5 @@ SET(kvilog_SRCS
 
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvilog_MOC_SRCS ${kvilog_MOC_HDRS})
-
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvilog MODULE ${kvilog_SRCS} ${kvilog_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvilog SHARED ${kvilog_SRCS} ${kvilog_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvilog ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvilog kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvilog PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvilog LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvilog PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvilog LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvilog PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvilog LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvilog)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/logview/CMakeLists.txt b/src/modules/logview/CMakeLists.txt
index 3e60cc465..0f72e7c44 100644
--- a/src/modules/logview/CMakeLists.txt
+++ b/src/modules/logview/CMakeLists.txt
@@ -14,31 +14,5 @@ SET(kvilogview_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvilogview_MOC_SRCS ${kvilogview_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvilogview MODULE ${kvilogview_SRCS} ${kvilogview_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvilogview SHARED ${kvilogview_SRCS} ${kvilogview_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvilogview ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvilogview kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvilogview PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvilogview LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvilogview PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvilogview LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvilogview PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvilogview LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvilogview)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/mask/CMakeLists.txt b/src/modules/mask/CMakeLists.txt
index a3ad96bbb..7c8fbd327 100644
--- a/src/modules/mask/CMakeLists.txt
+++ b/src/modules/mask/CMakeLists.txt
@@ -4,31 +4,5 @@ SET(kvimask_SRCS
 	libkvimask.cpp
 )
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvimask MODULE ${kvimask_SRCS} ${kvimask_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvimask SHARED ${kvimask_SRCS} ${kvimask_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvimask ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvimask kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvimask PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvimask LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvimask PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvimask LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvimask PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvimask LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvimask)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/math/CMakeLists.txt b/src/modules/math/CMakeLists.txt
index 5b11e3382..3aebada65 100644
--- a/src/modules/math/CMakeLists.txt
+++ b/src/modules/math/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvimath_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvimath_MOC_SRCS ${kvimath_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvimath MODULE ${kvimath_SRCS} ${kvimath_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvimath SHARED ${kvimath_SRCS} ${kvimath_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvimath ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvimath kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvimath PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvimath LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvimath PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvimath LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvimath PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvimath LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvimath)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/mediaplayer/CMakeLists.txt b/src/modules/mediaplayer/CMakeLists.txt
index 8c2a17b9f..71fbfc7d9 100644
--- a/src/modules/mediaplayer/CMakeLists.txt
+++ b/src/modules/mediaplayer/CMakeLists.txt
@@ -28,31 +28,5 @@ SET(kvimediaplayer_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvimediaplayer_MOC_SRCS ${kvimediaplayer_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvimediaplayer MODULE ${kvimediaplayer_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvimediaplayer SHARED ${kvimediaplayer_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvimediaplayer ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvimediaplayer kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvimediaplayer PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvimediaplayer LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvimediaplayer PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvimediaplayer LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvimediaplayer PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvimediaplayer LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvimediaplayer)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/mircimport/CMakeLists.txt b/src/modules/mircimport/CMakeLists.txt
index d31bcf28d..6dd6cad5f 100644
--- a/src/modules/mircimport/CMakeLists.txt
+++ b/src/modules/mircimport/CMakeLists.txt
@@ -11,32 +11,5 @@ SET(kvimircimport_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvimircimport_MOC_SRCS ${kvimircimport_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvimircimport MODULE ${kvimircimport_SRCS} ${kvimircimport_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvimircimport SHARED ${kvimircimport_SRCS} ${kvimircimport_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvimircimport ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvimircimport kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvimircimport PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvimircimport LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvimircimport PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvimircimport LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	# Windows
-	SET_TARGET_PROPERTIES(kvimircimport PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvimircimport LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvimircimport)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/my/CMakeLists.txt b/src/modules/my/CMakeLists.txt
index 6ce2e84db..89248553d 100644
--- a/src/modules/my/CMakeLists.txt
+++ b/src/modules/my/CMakeLists.txt
@@ -14,31 +14,5 @@ SET(kvimy_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvimy_MOC_SRCS ${kvimy_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvimy MODULE ${kvimy_SRCS} ${kvimy_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvimy SHARED ${kvimy_SRCS} ${kvimy_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvimy ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvimy kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvimy PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvimy LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvimy PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvimy LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvimy PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvimy LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvimy)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/notifier/CMakeLists.txt b/src/modules/notifier/CMakeLists.txt
index e67d0b27b..beaa1f033 100644
--- a/src/modules/notifier/CMakeLists.txt
+++ b/src/modules/notifier/CMakeLists.txt
@@ -23,31 +23,5 @@ SET(kvinotifier_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvinotifier_MOC_SRCS ${kvinotifier_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvinotifier MODULE ${kvinotifier_SRCS} ${kvinotifier_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvinotifier SHARED ${kvinotifier_SRCS} ${kvinotifier_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvinotifier ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvinotifier kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvinotifier PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvinotifier LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvinotifier PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvinotifier LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvinotifier PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvinotifier LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvinotifier)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/objects/CMakeLists.txt b/src/modules/objects/CMakeLists.txt
index afa4edec3..4c06775a3 100644
--- a/src/modules/objects/CMakeLists.txt
+++ b/src/modules/objects/CMakeLists.txt
@@ -100,31 +100,5 @@ SET(kviobjects_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviobjects_MOC_SRCS ${kviobjects_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviobjects MODULE ${kviobjects_SRCS} ${kviobjects_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviobjects SHARED ${kviobjects_SRCS} ${kviobjects_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviobjects ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviobjects kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviobjects PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviobjects LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviobjects PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviobjects LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviobjects PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviobjects LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviobjects)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/options/CMakeLists.txt b/src/modules/options/CMakeLists.txt
index 0a23d8897..f87c2d51e 100644
--- a/src/modules/options/CMakeLists.txt
+++ b/src/modules/options/CMakeLists.txt
@@ -90,31 +90,5 @@ SET(kvioptions_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvioptions_MOC_SRCS ${kvioptions_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvioptions MODULE ${kvioptions_SRCS} ${kvioptions_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvioptions SHARED ${kvioptions_SRCS} ${kvioptions_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvioptions ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvioptions kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvioptions PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvioptions LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvioptions PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvioptions LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvioptions PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvioptions LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvioptions)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/options/optw_texticons.cpp b/src/modules/options/optw_texticons.cpp
index 9487b5279..bf9b7aa27 100644
--- a/src/modules/options/optw_texticons.cpp
+++ b/src/modules/options/optw_texticons.cpp
@@ -261,7 +261,6 @@ KviTextIconsOptionsWidget::KviTextIconsOptionsWidget(QWidget * parent)
 
 	m_pDel->setEnabled(false);
 
-	// FIXME: this does not work
 	connect(m_pTable,SIGNAL(itemSelectionChanged()),this,SLOT(itemSelectionChanged()));
 }
 
diff --git a/src/modules/perl/CMakeLists.txt b/src/modules/perl/CMakeLists.txt
index 7ef286aae..eef258bf9 100644
--- a/src/modules/perl/CMakeLists.txt
+++ b/src/modules/perl/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kviperl_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviperl_MOC_SRCS ${kviperl_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviperl MODULE ${kviperl_SRCS} ${kviperl_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviperl SHARED ${kviperl_SRCS} ${kviperl_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviperl ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviperl kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviperl PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviperl LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviperl PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviperl LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviperl PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviperl LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviperl)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/perlcore/CMakeLists.txt b/src/modules/perlcore/CMakeLists.txt
index 27c857cff..88eccb710 100644
--- a/src/modules/perlcore/CMakeLists.txt
+++ b/src/modules/perlcore/CMakeLists.txt
@@ -2,12 +2,10 @@
 
 # From qmake
 #win32{
-#	INCLUDEPATH += $(PERLDIR)/lib/CORE/
 #	LIBS += -lperl58
 #}
 #
 #mac {
-#	INCLUDEPATH += $(PERLDIR)/CORE/
 #	LIBS += -lperl -L$(PERLDIR)/CORE/
 #}
 
@@ -31,31 +29,5 @@ SET(kviperlcore_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviperlcore_MOC_SRCS ${kviperlcore_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviperlcore MODULE ${kviperlcore_SRCS} ${kviperlcore_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviperlcore SHARED ${kviperlcore_SRCS} ${kviperlcore_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviperlcore ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviperlcore kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviperlcore PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviperlcore LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviperlcore PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviperlcore LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviperlcore PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviperlcore LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviperlcore)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/popupeditor/CMakeLists.txt b/src/modules/popupeditor/CMakeLists.txt
index 1a480fb94..87c8617b4 100644
--- a/src/modules/popupeditor/CMakeLists.txt
+++ b/src/modules/popupeditor/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvipopupeditor_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvipopupeditor_MOC_SRCS ${kvipopupeditor_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvipopupeditor MODULE ${kvipopupeditor_SRCS} ${kvipopupeditor_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvipopupeditor SHARED ${kvipopupeditor_SRCS} ${kvipopupeditor_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvipopupeditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvipopupeditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvipopupeditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvipopupeditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvipopupeditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvipopupeditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvipopupeditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvipopupeditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvipopupeditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/raweditor/CMakeLists.txt b/src/modules/raweditor/CMakeLists.txt
index 75e032400..1c02c2457 100644
--- a/src/modules/raweditor/CMakeLists.txt
+++ b/src/modules/raweditor/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kviraweditor_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviraweditor_MOC_SRCS ${kviraweditor_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviraweditor MODULE ${kviraweditor_SRCS} ${kviraweditor_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviraweditor SHARED ${kviraweditor_SRCS} ${kviraweditor_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviraweditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviraweditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviraweditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviraweditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviraweditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviraweditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviraweditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviraweditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviraweditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/regchan/CMakeLists.txt b/src/modules/regchan/CMakeLists.txt
index f3977d734..3ef901ed4 100644
--- a/src/modules/regchan/CMakeLists.txt
+++ b/src/modules/regchan/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kviregchan_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviregchan_MOC_SRCS ${kviregchan_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviregchan MODULE ${kviregchan_SRCS} ${kviregchan_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviregchan SHARED ${kviregchan_SRCS} ${kviregchan_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviregchan ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviregchan kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviregchan PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviregchan LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviregchan PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviregchan LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviregchan PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviregchan LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviregchan)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/reguser/CMakeLists.txt b/src/modules/reguser/CMakeLists.txt
index bc3857a67..8a4e16f24 100644
--- a/src/modules/reguser/CMakeLists.txt
+++ b/src/modules/reguser/CMakeLists.txt
@@ -16,31 +16,5 @@ SET(kvireguser_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvireguser_MOC_SRCS ${kvireguser_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvireguser MODULE ${kvireguser_SRCS} ${kvireguser_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvireguser SHARED ${kvireguser_SRCS} ${kvireguser_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvireguser ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvireguser kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvireguser PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvireguser LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvireguser PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvireguser LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvireguser PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvireguser LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvireguser)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/rijndael/CMakeLists.txt b/src/modules/rijndael/CMakeLists.txt
index d4e81fe18..df6faf042 100644
--- a/src/modules/rijndael/CMakeLists.txt
+++ b/src/modules/rijndael/CMakeLists.txt
@@ -15,31 +15,5 @@ SET(kvirijndael_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvirijndael_MOC_SRCS ${kvirijndael_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvirijndael MODULE ${kvirijndael_SRCS} ${kvirijndael_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvirijndael SHARED ${kvirijndael_SRCS} ${kvirijndael_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvirijndael ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvirijndael kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvirijndael PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvirijndael LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvirijndael PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvirijndael LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvirijndael PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvirijndael LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvirijndael)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/setup/CMakeLists.txt b/src/modules/setup/CMakeLists.txt
index ed41af712..ed4d0c978 100644
--- a/src/modules/setup/CMakeLists.txt
+++ b/src/modules/setup/CMakeLists.txt
@@ -16,31 +16,5 @@ SET(kvisetup_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvisetup_MOC_SRCS ${kvisetup_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvisetup MODULE ${kvisetup_SRCS} ${kvisetup_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvisetup SHARED ${kvisetup_SRCS} ${kvisetup_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvisetup ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvisetup kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvisetup PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvisetup LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvisetup PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvisetup LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvisetup PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvisetup LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvisetup)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/sharedfile/CMakeLists.txt b/src/modules/sharedfile/CMakeLists.txt
index c1500b117..fbefe8ec4 100644
--- a/src/modules/sharedfile/CMakeLists.txt
+++ b/src/modules/sharedfile/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvisharedfile_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvisharedfile_MOC_SRCS ${kvisharedfile_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvisharedfile MODULE ${kvisharedfile_SRCS} ${kvisharedfile_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvisharedfile SHARED ${kvisharedfile_SRCS} ${kvisharedfile_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvisharedfile ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvisharedfile kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvisharedfile PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvisharedfile LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvisharedfile PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvisharedfile LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvisharedfile PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvisharedfile LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvisharedfile)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/sharedfileswindow/CMakeLists.txt b/src/modules/sharedfileswindow/CMakeLists.txt
index d2eaab0cb..b63e556b2 100644
--- a/src/modules/sharedfileswindow/CMakeLists.txt
+++ b/src/modules/sharedfileswindow/CMakeLists.txt
@@ -12,32 +12,5 @@ SET(kvisharedfilewindow_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvisharedfilewindow_MOC_SRCS ${kvisharedfilewindow_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvisharedfilewindow MODULE ${kvisharedfilewindow_SRCS} ${kvisharedfilewindow_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvisharedfilewindow SHARED ${kvisharedfilewindow_SRCS} ${kvisharedfilewindow_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvisharedfilewindow ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvisharedfilewindow kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvisharedfilewindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvisharedfilewindow LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvisharedfilewindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvisharedfilewindow LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSE()
-	# Windows
-	SET_TARGET_PROPERTIES(kvisharedfilewindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvisharedfilewindow LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvisharedfilewindow)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/snd/CMakeLists.txt b/src/modules/snd/CMakeLists.txt
index 1b18c8c59..fcb3c60b0 100644
--- a/src/modules/snd/CMakeLists.txt
+++ b/src/modules/snd/CMakeLists.txt
@@ -15,31 +15,5 @@ SET(kvisnd_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvisnd_MOC_SRCS ${kvisnd_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvisnd MODULE ${kvisnd_SRCS} ${kvisnd_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvisnd SHARED ${kvisnd_SRCS} ${kvisnd_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvisnd ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvisnd kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvisnd PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvisnd LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvisnd PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvisnd LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvisnd PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvisnd LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvisnd)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/socketspy/CMakeLists.txt b/src/modules/socketspy/CMakeLists.txt
index 4c2b93244..6ca7ca2a7 100644
--- a/src/modules/socketspy/CMakeLists.txt
+++ b/src/modules/socketspy/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvisocketspy_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvisocketspy_MOC_SRCS ${kvisocketspy_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvisocketspy MODULE ${kvisocketspy_SRCS} ${kvisocketspy_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvisocketspy SHARED ${kvisocketspy_SRCS} ${kvisocketspy_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvisocketspy ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvisocketspy kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvisocketspy PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvisocketspy LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvisocketspy PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvisocketspy LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvisocketspy PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvisocketspy LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvisocketspy)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/spaste/CMakeLists.txt b/src/modules/spaste/CMakeLists.txt
index 716a36cda..f007fea54 100644
--- a/src/modules/spaste/CMakeLists.txt
+++ b/src/modules/spaste/CMakeLists.txt
@@ -13,31 +13,5 @@ SET(kvispaste_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvispaste_MOC_SRCS ${kvispaste_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvispaste MODULE ${kvispaste_SRCS} ${kvispaste_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvispaste SHARED ${kvispaste_SRCS} ${kvispaste_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvispaste ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvispaste kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvispaste PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvispaste LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvispaste PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvispaste LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvispaste PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvispaste LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvispaste)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/str/CMakeLists.txt b/src/modules/str/CMakeLists.txt
index 7a116106f..6f94807c6 100644
--- a/src/modules/str/CMakeLists.txt
+++ b/src/modules/str/CMakeLists.txt
@@ -16,31 +16,5 @@ SET(kvistr_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvistr_MOC_SRCS ${kvistr_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvistr MODULE ${kvistr_SRCS} ${kvistr_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvistr SHARED ${kvistr_SRCS} ${kvistr_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvistr ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvistr kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvistr PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvistr LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvistr PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvistr LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvistr PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvistr LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvistr)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/system/CMakeLists.txt b/src/modules/system/CMakeLists.txt
index e8089fa53..d66f94a59 100644
--- a/src/modules/system/CMakeLists.txt
+++ b/src/modules/system/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvisystem_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvisystem_MOC_SRCS ${kvisystem_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvisystem MODULE ${kvisystem_SRCS} ${kvisystem_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvisystem SHARED ${kvisystem_SRCS} ${kvisystem_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvisystem ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvisystem kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvisystem PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvisystem LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvisystem PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvisystem LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvisystem PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvisystem LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvisystem)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/term/CMakeLists.txt b/src/modules/term/CMakeLists.txt
index 836fd04e7..3598ab444 100644
--- a/src/modules/term/CMakeLists.txt
+++ b/src/modules/term/CMakeLists.txt
@@ -14,31 +14,5 @@ SET(kviterm_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviterm_MOC_SRCS ${kviterm_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviterm MODULE ${kviterm_SRCS} ${kviterm_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviterm SHARED ${kviterm_SRCS} ${kviterm_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviterm ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviterm kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviterm PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviterm LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviterm PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviterm LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviterm PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviterm LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviterm)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/texticons/CMakeLists.txt b/src/modules/texticons/CMakeLists.txt
index 500f53a54..b8c3f6397 100644
--- a/src/modules/texticons/CMakeLists.txt
+++ b/src/modules/texticons/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvitexticons_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitexticons_MOC_SRCS ${kvitexticons_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitexticons MODULE ${kvitexticons_SRCS} ${kvitexticons_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitexticons SHARED ${kvitexticons_SRCS} ${kvitexticons_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitexticons ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitexticons kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitexticons PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitexticons LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitexticons PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitexticons LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitexticons PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitexticons LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitexticons)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/theme/CMakeLists.txt b/src/modules/theme/CMakeLists.txt
index 0eddbe56c..fb359436a 100644
--- a/src/modules/theme/CMakeLists.txt
+++ b/src/modules/theme/CMakeLists.txt
@@ -18,31 +18,5 @@ SET(kvitheme_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitheme_MOC_SRCS ${kvitheme_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitheme MODULE ${kvitheme_SRCS} ${kvitheme_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitheme SHARED ${kvitheme_SRCS} ${kvitheme_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitheme ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitheme kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitheme PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitheme LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitheme PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitheme LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitheme PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitheme LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitheme)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/tip/CMakeLists.txt b/src/modules/tip/CMakeLists.txt
index b2ba264be..91048ea74 100644
--- a/src/modules/tip/CMakeLists.txt
+++ b/src/modules/tip/CMakeLists.txt
@@ -11,31 +11,5 @@ SET(kvitip_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitip_MOC_SRCS ${kvitip_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitip MODULE ${kvitip_SRCS} ${kvitip_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitip SHARED ${kvitip_SRCS} ${kvitip_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitip ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitip kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitip PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitip LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitip PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitip LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitip PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitip LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitip)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/tmphighlight/CMakeLists.txt b/src/modules/tmphighlight/CMakeLists.txt
index 8cd8b7468..fd5da41aa 100644
--- a/src/modules/tmphighlight/CMakeLists.txt
+++ b/src/modules/tmphighlight/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvitmphighlight_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitmphighlight_MOC_SRCS ${kvitmphighlight_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitmphighlight MODULE ${kvitmphighlight_SRCS} ${kvitmphighlight_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitmphighlight SHARED ${kvitmphighlight_SRCS} ${kvitmphighlight_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitmphighlight ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitmphighlight kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitmphighlight PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitmphighlight LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitmphighlight PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitmphighlight LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitmphighlight PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitmphighlight LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitmphighlight)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/toolbar/CMakeLists.txt b/src/modules/toolbar/CMakeLists.txt
index 179543388..14f13795e 100644
--- a/src/modules/toolbar/CMakeLists.txt
+++ b/src/modules/toolbar/CMakeLists.txt
@@ -7,31 +7,5 @@ SET(kvitoolbar_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitoolbar_MOC_SRCS ${kvitoolbar_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitoolbar MODULE ${kvitoolbar_SRCS} ${kvitoolbar_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitoolbar SHARED ${kvitoolbar_SRCS} ${kvitoolbar_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitoolbar ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitoolbar kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitoolbar PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitoolbar LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitoolbar PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitoolbar LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitoolbar PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitoolbar LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitoolbar)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/toolbareditor/CMakeLists.txt b/src/modules/toolbareditor/CMakeLists.txt
index 66ca2d994..be501833f 100644
--- a/src/modules/toolbareditor/CMakeLists.txt
+++ b/src/modules/toolbareditor/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kvitoolbareditor_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitoolbareditor_MOC_SRCS ${kvitoolbareditor_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitoolbareditor MODULE ${kvitoolbareditor_SRCS} ${kvitoolbareditor_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitoolbareditor SHARED ${kvitoolbareditor_SRCS} ${kvitoolbareditor_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitoolbareditor ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitoolbareditor kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitoolbareditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitoolbareditor LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitoolbareditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitoolbareditor LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitoolbareditor PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitoolbareditor LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitoolbareditor)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/torrent/CMakeLists.txt b/src/modules/torrent/CMakeLists.txt
index dfd27b8be..82823bb31 100644
--- a/src/modules/torrent/CMakeLists.txt
+++ b/src/modules/torrent/CMakeLists.txt
@@ -16,31 +16,5 @@ SET(kvitorrent_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitorrent_MOC_SRCS ${kvitorrent_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitorrent MODULE ${kvitorrent_SRCS} ${kvitorrent_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitorrent SHARED ${kvitorrent_SRCS} ${kvitorrent_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitorrent ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitorrent kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitorrent PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitorrent LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitorrent PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitorrent LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitorrent PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitorrent LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitorrent)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/trayicon/CMakeLists.txt b/src/modules/trayicon/CMakeLists.txt
index b11091c0b..13689c365 100644
--- a/src/modules/trayicon/CMakeLists.txt
+++ b/src/modules/trayicon/CMakeLists.txt
@@ -11,31 +11,5 @@ SET(kvitrayicon_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kvitrayicon_MOC_SRCS ${kvitrayicon_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kvitrayicon MODULE ${kvitrayicon_SRCS} ${kvitrayicon_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kvitrayicon SHARED ${kvitrayicon_SRCS} ${kvitrayicon_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kvitrayicon ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kvitrayicon kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kvitrayicon PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kvitrayicon LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kvitrayicon PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kvitrayicon LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kvitrayicon PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kvitrayicon LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kvitrayicon)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/url/CMakeLists.txt b/src/modules/url/CMakeLists.txt
index 7e95ccb5a..4eec1ed2c 100644
--- a/src/modules/url/CMakeLists.txt
+++ b/src/modules/url/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kviurl_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviurl_MOC_SRCS ${kviurl_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviurl MODULE ${kviurl_SRCS} ${kviurl_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviurl SHARED ${kviurl_SRCS} ${kviurl_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviurl ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviurl kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviurl PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviurl LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviurl PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviurl LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviurl PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviurl LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviurl)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)
diff --git a/src/modules/window/CMakeLists.txt b/src/modules/window/CMakeLists.txt
index 8691bf944..6bb949398 100644
--- a/src/modules/window/CMakeLists.txt
+++ b/src/modules/window/CMakeLists.txt
@@ -12,31 +12,5 @@ SET(kviwindow_SRCS
 # After this call, files will be moc'ed to moc_kvi_*.cpp
 QT4_WRAP_CPP(kviwindow_MOC_SRCS ${kviwindow_MOC_HDRS})
 
-# Create library
-IF(UNIX)
-	IF(APPLE)
-		ADD_LIBRARY(kviwindow MODULE ${kviwindow_SRCS} ${kviwindow_MOC_SRCS})
-	ELSE()
-		# Assume linux
-		ADD_LIBRARY(kviwindow SHARED ${kviwindow_SRCS} ${kviwindow_MOC_SRCS})
-	ENDIF()
-ELSE()
-	# Assume windows
-	#ADD_LIBRARY(kviwindow ???)
-ENDIF()
-
-# Install target
-IF(UNIX)
-	IF(APPLE)
-		TARGET_LINK_LIBRARIES(kviwindow kvilib ${LIBS})
-		SET_TARGET_PROPERTIES(kviwindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR} INSTALL_NAME_DIR @executable_path/../Frameworks)
-		INSTALL(TARGETS kviwindow LIBRARY DESTINATION ${INSTALL_PREFIX}/Contents/Resources/modules/)
-	ELSE()
-		# Assume linux
-		SET_TARGET_PROPERTIES(kviwindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-		INSTALL(TARGETS kviwindow LIBRARY DESTINATION ${INSTALL_PREFIX}/share/kvirc/${VERSION_BRANCH}/modules/)
-	ENDIF()
-ELSEIF(WIN32)
-	SET_TARGET_PROPERTIES(kviwindow PROPERTIES VERSION ${VERSION_RELEASE} SOVERSION ${VERSION_MAJOR})
-	#INSTALL(TARGETS kviwindow LIBRARY DESTINATION ${INSTALL_PREFIX}/ ??? /${VERSION_BRANCH}/modules/)
-ENDIF()
+SET(kvi_module_name kviwindow)
+INCLUDE(${CMAKE_SOURCE_DIR}/cmake/module.rules.txt)