No OneTemporary
Actions

Size

52 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 12a563bbf..32ff2d3f6 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,408 +1,408 @@
	kde4_no_enable_final(kleopatra)
	project(kleopatra)

	add_definitions( -DQT_NO_CAST_FROM_ASCII )
	add_definitions( -DQT_NO_CAST_TO_ASCII )


	option(KLEO_STATIC_KCMODULES "Build Kleopatra's KCMs into Kleopatra; don't install plugins" WINCE)

	include(MacroOptionalAddSubdirectory)

	set(kleopatra_version 2.2.0)
	set(kleopatra_release FALSE)

	if(NOT kleopatra_release)
	if(GIT_FOUND)
	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
	OUTPUT_VARIABLE Kleopatra_WC_REVISION)
	string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")

	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%ci ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
	OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
	string(REGEX REPLACE " [-0-9:+ ]*\n" "" Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")

	set(kleopatra_version "${kleopatra_version}-git${Kleopatra_WC_REVISION} (${Kleopatra_WC_LAST_CHANGED_DATE})")
	endif()
	endif()

	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)

	include_directories(
	${CMAKE_CURRENT_BINARY_DIR}
	${CMAKE_SOURCE_DIR}/libkleo
	${CMAKE_SOURCE_DIR}/libkdepim
	${CMAKE_SOURCE_DIR}/mobile/lib
	${Boost_INCLUDE_DIR}
	${QGPGME_INCLUDES}
	${GPGME_INCLUDES}
	)

	if(USABLE_ASSUAN_FOUND)
	if(ASSUAN2_FOUND)
	include_directories(${ASSUAN2_INCLUDES})
	else()
	include_directories(${ASSUAN_INCLUDES})
	endif()
	endif()

	add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
	add_definitions(-DQT_STL)
	remove_definitions(-DQT_NO_STL)

	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${KDE4_ENABLE_EXCEPTIONS}")
	if(GCC_IS_NEWER_THAN_4_3)
	if(CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
	endif()
	endif()

	add_subdirectory(pics)
	add_subdirectory(conf)

	if(USABLE_ASSUAN_FOUND AND BUILD_libkleopatraclient)
	# can't use macro_optional_add_subdirectory here, since it's split
	# off into ConfigureChecks.cmake..
	add_subdirectory(libkleopatraclient)
	endif()

	add_subdirectory(kgpgconf)
	add_subdirectory(kwatchgnupg)
	add_subdirectory(tests)

	if(WIN32)
	set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_win.cpp)
	set(_kleopatra_extra_SRCS utils/gnupg-registry.c selftest/registrycheck.cpp)
	else()
	set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_unix.cpp)
	set(_kleopatra_extra_SRCS)
	endif()

	if(USABLE_ASSUAN_FOUND)
	add_definitions(-DKLEOPATRACLIENT_NAMESPACE=KleopatraClientCopy -DKLEOPATRACLIENTCORE_EXPORT=)
	set(_kleopatra_uiserver_SRCS
	uiserver/sessiondata.cpp
	uiserver/uiserver.cpp
	${_kleopatra_extra_uiserver_SRCS}
	uiserver/assuanserverconnection.cpp
	uiserver/echocommand.cpp
	uiserver/decryptverifycommandemailbase.cpp
	uiserver/decryptverifycommandfilesbase.cpp
	uiserver/signcommand.cpp
	uiserver/signencryptfilescommand.cpp
	uiserver/prepencryptcommand.cpp
	uiserver/prepsigncommand.cpp
	uiserver/encryptcommand.cpp
	uiserver/selectcertificatecommand.cpp
	uiserver/importfilescommand.cpp
	uiserver/createchecksumscommand.cpp
	uiserver/verifychecksumscommand.cpp

	libkleopatraclient/core/command.cpp
	selftest/uiservercheck.cpp
	)
	set_source_files_properties(libkleopatraclient/core/command.cpp PROPERTIES SKIP_AUTOMOC TRUE)

	qt4_generate_moc(libkleopatraclient/core/command_p.h "${CMAKE_CURRENT_BINARY_DIR}/libkleopatraclient/core/moc_command_p.cpp")
	qt4_generate_moc(libkleopatraclient/core/command.h "${CMAKE_CURRENT_BINARY_DIR}/libkleopatraclient/core/moc_command.cpp")

	list(APPEND _kleopatra_uiserver_SRCS
	"${CMAKE_CURRENT_BINARY_DIR}/libkleopatraclient/core/moc_command_p.cpp"
	"${CMAKE_CURRENT_BINARY_DIR}/libkleopatraclient/core/moc_command.cpp"
	)

	if(ASSUAN2_FOUND)
	set(_kleopatra_uiserver_extra_libs ${ASSUAN2_LIBRARIES})
	else()
	if(WIN32)
	set(_kleopatra_uiserver_extra_libs ${ASSUAN_VANILLA_LIBRARIES})
	else()
	set(_kleopatra_uiserver_extra_libs ${ASSUAN_PTHREAD_LIBRARIES})
	endif()
	endif()

	if(HAVE_GPG_ERR_SOURCE_KLEO)
	add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO)
	else()
	add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1)
	endif()

	else()
	set(_kleopatra_uiserver_SRCS)
	endif()

	kde4_add_ui_files(_kleopatra_uiserver_SRCS crypto/gui/signingcertificateselectionwidget.ui)

	set(_kleopatra_SRCS
	utils/gnupg-helper.cpp
	utils/filesystemwatcher.cpp
	utils/filedialog.cpp
	utils/kdpipeiodevice.cpp
	utils/kdlogtextwidget.cpp
	utils/kdsignalblocker.cpp
	utils/headerview.cpp
	utils/scrollarea.cpp
	utils/dragqueen.cpp
	utils/multivalidator.cpp
	utils/progressmanager.cpp
	utils/systemtrayicon.cpp

	utils/hex.cpp
	utils/path-helper.cpp
	utils/input.cpp
	utils/output.cpp
	utils/formatting.cpp
	utils/validation.cpp
	utils/wsastarter.cpp
	utils/classify.cpp
	utils/iodevicelogger.cpp
	utils/log.cpp
	utils/action_data.cpp
	utils/types.cpp
	utils/archivedefinition.cpp
	utils/auditlog.cpp
	utils/clipboardmenu.cpp

	selftest/selftest.cpp
	selftest/enginecheck.cpp
	selftest/gpgconfcheck.cpp
	selftest/gpgagentcheck.cpp
	selftest/libkleopatrarccheck.cpp

	${_kleopatra_extra_SRCS}

	models/keycache.cpp
	models/keylistmodel.cpp
	models/keylistsortfilterproxymodel.cpp
	models/subkeylistmodel.cpp
	models/useridlistmodel.cpp

	view/keylistcontroller.cpp
	view/keytreeview.cpp
	view/searchbar.cpp
	view/tabwidget.cpp

	dialogs/certificateselectiondialog.cpp
	dialogs/expirydialog.cpp
	dialogs/lookupcertificatesdialog.cpp
	dialogs/ownertrustdialog.cpp
	dialogs/selftestdialog.cpp
	dialogs/certifycertificatedialog.cpp
	dialogs/exportsecretkeydialog.cpp
	dialogs/adduseriddialog.cpp
	dialogs/certificatedetailsdialog.cpp
	dialogs/exportcertificatesdialog.cpp
	dialogs/deletecertificatesdialog.cpp
	dialogs/setinitialpindialog.cpp

	crypto/controller.cpp
	crypto/certificateresolver.cpp
	crypto/sender.cpp
	crypto/recipient.cpp
	crypto/task.cpp
	crypto/taskcollection.cpp
	crypto/decryptverifytask.cpp
	crypto/decryptverifyemailcontroller.cpp
	crypto/decryptverifyfilescontroller.cpp
	crypto/encryptemailtask.cpp
	crypto/encryptemailcontroller.cpp
	crypto/newsignencryptemailcontroller.cpp
	crypto/signencryptfilestask.cpp
	crypto/signencryptfilescontroller.cpp
	crypto/signemailtask.cpp
	crypto/signemailcontroller.cpp
	crypto/createchecksumscontroller.cpp
	crypto/verifychecksumscontroller.cpp

	crypto/gui/wizard.cpp
	crypto/gui/wizardpage.cpp

	crypto/gui/signingcertificateselectionwidget.cpp
	crypto/gui/signingcertificateselectiondialog.cpp

	crypto/gui/resultitemwidget.cpp
	crypto/gui/resultlistwidget.cpp
	crypto/gui/resultpage.cpp

	crypto/gui/newresultpage.cpp
	crypto/gui/newsignencryptfileswizard.cpp

	crypto/gui/signencryptemailconflictdialog.cpp

	crypto/gui/decryptverifyoperationwidget.cpp
	crypto/gui/decryptverifyfileswizard.cpp

	crypto/gui/objectspage.cpp
	crypto/gui/resolverecipientspage.cpp
	crypto/gui/signerresolvepage.cpp
	crypto/gui/encryptemailwizard.cpp
	crypto/gui/signemailwizard.cpp
	crypto/gui/signencryptfileswizard.cpp
	crypto/gui/signencryptwizard.cpp

	crypto/gui/verifychecksumsdialog.cpp

	commands/command.cpp
	commands/gnupgprocesscommand.cpp
	commands/detailscommand.cpp
	commands/exportcertificatecommand.cpp
	commands/importcertificatescommand.cpp
	commands/importcertificatefromfilecommand.cpp
	commands/importcertificatefromclipboardcommand.cpp
	commands/lookupcertificatescommand.cpp
	commands/reloadkeyscommand.cpp
	commands/refreshx509certscommand.cpp
	commands/refreshopenpgpcertscommand.cpp
	commands/deletecertificatescommand.cpp
	commands/decryptverifyfilescommand.cpp
	commands/signencryptfilescommand.cpp
	commands/encryptclipboardcommand.cpp
	commands/signclipboardcommand.cpp
	commands/decryptverifyclipboardcommand.cpp
	commands/clearcrlcachecommand.cpp
	commands/dumpcrlcachecommand.cpp
	commands/dumpcertificatecommand.cpp
	commands/importcrlcommand.cpp
	commands/changeexpirycommand.cpp
	commands/changeownertrustcommand.cpp
	commands/changeroottrustcommand.cpp
	commands/changepassphrasecommand.cpp
	commands/certifycertificatecommand.cpp
	commands/selftestcommand.cpp
	commands/exportsecretkeycommand.cpp
	commands/exportopenpgpcertstoservercommand.cpp
	commands/adduseridcommand.cpp
	commands/newcertificatecommand.cpp
	commands/setinitialpincommand.cpp
	commands/learncardkeyscommand.cpp
	commands/checksumcreatefilescommand.cpp
	commands/checksumverifyfilescommand.cpp

	${_kleopatra_uiserver_files}

	conf/configuredialog.cpp

	newcertificatewizard/listwidget.cpp
	newcertificatewizard/newcertificatewizard.cpp

	smartcard/readerstatus.cpp

	aboutdata.cpp
	systrayicon.cpp
	kleopatraapplication.cpp
	main.cpp
	)

	if(KLEO_STATIC_KCMODULES)
	add_definitions(-DKLEO_STATIC_KCMODULES)
	set(_kleopatra_extra_libs kcm_kleopatra)
	else()
	set(_kleopatra_extra_libs)
	endif()

	if(KLEO_MODEL_TEST)
	add_definitions(-DKLEO_MODEL_TEST)
	set(_kleopatra_SRCS ${_kleopatra_SRCS} models/modeltest.cpp)
	endif()

	kde4_add_ui_files(_kleopatra_SRCS
	dialogs/certificationoptionswidget.ui
	dialogs/expirydialog.ui
	dialogs/lookupcertificatesdialog.ui
	dialogs/ownertrustdialog.ui
	dialogs/selectchecklevelwidget.ui
	dialogs/selftestdialog.ui
	dialogs/exportsecretkeydialog.ui
	dialogs/adduseriddialog.ui
	dialogs/certificatedetailsdialog.ui
	dialogs/setinitialpindialog.ui
	newcertificatewizard/listwidget.ui
	newcertificatewizard/chooseprotocolpage.ui
	newcertificatewizard/enterdetailspage.ui
	newcertificatewizard/overviewpage.ui
	newcertificatewizard/keycreationpage.ui
	newcertificatewizard/resultpage.ui
	newcertificatewizard/advancedsettingsdialog.ui
	)

	kde4_add_kcfg_files(_kleopatra_SRCS
	kcfg/tooltippreferences.kcfgc
	kcfg/emailoperationspreferences.kcfgc
	kcfg/fileoperationspreferences.kcfgc
	kcfg/smimevalidationpreferences.kcfgc
	)

	if(KDEPIM_ONLY_KLEO)
	add_definitions(-DKDEPIM_ONLY_KLEO -DKDEPIM_EXPORT=)
	set(_kleopatra_libkdepim_SRCS
	- ../libkdepim/progressmanager.cpp
	- ../libkdepim/progressdialog.cpp
	- ../libkdepim/overlaywidget.cpp
	- ../libkdepim/ssllabel.cpp
	- ../libkdepim/statusbarprogresswidget.cpp
	+ ${CMAKE_SOURCE_DIR}/libkdepim/progresswidget/progressmanager.cpp
	+ ${CMAKE_SOURCE_DIR}/libkdepim/progresswidget/progressdialog.cpp
	+ ${CMAKE_SOURCE_DIR}/libkdepim/progresswidget/ssllabel.cpp
	+ ${CMAKE_SOURCE_DIR}/libkdepim/progresswidget/statusbarprogresswidget.cpp
	+ ${CMAKE_SOURCE_DIR}/libkdepim/widgets/overlaywidget.cpp
	)
	set(_kleopatra_libkdepim_LIBS)
	else()
	set(_kleopatra_libkdepim_SRCS)
	set(_kleopatra_libkdepim_LIBS kdepim)
	endif()

	if(KDEPIM_MOBILE_UI)
	set(_kleopatra_uiserver_extra_libs ${_kleopatra_uiserver_extra_libs} kdepimmobileui)
	set(_kleopatra_mainwindow_SRCS mainwindow_mobile.cpp)
	else()
	set(_kleopatra_mainwindow_SRCS mainwindow_desktop.cpp)
	endif()

	add_definitions(-DKDE_DEFAULT_DEBUG_AREA=5151)

	kde4_add_app_icon(_kleopatra_mainwindow_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/hi*-app-kleopatra.png")

	kde4_add_executable(kleopatra_bin ${_kleopatra_SRCS} ${_kleopatra_mainwindow_SRCS} ${_kleopatra_uiserver_SRCS} ${_kleopatra_libkdepim_SRCS})
	set_target_properties(kleopatra_bin PROPERTIES OUTPUT_NAME kleopatra)

	target_link_libraries(kleopatra_bin
	${_kleopatra_extra_libs}
	kleo
	${QGPGME_LIBRARIES}
	${KDE4_KDEUI_LIBS}
	${KDEPIMLIBS_KMIME_LIBS}
	${KDE4_KCMUTILS_LIBS}
	${_kleopatra_uiserver_extra_libs}
	${_kleopatra_libkdepim_LIBS}
	)

	if(KDEPIM_MOBILE_UI)
	target_link_libraries(kleopatra_bin ${QT_QTDECLARATIVE_LIBRARY})
	endif()

	if(USABLE_ASSUAN_FOUND)
	target_link_libraries(kleopatra_bin ${QT_QTNETWORK_LIBRARY})
	endif()

	install(TARGETS kleopatra_bin ${INSTALL_TARGETS_DEFAULT_ARGS})

	install(
	PROGRAMS data/kleopatra.desktop data/kleopatra_import.desktop
	DESTINATION ${XDG_APPS_INSTALL_DIR}
	)
	install(
	FILES data/kleopatra_signencryptfiles.desktop
	data/kleopatra_signencryptfolders.desktop
	data/kleopatra_decryptverifyfiles.desktop
	data/kleopatra_decryptverifyfolders.desktop
	DESTINATION ${SERVICES_INSTALL_DIR}
	)

	install(FILES kleopatra.rc DESTINATION ${DATA_INSTALL_DIR}/kleopatra)

	if(KDEPIM_MOBILE_UI)
	install(
	FILES qml/kleopatra-mobile.qml qml/KleopatraActions.qml
	DESTINATION ${DATA_INSTALL_DIR}/kleopatra
	)
	endif()
	add_subdirectory(icons)
	diff --git a/kleopatraapplication.cpp b/kleopatraapplication.cpp
	index 08e1bdbae..e8487edc6 100644
	--- a/kleopatraapplication.cpp
	+++ b/kleopatraapplication.cpp
	@@ -1,530 +1,537 @@
	/*
	kleopatraapplication.cpp

	This file is part of Kleopatra, the KDE keymanager
	Copyright (c) 2008 Klarälvdalens Datakonsult AB

	Kleopatra is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	Kleopatra is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

	In addition, as a special exception, the copyright holders give
	permission to link the code of this program with any edition of
	the Qt library by Trolltech AS, Norway (or with modified versions
	of Qt that use the same license as Qt), and distribute linked
	combinations including the two. You must obey the GNU General
	Public License in all respects for all of the code used other than
	Qt. If you modify this file, you may extend this exception to
	your version of the file, but you are not obligated to do so. If
	you do not wish to do so, delete this exception statement from
	your version.
	*/

	#include <config-kleopatra.h>

	#include "kleopatraapplication.h"

	#include "mainwindow.h"
	#include "systrayicon.h"
	#include <smartcard/readerstatus.h>
	#include <conf/configuredialog.h>

	#include <utils/gnupg-helper.h>
	#include <utils/filesystemwatcher.h>
	#include <utils/kdpipeiodevice.h>
	#include <utils/log.h>
	#include <utils/getpid.h>

	#include <gpgme++/key.h>
	#include <models/keycache.h>

	#ifdef HAVE_USABLE_ASSUAN
	# include <uiserver/uiserver.h>
	#endif

	#include <commands/signencryptfilescommand.h>
	#include <commands/decryptverifyfilescommand.h>
	#include <commands/lookupcertificatescommand.h>
	#include <commands/detailscommand.h>

	#include <KGlobal>
	#include <KIconLoader>
	#include <KLocalizedString>
	#include <KCmdLineOptions>
	#include <KDebug>
	#include <KUrl>
	#include <KWindowSystem>

	#include <QFile>
	#include <QDir>
	#include <QPointer>

	#include <boost/shared_ptr.hpp>
	#include <boost/range.hpp>
	#include <boost/bind.hpp>
	#include <boost/mem_fn.hpp>

	#include <memory>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace boost;

	static void add_resources() {
	KGlobal::locale()->insertCatalog( QLatin1String("libkleopatra") );
	KIconLoader::global()->addAppDir( QLatin1String("libkleopatra") );
	KIconLoader::global()->addAppDir( QLatin1String("kwatchgnupg") );
	KIconLoader::global()->addAppDir( QLatin1String("kdepim") );
	}

	static const struct {
	const char * option;
	const char * description;
	char short_option[4];
	} kleo_options[] = {
	{ "daemon", I18N_NOOP("Run UI server only, hide main window"), "" },
	{ "openpgp", I18N_NOOP("Use OpenPGP for the following operation"), "p" },
	{ "cms", I18N_NOOP("Use CMS (X.509, S/MIME) for the following operation"), "c" },
	{ "import-certificate", I18N_NOOP("Import certificate file(s)"), "i" },
	{ "encrypt", I18N_NOOP("Encrypt file(s)"), "e" },
	{ "sign", I18N_NOOP("Sign file(s)"), "s" },
	{ "sign-encrypt", I18N_NOOP("Sign and/or encrypt file(s)"), "E" },
	{ "encrypt-sign", I18N_NOOP("Same as --sign-encrypt, do not use"), "" },
	{ "decrypt", I18N_NOOP("Decrypt file(s)"), "d" },
	{ "verify", I18N_NOOP("Verify file/signature"), "V" },
	{ "decrypt-verify", I18N_NOOP("Decrypt and/or verify file(s)"), "D" },
	{ "query <fingerprint>",I18N_NOOP("Search for Certificate by fingerprint"), "q" },
	{ "parent-windowid <windowId>", I18N_NOOP("Parent Window Id for dialogs"), "" },
	//{ "show-certificate", I18N_NOOP("Show Certificate(s) by fingerprint(s)"), "" },
	};


	static KCmdLineOptions make_kleopatra_args() {
	KCmdLineOptions options;
	#ifdef HAVE_USABLE_ASSUAN
	options.add("uiserver-socket <argument>", ki18n("Location of the socket the ui server is listening on" ));
	#endif
	for ( unsigned int i = 0 ; i < sizeof kleo_options / sizeof *kleo_options ; ++i ) {
	if ( *kleo_options[i].short_option )
	options.add( kleo_options[i].short_option );
	options.add( kleo_options[i].option, ki18n( kleo_options[i].description ) );
	}
	options.add("+[File]", ki18n("File(s) to process"));
	return options;
	}

	// static
	KCmdLineOptions KleopatraApplication::commandLineOptions() {
	static KCmdLineOptions options = make_kleopatra_args();
	return options;
	}

	static QList<QByteArray> default_logging_options() {
	QList<QByteArray> result;
	result.push_back( "io" );
	return result;
	}

	class KleopatraApplication::Private {
	friend class ::KleopatraApplication;
	KleopatraApplication * const q;
	public:
	explicit Private( KleopatraApplication * qq )
	: q( qq ),
	ignoreNewInstance( true ),
	firstNewInstance( true )
	{
	KDAB_SET_OBJECT_NAME( readerStatus );
	#ifndef QT_NO_SYSTEMTRAYICON
	KDAB_SET_OBJECT_NAME( sysTray );

	sysTray.setAnyCardHasNullPin( readerStatus.anyCardHasNullPin() );
	sysTray.setAnyCardCanLearnKeys( readerStatus.anyCardCanLearnKeys() );

	connect( &readerStatus, SIGNAL(anyCardHasNullPinChanged(bool)),
	&sysTray, SLOT(setAnyCardHasNullPin(bool)) );
	connect( &readerStatus, SIGNAL(anyCardCanLearnKeysChanged(bool)),
	&sysTray, SLOT(setAnyCardCanLearnKeys(bool)) );
	#endif
	}

	private:
	void connectConfigureDialog() {
	if ( configureDialog && q->mainWindow() )
	connect( configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()) );
	}
	void disconnectConfigureDialog() {
	if ( configureDialog && q->mainWindow() )
	disconnect( configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()) );
	}

	public:
	bool ignoreNewInstance;
	bool firstNewInstance;
	QPointer<ConfigureDialog> configureDialog;
	QPointer<MainWindow> mainWindow;
	SmartCard::ReaderStatus readerStatus;
	#ifndef QT_NO_SYSTEMTRAYICON
	SysTrayIcon sysTray;
	#endif
	shared_ptr<KeyCache> keyCache;
	shared_ptr<Log> log;
	shared_ptr<FileSystemWatcher> watcher;

	public:
	void setupKeyCache() {
	keyCache = KeyCache::mutableInstance();
	watcher.reset( new FileSystemWatcher );

	watcher->blacklistFiles( gnupgFileBlacklist() );
	watcher->addPath( gnupgHomeDirectory() );
	watcher->setDelay( 1000 );
	keyCache->addFileSystemWatcher( watcher );
	}

	void setupLogging() {
	log = Log::mutableInstance();

	const QByteArray envOptions = qgetenv( "KLEOPATRA_LOGOPTIONS" );
	const bool logAll = envOptions.trimmed() == "all";
	const QList<QByteArray> options = envOptions.isEmpty() ? default_logging_options() : envOptions.split( ',' ) ;

	const QByteArray dirNative = qgetenv( "KLEOPATRA_LOGDIR" );
	if ( dirNative.isEmpty() )
	return;
	const QString dir = QFile::decodeName( dirNative );
	const QString logFileName = QDir( dir ).absoluteFilePath( QString::fromLatin1( "kleopatra.log.%1" ).arg( mygetpid() ) );
	std::auto_ptr<QFile> logFile( new QFile( logFileName ) );
	if ( !logFile->open( QIODevice::WriteOnly \| QIODevice::Append ) ) {
	kDebug() << "Could not open file for logging: " << logFileName << "\nLogging disabled";
	return;
	}

	log->setOutputDirectory( dir );
	if ( logAll \|\| options.contains( "io" ) )
	log->setIOLoggingEnabled( true );
	qInstallMsgHandler( Log::messageHandler );

	#ifdef HAVE_USABLE_ASSUAN
	if ( logAll \|\| options.contains( "pipeio" ) )
	KDPipeIODevice::setDebugLevel( KDPipeIODevice::Debug );
	UiServer::setLogStream( log->logFile() );
	#endif

	}
	};


	KleopatraApplication::KleopatraApplication()
	: KUniqueApplication(), d( new Private( this ) )
	{
	add_resources();
	d->setupKeyCache();
	d->setupLogging();
	#ifndef QT_NO_SYSTEMTRAYICON
	d->sysTray.show();
	#endif
	setQuitOnLastWindowClosed( false );
	KWindowSystem::allowExternalProcessWindowActivation();
	}

	KleopatraApplication::~KleopatraApplication() {
	// work around kdelibs bug https://bugs.kde.org/show_bug.cgi?id=162514
	KGlobal::config()->sync();
	}

	static QStringList files_from_args( const shared_ptr<const KCmdLineArgs> & args ) {
	QStringList result;
	for ( int i = 0, end = args->count() ; i < end ; ++i ) {
	const KUrl url = args->url(i);
	if ( url.protocol() == QLatin1String("file") )
	result.push_back( url.toLocalFile() );
	}
	return result;
	}

	namespace {
	typedef void (KleopatraApplication::*Func)( const QStringList &, GpgME::Protocol );
	struct _Funcs {
	const char * opt;
	Func func;
	};
	}

	int KleopatraApplication::newInstance() {
	kDebug() << "ignoreNewInstance =" << d->ignoreNewInstance;
	if ( d->ignoreNewInstance )
	return 0;

	const shared_ptr<KCmdLineArgs> args( KCmdLineArgs::parsedArgs(), mem_fn( &KCmdLineArgs::clear ) );

	const QStringList files = files_from_args( args );

	const bool openpgp = args->isSet( "openpgp" );
	const bool cms = args->isSet( "cms" );

	kDebug( openpgp ) << "found OpenPGP";
	kDebug( cms ) << "found CMS";

	if ( openpgp && cms ) {
	kDebug() << "ambigious protocol: --openpgp and --cms";
	return 1;
	}

	// Check for --query command
	if ( args->isSet( "query" ) ) {
	const QString fingerPrint = args->getOption( "query" );
	if ( fingerPrint.isEmpty() ) {
	kDebug() << "no fingerprint specified: --query";
	return 1;
	}

	// Check for Parent Window id
	WId parentId = 0;
	if ( args->isSet( "parent-windowid" ) ) {
	+#ifdef Q_OS_WIN
	+ // WId is not a portable type as it is a pointer type on Windows.
	+ // casting it from an integer is ok though as the values are guranteed to
	+ // be compatible in the documentation.
	+ parentId = reinterpret_cast<WId>( args->getOption( "parent-windowid" ).toUInt() );
	+#else
	parentId = args->getOption( "parent-windowid" ).toUInt();
	+#endif
	}

	// Search for local keys
	const GpgME::Key &key = Kleo::KeyCache::instance()->findByKeyIDOrFingerprint( fingerPrint.toLocal8Bit().data() );
	if ( key.isNull() ) {
	// Show external search dialog
	LookupCertificatesCommand * const cmd = new LookupCertificatesCommand( fingerPrint, 0 );
	if ( parentId != 0 ) {
	cmd->setParentWId( parentId );
	};
	cmd->start();
	return 0;
	} else {
	// show local detail
	DetailsCommand * const cmd = new DetailsCommand( key, 0 );
	if ( parentId != 0 ) {
	cmd->setParentWId( parentId );
	};
	cmd->start();
	return 0;
	}

	}

	static const _Funcs funcs[] = {
	#ifndef QT_NO_SYSTEMTRAYICON
	{ "import-certificate", &KleopatraApplication::importCertificatesFromFile },
	#endif
	{ "encrypt", &KleopatraApplication::encryptFiles },
	{ "sign", &KleopatraApplication::signFiles },
	{ "encrypt-sign", &KleopatraApplication::signEncryptFiles },
	{ "sign-encrypt", &KleopatraApplication::signEncryptFiles },
	{ "decrypt", &KleopatraApplication::decryptFiles },
	{ "verify", &KleopatraApplication::verifyFiles },
	{ "decrypt-verify", &KleopatraApplication::decryptVerifyFiles },
	};

	const _Funcs * const it1 = std::find_if( begin( funcs ), end( funcs ),
	boost::bind( &KCmdLineArgs::isSet, args, boost::bind( &_Funcs::opt, _1 ) ) );

	if ( const Func func = it1 == end( funcs ) ? 0 : it1->func ) {
	const _Funcs * it2 = std::find_if( it1+1, end( funcs ),
	boost::bind( &KCmdLineArgs::isSet, args, boost::bind( &_Funcs::opt, _1 ) ) );
	if ( it2 != end( funcs ) ) {
	kDebug() << "ambiguous command" << it1->opt << "vs." << it2->opt;
	return 1;
	}
	if ( files.empty() ) {
	kDebug() << it1->opt << "without arguments";
	return 1;
	}
	kDebug() << "found" << it1->opt;
	(this->*func)( files, openpgp ? GpgME::OpenPGP : cms ? GpgME::CMS : GpgME::UnknownProtocol );
	} else {
	if ( files.empty() ) {
	if ( ! ( d->firstNewInstance && isSessionRestored() ) ) {
	kDebug() << "openOrRaiseMainWindow";
	openOrRaiseMainWindow();
	}
	} else {
	kDebug() << "files without command"; // possible?
	return 1;
	}
	}

	return 0;
	}

	#ifndef QT_NO_SYSTEMTRAYICON
	const SysTrayIcon * KleopatraApplication::sysTrayIcon() const {
	return &d->sysTray;
	}

	SysTrayIcon * KleopatraApplication::sysTrayIcon() {
	return &d->sysTray;
	}
	#endif

	const MainWindow * KleopatraApplication::mainWindow() const {
	return d->mainWindow;
	}

	MainWindow * KleopatraApplication::mainWindow() {
	return d->mainWindow;
	}

	void KleopatraApplication::setMainWindow( MainWindow * mainWindow ) {
	if ( mainWindow == d->mainWindow )
	return;

	d->disconnectConfigureDialog();

	d->mainWindow = mainWindow;
	#ifndef QT_NO_SYSTEMTRAYICON
	d->sysTray.setMainWindow( mainWindow );
	#endif

	d->connectConfigureDialog();
	}

	static void open_or_raise( QWidget * w ) {
	if ( w->isMinimized() ) {
	KWindowSystem::unminimizeWindow( w->winId());
	w->raise();
	} else if ( w->isVisible() ) {
	w->raise();
	} else {
	w->show();
	}
	}

	void KleopatraApplication::toggleMainWindowVisibility()
	{
	if ( mainWindow() ) {
	mainWindow()->setVisible( !mainWindow()->isVisible() );
	} else {
	openOrRaiseMainWindow();
	}
	}

	void KleopatraApplication::restoreMainWindow() {
	kDebug() << "restoring main window";

	// Sanity checks
	if ( !isSessionRestored() ) {
	kDebug() << "Not in session restore";
	return;
	}

	if ( mainWindow() ) {
	kDebug() << "Already have main window";
	return;
	}


	MainWindow * mw = new MainWindow;
	if ( KMainWindow::canBeRestored( 1 ) ) {
	// restore to hidden state, Mainwindow::readProperties() will
	// restore saved visibility.
	mw->restore( 1, false );
	}

	mw->setAttribute( Qt::WA_DeleteOnClose );
	setMainWindow( mw );
	d->connectConfigureDialog();

	}

	void KleopatraApplication::openOrRaiseMainWindow() {
	MainWindow * mw = mainWindow();
	if ( !mw ) {
	mw = new MainWindow;
	mw->setAttribute( Qt::WA_DeleteOnClose );
	setMainWindow( mw );
	d->connectConfigureDialog();
	}
	open_or_raise( mw );
	}

	void KleopatraApplication::openOrRaiseConfigDialog() {
	if ( !d->configureDialog ) {
	d->configureDialog = new ConfigureDialog;
	d->configureDialog->setAttribute( Qt::WA_DeleteOnClose );
	d->connectConfigureDialog();
	}
	open_or_raise( d->configureDialog );
	}

	#ifndef QT_NO_SYSTEMTRAYICON
	void KleopatraApplication::startMonitoringSmartCard() {
	d->readerStatus.startMonitoring();
	}

	void KleopatraApplication::importCertificatesFromFile( const QStringList & files, GpgME::Protocol /proto/) {
	openOrRaiseMainWindow();
	if ( !files.empty() )
	d->sysTray.mainWindow()->importCertificatesFromFile( files );
	}
	#endif // QT_NO_SYSTEMTRAYICON

	void KleopatraApplication::encryptFiles( const QStringList & files, GpgME::Protocol proto ) {
	SignEncryptFilesCommand * const cmd = new SignEncryptFilesCommand( files, 0 );
	cmd->setEncryptionPolicy( Force );
	cmd->setSigningPolicy( Allow );
	if ( proto != GpgME::UnknownProtocol )
	cmd->setProtocol( proto );
	cmd->start();
	}

	void KleopatraApplication::signFiles( const QStringList & files, GpgME::Protocol proto ) {
	SignEncryptFilesCommand * const cmd = new SignEncryptFilesCommand( files, 0 );
	cmd->setSigningPolicy( Force );
	cmd->setEncryptionPolicy( Deny );
	if ( proto != GpgME::UnknownProtocol )
	cmd->setProtocol( proto );
	cmd->start();
	}

	void KleopatraApplication::signEncryptFiles( const QStringList & files, GpgME::Protocol proto ) {
	SignEncryptFilesCommand * const cmd = new SignEncryptFilesCommand( files, 0 );
	if ( proto != GpgME::UnknownProtocol )
	cmd->setProtocol( proto );
	cmd->start();
	}

	void KleopatraApplication::decryptFiles( const QStringList & files, GpgME::Protocol /proto/ ) {
	DecryptVerifyFilesCommand * const cmd = new DecryptVerifyFilesCommand( files, 0 );
	cmd->setOperation( Decrypt );
	cmd->start();
	}

	void KleopatraApplication::verifyFiles( const QStringList & files, GpgME::Protocol /proto/ ) {
	DecryptVerifyFilesCommand * const cmd = new DecryptVerifyFilesCommand( files, 0 );
	cmd->setOperation( Verify );
	cmd->start();
	}

	void KleopatraApplication::decryptVerifyFiles( const QStringList & files, GpgME::Protocol /proto/ ) {
	DecryptVerifyFilesCommand * const cmd = new DecryptVerifyFilesCommand( files, 0 );
	cmd->start();
	}

	void KleopatraApplication::setIgnoreNewInstance( bool ignore ) {
	d->ignoreNewInstance = ignore;
	}

	void KleopatraApplication::setFirstNewInstance( bool on ) {
	d->firstNewInstance = on;
	}


	bool KleopatraApplication::ignoreNewInstance() const {
	return d->ignoreNewInstance;
	}

	diff --git a/utils/kleo_kicondialog.cpp b/utils/kleo_kicondialog.cpp
	index 990f12d6b..b80141199 100644
	--- a/utils/kleo_kicondialog.cpp
	+++ b/utils/kleo_kicondialog.cpp
	@@ -1,795 +1,797 @@
	/* vi: ts=8 sts=4 sw=4
	*
	* This file is part of the KDE project, module kfile.
	* Copyright (C) 2000 Geert Jansen <jansen@kde.org>
	* (C) 2000 Kurt Granroth <granroth@kde.org>
	* (C) 1997 Christoph Neerfeld <chris@kde.org>
	* (C) 2002 Carsten Pfeiffer <pfeiffer@kde.org>
	*
	* This is free software; it comes under the GNU Library General
	* Public License, version 2. See the file "COPYING.LIB" for the
	* exact licensing terms.
	*/

	#include <config-kleopatra.h>

	#include "kleo_kicondialog.h"

	#include <kbuttongroup.h>
	#include <klistwidgetsearchline.h>
	#include <kapplication.h>
	#include <klocale.h>
	#include <kstandarddirs.h>
	#include <kiconloader.h>

	#include <QLabel>
	#include <QComboBox>
	#include <QtCore/QTimer>
	#include <QRadioButton>
	#include <QtCore/QFileInfo>
	#include <QProgressBar>
	#include <QPainter>
	#include <QFileDialog>
	#include <QtSvg/QSvgRenderer>
	+#include <QVBoxLayout>
	+#include <QHBoxLayout>

	using namespace Kleo::KioAvoidance;

	class KIconCanvas::KIconCanvasPrivate
	{
	public:
	KIconCanvasPrivate(KIconCanvas *qq) { q = qq; m_bLoading = false; }
	~KIconCanvasPrivate() {}
	KIconCanvas *q;
	bool m_bLoading;
	QStringList mFiles;
	QTimer *mpTimer;

	// slots
	void _k_slotLoadFiles();
	void _k_slotCurrentChanged(QListWidgetItem *item);
	};

	/**
	* Helper class for sorting icon paths by icon name
	*/
	class IconPath : public QString
	{
	protected:
	QString m_iconName;

	public:
	IconPath(const QString &ip) : QString (ip)
	{
	- int n = lastIndexOf('/');
	+ int n = lastIndexOf(QLatin1Char('/'));
	m_iconName = (n==-1) ? static_cast<QString>(*this) : mid(n+1);
	}


	IconPath() : QString ()
	{ }

	bool operator== (const IconPath &ip) const
	{ return m_iconName == ip.m_iconName; }

	bool operator< (const IconPath &ip) const
	{ return m_iconName < ip.m_iconName; }

	};

	/*
	* KIconCanvas: Iconview for the iconloader dialog.
	*/

	KIconCanvas::KIconCanvas(QWidget *parent)
	: KListWidget(parent), d(new KIconCanvasPrivate(this))
	{
	setViewMode(IconMode);
	setUniformItemSizes(true);
	setMovement(Static);
	setIconSize(QSize(60, 60));
	d->mpTimer = new QTimer(this);
	connect(d->mpTimer, SIGNAL(timeout()), this, SLOT(_k_slotLoadFiles()));
	connect(this, SIGNAL(currentItemChanged(QListWidgetItem,QListWidgetItem)),
	this, SLOT(_k_slotCurrentChanged(QListWidgetItem*)));
	setGridSize(QSize(80,80));
	}

	KIconCanvas::~KIconCanvas()
	{
	delete d->mpTimer;
	delete d;
	}

	void KIconCanvas::loadFiles(const QStringList& files)
	{
	clear();
	d->mFiles = files;
	emit startLoading(d->mFiles.count());
	d->mpTimer->setSingleShot(true);
	d->mpTimer->start(10);
	d->m_bLoading = false;
	}

	void KIconCanvas::KIconCanvasPrivate::_k_slotLoadFiles()
	{
	q->setResizeMode(QListWidget::Fixed);
	#ifndef QT_NO_CURSOR
	QApplication::setOverrideCursor(Qt::WaitCursor);
	#endif

	// disable updates to not trigger paint events when adding child items
	q->setUpdatesEnabled(false);

	m_bLoading = true;
	int i;
	QStringList::ConstIterator it;
	uint emitProgress = 10; // so we will emit it once in the beginning
	QStringList::ConstIterator end(mFiles.end());
	for (it=mFiles.begin(), i=0; it!=end; ++it, i++)
	{
	if ( emitProgress >= 10 ) {
	emit q->progress(i);
	emitProgress = 0;
	}

	emitProgress++;

	if (!m_bLoading) { // user clicked on a button that will load another set of icons
	break;
	}
	QImage img;

	// Use the extension as the format. Works for XPM and PNG, but not for SVG
	QString path= *it;
	QString ext = path.right(3).toUpper();

	- if (ext != "SVG" && ext != "VGZ")
	+ if (ext != QLatin1String("SVG") && ext != QLatin1String("VGZ"))
	img.load(*it);
	#ifndef QT_NO_SVGRENDERER
	else {
	// Special stuff for SVG icons
	img = QImage(60, 60, QImage::Format_ARGB32_Premultiplied);
	img.fill(0);
	QSvgRenderer renderer(*it);
	if (renderer.isValid()) {
	QPainter p(&img);
	renderer.render(&p);
	}
	}
	#endif // QT_NO_SVGRENDERER

	if (img.isNull())
	continue;
	if (img.width() > 60 \|\| img.height() > 60)
	{
	if (img.width() > img.height())
	{
	int height = (int) ((60.0 / img.width()) * img.height());
	img = img.scaled(60, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
	} else
	{
	int width = (int) ((60.0 / img.height()) * img.width());
	img = img.scaled(width, 60, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
	}
	}
	QPixmap pm = QPixmap::fromImage(img);
	QFileInfo fi(*it);
	QListWidgetItem *item = new QListWidgetItem(pm, fi.completeBaseName(), q);
	item->setData(Qt::UserRole, *it);
	item->setToolTip(fi.completeBaseName());
	}

	// enable updates since we have to draw the whole view now
	q->setUpdatesEnabled(true);

	#ifndef QT_NO_CURSOR
	QApplication::restoreOverrideCursor();
	#endif
	m_bLoading = false;
	emit q->finished();
	q->setResizeMode(QListWidget::Adjust);
	}

	QString KIconCanvas::getCurrent() const
	{
	if (!currentItem())
	return QString();
	return currentItem()->data(Qt::UserRole).toString();
	}

	void KIconCanvas::stopLoading()
	{
	d->m_bLoading = false;
	}

	void KIconCanvas::KIconCanvasPrivate::_k_slotCurrentChanged(QListWidgetItem *item)
	{
	emit q->nameChanged((item != 0L) ? item->text() : QString());
	}

	class KIconDialog::KIconDialogPrivate
	{
	public:
	KIconDialogPrivate(KIconDialog *qq) {
	q = qq;
	m_bStrictIconSize = true;
	m_bLockUser = false;
	m_bLockCustomDir = false;
	searchLine = 0;
	mNumOfSteps = 1;
	}
	~KIconDialogPrivate() {}

	void init();
	void showIcons();
	void setContext( KIconLoader::Context context );

	// slots
	void _k_slotContext(int);
	void _k_slotStartLoading(int);
	void _k_slotProgress(int);
	void _k_slotFinished();
	void _k_slotAcceptIcons();
	#ifndef QT_NO_FILEDIALOG
	void _k_slotBrowse();
	#endif
	void _k_slotOtherIconClicked();
	void _k_slotSystemIconClicked();

	KIconDialog *q;

	int mGroupOrSize;
	KIconLoader::Context mContext;

	QStringList mFileList;
	QComboBox *mpCombo;
	#ifndef QT_NO_FILEDIALOG
	QPushButton *mpBrowseBut;
	#endif
	QRadioButton mpSystemIcons, mpOtherIcons;
	QProgressBar *mpProgress;
	int mNumOfSteps;
	KIconLoader *mpLoader;
	KIconCanvas *mpCanvas;
	int mNumContext;
	KIconLoader::Context mContextMap[ 12 ]; // must match KIcon::Context size, code has assert

	bool m_bStrictIconSize, m_bLockUser, m_bLockCustomDir;
	QString custom;
	QString customLocation;
	KListWidgetSearchLine *searchLine;
	};

	/*
	* KIconDialog: Dialog for selecting icons. Both system and user
	* specified icons can be chosen.
	*/

	KIconDialog::KIconDialog(QWidget *parent)
	: KDialog(parent), d(new KIconDialogPrivate(this))
	{
	setModal( true );
	setCaption( i18n("Select Icon") );
	setButtons( Ok \| Cancel );
	setDefaultButton( Ok );

	d->mpLoader = KIconLoader::global();
	d->init();
	}

	KIconDialog::KIconDialog(KIconLoader loader, QWidget parent)
	: KDialog(parent), d(new KIconDialogPrivate(this))
	{
	setModal( true );
	setCaption( i18n("Select Icon") );
	setButtons( Ok \| Cancel );
	setDefaultButton( Ok );

	d->mpLoader = loader;
	d->init();
	}

	void KIconDialog::KIconDialogPrivate::init()
	{
	mGroupOrSize = KIconLoader::Desktop;
	mContext = KIconLoader::Any;
	mFileList = KGlobal::dirs()->findAllResources("appicon", QLatin1String("*.png"));

	QWidget *main = new QWidget(q);
	q->setMainWidget(main);

	QVBoxLayout *top = new QVBoxLayout(main);
	top->setMargin(0);

	QGroupBox *bgroup = new QGroupBox(main);
	bgroup->setTitle(i18n("Icon Source"));

	QVBoxLayout *vbox = new QVBoxLayout;
	bgroup->setLayout( vbox );
	top->addWidget(bgroup);

	QGridLayout *grid = new QGridLayout();
	grid->setSpacing(KDialog::spacingHint());
	bgroup->layout()->addItem(grid);

	mpSystemIcons = new QRadioButton(i18n("S&ystem icons:"), bgroup);
	connect(mpSystemIcons, SIGNAL(clicked()), q, SLOT(_k_slotSystemIconClicked()));
	grid->addWidget(mpSystemIcons, 1, 0);
	mpCombo = new QComboBox(bgroup);
	connect(mpCombo, SIGNAL(activated(int)), q, SLOT(_k_slotContext(int)));
	grid->addWidget(mpCombo, 1, 1);
	mpOtherIcons = new QRadioButton(i18n("O&ther icons:"), bgroup);
	connect(mpOtherIcons, SIGNAL(clicked()), q, SLOT(_k_slotOtherIconClicked()));
	grid->addWidget(mpOtherIcons, 2, 0);
	#ifndef QT_NO_FILEDIALOG
	mpBrowseBut = new QPushButton(i18n("&Browse..."), bgroup);
	connect(mpBrowseBut, SIGNAL(clicked()), q, SLOT(_k_slotBrowse()));
	grid->addWidget(mpBrowseBut, 2, 1);
	#endif // QT_NO_FILEDIALOG

	//
	// ADD SEARCHLINE
	//
	QHBoxLayout *searchLayout = new QHBoxLayout();
	searchLayout->setMargin(0);
	searchLayout->setSpacing(KDialog::spacingHint());
	top->addLayout(searchLayout);

	QLabel *searchLabel = new QLabel(i18n("&Search:"), main);
	searchLayout->addWidget(searchLabel);

	searchLine = new KListWidgetSearchLine(main);
	searchLayout->addWidget(searchLine);
	searchLabel->setBuddy(searchLine);

	QString wtstr = i18n("Search interactively for icon names (e.g. folder).");
	searchLabel->setWhatsThis(wtstr);
	searchLine->setWhatsThis(wtstr);


	mpCanvas = new KIconCanvas(main);
	connect(mpCanvas, SIGNAL(itemActivated(QListWidgetItem*)), q, SLOT(_k_slotAcceptIcons()));
	mpCanvas->setMinimumSize(400, 125);
	top->addWidget(mpCanvas);
	searchLine->setListWidget(mpCanvas);

	mpProgress = new QProgressBar(main);
	top->addWidget(mpProgress);
	connect(mpCanvas, SIGNAL(startLoading(int)), q, SLOT(_k_slotStartLoading(int)));
	connect(mpCanvas, SIGNAL(progress(int)), q, SLOT(_k_slotProgress(int)));
	connect(mpCanvas, SIGNAL(finished()), q, SLOT(_k_slotFinished()));

	// When pressing Ok or Cancel, stop loading icons
	connect(q, SIGNAL(hidden()), mpCanvas, SLOT(stopLoading()));

	static const char* const context_text[] = {
	I18N_NOOP( "Actions" ),
	I18N_NOOP( "Animations" ),
	I18N_NOOP( "Applications" ),
	I18N_NOOP( "Categories" ),
	I18N_NOOP( "Devices" ),
	I18N_NOOP( "Emblems" ),
	I18N_NOOP( "Emotes" ),
	I18N_NOOP( "Filesystems" ),
	I18N_NOOP( "International" ),
	I18N_NOOP( "Mimetypes" ),
	I18N_NOOP( "Places" ),
	I18N_NOOP( "Status" ) };
	static const KIconLoader::Context context_id[] = {
	KIconLoader::Action,
	KIconLoader::Animation,
	KIconLoader::Application,
	KIconLoader::Category,
	KIconLoader::Device,
	KIconLoader::Emblem,
	KIconLoader::Emote,
	KIconLoader::FileSystem,
	KIconLoader::International,
	KIconLoader::MimeType,
	KIconLoader::Place,
	KIconLoader::StatusIcon };
	mNumContext = 0;
	int cnt = sizeof( context_text ) / sizeof( context_text[ 0 ] );
	// check all 3 arrays have same sizes
	Q_ASSERT( cnt == sizeof( context_id ) / sizeof( context_id[ 0 ] )
	&& cnt == sizeof( mContextMap ) / sizeof( mContextMap[ 0 ] ));
	for( int i = 0;
	i < cnt;
	++i )
	{
	if( mpLoader->hasContext( context_id[ i ] ))
	{
	mpCombo->addItem(i18n( context_text[ i ] ));
	mContextMap[ mNumContext++ ] = context_id[ i ];
	}
	}
	mpCombo->setFixedSize(mpCombo->sizeHint());

	#ifndef QT_NO_FILEDIALOG
	mpBrowseBut->setFixedWidth(mpCombo->width());
	#endif

	// Make the dialog a little taller
	q->incrementInitialSize(QSize(0,100));
	connect(q, SIGNAL(okClicked()), q, SLOT(slotOk()));
	}


	KIconDialog::~KIconDialog()
	{
	delete d;
	}

	void KIconDialog::KIconDialogPrivate::_k_slotAcceptIcons()
	{
	custom.clear();
	q->slotOk();
	}

	void KIconDialog::KIconDialogPrivate::showIcons()
	{
	mpCanvas->clear();
	QStringList filelist;
	if (mpSystemIcons->isChecked())
	if (m_bStrictIconSize)
	filelist=mpLoader->queryIcons(mGroupOrSize, mContext);
	else
	filelist=mpLoader->queryIconsByContext(mGroupOrSize, mContext);
	else if (!customLocation.isNull()) {
	filelist = mpLoader->queryIconsByDir(customLocation);
	}
	else
	filelist=mFileList;

	QList<IconPath> iconlist;
	QStringList::Iterator it;
	foreach (const QString &it, filelist) {
	iconlist.append(IconPath(it));
	}

	qSort(iconlist);
	filelist.clear();

	foreach (const IconPath &ip, iconlist) {
	filelist.append(ip);
	}

	searchLine->clear();
	mpCanvas->loadFiles(filelist);
	}

	void KIconDialog::setStrictIconSize(bool b)
	{
	d->m_bStrictIconSize=b;
	}

	bool KIconDialog::strictIconSize() const
	{
	return d->m_bStrictIconSize;
	}

	void KIconDialog::setIconSize( int size )
	{
	// see KIconLoader, if you think this is weird
	if (size == 0) {
	d->mGroupOrSize = KIconLoader::Desktop; // default Group
	} else {
	d->mGroupOrSize = -size; // yes, KIconLoader::queryIconsByContext is weird
	}
	}

	int KIconDialog::iconSize() const
	{
	// 0 or any other value ==> mGroupOrSize is a group, so we return 0
	return (d->mGroupOrSize < 0) ? -d->mGroupOrSize : 0;
	}

	void KIconDialog::setup(KIconLoader::Group group, KIconLoader::Context context,
	bool strictIconSize, int iconSize, bool user,
	bool lockUser, bool lockCustomDir )
	{
	d->m_bStrictIconSize = strictIconSize;
	d->m_bLockUser = lockUser;
	d->m_bLockCustomDir = lockCustomDir;
	d->mGroupOrSize = (iconSize == 0) ? group : -iconSize;
	d->mpSystemIcons->setChecked(!user);
	d->mpSystemIcons->setEnabled(!lockUser \|\| !user);
	d->mpOtherIcons->setChecked(user);
	d->mpOtherIcons->setEnabled(!lockUser \|\| user);
	d->mpCombo->setEnabled(!user);
	#ifndef QT_NO_FILEDIALOG
	d->mpBrowseBut->setEnabled(user && !lockCustomDir);
	#endif
	d->setContext(context);
	}

	void KIconDialog::KIconDialogPrivate::setContext(KIconLoader::Context context)
	{
	mContext = context;
	for( int i = 0;
	i < mNumContext;
	++i )
	if( mContextMap[ i ] == context )
	{
	mpCombo->setCurrentIndex( i );
	return;
	}
	}

	void KIconDialog::setCustomLocation( const QString& location )
	{
	d->customLocation = location;
	}

	QString KIconDialog::openDialog()
	{
	d->showIcons();

	if ( exec() == Accepted )
	{
	if (!d->custom.isNull())
	return d->custom;
	QString name = d->mpCanvas->getCurrent();
	if (name.isEmpty() \|\| d->mpOtherIcons->isChecked()) {
	return name;
	}
	QFileInfo fi(name);
	return fi.baseName();
	}
	return QString();
	}

	void KIconDialog::showDialog()
	{
	setModal(false);
	d->showIcons();
	show();
	}

	void KIconDialog::slotOk()
	{
	QString name;
	if (!d->custom.isNull())
	{
	name = d->custom;
	}
	else
	{
	name = d->mpCanvas->getCurrent();
	if (!name.isEmpty() && d->mpSystemIcons->isChecked()) {
	QFileInfo fi(name);
	name = fi.baseName();
	}
	}

	emit newIconName(name);
	KDialog::accept();
	}

	QString KIconDialog::getIcon(KIconLoader::Group group, KIconLoader::Context context,
	bool strictIconSize, int iconSize, bool user,
	QWidget *parent, const QString &caption)
	{
	KIconDialog dlg(parent);
	dlg.setup( group, context, strictIconSize, iconSize, user );
	if (!caption.isNull())
	dlg.setCaption(caption);

	return dlg.openDialog();
	}

	#ifndef QT_NO_FILEDIALOG
	void KIconDialog::KIconDialogPrivate::_k_slotBrowse()
	{
	const QString file = QFileDialog::getOpenFileName( q, i18n("Open"), QString(), i18n("Icon Files (.png .xpm .svg .svgz)") );
	if (!file.isEmpty())
	{
	custom = file;
	if (mpSystemIcons->isChecked()) {
	customLocation = QFileInfo(file).absolutePath();
	}
	q->slotOk();
	}
	}
	#endif

	void KIconDialog::KIconDialogPrivate::_k_slotSystemIconClicked()
	{
	#ifndef QT_NO_FILEDIALOG
	mpBrowseBut->setEnabled(false);
	#endif
	mpCombo->setEnabled(true);
	showIcons();
	}

	void KIconDialog::KIconDialogPrivate::_k_slotOtherIconClicked()
	{
	#ifndef QT_NO_FILEDIALOG
	mpBrowseBut->setEnabled(!m_bLockCustomDir);
	#endif
	mpCombo->setEnabled(false);
	showIcons();
	}

	void KIconDialog::KIconDialogPrivate::_k_slotContext(int id)
	{
	mContext = static_cast<KIconLoader::Context>( mContextMap[ id ] );
	showIcons();
	}

	void KIconDialog::KIconDialogPrivate::_k_slotStartLoading(int steps)
	{
	if (steps < 10)
	mpProgress->hide();
	else
	{
	mNumOfSteps = steps;
	mpProgress->setValue(0);
	mpProgress->show();
	}
	}

	void KIconDialog::KIconDialogPrivate::_k_slotProgress(int p)
	{
	mpProgress->setValue(static_cast<int>(100.0 * (double)p / (double)mNumOfSteps));
	}

	void KIconDialog::KIconDialogPrivate::_k_slotFinished()
	{
	mNumOfSteps = 1;
	mpProgress->hide();
	}

	class KIconButton::KIconButtonPrivate
	{
	public:
	KIconButtonPrivate(KIconButton qq, KIconLoader loader);
	~KIconButtonPrivate();

	// slots
	void _k_slotChangeIcon();
	void _k_newIconName(const QString&);

	KIconButton *q;

	int iconSize;
	bool m_bStrictIconSize;

	bool mbUser;
	KIconLoader::Group mGroup;
	KIconLoader::Context mContext;

	QString mIcon;
	KIconDialog *mpDialog;
	KIconLoader *mpLoader;
	};


	/*
	* KIconButton: A "choose icon" pushbutton.
	*/

	KIconButton::KIconButton(QWidget *parent)
	: QPushButton(parent), d(new KIconButtonPrivate(this, KIconLoader::global()))
	{
	QPushButton::setIconSize(QSize(48, 48));
	}

	KIconButton::KIconButton(KIconLoader loader, QWidget parent)
	: QPushButton(parent), d(new KIconButtonPrivate(this, loader))
	{
	QPushButton::setIconSize(QSize(48, 48));
	}

	KIconButton::KIconButtonPrivate::KIconButtonPrivate(KIconButton qq, KIconLoader loader)
	: q(qq)
	{
	m_bStrictIconSize = false;
	iconSize = 0; // let KIconLoader choose the default

	mGroup = KIconLoader::Desktop;
	mContext = KIconLoader::Application;
	mbUser = false;

	mpLoader = loader;
	mpDialog = 0L;
	connect(q, SIGNAL(clicked()), q, SLOT(_k_slotChangeIcon()));
	}

	KIconButton::KIconButtonPrivate::~KIconButtonPrivate()
	{
	delete mpDialog;
	}

	KIconButton::~KIconButton()
	{
	delete d;
	}

	void KIconButton::setStrictIconSize(bool b)
	{
	d->m_bStrictIconSize=b;
	}

	bool KIconButton::strictIconSize() const
	{
	return d->m_bStrictIconSize;
	}

	void KIconButton::setIconSize( int size )
	{
	QPushButton::setIconSize(QSize(size, size));
	d->iconSize = size;
	}

	int KIconButton::iconSize() const
	{
	return d->iconSize;
	}

	void KIconButton::setIconType(KIconLoader::Group group, KIconLoader::Context context, bool user)
	{
	d->mGroup = group;
	d->mContext = context;
	d->mbUser = user;
	}

	void KIconButton::setIcon(const QString& icon)
	{
	d->mIcon = icon;
	setIcon(KIcon(d->mIcon));

	if (!d->mpDialog) {
	d->mpDialog = new KIconDialog(d->mpLoader, this);
	connect(d->mpDialog, SIGNAL(newIconName(QString)), this, SLOT(_k_newIconName(QString)));
	}

	if (d->mbUser) {
	d->mpDialog->setCustomLocation(QFileInfo(d->mpLoader->iconPath(d->mIcon, d->mGroup, true) ).absolutePath());
	}
	}

	void KIconButton::setIcon(const QIcon& icon)
	{
	QPushButton::setIcon(icon);
	}

	void KIconButton::resetIcon()
	{
	d->mIcon.clear();
	setIcon(QIcon());
	}

	const QString &KIconButton::icon() const
	{
	return d->mIcon;
	}

	void KIconButton::KIconButtonPrivate::_k_slotChangeIcon()
	{
	if (!mpDialog)
	{
	mpDialog = new KIconDialog(mpLoader, q);
	connect(mpDialog, SIGNAL(newIconName(QString)), q, SLOT(_k_newIconName(QString)));
	}

	mpDialog->setup(mGroup, mContext, m_bStrictIconSize, iconSize, mbUser);
	mpDialog->showDialog();
	}

	void KIconButton::KIconButtonPrivate::_k_newIconName(const QString& name)
	{
	if (name.isEmpty())
	return;

	q->setIcon(KIcon(name));
	mIcon = name;

	if (mbUser) {
	mpDialog->setCustomLocation(QFileInfo(mpLoader->iconPath(mIcon, mGroup, true)).absolutePath());
	}

	emit q->iconChanged(name);
	}

	#include "moc_kleo_kicondialog.cpp"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Feb 5, 9:27 PM (17 h, 16 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 5d/57/067dc4e79ccb23f39be46172f79f

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions