diff --git a/bin/BuildSystem/QMakeBuildSystem.py b/bin/BuildSystem/QMakeBuildSystem.py
index 7e7488619..86ad017b2 100644
--- a/bin/BuildSystem/QMakeBuildSystem.py
+++ b/bin/BuildSystem/QMakeBuildSystem.py
@@ -1,113 +1,110 @@
 #
 # copyright (c) 2009 Ralf Habacker <ralf.habacker@freenet.de>
 #
 # definitions for the qmake build system
 
 import os
 import utils
 import compiler
 
 from BuildSystem.BuildSystemBase import *
 
 class QMakeBuildSystem(BuildSystemBase):
     def __init__( self):
         BuildSystemBase.__init__(self, "qmake")
         self.platform = ""
         if compiler.isMSVC():
             self.platform = "win32-%s" % self.compiler()
-            if compiler.isMSVC2011():
-                print("Warning: using win32-msvc2010 instead of win32-msvc2011")
-                self.platform = "win32-msvc2010"
         elif compiler.isMinGW():
             self.platform = "win32-g++"
         else:
             utils.die( "QMakeBuildSystem: unsupported compiler platform %s" % self.compiler() )
 
     def setPathes( self ):
             # for building qt with qmake
         utils.putenv( "PATH", os.path.join( self.buildDir(), "bin" ) + ";" + os.getenv("PATH") )
 
         # so that the mkspecs can be found, when -prefix is set
         utils.putenv( "QMAKEPATH", self.sourceDir() )
         # to be sure
         utils.putenv( "QMAKESPEC", os.path.join(self.sourceDir(), 'mkspecs', self.platform ))
 
     def configure( self, configureDefines="" ):
         """inplements configure step for Qt projects"""
 
         self.enterBuildDir()
 
         # here follows some automatic configure tool detection
         # 1. search for configure.exe in the order
         #      a. provided by method call
         #      b. in source directory
         # 2. if qmake is available search for a pro-file named as the package
         # 3. if a pro-file is available through configureOptions, run it with qmake
         # 4. otherwise run qmake without any pro file given
         configTool = os.path.join(self.configureSourceDir(), "configure.exe")
         qmakeTool = os.path.join(self.mergeDestinationDir(), "bin", "qmake.exe")
         topLevelProFilesFound = 0
         topLevelProFile = ""
         for fileListed in os.listdir(self.configureSourceDir()):
             if fileListed.endswith(".pro"):
                 if topLevelProFilesFound == 0:
                     topLevelProFile = os.path.join(self.configureSourceDir(), fileListed)
                 topLevelProFilesFound += 1
         if self.subinfo.options.configure.tool != None and self.subinfo.options.configure.tool != False:
             command = "%s %s" % (self.subinfo.options.configure.tool, self.configureOptions(configureDefines))
         elif os.path.exists(configTool):
             command = "%s %s" % (configTool, self.configureOptions(configureDefines))
         elif os.path.exists(qmakeTool):
             if utils.envAsBool("EMERGE_USE_CCACHE") and compiler.isMinGW():
                 configureDefines += ' "QMAKE_CC=ccache gcc" "QMAKE_CXX=ccache g++" '
             if self.buildType() == "Release":
                 configureDefines += ' "CONFIG -= debug"'
                 configureDefines += ' "CONFIG += release"'
                 configureDefines += ' "CONFIG -= debug_and_release"'
             elif self.buildType() == "Debug":
                 configureDefines += ' "CONFIG += debug"'
                 configureDefines += ' "CONFIG -= release"'
                 configureDefines += ' "CONFIG -= debug_and_release"'
             elif self.buildType() == "RelWithDebInfo":
                 configureDefines += ' "CONFIG -= debug"'
                 configureDefines += ' "CONFIG -= release"'
                 configureDefines += ' "CONFIG += debug_and_release"'
             if os.path.exists(topLevelProFile) and topLevelProFilesFound == 1:
                 command = "qmake -makefile %s %s" % (topLevelProFile, self.configureOptions(configureDefines))
             else:
                 command = "qmake %s" % self.configureOptions(configureDefines)
         else:
             utils.die("could not find configure.exe or top level pro-file, please take a look into the source and setup the config process.")
 
         return self.system( command, "configure" )
 
     def make( self, options=""):
         """implements the make step for Qt projects"""
         self.enterBuildDir()
 
         command = ' '.join([self.makeProgramm, self.makeOptions(options, maybeVerbose=False)])
 
         return self.system( command, "make" )
 
     def install( self, options=None ):
         """implements the make step for Qt projects"""
 
         # There is a bug in jom that parallel installation of qmake projects
         # does not work. So just use the usual make programs. It's hacky but
         # this was decided on the 2012 Windows sprint.
         if compiler.isMSVC():
             installmake="nmake /NOLOGO"
         elif compiler.isMinGW():
             installmake="mingw32-make"
 
         self.enterBuildDir()
         if options != None:
             command = "%s %s" % ( installmake, options )
         else:
             command = "%s install" % ( installmake )
 
         return self.system( command )
 
     def runTest( self ):
         """running qmake based unittests"""
         return True
