Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-23 10:22:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove win and mac cruft

Browse source
This commit is contained in:
Ivailo Monev 2014-11-27 18:22:42 +00:00
parent 325dc03020
commit 3f0dd268de
39 changed files with 82 additions and 651 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
CreateKDELibsDependenciesFile.cmake
View file

@ -94,24 +94,6 @@ set(KDE4_TARGET_PREFIX ${KDE4_TARGET_PREFIX} )
")
# write library dependencies
if (WIN32)
file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/KDELibsDependencies.cmake"
"if (NOT QT_INSTALL_DIR)
set (QT_INSTALL_DIR \"${QT_INSTALL_DIR}\")
endif (NOT QT_INSTALL_DIR)
")
# replace hard coded paths by variables
# !!! the following stuff does not work because export_library_dependencies
# !!! does not wait until the file is written completely
# export_library_dependencies(${CMAKE_BINARY_DIR}/tmpdeps.cmake)
# file(READ ${CMAKE_BINARY_DIR}/tmpdeps.cmake _deps)
# string(REPLACE "${QT_INSTALL_DIR}" "\${QT_INSTALL_DIR}" __deps "${_deps}")
# file (APPEND ${CMAKE_BINARY_DIR}/KDELibsDependencies.cmake "${__deps}")
endif(WIN32)
# This variable defines whether KPty::login/logout have been built with
# utempter support so that they don't require special user permissions
# in order to work properly. Used by kwrited.

5
cmake/modules/FindKDE4Internal.cmake
View file

@ -562,13 +562,8 @@ else (_kdeBootStrapping)
get_target_property(_importedConfigurations ${KDE4_TARGET_PREFIX}kconfig_compiler IMPORTED_CONFIGURATIONS )
list(GET _importedConfigurations 0 _firstConfig)
if(NOT WINCE)
get_target_property(KDE4_KCFGC_EXECUTABLE ${KDE4_TARGET_PREFIX}kconfig_compiler LOCATION_${_firstConfig})
get_target_property(KDE4_MEINPROC_EXECUTABLE ${KDE4_TARGET_PREFIX}meinproc4 LOCATION_${_firstConfig})
else(NOT WINCE)
set(KDE4_KCFGC_EXECUTABLE ${HOST_BINDIR}/${CMAKE_CFG_INTDIR}/kconfig_compiler )
set(KDE4_MEINPROC_EXECUTABLE ${HOST_BINDIR}/${CMAKE_CFG_INTDIR}/meinproc4 )
endif(NOT WINCE)
get_target_property(KDE4_MAKEKDEWIDGETS_EXECUTABLE ${KDE4_TARGET_PREFIX}makekdewidgets LOCATION_${_firstConfig})
# allow searching cmake modules in all given kde install locations (KDEDIRS based)

4
cmake/modules/FindLibXslt.cmake
View file

@ -50,11 +50,7 @@ ELSE (LIBXSLT_INCLUDE_DIR AND LIBXSLT_LIBRARIES)
SET(LIBXSLT_FOUND FALSE)
ENDIF (LIBXSLT_INCLUDE_DIR AND LIBXSLT_LIBRARIES)
if(NOT WINCE)
FIND_PROGRAM(LIBXSLT_XSLTPROC_EXECUTABLE xsltproc)
else(NOT WINCE)
FIND_PROGRAM(LIBXSLT_XSLTPROC_EXECUTABLE xsltproc PATHS ${HOST_BINDIR} NO_DEFAULT_PATH)
endif(NOT WINCE)
# For compatibility with FindLibXslt.cmake from KDE 4.[01].x
SET(XSLTPROC_EXECUTABLE ${LIBXSLT_XSLTPROC_EXECUTABLE})

18
cmake/modules/FindQt4.cmake
View file

@ -1087,22 +1087,8 @@ IF (QT4_QMAKE_FOUND)
_find_qt4_program(QT_UIC_EXECUTABLE Qt4::uic uic-qt4 uic uic4)
_find_qt4_program(QT_UIC3_EXECUTABLE Qt4::uic3 uic3)
_find_qt4_program(QT_RCC_EXECUTABLE Qt4::rcc rcc)
if(NOT WINCE)
_find_qt4_program(QT_DBUSCPP2XML_EXECUTABLE Qt4::qdbuscpp2xml qdbuscpp2xml)
_find_qt4_program(QT_DBUSXML2CPP_EXECUTABLE Qt4::qdbusxml2cpp qdbusxml2cpp)
else()
FIND_PROGRAM(QT_DBUSCPP2XML_EXECUTABLE
NAMES qdbuscpp2xml
PATHS ${HOST_BINDIR}
NO_DEFAULT_PATH
)
FIND_PROGRAM(QT_DBUSXML2CPP_EXECUTABLE
NAMES qdbusxml2cpp
PATHS ${HOST_BINDIR}
NO_DEFAULT_PATH
)
endif()
_find_qt4_program(QT_DBUSCPP2XML_EXECUTABLE Qt4::qdbuscpp2xml qdbuscpp2xml)
_find_qt4_program(QT_DBUSXML2CPP_EXECUTABLE Qt4::qdbusxml2cpp qdbusxml2cpp)
_find_qt4_program(QT_LUPDATE_EXECUTABLE Qt4::lupdate lupdate-qt4 lupdate lupdate4)
_find_qt4_program(QT_LRELEASE_EXECUTABLE Qt4::lrelease lrelease-qt4 lrelease lrelease4)
_find_qt4_program(QT_QCOLLECTIONGENERATOR_EXECUTABLE Qt4::qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator)

233
cmake/modules/KDE4Macros.cmake
View file

@ -176,10 +176,6 @@ macro (_KDE4_GET_MOC_FLAGS _moc_flags)
set(${_moc_flags} ${${_moc_flags}} "-D${_current}")
endforeach(_current ${_defines})
if(Q_WS_WIN)
set(${_moc_flags} ${${_moc_flags}} -DWIN32)
endif(Q_WS_WIN)
# if Qt is installed only as framework, add -F /library/Frameworks to the moc arguments
# otherwise moc can't find the headers in the framework include dirs
if(APPLE AND "${QT_QTCORE_INCLUDE_DIR}" MATCHES "/Library/Frameworks/")
@ -781,62 +777,25 @@ macro (KDE4_ADD_KDEINIT_EXECUTABLE _target_NAME )
# keep the linking logic from the CMakeLists.txt on UNIX working (under UNIX all necessary libs are linked against the kdeinit
# library instead against the executable, under windows we want to have everything in the executable, but for compatibility we have to
# keep the library there-
if(WIN32)
if (MINGW)
list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_res.o _res_position)
else(MINGW)
list(FIND _SRCS ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}.rc _res_position)
endif(MINGW)
if(NOT _res_position EQUAL -1)
list(GET _SRCS ${_res_position} _resourcefile)
list(REMOVE_AT _SRCS ${_res_position})
endif(NOT _res_position EQUAL -1)
if (NOT CMAKE_AUTOMOC)
_automoc4_kde4_pre_target_handling(kdeinit_${_target_NAME} _SRCS)
endif()
set(_KDEINIT4_TARGET_NAME_ ${_target_NAME})
string(REGEX REPLACE "[-]" "_" _KDEINIT4_TARGET_NAME_ "${_KDEINIT4_TARGET_NAME_}")
configure_file(${KDE4_MODULE_DIR}/kde4init_win32lib_dummy.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp)
add_library(kdeinit_${_target_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_win32lib_dummy.cpp)
if (KDE4_ENABLE_FINAL)
kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
add_library(kdeinit_${_target_NAME} SHARED ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files})
else (KDE4_ENABLE_FINAL)
add_library(kdeinit_${_target_NAME} SHARED ${_SRCS})
endif (KDE4_ENABLE_FINAL)
if (KDE4_ENABLE_FINAL)
kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
if (NOT CMAKE_AUTOMOC)
_automoc4_kde4_post_target_handling(kdeinit_${_target_NAME})
endif()
else (KDE4_ENABLE_FINAL)
kde4_add_executable(${_target_NAME} "${_nogui}" ${_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
endif (KDE4_ENABLE_FINAL)
set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME})
target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY} kdeinit_${_target_NAME})
else(WIN32)
if (NOT CMAKE_AUTOMOC)
_automoc4_kde4_pre_target_handling(kdeinit_${_target_NAME} _SRCS)
endif()
if (KDE4_ENABLE_FINAL)
kde4_create_final_files(${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp _separate_files ${_SRCS})
add_library(kdeinit_${_target_NAME} SHARED ${CMAKE_CURRENT_BINARY_DIR}/kdeinit_${_target_NAME}_final_cpp.cpp ${_separate_files})
else (KDE4_ENABLE_FINAL)
add_library(kdeinit_${_target_NAME} SHARED ${_SRCS})
endif (KDE4_ENABLE_FINAL)
if (NOT CMAKE_AUTOMOC)
_automoc4_kde4_post_target_handling(kdeinit_${_target_NAME})
endif()
set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME})
if (Q_WS_MAC)
list(FIND _SRCS *.icns _icon_position)
if(NOT _icon_position EQUAL -1)
list(GET _SRCS ${_icon_position} _resourcefile)
endif(NOT _icon_position EQUAL -1)
endif (Q_WS_MAC)
kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
endif(WIN32)
set_target_properties(kdeinit_${_target_NAME} PROPERTIES OUTPUT_NAME kdeinit4_${_target_NAME})
kde4_add_executable(${_target_NAME} "${_nogui}" ${CMAKE_CURRENT_BINARY_DIR}/${_target_NAME}_dummy.cpp ${_resourcefile})
target_link_libraries(${_target_NAME} kdeinit_${_target_NAME})
endmacro (KDE4_ADD_KDEINIT_EXECUTABLE)
# Add a unit test, which is executed when running make test .
@ -877,21 +836,7 @@ macro (KDE4_ADD_UNIT_TEST _test_NAME)
endforeach(_filename)
get_target_property( loc ${_test_NAME} LOCATION )
if(WIN32)
if(MSVC_IDE)
STRING(REGEX REPLACE "\\$\\(.*\\)" "\${CTEST_CONFIGURATION_TYPE}" loc "${loc}")
endif()
# .bat because of rpath handling
set(_executable "${loc}.bat")
else(WIN32)
if (Q_WS_MAC AND NOT _nogui)
set(_executable ${EXECUTABLE_OUTPUT_PATH}/${_test_NAME}.app/Contents/MacOS/${_test_NAME})
else (Q_WS_MAC AND NOT _nogui)
# .shell because of rpath handling
set(_executable "${loc}.shell")
endif (Q_WS_MAC AND NOT _nogui)
endif(WIN32)
if (using_qtest AND KDE4_TEST_OUTPUT STREQUAL "xml")
#MESSAGE(STATUS "${_targetName} : Using QTestLib, can produce XML report.")
add_test( ${_targetName} ${_executable} -xml -o ${_targetName}.tml)
@ -980,17 +925,6 @@ macro (KDE4_ADD_EXECUTABLE _target_NAME)
set(_add_executable_param)
# determine additional parameters for add_executable()
# for GUI apps, create a bundle on OSX
if (Q_WS_MAC)
set(_add_executable_param MACOSX_BUNDLE)
endif (Q_WS_MAC)
# for GUI apps, this disables the additional console under Windows
if (WIN32)
set(_add_executable_param WIN32)
endif (WIN32)
if (_nogui)
set(_add_executable_param)
endif (_nogui)
@ -1023,11 +957,6 @@ macro (KDE4_ADD_EXECUTABLE _target_NAME)
endif (_test)
kde4_handle_rpath_for_executable(${_target_NAME})
if (WIN32)
target_link_libraries(${_target_NAME} ${QT_QTMAIN_LIBRARY})
endif (WIN32)
endmacro (KDE4_ADD_EXECUTABLE)
@ -1150,140 +1079,10 @@ macro (KDE4_CREATE_HTML_HANDBOOK _docbook)
endmacro (KDE4_CREATE_HTML_HANDBOOK)
# adds application icon to target source list
# 'appsources' - the sources of the application
# 'pngfiles' - specifies the list of icon files
# example: KDE4_ADD_WIN32_APP_ICON(myapp_SRCS "pics/cr16-myapp.png;pics/cr32-myapp.png")
macro (KDE4_ADD_WIN32_APP_ICON appsources)
message(STATUS "KDE4_ADD_WIN32_APP_ICON() is deprecated, use KDE4_ADD_APP_ICON() instead")
if (WIN32)
if(NOT WINCE)
find_program(PNG2ICO_EXECUTABLE NAMES png2ico)
else(NOT WINCE)
find_program(PNG2ICO_EXECUTABLE NAMES png2ico PATHS ${HOST_BINDIR} NO_DEFAULT_PATH )
endif(NOT WINCE)
string(REPLACE _SRCS "" appname ${appsources})
if (PNG2ICO_EXECUTABLE)
set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appname})
# png2ico is found by the above find_program
# message("png2ico ${_outfilename}.ico ${ARGN}")
exec_program(png2ico ARGS ${_outfilename}.ico ${ARGN})
# now make rc file for adding it to the sources
file(WRITE ${_outfilename}.rc "IDI_ICON1 ICON DISCARDABLE \"${_outfilename}.ico\"\n")
list(APPEND ${appsources} ${CMAKE_CURRENT_BINARY_DIR}/${appname}.rc)
endif(PNG2ICO_EXECUTABLE)
endif(WIN32)
endmacro (KDE4_ADD_WIN32_APP_ICON)
# adds application icon to target source list
# for detailed documentation see the top of FindKDE4Internal.cmake
macro (KDE4_ADD_APP_ICON appsources pattern)
set (_outfilename ${CMAKE_CURRENT_BINARY_DIR}/${appsources})
if (WIN32)
if(NOT WINCE)
find_program(PNG2ICO_EXECUTABLE NAMES png2ico)
else(NOT WINCE)
find_program(PNG2ICO_EXECUTABLE NAMES png2ico PATHS ${HOST_BINDIR} NO_DEFAULT_PATH )
endif(NOT WINCE)
if (PNG2ICO_EXECUTABLE)
string(REPLACE "*" "(.*)" pattern_rx "${pattern}")
file(GLOB files "${pattern}")
foreach (it ${files})
string(REGEX REPLACE "${pattern_rx}" "\\1" fn "${it}")
if (fn MATCHES ".*16.*" )
list (APPEND _icons ${it})
endif (fn MATCHES ".*16.*")
if (fn MATCHES ".*32.*" )
list (APPEND _icons ${it})
endif (fn MATCHES ".*32.*")
if (fn MATCHES ".*48.*" )
list (APPEND _icons ${it})
endif (fn MATCHES ".*48.*")
if (fn MATCHES ".*64.*" )
list (APPEND _icons ${it})
endif (fn MATCHES ".*64.*")
if (fn MATCHES ".*128.*" )
list (APPEND _icons ${it})
endif (fn MATCHES ".*128.*")
endforeach (it)
if (_icons)
add_custom_command(OUTPUT ${_outfilename}.ico ${_outfilename}.rc
COMMAND ${PNG2ICO_EXECUTABLE} ARGS --rcfile ${_outfilename}.rc ${_outfilename}.ico ${_icons}
DEPENDS ${PNG2ICO_EXECUTABLE} ${_icons}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
list(APPEND ${appsources} ${_outfilename}.rc)
else(_icons)
message(STATUS "Unable to find a related icon that matches pattern ${pattern} for variable ${appsources} - application will not have an application icon!")
endif(_icons)
else(PNG2ICO_EXECUTABLE)
message(STATUS "Unable to find the png2ico utility - application will not have an application icon!")
endif(PNG2ICO_EXECUTABLE)
endif(WIN32)
if (Q_WS_MAC)
# first generate .iconset directory structure, then convert to .icns format using the Mac OS X "iconutil" utility,
# to create retina compatible icon, you need png source files in pixel resolution 16x16, 32x32, 64x64, 128x128,
# 256x256, 512x512, 1024x1024
find_program(ICONUTIL_EXECUTABLE NAMES iconutil)
if (ICONUTIL_EXECUTABLE)
file(GLOB_RECURSE files "${pattern}")
add_custom_command(OUTPUT ${_outfilename}.iconset
COMMAND ${CMAKE_COMMAND} -E make_directory ${_outfilename}.iconset
DEPENDS ${files}
)
set(_icons)
macro(copy_icons _pattern output)
foreach(it ${files})
if(it MATCHES ${_pattern})
add_custom_command(OUTPUT ${_outfilename}.iconset/icon_${output}.png
COMMAND ${CMAKE_COMMAND} -E copy ${it} icon_${output}.png
WORKING_DIRECTORY ${_outfilename}.iconset
DEPENDS ${_outfilename}.iconset
)
list(APPEND _icons ${_outfilename}.iconset/icon_${output}.png)
endif(it MATCHES ${_pattern})
endforeach(it ${files})
endmacro(copy_icons)
copy_icons(".*16.*" "16x16")
copy_icons(".*32.*" "16x16@2x")
copy_icons(".*32.*" "32x32")
copy_icons(".*64.*" "32x32@2x")
copy_icons(".*128.*" "128x128")
copy_icons(".*256.*" "128x128@2x")
copy_icons(".*256.*" "256x256")
copy_icons(".*512.*" "256x256@2x")
copy_icons(".*512.*" "512x512")
copy_icons(".*1024.*" "512x512@2x")
if (_icons)
# generate .icns icon file
add_custom_command(OUTPUT ${_outfilename}.icns
COMMAND ${ICONUTIL_EXECUTABLE} --convert icns
--output ${_outfilename}.icns ${_outfilename}.iconset
DEPENDS ${_icons}
)
# This will register the icon into the bundle
set(MACOSX_BUNDLE_ICON_FILE ${appsources}.icns)
# Append the icns file to the sources list so it will be a dependency to the
# main target
list(APPEND ${appsources} ${_outfilename}.icns)
# Install the icon into the Resources dir in the bundle
set_source_files_properties(${_outfilename}.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
else(_icons)
message(STATUS "Unable to find an icon that matches pattern ${pattern}
for variable ${appsources} - application will not have an
application icon!
")
endif(_icons)
else(ICONUTIL_EXECUTABLE)
message(STATUS "Unable to find the iconutil utility - application will not have an application icon!")
endif(ICONUTIL_EXECUTABLE)
endif(Q_WS_MAC)
endmacro (KDE4_ADD_APP_ICON)

47
kconf_update/kconf_update.cpp
View file

@ -28,9 +28,6 @@
#include <QtCore/QFile>
#include <QtCore/QTextStream>
#include <QtCore/QTextCodec>
#ifdef _WIN32_WCE
#include <QtCore/QDir>
#endif
#include <kconfig.h>
#include <kconfiggroup.h>
@ -822,54 +819,10 @@ void KonfUpdate::gotScript(const QString &_script)
copyGroup(cg1, cg2);
}
cfg.sync();
#ifndef _WIN32_WCE
result = system(QFile::encodeName(QString("%1 < %2 > %3 2> %4").arg(cmd, scriptIn.fileName(), scriptOut.fileName(), scriptErr.fileName())));
#else
QString path_ = QDir::convertSeparators ( QFileInfo ( cmd ).absoluteFilePath() );
QString file_ = QFileInfo ( cmd ).fileName();
SHELLEXECUTEINFO execInfo;
memset ( &execInfo,0,sizeof ( execInfo ) );
execInfo.cbSize = sizeof ( execInfo );
execInfo.fMask = SEE_MASK_FLAG_NO_UI;
execInfo.lpVerb = L"open";
execInfo.lpFile = (LPCWSTR) path_.utf16();
execInfo.lpDirectory = (LPCWSTR) file_.utf16();
execInfo.lpParameters = (LPCWSTR) QString(" < %1 > %2 2> %3").arg( scriptIn.fileName(), scriptOut.fileName(), scriptErr.fileName()).utf16();
result = ShellExecuteEx ( &execInfo );
if (result != 0)
{
result = 0;
}
else
{
result = -1;
}
#endif
} else {
// No config file
#ifndef _WIN32_WCE
result = system(QFile::encodeName(QString("%1 2> %2").arg(cmd, scriptErr.fileName())));
#else
QString path_ = QDir::convertSeparators ( QFileInfo ( cmd ).absoluteFilePath() );
QString file_ = QFileInfo ( cmd ).fileName();
SHELLEXECUTEINFO execInfo;
memset ( &execInfo,0,sizeof ( execInfo ) );
execInfo.cbSize = sizeof ( execInfo );
execInfo.fMask = SEE_MASK_FLAG_NO_UI;
execInfo.lpVerb = L"open";
execInfo.lpFile = (LPCWSTR) path_.utf16();
execInfo.lpDirectory = (LPCWSTR) file_.utf16();
execInfo.lpParameters = (LPCWSTR) QString(" 2> %1").arg( scriptErr.fileName()).utf16();
result = ShellExecuteEx ( &execInfo );
if (result != 0)
{
result = 0;
}
else
{
result = -1;
}
#endif
}
// Copy script stderr to log file

2
kdecore/config/kconfig.cpp
View file

@ -175,14 +175,12 @@ QString KConfigPrivate::expandString(const QString& value)
newpath += oldpath;
setenv( "PATH", newpath, 1/*overwrite*/ );
// FIXME: wince does not have pipes
#ifndef _WIN32_WCE
FILE *fs = popen(QFile::encodeName(cmd).data(), "r");
if (fs) {
QTextStream ts(fs, QIODevice::ReadOnly);
result = ts.readAll().trimmed();
pclose(fs);
}
#endif
setenv( "PATH", oldpath, 1/*overwrite*/ );
aValue.replace( nDollarPos, nEndPos-nDollarPos, result );
nDollarPos += result.length();

5
kdecore/io/kmountpoint.cpp
View file

@ -389,11 +389,6 @@ KMountPoint::List KMountPoint::currentMountPoints(DetailsNeededFlags infoNeeded)
}
free( mntctl_buffer );
#elif defined(_WIN32_WCE)
Ptr mp(new KMountPoint);
mp->d->mountPoint = QString("/");
result.append(mp);
#else
STRUCT_SETMNTENT mnttab;
if ((mnttab = SETMNTENT(MNTTAB, "r")) == 0)