diff --git a/bin/EmergeBase.py b/bin/EmergeBase.py
index 30ccd3798..f90e18a0b 100644
--- a/bin/EmergeBase.py
+++ b/bin/EmergeBase.py
@@ -1,378 +1,378 @@
 #
 # copyright (c) 2009 Ralf Habacker <ralf.habacker@freenet.de>
 #
 import utils
 import portage
 import os
 import sys
 import datetime
 import emergePlatform
 from ctypes import *
 import compiler
 
 ## @todo complete a release and binary merge dir below rootdir
 # 1.  enable build type related otDmerge install settings
 # 2a. use different install databases for debug and release
 # 3. binary packages which are build type independent should be
 # marked in both databases or should have a separate install database
 # question: How to detect reliable this case ?
 
 
 ROOTDIR = os.getenv( "KDEROOT" )
 COMPILER = os.getenv( "KDECOMPILER" )
 DOWNLOADDIR = os.getenv( "DOWNLOADDIR" )
 if ( DOWNLOADDIR == None ):
     DOWNLOADDIR = os.path.join( ROOTDIR, "distfiles" )
 
 KDESVNDIR = os.getenv( "KDESVNDIR" )
 if ( KDESVNDIR == None ):
     KDESVNDIR = os.path.join( DOWNLOADDIR, "svn-src", "kde" )
 KDESVNSERVER = os.getenv( "KDESVNSERVER" )
 if ( KDESVNSERVER == None ):
     KDESVNSERVER = "svn://anonsvn.kde.org"
 KDESVNUSERNAME = os.getenv( "KDESVNUSERNAME" )
 
 # ok, we have the following dirs:
 # ROOTDIR: the root where all this is below
 # DOWNLOADDIR: the dir under rootdir, where the downloaded files are put into
 # WORKDIR: the directory, under which the files are unpacked and compiled.
 #            here rootdir/tmp/packagename/work
 # IMAGEDIR: the directory, under which the compiled files are installed.
 #            here rootdir/tmp/packagename/image
 
 
 class EmergeBase(object):
     """base class for emerge system - holds attributes and methods required by base classes"""
 
     def __init__( self, **args):
         """args really should be documented, see self.argv0 below"""
         # TODO: some __init__  of subclasses need to already have been
         # called here. That is really the wrong way round.
         object.__init__(self)
         utils.debug( "EmergeBase.__init__ called", 2 )
 
         if not hasattr(self, 'subinfo'):
             # see the TODO above. This helps pylint understand the code, otherwise
             # it generates tons of error messages.
             self.subinfo = None
         if not hasattr(self, 'buildSystemType'):
             self.buildSystemType = None
 
         # if implicit build time dependency is wanted, depend on internal packages
         # for this class and all of its ancestor classes
         if utils.envAsBool('EMERGE_ENABLE_IMPLICID_BUILDTIME_DEPENDENCIES'):
             for cls in type(self).mro():
                 className = cls.__name__
                 packageName = 'internal/%s' % className
                 if os.path.exists(os.path.join(ROOTDIR, 'emerge', 'portage',
                         'internal', className, '%s-internal.py' % className)):
                     if self.subinfo and not packageName in self.subinfo.buildDependencies:
                         self.subinfo.buildDependencies[packageName] = 'default'
 
         if hasattr(self,'alreadyCalled'):
             return
         self.alreadyCalled = True
         self.buildTarget = None
 
         if "args" in list(args.keys()) and "argv0" in list(args["args"].keys()):
             self.argv0 = args["args"]["argv0"]
         else:
             self.argv0 = sys.argv[ 0 ]
 
         self.versioned              = False
         self.CustomDefines       = ""
         self.createCombinedPackage  = False
 
         ## specifies if a build type related root directory should be used
         self.useBuildTypeRelatedMergeRoot = False
         if utils.envAsBool("EMERGE_MERGE_ROOT_WITH_BUILD_TYPE"):
             self.useBuildTypeRelatedMergeRoot = True
 
         self.isoDateToday           = str( datetime.date.today() ).replace('-', '')
 
         self.noFetch = utils.envAsBool( "EMERGE_OFFLINE" )
         self.noCopy = utils.envAsBool( "EMERGE_NOCOPY")
         self.noFast = utils.envAsBool( "EMERGE_NOFAST", default=True )
         self.noClean = utils.envAsBool( "EMERGE_NOCLEAN" )
         self.forced = utils.envAsBool( "EMERGE_FORCED" )
         self.buildTests = utils.envAsBool( "EMERGE_BUILDTESTS" )
 
         if COMPILER == "msvc2005":
             self.__compiler = "msvc2005"
         elif COMPILER == "msvc2008":
             self.__compiler = "msvc2008"
         elif COMPILER == "msvc2010":
             self.__compiler = "msvc2010"
-        elif COMPILER == "msvc2011":
-            self.__compiler = "msvc2011"
+        elif COMPILER == "msvc2012":
+            self.__compiler = "msvc2012"
         elif COMPILER == "mingw":
             self.__compiler = "mingw"
         elif COMPILER == "mingw4":
             self.__compiler = "mingw4"
         else:
             print("emerge error: KDECOMPILER: '%s' not understood" % COMPILER, file=sys.stderr)
             exit( 1 )
         self.rootdir = ROOTDIR
         if self.subinfo:
             self.setup()
 
     def __adjustPath(self, directory):
         """return adjusted path"""
         if not self.subinfo.options.useShortPathes:
             return directory
         path = c_char_p(directory)
         length = windll.kernel32.GetShortPathNameA(path, 0, 0)
         if length == 0:
             return directory
         buf = create_string_buffer('\000' * (length + 1))
         windll.kernel32.GetShortPathNameA(path, byref(buf), length+1) # ignore function result...
         if utils.verbose() > 0:
             print("converting " + directory + " to " + buf.value)
         return buf.value
 
     def buildType(self):
         """return currently selected build type"""
         Type = os.getenv( "EMERGE_BUILDTYPE" )
         if ( not Type == None ):
             buildType = Type
         else:
             buildType = None
         return buildType
 
     def compiler(self):
         """return currently selected compiler"""
         return self.__compiler
 
     def isTargetBuild(self):
         if not emergePlatform.isCrossCompilingEnabled():
             return False
         else:
             return os.getenv( "EMERGE_BUILD_STEP" ) == "target"
 
     def isHostBuild(self):
         if not emergePlatform.isCrossCompilingEnabled():
             return True
         else:
             return os.getenv( "EMERGE_BUILD_STEP" ) == "host"
 
     def buildPlatform(self):
         """return the cross-compiling target platform"""
         if self.isTargetBuild():
             return os.getenv( "EMERGE_TARGET_PLATFORM" )
         else:
             return "WIN32"
 
     def buildArchitecture(self):
         """return the target CPU architecture"""
         if self.isTargetBuild():
             return os.getenv( "EMERGE_TARGET_ARCHITECTURE" )
         else:
             return os.getenv( "EMERGE_ARCHITECTURE" )
 
     def workDirPattern(self):
         """return base directory name for package related work directory"""
         directory = ""
         if self.subinfo.options.useCompilerType == True:
             directory += "%s-" % COMPILER
         if self.isTargetBuild():
             directory += "%s-" % self.buildPlatform()
         if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
             directory += "ide-"
         if self.subinfo.options.useBuildType == False:
             directory += "%s" % (self.buildTarget)
         elif( self.buildType() == None ):
             directory += "%s-%s" % ("default", self.buildTarget)
         else:
             directory += "%s-%s" % (self.buildType(), self.buildTarget)
         return directory
 
     def imageDirPattern(self):
         """return base directory name for package related image directory"""
         directory = "image"
 
         # we assume that binary packages are for all compiler and targets
         ## \todo add image directory support for using binary packages for a specific compiler and build type
         if self.buildSystemType == 'binary':
             return directory
 
         if self.subinfo.options.useCompilerType == True:
             directory += '-' + COMPILER
         if self.isTargetBuild():
             directory += "-%s" % self.buildPlatform()
         if self.subinfo.options.useBuildType == True:
             directory += '-' + self.buildType()
         directory += '-' + self.buildTarget
         return directory
 
     def downloadDir(self):
         """ location of directory where fetched files are  stored """
         return self.__adjustPath(DOWNLOADDIR)
 
     def sourceDir(self, dummyIndex=0):
         utils.abstract()
 
     def packageDir(self):
         """ add documentation """
         return self.__adjustPath( portage.getDirname( self.category, self.package ) )
 
     def buildRoot(self):
         """return absolute path to the root directory of the currently active package"""
         buildroot    = os.path.join( ROOTDIR, "build", self.category, self.PV )
         return self.__adjustPath(buildroot)
 
     def workDir(self):
         """return absolute path to the 'work' subdirectory of the currently active package"""
         _workDir = os.path.join( self.buildRoot(), "work" )
         return self.__adjustPath(_workDir)
 
     def buildDir(self):
         utils.debug("EmergeBase.buildDir() called", 2)
         self.setBuildTarget()
         builddir = os.path.join(self.workDir(), self.workDirPattern())
         if self.subinfo.options.unpack.unpackIntoBuildDir and self.subinfo.hasTargetSourcePath():
             builddir = os.path.join(builddir, self.subinfo.targetSourcePath())
         utils.debug("package builddir is: %s" % builddir, 2)
         return self.__adjustPath(builddir)
 
     def imageDir(self):
         """return absolute path to the install root directory of the currently active package
         """
         imageDir =  os.path.join( self.buildRoot(), self.imageDirPattern() )
         return self.__adjustPath(imageDir)
 
     def installDir(self):
         """return absolute path to the install directory of the currently active package.
         This path may point to a subdir of imageDir() in case @ref info.targetInstallPath is used
         """
         if self.subinfo.hasInstallPath():
             installDir = os.path.join( self.imageDir(), self.subinfo.installPath())
         elif self.subinfo.options.install.installPath:
             installDir = os.path.join(self.imageDir(), self.subinfo.options.install.installPath)
         else:
             installDir = self.imageDir()
         return self.__adjustPath(installDir)
 
     def mergeSourceDir(self):
         """return absolute path to the merge source directory of the currently active package.
         This path may point to a subdir of imageDir() in case @ref info.targetInstallPath for a
         specific target or @ref self.subinfo.options.merge.sourcePath is used
         """
         if self.subinfo.hasMergeSourcePath():
             directory = os.path.join( self.imageDir(), self.subinfo.mergeSourcePath() )
         elif not self.subinfo.options.merge.sourcePath == None:
             directory = os.path.join( self.imageDir(), self.subinfo.options.merge.sourcePath )
         else:
             directory = self.imageDir()
         return self.__adjustPath(directory)
 
     def mergeDestinationDir(self):
         """return absolute path to the merge destination directory of the currently active package.
         This path may point to a subdir of rootdir in case @ref info.targetMergePath for a specific
         build target or @ref self.subinfo.options.merge.destinationPath is used
         """
 
         if self.subinfo.hasMergePath():
             directory = os.path.join( ROOTDIR, self.subinfo.mergePath() )
         elif self.isTargetBuild():
             directory = os.path.join(ROOTDIR, self.buildPlatform())
         elif not self.subinfo.options.merge.destinationPath == None:
             directory = os.path.join( ROOTDIR, self.subinfo.options.merge.destinationPath )
         elif not self.useBuildTypeRelatedMergeRoot or self.subinfo.options.merge.ignoreBuildType:
             directory = ROOTDIR
         elif self.buildType() == 'Debug':
             directory = os.path.join(ROOTDIR,'debug')
         elif self.buildType() == 'Release':
             directory = os.path.join(ROOTDIR,'release')
         elif self.buildType() == 'RelWithDebInfo':
             directory = os.path.join(ROOTDIR,'relwithdebinfo')
         else:
             directory = ROOTDIR
         return self.__adjustPath(directory)
 
     def packageDestinationDir( self, withBuildType=True ):
         """return absolute path to the directory where binary packages are placed into.
         Default is to optionally append build type subdirectory"""
 
         utils.debug( "EmergeBase.packageDestinationDir called", 2 )
         dstpath = os.getenv( "EMERGE_PKGDSTDIR" )
         if not dstpath:
             dstpath = os.path.join( self.rootdir, "tmp" )
 
         if withBuildType:
             if utils.envAsBool( "EMERGE_MERGE_ROOT_WITH_BUILD_TYPE" ):
                 dstpath = os.path.join( dstpath, self.buildType())
 
         if not os.path.exists(dstpath):
             utils.createDir(dstpath)
         return dstpath
 
     def setBuildTarget( self, target = None):
         utils.debug( "EmergeBase.setBuildTarget called", 2 )
 
         self.subinfo.setBuildTarget(target)
         ## \todo replace self.buildTarget by self.buildTarget()
         self.buildTarget = self.subinfo.buildTarget
         if hasattr(self,'source'):
             # pylint: disable=E1101
             # this class never defines self.source, that happens only
             # in MultiSource.
             self.source.buildTarget = self.subinfo.buildTarget
 
     def setup( self, fileName=None, category=None, package=None, version=None, buildTarget=None):
         if fileName == None:
             self.PV, _ = os.path.splitext( os.path.basename( self.argv0 ) )
             self.category, self.package, self.version = portage.getCategoryPackageVersion( self.argv0 )
         else:
             self.category = category
             self.package = package
             self.version = version
             self.PV, _ = os.path.splitext( os.path.basename( fileName) )
         self.setBuildTarget(buildTarget)
         if hasattr(self,'source'):
             # pylint: disable=E1101
             # this class never defines self.source, that happens only
             # in MultiSource.
             self.source.setup( fileName, category, package, version, buildTarget)
 
     def enterBuildDir(self):
         utils.debug( "EmergeBase.enterBuildDir called", 2 )
 
         if ( not os.path.exists( self.buildDir() ) ):
             os.makedirs( self.buildDir() )
             if utils.verbose() > 0:
                 print("creating: %s" % self.buildDir())
 
         os.chdir( self.buildDir() )
         if utils.verbose() > 0:
             print("entering: %s" % self.buildDir())
 
     def enterSourceDir(self):
         if ( not os.path.exists( self.sourceDir() ) ):
             return False
         utils.warning("entering the source directory!")
         os.chdir( self.sourceDir() )
         if utils.verbose() > 0:
             print("entering: %s" % self.sourceDir())
 
     def system( self, command, errorMessage="", debuglevel=1, **kw):
         """convencience function for running system commands.
         This method prints a debug message and then runs a system command.
         If the system command returns with errors the method prints an error
         message and exits if @ref self.subinfo.options.exitOnErrors  is true"""
 
         utils.debug( str(command), debuglevel )
         if utils.system( command, **kw):
             return True
         if self.subinfo.options.exitOnErrors:
             utils.die( "while running %s cmd: %s" % (errorMessage, str(command)) )
         else:
             utils.warning( "while running %s cmd: %s" % (errorMessage, str(command)) )
         return False
 
     def proxySettings(self):
         host = os.getenv('EMERGE_PROXY_HOST')
         port = os.getenv('EMERGE_PROXY_PORT')
         username = os.getenv('EMERGE_PROXY_USERNAME')
         password = os.getenv('EMERGE_PROXY_PASSWORD')
         return [host, port, username, password]
 