16
kdecore/io/kprocess.cpp
View file

@ -32,9 +32,6 @@
# define STD_OUTPUT_HANDLE 1
# define STD_ERROR_HANDLE 2
#ifdef _WIN32_WCE
#include <stdio.h>
#endif
void KProcessPrivate::writeAll(const QByteArray &buf, int fd)
{
@ -62,20 +59,12 @@ void KProcessPrivate::forwardStd(KProcess::ProcessChannel good, int fd)
void KProcessPrivate::_k_forwardStdout()
{
#ifndef _WIN32_WCE
forwardStd(KProcess::StandardOutput, STD_OUTPUT_HANDLE);
#else
forwardStd(KProcess::StandardOutput, (int)stdout);
#endif
}
void KProcessPrivate::_k_forwardStderr()
{
#ifndef _WIN32_WCE
forwardStd(KProcess::StandardError, STD_ERROR_HANDLE);
#else
forwardStd(KProcess::StandardError, (int)stderr);
#endif
}
/////////////////////////////
@ -282,16 +271,11 @@ void KProcess::setShellCommand(const QString &cmd)
// KShell::joinArgs() may generate these for security reasons.
setEnv(PERCENT_VARIABLE, QLatin1String("%"));
#ifndef _WIN32_WCE
WCHAR sysdir[MAX_PATH + 1];
UINT size = GetSystemDirectoryW(sysdir, MAX_PATH + 1);
d->prog = QString::fromUtf16((const ushort *) sysdir, size);
d->prog += QLatin1String("\\cmd.exe");
setNativeArguments(QLatin1String("/V:OFF /S /C \"") + cmd + QLatin1Char('"'));
#else
d->prog = QLatin1String("\\windows\\cmd.exe");
setNativeArguments(QLatin1String("/S /C \"") + cmd + QLatin1Char('"'));
#endif
#endif
}