diff --git a/bin/compiler.py b/bin/compiler.py
index ccff4f7bc..768981d3e 100644
--- a/bin/compiler.py
+++ b/bin/compiler.py
@@ -1,117 +1,117 @@
 # -*- coding: utf-8 -*-
 # this package contains functions to check the current compiler
 # copyright:
 # Patrick von Reth <patrick.vonreth [AT] gmail [DOT] com>
 
 import os
 import utils
 import subprocess
 import emergePlatform
 import re
 
 COMPILER = os.getenv("KDECOMPILER")
 
 GCCTARGET = None
 MINGW_VERSION = None
 
 def getGCCTarget():
     global GCCTARGET # pylint: disable=W0603
     if not GCCTARGET:
         try:
             result = str(subprocess.Popen("gcc -dumpmachine", stdout=subprocess.PIPE).communicate()[0],'windows-1252')
             utils.debug("GCC Target Processor:%s" % result, 1 )
             GCCTARGET = result.strip()
         except OSError:
             #if no mingw is installed return mingw-w32 it is part of base
             if os.getenv("EMERGE_ARCHITECTURE") == "x64":
                 GCCTARGET = "x86_64-w64-mingw32"
             else:
                 GCCTARGET = "i686-w64-mingw32"
     return GCCTARGET
 
 def isMinGW():
     return COMPILER.startswith("mingw")
 
 def isMinGW32():
     return isMinGW() and getGCCTarget() == "mingw32"
 
 def isMinGW_WXX():
     return isMinGW_W32() or isMinGW_W64()
 
 def isMinGW_W32():
     return isMinGW() and getGCCTarget() == "i686-w64-mingw32"
 
 def isMinGW_W64():
     return isMinGW() and emergePlatform.buildArchitecture() == "x64"
 
 def isMinGW_ARM():
     return isMinGW() and emergePlatform.buildArchitecture() == 'arm-wince'
 
 
 def isMSVC():
     return COMPILER.startswith("msvc")
 
 def isMSVC2005():
     return COMPILER == "msvc2005"
 
 def isMSVC2008():
     return COMPILER == "msvc2008"
 
 def isMSVC2010():
     return COMPILER == "msvc2010"
 
-def isMSVC2011():
-    return COMPILER == "msvc2011"
+def isMSVC2012():
+    return COMPILER == "msvc2012"
 
 
 def getCompilerName():
     if isMinGW():
         if isMinGW_W32():
             return "mingw-w32"
         elif isMinGW_W64():
             return "mingw-w64"
         elif isMinGW32():
             return "mingw32"
         elif isMinGW_ARM():
             return "arm-wince"
     elif isMSVC():
         return COMPILER
     else:
         return "Unknown Compiler"
 
 def getSimpleCompilerName():
     if isMinGW():
         if isMinGW_W64():
             return "mingw64"
         else:
             return "mingw"
     elif isMSVC():
         return "msvc"
     else:
         return "Unknown Compiler"
 
 def getMinGWVersion():
     global MINGW_VERSION # pylint: disable=W0603
     if not MINGW_VERSION:
         try:
             result = str(subprocess.Popen("gcc --version", stdout=subprocess.PIPE).communicate()[0],'windows-1252')
             result = re.findall("\d+\.\d+\.?\d*",result)[0]
             utils.debug("GCC Version:%s" % result, 1 )
             MINGW_VERSION = result.strip()
         except OSError:
             #if no mingw is installed return 0
             MINGW_VERSION = "0"
     return MINGW_VERSION
 
 def getVersion():
     if isMinGW():
         return "%s %s" % ( getCompilerName(), getMinGWVersion() )
     return "Microsoft Visual Studio 20%s" %  COMPILER[len(COMPILER)-2:]
 
 
 if __name__ == '__main__':
     print("Testing Compiler.py")
     print("Version: %s" % getVersion())
     print("Compiler Name: %s" % getCompilerName())
     print("Compiler Version: %s" % getMinGWVersion())
 