3
kdecore/io/ktempdir.cpp
View file

@ -51,9 +51,6 @@
#include "kde_file.h"
#ifdef _WIN32_WCE
#include <shellapi.h>
#endif
class KTempDir::Private
{

10
kdecore/kernel/kstandarddirs.cpp
View file

@ -1366,19 +1366,9 @@ bool KStandardDirs::makeDir(const QString& dir, int mode)
static QString readEnvPath(const char *env)
{
QByteArray c_path;
#ifndef _WIN32_WCE
c_path = qgetenv(env);
if (c_path.isEmpty())
return QString();
#else
bool ok;
QString retval = getWin32RegistryValue(HKEY_LOCAL_MACHINE, "Software\\kde", "KDEDIRS", &ok);
if (!ok){
return QString();
} else {
c_path = retval.toLatin1();
}
#endif
return QDir::fromNativeSeparators(QFile::decodeName(c_path));
}

2
kdecore/localization/kcatalog.cpp
View file

@ -39,9 +39,7 @@ static bool s_localeSet = false;
// a Q[Core]Application exists (David)
int kInitializeLocale()
{
#ifndef _WIN32_WCE
setlocale(LC_ALL, "");
#endif
extern Q_CORE_EXPORT bool qt_locale_initialized; // in Qt since 4.5.0
qt_locale_initialized = true; // as recommended by Thiago
s_localeSet = true;

10
kdecore/tests/CMakeLists.txt
View file

@ -6,18 +6,12 @@ MACRO(KDECORE_UNIT_TESTS)
FOREACH(_testname ${ARGN})
kde4_add_unit_test(${_testname} TESTNAME "kdecore-${_testname}" NOGUI ${_testname}.cpp)
target_link_libraries(${_testname} ${KDE4_KDECORE_LIBS} ${QT_QTTEST_LIBRARY} ${QT_QTNETWORK_LIBRARY})
if(WINCE)
target_link_libraries(${_testname} ${WCECOMPAT_LIBRARIES})
endif(WINCE)
ENDFOREACH(_testname)
ENDMACRO(KDECORE_UNIT_TESTS)
MACRO(KDECORE_EXECUTABLE_TESTS)
FOREACH(_testname ${ARGN})
kde4_add_executable(${_testname} NOGUI TEST ${_testname}.cpp)
target_link_libraries(${_testname} ${KDE4_KDECORE_LIBS} ${QT_QTTEST_LIBRARY})
if(WINCE)
target_link_libraries(${_testname} ${WCECOMPAT_LIBRARIES})
endif(WINCE)
ENDFOREACH(_testname)
ENDMACRO(KDECORE_EXECUTABLE_TESTS)
@ -169,8 +163,6 @@ endif(NOT KDE_NO_DEPRECATED)
########### module for klibloadertest4 ###############
if (NOT WIN32) # TODO: reenable for win32
set(klibloadertestmodule4_PART_SRCS klibloadertest4_module.cpp )
kde4_add_plugin(klibloadertestmodule4 ${klibloadertestmodule4_PART_SRCS})
@ -179,8 +171,6 @@ target_link_libraries(klibloadertestmodule4 ${KDE4_KDECORE_LIBS} ${QT_QTTEST_LI
set_target_properties(klibloadertestmodule4 PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE)
endif (NOT WIN32)
########### kcompositejobtest ###############
set(kcompositejobtest_SRCS kcompositejobtest.cpp)

5
kded/CMakeLists.txt
View file

@ -71,11 +71,8 @@ target_link_libraries( kbuildsycoca4 kdeinit_kbuildsycoca4 )
install(TARGETS kbuildsycoca4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
########### install files ###############
if (WIN32)
install( FILES applications.menu DESTINATION ${SHARE_INSTALL_PREFIX}/xdg/menus )
else (WIN32)
install( FILES applications.menu DESTINATION ${SYSCONF_INSTALL_DIR}/xdg/menus )
endif (WIN32)
install( FILES kdedmodule.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )

2
kded/kded.cpp
View file

@ -923,9 +923,7 @@ extern "C" KDE_EXPORT int kdemain(int argc, char *argv[])
Kded *kded = new Kded(); // Build data base
#ifndef _WIN32_WCE
KDE_signal(SIGTERM, sighandler);
#endif
KDE_signal(SIGHUP, sighandler);
KDEDApplication k;
k.setQuitOnLastWindowClosed(false);

4
kdemacros.h.cmake
View file

@ -73,10 +73,6 @@
#define KDE_NO_EXPORT __attribute__ ((visibility("hidden")))
#define KDE_EXPORT __attribute__ ((visibility("default")))
#define KDE_IMPORT __attribute__ ((visibility("default")))
#elif defined(_WIN32) || defined(_WIN64)
#define KDE_NO_EXPORT
#define KDE_EXPORT __declspec(dllexport)
#define KDE_IMPORT __declspec(dllimport)
#else
#define KDE_NO_EXPORT
#define KDE_EXPORT

17
kdeui/CMakeLists.txt
View file

@ -333,7 +333,6 @@ else(Q_WS_MAC AND MAC_USE_OSXKEYCHAIN)
set(kdeui_LIB_SRCS ${kdeui_LIB_SRCS} util/kwallet.cpp)
endif(Q_WS_MAC AND MAC_USE_OSXKEYCHAIN)
if(NOT WINCE)
set(kdeui_LIB_SRCS
${kdeui_LIB_SRCS}
dialogs/kdeprintdialog.cpp
@ -342,8 +341,6 @@ set(kdeui_LIB_SRCS
notifications/kstatusnotifieritemdbus_p.cpp
notifications/ksystemtrayicon.cpp
)
endif(NOT WINCE)
if (Q_WS_X11)
@ -421,10 +418,8 @@ qt4_add_dbus_interface(kdeui_LIB_SRCS ${statusnotifierwatcher_xml} statusnotifie
set(notifications_xml ${CMAKE_CURRENT_SOURCE_DIR}/notifications/org.freedesktop.Notifications.xml)
qt4_add_dbus_interface(kdeui_LIB_SRCS ${notifications_xml} notifications_interface)
if(NOT WINCE)
qt4_add_dbus_adaptor(kdeui_LIB_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/notifications/org.kde.StatusNotifierItem.xml
${CMAKE_CURRENT_SOURCE_DIR}/notifications/kstatusnotifieritemdbus_p.h KStatusNotifierItemDBus)
endif(NOT WINCE)
set(kglobalaccel_xml ${CMAKE_CURRENT_SOURCE_DIR}/shortcuts/org.kde.KGlobalAccel.xml)
set_source_files_properties(${kglobalaccel_xml} PROPERTIES INCLUDE "kglobalshortcutinfo_p.h")
@ -444,9 +439,7 @@ kde4_add_library(kdeui ${LIBRARY_TYPE} ${kdeui_LIB_SRCS})
target_link_libraries(kdeui ${KDE4_KDECORE_LIBS} ${X11_LIBRARIES} ${QT_QTGUI_LIBRARY}
${QT_QTXML_LIBRARY} ${KDEUI_EXTRA_LIBS} ${QT_QTNETWORK_LIBRARY})
if(NOT WINCE)
target_link_libraries(kdeui ${QT_QTSVG_LIBRARY} ${DBUSMENUQT_LIBRARIES})
endif(NOT WINCE)
if(MINGW)
target_link_libraries(kdeui gdi32 oleaut32)
@ -477,9 +470,7 @@ endif(X11_Xrender_FOUND)
target_link_libraries(kdeui LINK_INTERFACE_LIBRARIES kdecore ${QT_QTGUI_LIBRARY})
if(NOT WINCE)
target_link_libraries(kdeui LINK_INTERFACE_LIBRARIES ${QT_QTSVG_LIBRARY})
endif(NOT WINCE)
set_target_properties(kdeui PROPERTIES VERSION ${KDE_NON_GENERIC_LIB_VERSION}
SOVERSION ${KDE_NON_GENERIC_LIB_SOVERSION}
@ -488,13 +479,7 @@ set_target_properties(kdeui PROPERTIES VERSION ${KDE_NON_GENERIC_LIB_VERSION}
install(TARGETS kdeui EXPORT kdelibsLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
########### install files ###############
if (Q_WS_MAC)
install( FILES util/kkeyserver_mac.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
elseif (Q_WS_WIN)
install( FILES util/kkeyserver_win.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel )
else(Q_WS_WIN)
install( FILES util/fixx11h.h util/kkeyserver_x11.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
endif (Q_WS_MAC)
install( FILES util/fixx11h.h util/kkeyserver_x11.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
install( FILES
dialogs/aboutkde.png

2
kdeui/dialogs/kshortcutseditor.cpp
View file

@ -618,7 +618,6 @@ more important things):
void KShortcutsEditorPrivate::printShortcuts() const
{
// One cant print on wince
#ifndef _WIN32_WCE
QTreeWidgetItem* root = ui.list->invisibleRootItem();
QTextDocument doc;
doc.setDefaultFont(KGlobalSettings::generalFont());
@ -722,7 +721,6 @@ void KShortcutsEditorPrivate::printShortcuts() const
doc.print(&printer);
}
delete dlg;
#endif
}
#include "kshortcutseditor.moc"

4
kdeui/icons/kiconloader.cpp
View file

@ -43,9 +43,7 @@
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
#include <QtGui/QPixmapCache>
#ifndef _WIN32_WCE
#include <QtSvg/QSvgRenderer>
#endif
// kdecore
#include <kconfig.h>
@ -786,7 +784,6 @@ QImage KIconLoaderPrivate::createIconImage(const QString &path, int size)
}
else
{
#ifndef _WIN32_WCE
QSvgRenderer renderer(path, q);
if (renderer.isValid()) {
@ -795,7 +792,6 @@ QImage KIconLoaderPrivate::createIconImage(const QString &path, int size)
QPainter p(&img);
renderer.render(&p);
}
#endif
}
return img;

4
kdeui/util/kpixmapcache.cpp
View file

@ -40,9 +40,7 @@
#include <kdebug.h>
#include <klockfile.h>
#include <ksavefile.h>
#ifndef _WIN32_WCE
#include <ksvgrenderer.h>
#endif
#include <kdefakes.h>
#include <config.h>
@ -1469,7 +1467,6 @@ QPixmap KPixmapCache::loadFromFile(const QString& filename)
return pix;
}
#ifndef _WIN32_WCE
QPixmap KPixmapCache::loadFromSvg(const QString& filename, const QSize& size)
{
QFileInfo fi(filename);
@ -1502,5 +1499,4 @@ QPixmap KPixmapCache::loadFromSvg(const QString& filename, const QSize& size)
return pix;
}
#endif

34
kdewidgets/CMakeLists.txt
View file

@ -46,14 +46,12 @@ if(QT_QTDESIGNER_FOUND)
kde4_add_plugin(kdewidgets ${kdewidgets_PART_SRCS})
target_link_libraries(kdewidgets ${KDE4_KIO_LIBS})
if(NOT WIN32)
set_target_properties(kdewidgets PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
endif(NOT WIN32)
set_target_properties(kdewidgets PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
install(TARGETS kdewidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
@ -76,14 +74,12 @@ if(QT_QTDESIGNER_FOUND)
kde4_add_plugin(kdedeprecated ${kdedeprecated_PART_SRCS})
target_link_libraries(kdedeprecated ${KDE4_KIO_LIBS})
if(NOT WIN32)
set_target_properties(kdedeprecated PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
endif(NOT WIN32)
set_target_properties(kdedeprecated PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
install(TARGETS kdedeprecated DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
endif(NOT KDE_NO_DEPRECATED)
@ -111,14 +107,12 @@ if(QT_QTDESIGNER_FOUND)
kde4_add_plugin(kdewebkitwidgets ${kdewebkitwidgets_PART_SRCS})
target_link_libraries(kdewebkitwidgets ${KDE4_KDEUI_LIBS} ${KDE4_KDEWEBKIT_LIBS} ${QT_QTWEBKIT_LIBRARY})
if(NOT WIN32)
set_target_properties(kdewebkitwidgets PROPERTIES
set_target_properties(kdewebkitwidgets PROPERTIES
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH TRUE
BUILD_WITH_INSTALL_RPATH TRUE
INSTALL_RPATH ${LIB_INSTALL_DIR}
)
endif(NOT WIN32)
)
install(TARGETS kdewebkitwidgets DESTINATION ${PLUGIN_INSTALL_DIR}/plugins/designer )
endif (QT_QTDESIGNER_FOUND)

30
kdoctools/CMakeLists.txt
View file

@ -46,18 +46,8 @@ set_package_properties(DocBookXSL PROPERTIES DESCRIPTION "DocBook XSL"
set (_custom_dtd_kdex "customization/dtd/kdex.dtd")
configure_file(${_custom_dtd_kdex}.cmake ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex} )
# WARNING: this is due to severe limitations on the windows platform to keep the dtd relocateable
# see the .xsl.cmake files for a more verbose explanation below
if(NOT WIN32)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex}
DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization/dtd )
else(NOT WIN32)
install(CODE
"FILE(RELATIVE_PATH DOCBOOKXML_CURRENTDTD_DIR \${CMAKE_INSTALL_PREFIX}/${DATA_INSTALL_DIR}/ksgmltools2/customization/dtd ${DOCBOOKXML_CURRENTDTD_DIR})
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/${_custom_dtd_kdex}.cmake ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex}.install)")
get_filename_component(_custom_dtd_kdex_name ${_custom_dtd_kdex} NAME)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex}.install DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization/dtd RENAME ${_custom_dtd_kdex_name})
endif(NOT WIN32)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_custom_dtd_kdex}
DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization/dtd )
configure_file(config-kdoctools.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kdoctools.h )
@ -155,11 +145,6 @@ target_link_libraries(genshortcutents ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS})
########### customize includes for xslt ###############
# WARNING: this has severe limitations on the windows platform since the .xsl
# & docbook files need to be relocatable. We cannot just replace the paths in
# the .xsl with relative paths because these files are not installed while
# building kdelibs. Instead, we will reconfigure those files at install time
# with relative paths.
file( GLOB _kdeincludexslt_ALL "customization/kde-include*.xsl.cmake" )
foreach( _kdeincludexslt ${_kdeincludexslt_ALL} )
@ -167,15 +152,8 @@ foreach( _kdeincludexslt ${_kdeincludexslt_ALL} )
string( REGEX REPLACE ".cmake$" "" _kdeincludexslt_out "${_kdeincludexslt_name}" )
set( _kdeincludexslt_binarypath "${CMAKE_CURRENT_BINARY_DIR}/customization/${_kdeincludexslt_out}" )
configure_file( ${_kdeincludexslt} ${_kdeincludexslt_binarypath} )
if(NOT WIN32)
install(FILES ${_kdeincludexslt_binarypath}
DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization )
else(NOT WIN32)
install(CODE
"FILE(RELATIVE_PATH DOCBOOKXSL_DIR \${CMAKE_INSTALL_PREFIX}/${DATA_INSTALL_DIR}/ksgmltools2/customization ${DOCBOOKXSL_DIR})
CONFIGURE_FILE( ${_kdeincludexslt} ${_kdeincludexslt_binarypath}.install )")
install(FILES ${_kdeincludexslt_binarypath}.install DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization RENAME ${_kdeincludexslt_out})
endif(NOT WIN32)
install(FILES ${_kdeincludexslt_binarypath}
DESTINATION ${DATA_INSTALL_DIR}/ksgmltools2/customization )
endforeach( _kdeincludexslt ${_kdeincludexslt_ALL} )

15
kfile/kfileplacesmodel.cpp
View file

@ -21,11 +21,6 @@
#include "kfileplacesitem_p.h"
#include "kfileplacessharedbookmarks_p.h"
#ifdef _WIN32_WCE
#include "Windows.h"
#include "WinBase.h"
#include <QtCore/QDir>
#endif
#include <QtCore/QMimeData>
#include <QtCore/QTimer>
@ -121,19 +116,9 @@ KFilePlacesModel::KFilePlacesModel(QObject *parent)
KFilePlacesItem::createSystemBookmark(d->bookmarkManager,
"Network", I18N_NOOP2("KFile System Bookmarks", "Network"),
KUrl("remote:/"), "network-workgroup");
#if defined(_WIN32_WCE)
// adding drives
foreach ( const QFileInfo& info, QDir::drives() ) {
QString driveIcon = "drive-harddisk";
KFilePlacesItem::createSystemBookmark(d->bookmarkManager,
info.absoluteFilePath(), info.absoluteFilePath(),
KUrl(info.absoluteFilePath()), driveIcon);
}
#else
KFilePlacesItem::createSystemBookmark(d->bookmarkManager,
"Root", I18N_NOOP2("KFile System Bookmarks", "Root"),
KUrl("/"), "folder-red");
#endif
KFilePlacesItem::createSystemBookmark(d->bookmarkManager,
"Trash", I18N_NOOP2("KFile System Bookmarks", "Trash"),
KUrl("trash:/"), "user-trash");

101
kinit/CMakeLists.txt
View file

@ -27,29 +27,13 @@ endif(HAVE_SOCKET_LIBRARY)
########### kdeinit4 ###############
if (WIN32)
set(kdeinit_SRCS kinit_win.cpp klauncher_cmds.cpp )
if(NOT WINCE)
set(kdeinit_LIBS psapi)
else(NOT WINCE)
set(kdeinit_LIBS Toolhelp.lib)
endif(NOT WINCE)
else (WIN32)
set(kdeinit_SRCS kinit.cpp proctitle.cpp klauncher_cmds.cpp )
set(kdeinit_LIBS "")
endif (WIN32)
set(kdeinit_SRCS kinit.cpp proctitle.cpp klauncher_cmds.cpp )
set(kdeinit_LIBS "")
# on win32 kdeinit4 has to be a console application
# to be able to catch stderr based --verbose output
if (Q_WS_MAC)
# this has to be GUI on OSX because it launches GUI apps and need a quartz context
kde4_add_executable(kdeinit4 ${kdeinit_SRCS})
set_target_properties(kdeinit4 PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/Info.plist.template)
set_target_properties(kdeinit4 PROPERTIES MACOSX_BUNDLE_GUI_IDENTIFIER "org.kde.kdeinit4")
set_target_properties(kdeinit4 PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "KDE Init")
else (Q_WS_MAC)
kde4_add_executable(kdeinit4 NOGUI ${kdeinit_SRCS})
endif (Q_WS_MAC)
kde4_add_executable(kdeinit4 NOGUI ${kdeinit_SRCS})
target_link_libraries(kdeinit4 ${KDE4_KDEUI_LIBS} ${kdeinit_LIBS} ${KINIT_SOCKET_LIBRARY} )
if (Q_WS_X11)
@ -59,63 +43,52 @@ endif(Q_WS_X11)
install(TARGETS kdeinit4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
########### kwrapper4 ###############
if (WIN32)
set(kwrapper_SRCS kwrapper_win.cpp )
else (WIN32)
set(kwrapper_SRCS kwrapper.c )
endif (WIN32)
set(kwrapper_SRCS kwrapper.c )
kde4_add_executable(kwrapper4 NOGUI ${kwrapper_SRCS})
if (WIN32)
target_link_libraries(kwrapper4 ${KDE4_KDECORE_LIBS} ${KINIT_SOCKET_LIBRARY})
else (WIN32)
target_link_libraries(kwrapper4 ${KINIT_SOCKET_LIBRARY})
endif (WIN32)
target_link_libraries(kwrapper4 ${KINIT_SOCKET_LIBRARY})
install(TARGETS kwrapper4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
if (NOT WIN32)
########### kdeinit4_wrapper ###############
########### kdeinit4_wrapper ###############
kde4_add_executable(kdeinit4_wrapper NOGUI wrapper.c)
kde4_add_executable(kdeinit4_wrapper NOGUI wrapper.c)
target_link_libraries(kdeinit4_wrapper ${KINIT_SOCKET_LIBRARY})
target_link_libraries(kdeinit4_wrapper ${KINIT_SOCKET_LIBRARY})
if (NOT Q_WS_X11 AND NOT Q_WS_QWS)
if (NOT Q_WS_X11 AND NOT Q_WS_QWS)
add_definitions(-DNO_DISPLAY)
endif (NOT Q_WS_X11 AND NOT Q_WS_QWS)
endif (NOT Q_WS_X11 AND NOT Q_WS_QWS)
install(TARGETS kdeinit4_wrapper ${INSTALL_TARGETS_DEFAULT_ARGS} )
install(TARGETS kdeinit4_wrapper ${INSTALL_TARGETS_DEFAULT_ARGS} )
########### kshell4 ###############
########### kshell4 ###############
kde4_add_executable(kshell4 NOGUI shell.c)
kde4_add_executable(kshell4 NOGUI shell.c)
target_link_libraries(kshell4 ${KINIT_SOCKET_LIBRARY})
target_link_libraries(kshell4 ${KINIT_SOCKET_LIBRARY})
install(TARGETS kshell4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
install(TARGETS kshell4 ${INSTALL_TARGETS_DEFAULT_ARGS} )
########### kdeinit4_shutdown ###############
########### kdeinit4_shutdown ###############
kde4_add_executable(kdeinit4_shutdown NOGUI wrapper.c)
kde4_add_executable(kdeinit4_shutdown NOGUI wrapper.c)
target_link_libraries(kdeinit4_shutdown ${KINIT_SOCKET_LIBRARY})
target_link_libraries(kdeinit4_shutdown ${KINIT_SOCKET_LIBRARY})
install(TARGETS kdeinit4_shutdown ${INSTALL_TARGETS_DEFAULT_ARGS} )
install(TARGETS kdeinit4_shutdown ${INSTALL_TARGETS_DEFAULT_ARGS} )
########### lnusertemp ###############
########### lnusertemp ###############
set(lnusertemp_SRCS lnusertemp.c )
set(lnusertemp_SRCS lnusertemp.c )
kde4_add_executable(lnusertemp NOGUI ${lnusertemp_SRCS})
kde4_add_executable(lnusertemp NOGUI ${lnusertemp_SRCS})
target_link_libraries(lnusertemp kdefakes)
target_link_libraries(lnusertemp kdefakes)
install(TARGETS lnusertemp DESTINATION ${LIBEXEC_INSTALL_DIR} )
endif (NOT WIN32)
install(TARGETS lnusertemp DESTINATION ${LIBEXEC_INSTALL_DIR} )
########### kioslave ###############
@ -155,20 +128,18 @@ target_link_libraries( klauncher kdeinit_klauncher )
install(TARGETS klauncher DESTINATION ${LIBEXEC_INSTALL_DIR} )
########### start_kdeinit ###############
if (NOT WIN32)
set(start_kdeinit_SRCS start_kdeinit.c)
kde4_add_executable(start_kdeinit ${start_kdeinit_SRCS})
if(KDE4_ENABLE_FPIE)
macro_add_compile_flags(start_kdeinit ${KDE4_CXX_FPIE_FLAGS})
macro_add_link_flags(start_kdeinit ${KDE4_PIE_LDFLAGS})
endif(KDE4_ENABLE_FPIE)
set(start_kdeinit_SRCS start_kdeinit.c)
kde4_add_executable(start_kdeinit ${start_kdeinit_SRCS})
if(KDE4_ENABLE_FPIE)
macro_add_compile_flags(start_kdeinit ${KDE4_CXX_FPIE_FLAGS})
macro_add_link_flags(start_kdeinit ${KDE4_PIE_LDFLAGS})
endif(KDE4_ENABLE_FPIE)
set(start_kdeinit_wrapper_SRCS start_kdeinit_wrapper.c)
kde4_add_executable(start_kdeinit_wrapper ${start_kdeinit_wrapper_SRCS})
set(start_kdeinit_wrapper_SRCS start_kdeinit_wrapper.c)
kde4_add_executable(start_kdeinit_wrapper ${start_kdeinit_wrapper_SRCS})
install(TARGETS start_kdeinit DESTINATION ${LIBEXEC_INSTALL_DIR})
install(TARGETS start_kdeinit_wrapper DESTINATION ${LIBEXEC_INSTALL_DIR})
endif (NOT WIN32)
install(TARGETS start_kdeinit DESTINATION ${LIBEXEC_INSTALL_DIR})
install(TARGETS start_kdeinit_wrapper DESTINATION ${LIBEXEC_INSTALL_DIR})
if (CMAKE_SYSTEM_NAME MATCHES Linux)
MESSAGE(STATUS "Using setuid root kdeinit wrapper in order to protect it from bad Linux OOM-killer")

2
kinit/kinit.cpp
View file

@ -1630,10 +1630,8 @@ static void secondary_child_handler(int)
int main(int argc, char **argv, char **envp)
{
#ifndef _WIN32_WCE
setlocale (LC_ALL, "");
setlocale (LC_NUMERIC, "C");
#endif
pid_t pid;
bool do_fork = true;

2
kinit/kioslave.cpp
View file

@ -42,9 +42,7 @@ int main(int argc, char **argv)
fprintf(stderr, "Usage: kioslave <slave-lib> <protocol> <klauncher-socket> <app-socket>\n\nThis program is part of KDE.\n");
exit(1);
}
#ifndef _WIN32_WCE
setlocale(LC_ALL, "");
#endif
QString libpath = QFile::decodeName(argv[1]);
if (libpath.isEmpty())

20
kio/CMakeLists.txt
View file

@ -164,12 +164,6 @@ if(UNIX)
)
endif(UNIX)
if(WIN32)
set(kiocore_STAT_SRCS ${kiocore_STAT_SRCS}
kio/krun_win.cpp
)
endif(WIN32)
set(kbookmarks_STAT_SRCS
bookmarks/kbookmark.cc
bookmarks/kbookmarkimporter.cc
@ -226,13 +220,12 @@ if(NOT KIO_NO_SOLID)
)
endif(NOT KIO_NO_SOLID)
if(NOT WIN32)
set(kfile_STAT_SRCS
set(kfile_STAT_SRCS
${kfile_STAT_SRCS}
kfile/kfilesharedialog.cpp
kfile/kfsprocess.cpp
)
endif(NOT WIN32)
)
qt4_add_resources(kfile_STAT_SRCS kfile/kacleditwidget.qrc)
# kio/kssl/Makefile.am: kssl
@ -357,11 +350,8 @@ install( FILES
kssl/sslui.h
DESTINATION ${INCLUDE_INSTALL_DIR}/kio COMPONENT Devel)
if( NOT WIN32 )
install( FILES
kfile/kfilesharedialog.h
DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
endif( NOT WIN32 )
install( FILES kfile/kfilesharedialog.h
DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
install( FILES
kio/kabstractfileitemactionplugin.h

4
kio/kfile/kicondialog.cpp
View file

@ -22,9 +22,7 @@
#include <kiconloader.h>
#include <kfiledialog.h>
#include <kimagefilepreview.h>
#ifndef _WIN32_WCE
#include <ksvgrenderer.h>
#endif
#include <QtGui/QApplication>
#include <QtGui/QGroupBox>
@ -203,7 +201,6 @@ void KIconCanvas::KIconCanvasPrivate::_k_slotLoadFiles()
if (ext != "SVG" && ext != "VGZ") {
img.load(*it);
} else {
#ifndef _WIN32_WCE
// Special stuff for SVG icons
img = QImage(canvasIconWidth, canvasIconHeight, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
@ -212,7 +209,6 @@ void KIconCanvas::KIconCanvasPrivate::_k_slotLoadFiles()
QPainter p(&img);
renderer.render(&p);
}
#endif
}
if (img.isNull()) {

32
kio/kio/kprotocolmanager.cpp
View file

@ -34,11 +34,6 @@
#include <QtDBus/QtDBus>
#include <QtCore/QCache>
#if !defined(QT_NO_NETWORKPROXY) && (defined (Q_OS_WIN32) || defined(Q_OS_MAC))
#include <QtNetwork/QNetworkProxyFactory>
#include <QtNetwork/QNetworkProxyQuery>
#endif
#include <kdeversion.h>
#include <kdebug.h>
#include <kglobal.h>
@ -405,32 +400,6 @@ static QStringList getSystemProxyFor( const KUrl& url )
{
QStringList proxies;
#if !defined(QT_NO_NETWORKPROXY) && (defined(Q_OS_WIN32) || defined(Q_OS_MAC))
QNetworkProxyQuery query ( url );
const QList<QNetworkProxy> proxyList = QNetworkProxyFactory::systemProxyForQuery(query);
Q_FOREACH(const QNetworkProxy& proxy, proxyList)
{
KUrl url;
const QNetworkProxy::ProxyType type = proxy.type();
if (type == QNetworkProxy::NoProxy || type == QNetworkProxy::DefaultProxy)
{
proxies << QL1S("DIRECT");
continue;
}
if (type == QNetworkProxy::HttpProxy || type == QNetworkProxy::HttpCachingProxy)
url.setProtocol(QL1S("http"));
else if (type == QNetworkProxy::Socks5Proxy)
url.setProtocol(QL1S("socks"));
else if (type == QNetworkProxy::FtpCachingProxy)
url.setProtocol(QL1S("ftp"));
url.setHost(proxy.hostName());
url.setPort(proxy.port());
url.setUser(proxy.user());
proxies << url.url();
}
#else
// On Unix/Linux use system environment variables if any are set.
QString proxyVar (KProtocolManager::proxyFor(url.protocol()));
// Check for SOCKS proxy, if not proxy is found for given url.
@ -451,7 +420,6 @@ static QStringList getSystemProxyFor( const KUrl& url )
proxies << proxy;
}
}
#endif
return proxies;
}

4
kio/kio/slave.cpp
View file

@ -366,11 +366,7 @@ void Slave::kill()
<< "(" << QString(d->m_protocol) + "://" + d->m_host << ")";
if (d->m_pid)
{
#ifndef _WIN32_WCE
::kill(d->m_pid, SIGTERM);
#else
::kill(d->m_pid, SIGKILL);
#endif
d->m_pid = 0;
}
}

6
kio/misc/CMakeLists.txt
View file

@ -3,10 +3,8 @@
include_directories( BEFORE ${CMAKE_SOURCE_DIR}/kio )
add_subdirectory( ksendbugmail )
if(NOT WIN32)
# arpa/nameser.h
add_subdirectory( kpac )
endif(NOT WIN32)
# arpa/nameser.h
add_subdirectory( kpac )
add_subdirectory( kntlm )
########### next target ###############

7
kioslave/file/CMakeLists.txt
View file

@ -9,12 +9,7 @@ configure_file(config-kioslave-file.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-k
########### next target ###############
if(WIN32)
set(kio_file_PART_SRCS file.cpp file_win.cpp )
else(WIN32)
set(kio_file_PART_SRCS file.cpp file_unix.cpp )
endif(WIN32)
set(kio_file_PART_SRCS file.cpp file_unix.cpp )
kde4_add_plugin(kio_file ${kio_file_PART_SRCS})

20
kioslave/file/file.cpp
View file

@ -898,7 +898,6 @@ void FileProtocol::mount( bool _ro, const char *_fstype, const QString& _dev, co
{
kDebug(7101) << "fstype=" << _fstype;
#ifndef _WIN32_WCE
#ifdef HAVE_VOLMGT
/*
* support for Solaris volume management
@ -1033,18 +1032,12 @@ void FileProtocol::mount( bool _ro, const char *_fstype, const QString& _dev, co
}
}
#endif /* ! HAVE_VOLMGT */
#else
QString err;
err = i18n("mounting is not supported by wince.");
error( KIO::ERR_COULD_NOT_MOUNT, err );
#endif
}
void FileProtocol::unmount( const QString& _point )
{
#ifndef _WIN32_WCE
QByteArray buffer;
KTemporaryFile tmpFile;
@ -1155,11 +1148,6 @@ void FileProtocol::unmount( const QString& _point )
finished();
else
error( KIO::ERR_COULD_NOT_UNMOUNT, err );
#else
QString err;
err = i18n("unmounting is not supported by wince.");
error( KIO::ERR_COULD_NOT_MOUNT, err );
#endif
}
/*************************************
@ -1170,7 +1158,6 @@ void FileProtocol::unmount( const QString& _point )
bool FileProtocol::pmount(const QString &dev)
{
#ifndef _WIN32_WCE
QString epath = QString::fromLocal8Bit(qgetenv("PATH"));
QString path = QLatin1String("/sbin:/bin");
if (!epath.isEmpty())
@ -1186,14 +1173,10 @@ bool FileProtocol::pmount(const QString &dev)
int res = system( buffer.constData() );
return res==0;
#else
return false;
#endif
}
bool FileProtocol::pumount(const QString &point)
{
#ifndef _WIN32_WCE
KMountPoint::Ptr mp = KMountPoint::currentMountPoints(KMountPoint::NeedRealDeviceName).findByPath(point);
if (!mp)
return false;
@ -1216,9 +1199,6 @@ bool FileProtocol::pumount(const QString &point)
int res = system( buffer.data() );
return res==0;
#else
return false;
#endif
}
/*************************************

4
kutils/kidletime/windowspoller.cpp
View file

@ -34,7 +34,6 @@ WindowsPoller::~WindowsPoller()
int WindowsPoller::getIdleTime()
{
#ifndef _WIN32_WCE
int idle = 0;
LASTINPUTINFO lii;
@ -48,9 +47,6 @@ int WindowsPoller::getIdleTime()
}
return idle;
#else
return GetIdleTime();
#endif
}
bool WindowsPoller::additionalSetUp()

2
kutils/kprintpreview.cpp
View file

@ -135,7 +135,6 @@ KPrintPreview::KPrintPreview(QPrinter *printer, QWidget *parent)
kDebug(500) << "kdeprint: creating preview dialog";
//There is no printing on wince
#ifndef _WIN32_WCE
// Set up the dialog
setCaption(i18n("Print Preview"));
setButtons(KDialog::Close);
@ -145,7 +144,6 @@ KPrintPreview::KPrintPreview(QPrinter *printer, QWidget *parent)
printer->setOutputFileName(d->filename);
setInitialSize(QSize(600, 500));
#endif
}
KPrintPreview::~KPrintPreview()

7
solid/solid/CMakeLists.txt
View file

@ -6,12 +6,6 @@ include_directories( ${QT_QTDBUS_INCLUDE_DIR} )
configure_file(solid_export.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/solid_export.h)
include (CheckCXXSourceCompiles)
if(MSVC OR (WIN32 AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel"))
check_cxx_source_compiles("int main() { __asm { pxor mm0, mm0 }; }" HAVE_X86_MMX)
check_cxx_source_compiles("int main() { __asm { xorps xmm0, xmm0 }; }" HAVE_X86_SSE)
check_cxx_source_compiles("int main() { __asm { xorpd xmm0, xmm0 }; }" HAVE_X86_SSE2)
check_cxx_source_compiles("int main() { __asm { femms }; }" HAVE_X86_3DNOW)
else()
check_cxx_source_compiles(" #ifdef __SUNPRO_CC
#define __asm__ asm
#endif
@ -28,7 +22,6 @@ check_cxx_source_compiles(" #ifdef __SUNPRO_CC
#define __asm__ asm
#endif
int main() { __asm__(\"femms\"); }" HAVE_X86_3DNOW)
endif()
check_cxx_source_compiles(" #ifdef __SUNPRO_CC
#define __asm__ asm
#endif

14
solid/solid/solid_export.h.cmake
View file

@ -38,20 +38,6 @@
# define SOLID_NO_EXPORT __attribute__ ((visibility("hidden")))
# define SOLID_EXPORT __attribute__ ((visibility("default")))
# elif defined(_WIN32) || defined(_WIN64)
# define SOLID_NO_EXPORT
# if defined(KDELIBS_STATIC_LIBS)
/* No export/import for static libraries */
# define SOLID_EXPORT
# elif defined(MAKE_SOLID_LIB)
/* We are building this library */
# define SOLID_EXPORT __declspec(dllexport)
# else
/* We are using this library */
# define SOLID_EXPORT __declspec(dllimport)
# endif
# else
# define SOLID_NO_EXPORT

13
solid/tests/CMakeLists.txt
View file

@ -8,10 +8,6 @@ set(fakehardwaretest_SRCS fakehardwaretest.cpp )
kde4_add_unit_test(fakehardwaretest ${fakehardwaretest_SRCS})
if(WIN32)
set_target_properties(fakehardwaretest PROPERTIES COMPILE_FLAGS -DSOLID_EXPORT=)
endif(WIN32)
target_link_libraries(fakehardwaretest solid_static ${QT_QTCORE_LIBRARY} ${QT_QTDBUS_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTTEST_LIBRARY} )
add_definitions(-DTEST_DATA="\\"${CMAKE_CURRENT_SOURCE_DIR}/../solid/backends/fakehw/fakecomputer.xml\\"")
@ -26,11 +22,6 @@ add_definitions(-DFAKE_COMPUTER_XML="\\"${CMAKE_CURRENT_SOURCE_DIR}/../solid/bac
include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/../solid/backends/fakehw )
if(WIN32)
set_target_properties(solidhwtest PROPERTIES COMPILE_FLAGS -DSOLID_EXPORT=)
set (LIBS ${KDEWIN_LIBRARIES})
endif(WIN32)
target_link_libraries(solidhwtest ${QT_QTCORE_LIBRARY} ${QT_QTDBUS_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTTEST_LIBRARY} ${LIBS} solid_static)
########### solidnettestdbusservice ###############
@ -60,10 +51,6 @@ qt4_add_dbus_interface(networkingclient_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../soli
kde4_add_executable(networkingclient TEST ${networkingclient_SRCS})
if(WIN32)
set_target_properties( networkingclient PROPERTIES COMPILE_FLAGS -DSOLID_EXPORT=)
endif(WIN32)
target_link_libraries(networkingclient solid_static ${KDE4_KDEUI_LIBS})
########### install files ###############

5
threadweaver/Weaver/CMakeLists.txt
View file

@ -1,10 +1,5 @@
include_directories(${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
if(WIN32)
include_directories(${KDEWIN_INCLUDES})
endif(WIN32)
########### next target ###############
set(ThreadWeaver_LIB_SRCS