diff --git a/kdesettings-example.bat b/kdesettings-example.bat
index 98ea10f5f..5b4b9f43d 100644
--- a/kdesettings-example.bat
+++ b/kdesettings-example.bat
@@ -1,282 +1,282 @@
 @echo off
 
 rem Here you set the base directory under which the whole KDE subsystem will live.
 set KDEROOT=c:\kderoot
 
 rem ####### Compiler settings #######
 
 rem Here you set the compiler to be used.
 rem * mingw4   - use the mingw gcc compiler (recommended)
 rem * mingw    - use the mingw gcc compiler (gcc Version 3.4.5 - 
 rem               please only use this option if you are exactly 
 rem               sure about the consequences)
 rem * msvc2008 - use the Microsoft Visual C++ 2008 compiler
 rem * msvc2010 - use the Microsoft Visual C++ 2010 compiler
-rem * msvc2011 - use the Microsoft Visual C++ 2011 compiler (not supported) 
+rem * msvc2012 - use the Microsoft Visual C++ 2012 compiler 
 set KDECOMPILER=mingw4
 
 rem Here you can set the architecure for which packages are build. 
 rem Currently x86 (32bit), x64 (64) and arm (wince) are supported
 rem 
 rem               x86  x64  arm-wince
 rem  mingw4        x    x       x[1] 
 rem  mingw         x   ---     ---
 rem  msvc2005      x   ---     ---  
 rem  msvc2008      x   ---     ---
 rem  msvc2010      x   ---     ---
 rem 
 rem [1] by dev-utils/cegcc-arm-wince package
 rem 
 set EMERGE_ARCHITECTURE=x86
 rem set EMERGE_ARCHITECTURE=x64
 
 rem ####### Directory settings #######
 
 rem Here you change the download directory.
 rem If you want, so you can share the same download directory between
 rem mingw and msvc.
 set DOWNLOADDIR=%KDEROOT%\download
 rem This option defines the location for git checkouts.
 set KDEGITDIR=%KDEROOT%\git
 rem This option defines the location for svn checkouts.
 set KDESVNDIR=%KDEROOT%\svn
 
 rem substitute pathes by drives
 rem This option is needed to avoid path limit problems in case of long base pathes
 rem and compiling big packages like qt
 rem If you disable it do _not_ use any paths longer than 6 letters in the
 rem directory settings
 set EMERGE_USE_SHORT_PATH=1
 
 rem each drive could be commented out to skip substution
 set EMERGE_ROOT_DRIVE=r:
 set EMERGE_SVN_DRIVE=s:
 set EMERGE_GIT_DRIVE=q:
 set EMERGE_DOWNLOAD_DRIVE=t:
 
 rem ####### SVN Settings #######
 
 rem Here you can tell the emerge tool in which dir you want to save the
 rem SVN checkout of KDE source code. If you have SVN account registered
 rem within the KDE project, you can also set KDESVNUSERNAME and change
 rem KDESVNSERVER from svn://anonsvn.kde.org to https://svn.kde.org or
 rem svn+ssh://username@svn.kde.org, so that you can directly commit
 rem your changes from the emerge's SVN checkout. In case you use svn+ssh,
 rem also run 'plink username@svn.kde.org' after executing kdeenv.bat once
 rem to accept the fingerprint of the server or svn will hang forever when
 rem trying to download from the server.
 
 set KDESVNSERVER=svn://anonsvn.kde.org
 set KDESVNUSERNAME=username
 
 rem If you do not mind getting the output of the svn commands, then enable this
 rem option
 rem set KDESVNVERBOSE=True
 
 rem Non kde svn repository checkouts will be placed below %DOWNLOADDIR%/svn-src/<package>
 rem By default the emerge svn module supports only single branch svn checkouts.
 rem With this option emerge assumes that the svn repository have the svn standard layout 
 rem and will create related subdirectories for trunk, branches and tags below the above 
 rem mentioned root directory. 
 rem set EMERGE_SVN_STDLAYOUT=1
 
 rem If you use svn+ssh, you will need a ssh-agent equaivalent for managing
 rem the authorization. Pageant is provided by the Putty project, get it at 
 rem http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
 rem and make sure that plink is in your PATH and Pageant is configured
 rem (you need to import your key)
 set SVN_SSH=plink
 
 rem ####### Git Settings #######
 
 rem With this option set emerge checks out each git repository branch into a 
 rem separate subdirectory (see git clone --mirror at git clone  --shared --local).
 rem Without this option changing the branch will overwrite previous checkouts.
 rem Note: Changing the value invalidates available checkouts of related packages
 rem and requires a remove of the complete source dir.
 rem set EMERGE_GIT_MULTIBRANCH=True
 
 rem Setting up variables for git, not needed by emerge but preventing trouble
 rem with corrupted git pushes
 set GIT_SSH=plink
 set HOME=%USERPROFILE%
 rem set GIT_AUTHOR_NAME=authorname
 rem set GIT_AUTHOR_EMAIL=email
 rem set GIT_COMMITTER_NAME=username
 rem set GIT_COMMITTER_EMAIL=email
 
 rem ####### Python Settings #######
 
 rem Here you set the path to your Python installation,
 rem so that Python will be found, when Python scripts are be executed.
 rem By setting this here, you don't have to change the global environment
 rem settings of Windows. In case python is distributed with emerge the
 rem following setting is not used.
 if "%PYTHONPATH%" == "" (
     set PYTHONPATH="%PROGRAM_FILES%\python32"
 )
 
 rem ####### Proxy Settings #######
 
 rem proxy settings - in case a proxy is required uncomment the following variables 
 rem set EMERGE_PROXY_HOST=
 rem set EMERGE_PROXY_PORT=8080
 rem set EMERGE_PROXY_USERNAME=
 rem set EMERGE_PROXY_PASSWORD=
 
 rem Here you can set if emerge should not try to download files in passive mode
 rem set EMERGE_NO_PASSIVE_FTP=True
 
 rem ####### Visual Studio Settings #######
 
 rem Here you can adjust the path to your Visual Studio installation if needed
 rem This is used to set up the build environment automatically
 if %KDECOMPILER% == msvc2008 set VSDIR=%PROGRAM_FILES%\Microsoft Visual Studio 9.0
 if %KDECOMPILER% == msvc2010 set VSDIR=%PROGRAM_FILES%\Microsoft Visual Studio 10.0
-if %KDECOMPILER% == msvc2011 set VSDIR=%PROGRAM_FILES%\Microsoft Visual Studio 11.0
+if %KDECOMPILER% == msvc2012 set VSDIR=%PROGRAM_FILES%\Microsoft Visual Studio 11.0
 
 rem Here you can adjust the path to the Windows Mobile SDK installation
 rem This is used to set up the cross-compilation environment automatically
 if "%EMERGE_TARGET_PLATFORM%" == "WM50" set TARGET_SDKDIR=%PROGRAM_FILES%\Windows Mobile 5.0 SDK R2\PocketPC
 if "%EMERGE_TARGET_PLATFORM%" == "WM60" set TARGET_SDKDIR=%PROGRAM_FILES%\Windows Mobile 6 Professional SDK\PocketPC
 if "%EMERGE_TARGET_PLATFORM%" == "WM65" set TARGET_SDKDIR=%PROGRAM_FILES%\Windows Mobile 6 Professional SDK\PocketPC
 
 rem Here you can set a specific platform SDK to use with the Visual Studio toolchain
 rem Normally this is not needed as a default platform SDK is set by the build environment script
 rem set PSDKDIR=%PROGRAM_FILES%\Microsoft SDKs\Windows\v6.0A
 
 rem Here you can set the path to your Microsoft DirectX SDK installation
 rem This is not needed if you use MinGW or won't use the directx backend for Phonon
 rem set MSDXSDKDIR=%PROGRAM_FILES%\Microsoft DirectX SDK (August 2009)
 
 rem ####### Build Type Settings #######
 
 rem Here you can set type of the emerge build. 
 rem There are two standard build types: Debug and Release.
 rem Both are used if no EMERGE_BUILDTYPE is set.
 rem There is a third extra buildtype called RelWithDebInfo, which is
 rem release (optimized) build but containing debugging information.
 rem You can override the build type at the commandline using
 rem the '--buildtype=[BuildType]' option. The build type which is set here
 rem will not override the buildtype in .py package files.
 if "%1" == "debug" (
 set EMERGE_BUILDTYPE=Debug
 )
 if "%1" == "relwithdebinfo" (
 set EMERGE_BUILDTYPE=RelWithDebInfo
 )
 if "%1" == "release" (
 set EMERGE_BUILDTYPE=Release
 )
 if "%1" == "" (
 set EMERGE_BUILDTYPE=RelWithDebInfo
 )
 
 rem ####### Various Emerge Settings #######
 
 rem This option can be used to build only source packages and don't use binary packages
 rem it is needed for wince builds, but works everywhere and is the recommended way to
 rem use emerge.
 set EMERGE_SOURCEONLY=True
 
 rem override specific emerge options 
 rem This option makes it possible to set properties, which are defined in 
 rem bin\options.py. Multiple entries are separated by a space 
 rem Please note that properties may be overriden by dedicated package 
 rem  Example:
 rem    * set EMERGE_OPTIONS=cmake.useIDE=1 install.useMakeToolForInstall=1
 rem set EMERGE_OPTIONS=
 
 rem If you want to have verbose output, uncomment the following option
 rem and set it to positive integer for verbose output and to 0
 rem or disable it for normal output. Currently the highest verbosity level
 rem is 3 (equal to 'emerge -v -v -v'). level 0 equals 'emerge -q'
 set EMERGE_VERBOSE=1
 
 rem Enable this option if you want to have shorter build times, and less
 rem disk usage. It will then avoid copying source code files of the KDE
 rem svn repository. To disable, set EMERGE_NOCOPY=False.
 set EMERGE_NOCOPY=True
 
 rem By default emerge will merge all package into KDEROOT. By setting the following 
 rem option to true, the package will be installed into a subdir of KDEROOT. 
 rem The directory is named like the lower cased build type 
 rem When using this option you can run emerge/kdeenv.bat with the build mode type 
 rem parameter (release, releasedebug or debug) to have different shells for each 
 rem build type. 
 rem set EMERGE_MERGE_ROOT_WITH_BUILD_TYPE=True
 
 rem If you want to build all packages with buildTests option, enable
 rem this option. Applies only to the cmake based packages.
 rem set EMERGE_BUILDTESTS=True
 
 rem This option only applies if you want to make packages. It sets
 rem the output directory where your generated packages should be stored.
 rem set EMERGE_PKGDSTDIR=%KDEROOT%\tmp
 
 rem This option can be used to override the default make program
 rem change the value to the path of the executable you want to use instead.
 set EMERGE_MAKE_PROGRAM=%KDEROOT%\dev-utils\bin\jom.exe
 
 rem This option can be used to set the default category for packages with the same name
 rem that are contained in multiple categories; This is especially useful if you want
 rem to build e.g. from the 4.3 branch: simply set the variable to kde-4.3 then
 rem for all other packages this option doesn't have any effect
 rem set EMERGE_DEFAULTCATEGORY=kde-4.3
 
 rem This option can be used to set a directory where build logs are saved
 rem instead of being printed to the console. Logging information is appended to
 rem existing logs.
 rem set EMERGE_LOG_DIR=%KDEROOT%\buildlogs
 
 rem This option can be used to integrate packages from other portage directories
 rem or override the default packages. The default directory can be overridden by
 rem not including it in this list. If you do not set this option emerge will take
 rem the current portage directory instead.
 rem set EMERGE_PORTAGE_ROOT=C:\test\portage;%KDEROOT%\emerge\portage
 
 rem This option enables separating of package build dependencies from emerge internal 
 rem dependencies. When enabled packages depends on packages from the internal category 
 rem too. The packages from the internal package belongs to the related python class 
 rem with the same name. They provide a standardized way to define runtime dependencies 
 rem for emerge itself. 
 rem note: After finishing the testing phase this feature will be enabled by default 
 rem and this option removed. 
 rem set EMERGE_ENABLE_IMPLICID_BUILDTIME_DEPENDENCIES=1
 
 rem The following option makes the emerge run fail if applying patches fails
 rem the default is that failing patches do not result in a stop
 rem set EMERGE_HOLD_ON_PATCH_FAIL=True
 
 rem emerge supports two type of package state and manifest databases: a file based and
 rem an sqlite based. The file based database interacts better with kdewin
 rem installer/packager eg. you can directly integrate binary packages while the
 rem sqlite based database seems to be slighty faster but is only accessable
 rem through the emerge command line. This option let you choose the used on.
 rem By default the sqlite database is not used, because the implementation 
 rem results into errors on qmerge action.
 rem set EMERGE_ENABLE_SQLITEDB=FALSE
 
 rem ####### Cross Compiling
 
 rem The following variables are used for cross-compiling to Windows Mobile / WinCE
 rem when uncommented, the proper toolchain is set up for the specified target OS and architecture.
 rem EMERGE_TARGET_PLATFORM currently supports :
 rem * WM50 - Windows Mobile 5.0 PocketPC (based on WinCE 5.01)
 rem * WM60 - Windows Mobile 6.0 Professional (based on WinCE 5.02)
 rem * WM65 - Windows Mobile 6.5 Professional (based on WinCE 5.02)
 rem EMERGE_TARGET_ARCHITECTURE currently supports :
 rem * ARMV4I (all platforms)
 rem set EMERGE_TARGET_PLATFORM=WM60
 rem set EMERGE_TARGET_ARCHITECTURE=ARMV4I
 
 rem No editing should be necessary below this line (in an ideal world)
 rem ##################################################################
 
 rem internal used settings version only for emerge maintainers 
 rem increment for each definition change in this file and fix version
 rem issues in kdeenv.bat 
 rem Note: unset EMERGE_SETTINGS_VERSION means version 0
 SET EMERGE_SETTINGS_VERSION=1
 
 echo kdesettings.bat executed