No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/kparts/part.cpp b/kparts/part.cpp
	index 7c9e652a82..11ce7ad1ef 100644
	--- a/kparts/part.cpp
	+++ b/kparts/part.cpp
	@@ -1,1147 +1,1147 @@
	/* This file is part of the KDE project
	Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
	(C) 1999-2005 David Faure <faure@kde.org>

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

	This library 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
	Library General Public License for more details.

	You should have received a copy of the GNU Library General Public License
	along with this library; see the file COPYING.LIB. If not, write to
	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA.
	*/

	#include "part.h"
	#include <kprotocolinfo.h>
	#include "event.h"
	#include "plugin.h"
	#include "mainwindow.h"
	#include "partmanager.h"
	#include "browserextension.h"

	#include <QApplication>
	#include <QtCore/QFile>
	#include <QtCore/QFileInfo>
	#include <qtemporaryfile.h>
	#include <QtCore/QPoint>

	#include <kdirnotify.h>
	#include <kfiledialog.h>
	#include <kcomponentdata.h>
	#include <kio/job.h>
	#include <kio/jobuidelegate.h>
	#include <klocale.h>
	#include <kmessagebox.h>
	#include <kstandarddirs.h>
	#include <kxmlguifactory.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <assert.h>
	#include <kdebug.h>
	#include <kiconloader.h>

	using namespace KParts;

	namespace KParts
	{

	class PartBasePrivate
	{
	public:
	Q_DECLARE_PUBLIC(PartBase)

	PartBasePrivate(PartBase *q): q_ptr(q)
	{
	m_pluginLoadingMode = PartBase::LoadPlugins;
	m_pluginInterfaceVersion = 0;
	m_obj = 0;
	}

	virtual ~PartBasePrivate()
	{
	}

	PartBase *q_ptr;
	PartBase::PluginLoadingMode m_pluginLoadingMode;
	int m_pluginInterfaceVersion;
	QObject *m_obj;
	};

	class PartPrivate: public PartBasePrivate
	{
	public:
	Q_DECLARE_PUBLIC(Part)

	PartPrivate(Part *q)
	: PartBasePrivate(q),
	m_iconLoader(0),
	m_bSelectable(true),
	m_autoDeleteWidget(true),
	m_autoDeletePart(true),
	m_manager(0)
	{
	}

	~PartPrivate()
	{
	}

	KIconLoader* m_iconLoader;
	bool m_bSelectable;
	bool m_autoDeleteWidget;
	bool m_autoDeletePart;
	PartManager * m_manager;
	QPointer<QWidget> m_widget;
	};

	}

	PartBase::PartBase()
	: d_ptr(new PartBasePrivate(this))
	{
	}

	PartBase::PartBase(PartBasePrivate &dd)
	: d_ptr(&dd)
	{
	}

	PartBase::~PartBase()
	{
	delete d_ptr;
	}

	void PartBase::setPartObject( QObject *obj )
	{
	Q_D(PartBase);

	d->m_obj = obj;
	}

	QObject *PartBase::partObject() const
	{
	Q_D(const PartBase);

	return d->m_obj;
	}

	void PartBase::setComponentData(const KComponentData &componentData)
	{
	setComponentData(componentData, true);
	}

	void PartBase::setComponentData(const KComponentData &componentData, bool bLoadPlugins)
	{
	Q_D(PartBase);

	KXMLGUIClient::setComponentData(componentData);
	KGlobal::locale()->insertCatalog(componentData.catalogName());
	// install 'instancename'data resource type
	KGlobal::dirs()->addResourceType(QString(componentData.componentName() + "data").toUtf8(),
	"data", componentData.componentName());
	if (bLoadPlugins) {
	loadPlugins(d->m_obj, this, componentData);
	}
	}

	void PartBase::loadPlugins(QObject parent, KXMLGUIClient parentGUIClient, const KComponentData &instance)
	{
	Q_D(PartBase);

	if( d->m_pluginLoadingMode != DoNotLoadPlugins )
	Plugin::loadPlugins( parent, parentGUIClient, instance, d->m_pluginLoadingMode == LoadPlugins, d->m_pluginInterfaceVersion );
	}

	void PartBase::setPluginLoadingMode( PluginLoadingMode loadingMode )
	{
	Q_D(PartBase);

	d->m_pluginLoadingMode = loadingMode;
	}

	void KParts::PartBase::setPluginInterfaceVersion( int version )
	{
	Q_D(PartBase);

	d->m_pluginInterfaceVersion = version;
	}

	Part::Part( QObject *parent )
	: QObject( parent ), PartBase( *new PartPrivate(this) )
	{
	PartBase::setPartObject( this );
	}

	Part::Part(PartPrivate &dd, QObject *parent)
	: QObject( parent ), PartBase( dd )
	{
	PartBase::setPartObject( this );
	}

	Part::~Part()
	{
	Q_D(Part);

	//kDebug(1000) << this;

	if ( d->m_widget )
	{
	// We need to disconnect first, to avoid calling it !
	disconnect( d->m_widget, SIGNAL( destroyed() ),
	this, SLOT( slotWidgetDestroyed() ) );
	}

	if ( d->m_manager )
	d->m_manager->removePart(this);

	if ( d->m_widget && d->m_autoDeleteWidget )
	{
	kDebug(1000) << "deleting widget" << d->m_widget << d->m_widget->objectName();
	delete static_cast<QWidget*>(d->m_widget);
	}

	delete d->m_iconLoader;
	}

	void Part::embed( QWidget * parentWidget )
	{
	if ( widget() )
	{
	widget()->setParent( parentWidget, 0 );
	widget()->setGeometry( 0, 0, widget()->width(), widget()->height() );
	widget()->show();
	}
	}

	QWidget *Part::widget()
	{
	Q_D(Part);

	return d->m_widget;
	}

	void Part::setAutoDeleteWidget(bool autoDeleteWidget)
	{
	Q_D(Part);
	d->m_autoDeleteWidget = autoDeleteWidget;
	}

	void Part::setAutoDeletePart(bool autoDeletePart)
	{
	Q_D(Part);
	d->m_autoDeletePart = autoDeletePart;
	}



	KIconLoader* Part::iconLoader()
	{
	Q_D(Part);

	if (!d->m_iconLoader) {
	Q_ASSERT(componentData().isValid());
	d->m_iconLoader = new KIconLoader( componentData() );
	}
	return d->m_iconLoader;
	}

	void Part::setManager( PartManager *manager )
	{
	Q_D(Part);

	d->m_manager = manager;
	}

	PartManager *Part::manager() const
	{
	Q_D(const Part);

	return d->m_manager;
	}

	Part Part::hitTest( QWidget widget, const QPoint & )
	{
	Q_D(Part);

	if ( (QWidget *)d->m_widget != widget )
	return 0;

	return this;
	}

	void Part::setWidget( QWidget *widget )
	{
	Q_D(Part);
	d->m_widget = widget;
	connect( d->m_widget, SIGNAL( destroyed() ),
	this, SLOT( slotWidgetDestroyed() ), Qt::UniqueConnection );
	}

	void Part::setSelectable( bool selectable )
	{
	Q_D(Part);

	d->m_bSelectable = selectable;
	}

	bool Part::isSelectable() const
	{
	Q_D(const Part);

	return d->m_bSelectable;
	}

	void Part::customEvent( QEvent *ev )
	{
	if ( PartActivateEvent::test( ev ) )
	{
	partActivateEvent( static_cast<PartActivateEvent *>(ev) );
	return;
	}

	if ( PartSelectEvent::test( ev ) )
	{
	partSelectEvent( static_cast<PartSelectEvent *>(ev) );
	return;
	}

	if ( GUIActivateEvent::test( ev ) )
	{
	guiActivateEvent( static_cast<GUIActivateEvent *>(ev) );
	return;
	}

	QObject::customEvent( ev );
	}

	void Part::partActivateEvent( PartActivateEvent * )
	{
	}

	void Part::partSelectEvent( PartSelectEvent * )
	{
	}

	void Part::guiActivateEvent( GUIActivateEvent * )
	{
	}

	QWidget *Part::hostContainer( const QString &containerName )
	{
	if ( !factory() )
	return 0;

	return factory()->container( containerName, this );
	}

	void Part::slotWidgetDestroyed()
	{
	Q_D(Part);

	d->m_widget = 0;
	if (d->m_autoDeletePart) {
	kDebug(1000) << "deleting part" << objectName();
	delete this; // ouch, this should probably be deleteLater()
	}
	}

	void Part::loadPlugins()
	{
	PartBase::loadPlugins(this, this, componentData());
	}

	//////////////////////////////////////////////////

	namespace KParts
	{

	class ReadOnlyPartPrivate: public PartPrivate
	{
	public:
	Q_DECLARE_PUBLIC(ReadOnlyPart)

	ReadOnlyPartPrivate(ReadOnlyPart *q): PartPrivate(q)
	{
	m_job = 0;
	m_statJob = 0;
	m_uploadJob = 0;
	m_showProgressInfo = true;
	m_saveOk = false;
	m_waitForSave = false;
	m_duringSaveAs = false;
	m_bTemp = false;
	m_bAutoDetectedMime = false;
	}

	~ReadOnlyPartPrivate()
	{
	}

	void _k_slotJobFinished( KJob * job );
	void _k_slotStatJobFinished(KJob * job);
	void _k_slotGotMimeType(KIO::Job *job, const QString &mime);
	bool openLocalFile();
	void openRemoteFile();

	KIO::FileCopyJob * m_job;
	KIO::StatJob * m_statJob;
	KIO::FileCopyJob * m_uploadJob;
	KUrl m_originalURL; // for saveAs
	QString m_originalFilePath; // for saveAs
	bool m_showProgressInfo : 1;
	bool m_saveOk : 1;
	bool m_waitForSave : 1;
	bool m_duringSaveAs : 1;

	/**
	* If @p true, @p m_file is a temporary file that needs to be deleted later.
	*/
	bool m_bTemp: 1;

	// whether the mimetype in the arguments was detected by the part itself
	bool m_bAutoDetectedMime : 1;

	/**
	* Remote (or local) url - the one displayed to the user.
	*/
	KUrl m_url;

	/**
	* Local file - the only one the part implementation should deal with.
	*/
	QString m_file;

	OpenUrlArguments m_arguments;
	};

	class ReadWritePartPrivate: public ReadOnlyPartPrivate
	{
	public:
	Q_DECLARE_PUBLIC(ReadWritePart)

	ReadWritePartPrivate(ReadWritePart *q): ReadOnlyPartPrivate(q)
	{
	m_bModified = false;
	m_bReadWrite = true;
	m_bClosing = false;
	}

	void _k_slotUploadFinished( KJob * job );

	void prepareSaving();

	bool m_bModified;
	bool m_bReadWrite;
	bool m_bClosing;
	QEventLoop m_eventLoop;
	};

	}

	ReadOnlyPart::ReadOnlyPart( QObject *parent )
	: Part( *new ReadOnlyPartPrivate(this), parent )
	{
	}

	ReadOnlyPart::ReadOnlyPart( ReadOnlyPartPrivate &dd, QObject *parent )
	: Part( dd, parent )
	{
	}

	ReadOnlyPart::~ReadOnlyPart()
	{
	ReadOnlyPart::closeUrl();
	}

	KUrl ReadOnlyPart::url() const
	{
	Q_D(const ReadOnlyPart);

	return d->m_url;
	}

	void ReadOnlyPart::setUrl(const QUrl &url)
	{
	Q_D(ReadOnlyPart);

	d->m_url = url;
	}

	QString ReadOnlyPart::localFilePath() const
	{
	Q_D(const ReadOnlyPart);

	return d->m_file;
	}

	void ReadOnlyPart::setLocalFilePath( const QString &localFilePath )
	{
	Q_D(ReadOnlyPart);

	d->m_file = localFilePath;
	}

	#ifndef KDE_NO_DEPRECATED
	bool ReadOnlyPart::isLocalFileTemporary() const
	{
	Q_D(const ReadOnlyPart);

	return d->m_bTemp;
	}
	#endif

	#ifndef KDE_NO_DEPRECATED
	void ReadOnlyPart::setLocalFileTemporary( bool temp )
	{
	Q_D(ReadOnlyPart);

	d->m_bTemp = temp;
	}
	#endif

	void ReadOnlyPart::setProgressInfoEnabled( bool show )
	{
	Q_D(ReadOnlyPart);

	d->m_showProgressInfo = show;
	}

	bool ReadOnlyPart::isProgressInfoEnabled() const
	{
	Q_D(const ReadOnlyPart);

	return d->m_showProgressInfo;
	}

	#ifndef KDE_NO_COMPAT
	void ReadOnlyPart::showProgressInfo( bool show )
	{
	Q_D(ReadOnlyPart);

	d->m_showProgressInfo = show;
	}
	#endif

	bool ReadOnlyPart::openUrl( const QUrl &url )
	{
	Q_D(ReadOnlyPart);

	if ( !url.isValid() )
	return false;
	if (d->m_bAutoDetectedMime) {
	d->m_arguments.setMimeType(QString());
	d->m_bAutoDetectedMime = false;
	}
	OpenUrlArguments args = d->m_arguments;
	if ( !closeUrl() )
	return false;
	d->m_arguments = args;
	d->m_url = url;

	d->m_file.clear();

	if (d->m_url.isLocalFile()) {
	d->m_file = d->m_url.toLocalFile();
	return d->openLocalFile();
	} else if (KProtocolInfo::protocolClass(url.scheme()) == ":local") {
	// Maybe we can use a "local path", to avoid a temp copy?
	KIO::JobFlags flags = d->m_showProgressInfo ? KIO::DefaultFlags : KIO::HideProgressInfo;
	d->m_statJob = KIO::mostLocalUrl(d->m_url, flags);
	d->m_statJob->ui()->setWindow( widget() ? widget()->topLevelWidget() : 0 );
	connect(d->m_statJob, SIGNAL(result(KJob)), this, SLOT(_k_slotStatJobFinished(KJob)));
	return true;
	} else {
	d->openRemoteFile();
	return true;
	}
	}

	bool ReadOnlyPart::openFile()
	{
	kWarning(1000) << "Default implementation of ReadOnlyPart::openFile called!"
	<< metaObject()->className() << "should reimplement either openUrl or openFile.";
	return false;
	}

	bool ReadOnlyPartPrivate::openLocalFile()
	{
	Q_Q(ReadOnlyPart);
	emit q->started( 0 );
	m_bTemp = false;
	// set the mimetype only if it was not already set (for example, by the host application)
	if (m_arguments.mimeType().isEmpty()) {
	// get the mimetype of the file
	// using findByUrl() to avoid another string -> url conversion
	KMimeType::Ptr mime = KMimeType::findByUrl(m_url, 0, true /* local file*/);
	if (mime) {
	m_arguments.setMimeType(mime->name());
	m_bAutoDetectedMime = true;
	}
	}
	const bool ret = q->openFile();
	if (ret) {
	emit q->setWindowCaption(m_url.prettyUrl());
	emit q->completed();
	} else {
	emit q->canceled(QString());
	}
	return ret;
	}

	void ReadOnlyPartPrivate::openRemoteFile()
	{
	Q_Q(ReadOnlyPart);
	m_bTemp = true;
	// Use same extension as remote file. This is important for mimetype-determination (e.g. koffice)
	QString fileName = m_url.fileName();
	QFileInfo fileInfo(fileName);
	QString ext = fileInfo.completeSuffix();
	QString extension;
	if (!ext.isEmpty() && m_url.query().isNull()) // not if the URL has a query, e.g. cgi.pl?something
	extension = '.'+ext; // keep the '.'
	QTemporaryFile tempFile(QDir::tempPath() + QLatin1Char('/') + q->componentData().componentName() + QLatin1String("XXXXXX") + extension);
	tempFile.setAutoRemove(false);
	tempFile.open();
	m_file = tempFile.fileName();

	KUrl destURL;
	destURL.setPath( m_file );
	KIO::JobFlags flags = m_showProgressInfo ? KIO::DefaultFlags : KIO::HideProgressInfo;
	flags \|= KIO::Overwrite;
	m_job = KIO::file_copy(m_url, destURL, 0600, flags);
	m_job->ui()->setWindow(q->widget() ? q->widget()->topLevelWidget() : 0);
	emit q->started(m_job);
	QObject::connect(m_job, SIGNAL(result(KJob)), q, SLOT(_k_slotJobFinished(KJob)));
	QObject::connect(m_job, SIGNAL(mimetype(KIO::Job*, QString)),
	q, SLOT(_k_slotGotMimeType(KIO::Job*,QString)));
	}

	void ReadOnlyPart::abortLoad()
	{
	Q_D(ReadOnlyPart);

	if ( d->m_statJob ) {
	//kDebug(1000) << "Aborting job" << d->m_statJob;
	d->m_statJob->kill();
	d->m_statJob = 0;
	}
	if ( d->m_job ) {
	//kDebug(1000) << "Aborting job" << d->m_job;
	d->m_job->kill();
	d->m_job = 0;
	}
	}

	bool ReadOnlyPart::closeUrl()
	{
	Q_D(ReadOnlyPart);

	abortLoad(); //just in case

	d->m_arguments = KParts::OpenUrlArguments();

	if ( d->m_bTemp )
	{
	QFile::remove( d->m_file );
	d->m_bTemp = false;
	}
	// It always succeeds for a read-only part,
	// but the return value exists for reimplementations
	// (e.g. pressing cancel for a modified read-write part)
	return true;
	}

	void ReadOnlyPartPrivate::_k_slotStatJobFinished(KJob * job)
	{
	Q_ASSERT(job == m_statJob);
	m_statJob = 0;

	// We could emit canceled on error, but we haven't even emitted started yet,
	// this could maybe confuse some apps? So for now we'll just fallback to KIO::get
	// and error again. Well, maybe this even helps with wrong stat results.
	if (!job->error()) {
	const KUrl localUrl = static_cast<KIO::StatJob*>(job)->mostLocalUrl();
	if (localUrl.isLocalFile()) {
	m_file = localUrl.toLocalFile();
	(void)openLocalFile();
	return;
	}
	}
	openRemoteFile();
	}

	void ReadOnlyPartPrivate::_k_slotJobFinished( KJob * job )
	{
	Q_Q(ReadOnlyPart);

	assert( job == m_job );
	m_job = 0;
	if (job->error())
	emit q->canceled( job->errorString() );
	else
	{
	if ( q->openFile() ) {
	emit q->setWindowCaption( m_url.prettyUrl() );
	emit q->completed();
	} else emit q->canceled(QString());
	}
	}

	void ReadOnlyPartPrivate::_k_slotGotMimeType(KIO::Job *job, const QString &mime)
	{
	kDebug(1000) << mime;
	Q_ASSERT(job == m_job); Q_UNUSED(job)
	// set the mimetype only if it was not already set (for example, by the host application)
	if (m_arguments.mimeType().isEmpty()) {
	m_arguments.setMimeType(mime);
	m_bAutoDetectedMime = true;
	}
	}

	void ReadOnlyPart::guiActivateEvent( GUIActivateEvent * event )
	{
	Q_D(ReadOnlyPart);

	if (event->activated())
	{
	if (!d->m_url.isEmpty())
	{
	kDebug(1000) << d->m_url;
	emit setWindowCaption( d->m_url.prettyUrl() );
	} else emit setWindowCaption( "" );
	}
	}

	bool ReadOnlyPart::openStream( const QString& mimeType, const QUrl & url )
	{
	Q_D(ReadOnlyPart);

	OpenUrlArguments args = d->m_arguments;
	if ( !closeUrl() )
	return false;
	d->m_arguments = args;
	d->m_url = url;
	return doOpenStream( mimeType );
	}

	bool ReadOnlyPart::writeStream( const QByteArray& data )
	{
	return doWriteStream( data );
	}

	bool ReadOnlyPart::closeStream()
	{
	return doCloseStream();
	}

	BrowserExtension* ReadOnlyPart::browserExtension() const
	{
	return findChild<KParts::BrowserExtension *>();
	}

	void KParts::ReadOnlyPart::setArguments(const OpenUrlArguments& arguments)
	{
	Q_D(ReadOnlyPart);
	d->m_arguments = arguments;
	d->m_bAutoDetectedMime = arguments.mimeType().isEmpty();
	}

	OpenUrlArguments KParts::ReadOnlyPart::arguments() const
	{
	Q_D(const ReadOnlyPart);
	return d->m_arguments;
	}

	//////////////////////////////////////////////////


	ReadWritePart::ReadWritePart( QObject *parent )
	: ReadOnlyPart( *new ReadWritePartPrivate(this), parent )
	{
	}

	ReadWritePart::~ReadWritePart()
	{
	// parent destructor will delete temp file
	// we can't call our own closeUrl() here, because
	// "cancel" wouldn't cancel anything. We have to assume
	// the app called closeUrl() before destroying us.
	}

	void ReadWritePart::setReadWrite( bool readwrite )
	{
	Q_D(ReadWritePart);

	// Perhaps we should check isModified here and issue a warning if true
	d->m_bReadWrite = readwrite;
	}

	void ReadWritePart::setModified( bool modified )
	{
	Q_D(ReadWritePart);

	kDebug(1000) << "setModified(" << (modified ? "true" : "false") << ")";
	if ( !d->m_bReadWrite && modified )
	{
	kError(1000) << "Can't set a read-only document to 'modified' !" << endl;
	return;
	}
	d->m_bModified = modified;
	}

	void ReadWritePart::setModified()
	{
	setModified( true );
	}

	bool ReadWritePart::queryClose()
	{
	Q_D(ReadWritePart);

	if ( !isReadWrite() \|\| !isModified() )
	return true;

	QString docName = url().fileName();
	if (docName.isEmpty()) docName = i18n( "Untitled" );

	QWidget *parentWidget=widget();
	if(!parentWidget) parentWidget=QApplication::activeWindow();

	int res = KMessageBox::warningYesNoCancel( parentWidget,
	i18n( "The document \"%1\" has been modified.\n"
	"Do you want to save your changes or discard them?" , docName ),
	i18n( "Close Document" ), KStandardGuiItem::save(), KStandardGuiItem::discard() );

	bool abortClose=false;
	bool handled=false;

	switch(res) {
	case KMessageBox::Yes :
	sigQueryClose(&handled,&abortClose);
	if (!handled)
	{
	if (d->m_url.isEmpty())
	{
	KUrl url = KFileDialog::getSaveUrl(KUrl(), QString(), parentWidget);
	if (url.isEmpty())
	return false;

	saveAs( url );
	}
	else
	{
	save();
	}
	} else if (abortClose) return false;
	return waitSaveComplete();
	case KMessageBox::No :
	return true;
	default : // case KMessageBox::Cancel :
	return false;
	}
	}

	bool ReadWritePart::closeUrl()
	{
	abortLoad(); //just in case
	if ( isReadWrite() && isModified() )
	{
	if (!queryClose())
	return false;
	}
	// Not modified => ok and delete temp file.
	return ReadOnlyPart::closeUrl();
	}

	bool ReadWritePart::closeUrl( bool promptToSave )
	{
	return promptToSave ? closeUrl() : ReadOnlyPart::closeUrl();
	}

	bool ReadWritePart::save()
	{
	Q_D(ReadWritePart);

	d->m_saveOk = false;
	if ( d->m_file.isEmpty() ) // document was created empty
	d->prepareSaving();
	if( saveFile() )
	return saveToUrl();
	else
	emit canceled(QString());
	return false;
	}

	-bool ReadWritePart::saveAs( const QUrl & kurl )
	+bool ReadWritePart::saveAs(const QUrl & url)
	{
	Q_D(ReadWritePart);

	- if (!kurl.isValid())
	+ if (!url.isValid())
	{
	- kError(1000) << "saveAs: Malformed URL " << kurl.url() << endl;
	+ kError(1000) << "saveAs: Malformed URL " << url << endl;
	return false;
	}
	d->m_duringSaveAs = true;
	d->m_originalURL = d->m_url;
	d->m_originalFilePath = d->m_file;
	- d->m_url = kurl; // Store where to upload in saveToURL
	+ d->m_url = url; // Store where to upload in saveToURL
	d->prepareSaving();
	bool result = save(); // Save local file and upload local file
	if (result) {
	emit setWindowCaption( d->m_url.prettyUrl() );
	} else {
	d->m_url = d->m_originalURL;
	d->m_file = d->m_originalFilePath;
	d->m_duringSaveAs = false;
	d->m_originalURL = KUrl();
	d->m_originalFilePath.clear();
	}

	return result;
	}

	// Set m_file correctly for m_url
	void ReadWritePartPrivate::prepareSaving()
	{
	// Local file
	if ( m_url.isLocalFile() )
	{
	if ( m_bTemp ) // get rid of a possible temp file first
	{ // (happens if previous url was remote)
	QFile::remove( m_file );
	m_bTemp = false;
	}
	m_file = m_url.toLocalFile();
	}
	else
	{ // Remote file
	// We haven't saved yet, or we did but locally - provide a temp file
	if ( m_file.isEmpty() \|\| !m_bTemp )
	{
	QTemporaryFile tempFile;
	tempFile.setAutoRemove(false);
	tempFile.open();
	m_file = tempFile.fileName();
	m_bTemp = true;
	}
	// otherwise, we already had a temp file
	}
	}

	bool ReadWritePart::saveToUrl()
	{
	Q_D(ReadWritePart);

	if ( d->m_url.isLocalFile() )
	{
	setModified( false );
	emit completed();
	// if m_url is a local file there won't be a temp file -> nothing to remove
	assert( !d->m_bTemp );
	d->m_saveOk = true;
	d->m_duringSaveAs = false;
	d->m_originalURL = KUrl();
	d->m_originalFilePath.clear();
	return true; // Nothing to do
	}
	else
	{
	if (d->m_uploadJob)
	{
	QFile::remove(d->m_uploadJob->srcUrl().toLocalFile());
	d->m_uploadJob->kill();
	d->m_uploadJob = 0;
	}
	QTemporaryFile *tempFile = new QTemporaryFile();
	tempFile->open();
	QString uploadFile = tempFile->fileName();
	delete tempFile;
	KUrl uploadUrl;
	uploadUrl.setPath( uploadFile );
	// Create hardlink
	if (::link(QFile::encodeName(d->m_file), QFile::encodeName(uploadFile)) != 0)
	{
	// Uh oh, some error happened.
	return false;
	}
	d->m_uploadJob = KIO::file_move( uploadUrl, d->m_url, -1, KIO::Overwrite );
	d->m_uploadJob->ui()->setWindow( widget() ? widget()->topLevelWidget() : 0 );
	connect( d->m_uploadJob, SIGNAL( result( KJob * ) ), this, SLOT( _k_slotUploadFinished (KJob *) ) );
	return true;
	}
	}

	void ReadWritePartPrivate::_k_slotUploadFinished( KJob * )
	{
	Q_Q(ReadWritePart);

	if (m_uploadJob->error())
	{
	QFile::remove(m_uploadJob->srcUrl().toLocalFile());
	QString error = m_uploadJob->errorString();
	m_uploadJob = 0;
	if (m_duringSaveAs) {
	m_url = m_originalURL;
	m_file = m_originalFilePath;
	}
	emit q->canceled( error );
	}
	else
	{
	KUrl dirUrl( m_url );
	dirUrl.setPath( dirUrl.directory() );
	::org::kde::KDirNotify::emitFilesAdded( dirUrl.url() );

	m_uploadJob = 0;
	q->setModified( false );
	emit q->completed();
	m_saveOk = true;
	}
	m_duringSaveAs = false;
	m_originalURL = KUrl();
	m_originalFilePath.clear();
	if (m_waitForSave) {
	m_eventLoop.quit();
	}
	}

	bool ReadWritePart::isReadWrite() const
	{
	Q_D(const ReadWritePart);

	return d->m_bReadWrite;
	}

	bool ReadWritePart::isModified() const
	{
	Q_D(const ReadWritePart);

	return d->m_bModified;
	}

	bool ReadWritePart::waitSaveComplete()
	{
	Q_D(ReadWritePart);

	if (!d->m_uploadJob)
	return d->m_saveOk;

	d->m_waitForSave = true;

	d->m_eventLoop.exec(QEventLoop::ExcludeUserInputEvents);

	d->m_waitForSave = false;

	return d->m_saveOk;
	}

	////

	class KParts::OpenUrlArgumentsPrivate : public QSharedData
	{
	public:
	OpenUrlArgumentsPrivate()
	: reload(false),
	actionRequestedByUser(true),
	xOffset(0),
	yOffset(0),
	mimeType(),
	metaData()
	{}
	bool reload;
	bool actionRequestedByUser;
	int xOffset;
	int yOffset;
	QString mimeType;
	QMap<QString, QString> metaData;
	};

	KParts::OpenUrlArguments::OpenUrlArguments()
	: d(new OpenUrlArgumentsPrivate)
	{
	}

	KParts::OpenUrlArguments::OpenUrlArguments(const OpenUrlArguments &other)
	: d(other.d)
	{
	}

	KParts::OpenUrlArguments & KParts::OpenUrlArguments::operator=( const OpenUrlArguments &other)
	{
	d = other.d;
	return *this;
	}

	KParts::OpenUrlArguments::~OpenUrlArguments()
	{
	}

	bool KParts::OpenUrlArguments::reload() const
	{
	return d->reload;
	}

	void KParts::OpenUrlArguments::setReload(bool b)
	{
	d->reload = b;
	}

	int KParts::OpenUrlArguments::xOffset() const
	{
	return d->xOffset;
	}

	void KParts::OpenUrlArguments::setXOffset(int x)
	{
	d->xOffset = x;
	}

	int KParts::OpenUrlArguments::yOffset() const
	{
	return d->yOffset;
	}

	void KParts::OpenUrlArguments::setYOffset(int y)
	{
	d->yOffset = y;
	}

	QString KParts::OpenUrlArguments::mimeType() const
	{
	return d->mimeType;
	}

	void KParts::OpenUrlArguments::setMimeType(const QString& mime)
	{
	d->mimeType = mime;
	}

	QMap<QString, QString> & KParts::OpenUrlArguments::metaData()
	{
	return d->metaData;
	}

	const QMap<QString, QString> & KParts::OpenUrlArguments::metaData() const
	{
	return d->metaData;
	}

	bool KParts::OpenUrlArguments::actionRequestedByUser() const
	{
	return d->actionRequestedByUser;
	}

	void KParts::OpenUrlArguments::setActionRequestedByUser(bool userRequested)
	{
	d->actionRequestedByUser = userRequested;
	}

	#include "moc_part.cpp"
	diff --git a/kutils/CMakeLists.txt b/kutils/CMakeLists.txt
	index 2d5adfca1f..5e22707a91 100644
	--- a/kutils/CMakeLists.txt
	+++ b/kutils/CMakeLists.txt
	@@ -1,176 +1,177 @@
	project(kutils)
	include_directories( ${KDE4_KDEUI_INCLUDES}
	${KDE4_KPARTS_INCLUDES}
	${CMAKE_CURRENT_SOURCE_DIR}
	+ ${CMAKE_CURRENT_BINARY_DIR}
	${karchive_SOURCE_DIR}/src
	${karchive_BINARY_DIR}/src
	${CMAKE_SOURCE_DIR}/tier1/kauth/src/
	${CMAKE_BINARY_DIR}/tier1/kauth/src/
	)

	########### kemoticons ################
	add_subdirectory(kemoticons)

	set(kemoticons_LIB_SRCS
	kemoticons/kemoticons.cpp
	kemoticons/kemoticonstheme.cpp
	kemoticons/kemoticonsprovider.cpp
	)

	kde4_add_library(kemoticons ${LIBRARY_TYPE} ${kemoticons_LIB_SRCS})
	generate_export_header(kemoticons)
	target_link_libraries(kemoticons ${KDE4_KIO_LIBS} karchive kcoreaddons)
	target_link_libraries(kemoticons LINK_INTERFACE_LIBRARIES kdecore kdeui ${QT_QTGUI_LIBRARY})
	set_target_properties(kemoticons PROPERTIES
	VERSION ${GENERIC_LIB_VERSION}
	SOVERSION ${GENERIC_LIB_SOVERSION})

	install(FILES kemoticons/kemoticonsTheme.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR})

	install(FILES
	${CMAKE_CURRENT_BINARY_DIR}/kemoticons_export.h
	kemoticons/kemoticons.h
	kemoticons/kemoticonstheme.h
	kemoticons/kemoticonsprovider.h
	DESTINATION ${INCLUDE_INSTALL_DIR}
	COMPONENT Devel
	)

	install(TARGETS kemoticons ${INSTALL_TARGETS_DEFAULT_ARGS})


	######## kidletime ####################
	configure_file(kidletime/config-kidletime.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kidletime.h )

	set(kidletime_LIB_SRCS
	kidletime/kidletime.cpp
	kidletime/abstractsystempoller.cpp
	kidletime/widgetbasedpoller.cpp
	)

	if (Q_WS_X11)
	if (HAVE_XSCREENSAVER)
	set(kidletime_LIB_SRCS ${kidletime_LIB_SRCS}
	kidletime/xscreensaverbasedpoller.cpp)
	qt4_add_dbus_interface(kidletime_LIB_SRCS kidletime/org.freedesktop.ScreenSaver.xml screensaver_interface)
	endif (HAVE_XSCREENSAVER)
	if (HAVE_XSYNC)
	set(kidletime_LIB_SRCS ${kidletime_LIB_SRCS}
	kidletime/xsyncbasedpoller.cpp )
	endif (HAVE_XSYNC)
	elseif (Q_WS_MAC)
	set(kidletime_LIB_SRCS ${kidletime_LIB_SRCS} kidletime/macpoller.cpp)
	elseif (Q_WS_WIN)
	set(kidletime_LIB_SRCS ${kidletime_LIB_SRCS} kidletime/windowspoller.cpp)
	endif (Q_WS_X11)

	kde4_add_library(kidletime ${LIBRARY_TYPE} ${kidletime_LIB_SRCS})
	generate_export_header(kidletime)
	target_link_libraries(kidletime LINK_INTERFACE_LIBRARIES kdecore kdeui ${QT_QTGUI_LIBRARY})
	target_link_libraries(kidletime ${KDE4_KDEUI_LIBS})

	if (Q_WS_X11)
	if (HAVE_XSCREENSAVER)
	target_link_libraries(kidletime ${X11_Xss_LIB})
	endif (HAVE_XSCREENSAVER)
	if (HAVE_XSYNC)
	target_link_libraries(kidletime ${X11_Xext_LIB})
	endif (HAVE_XSYNC)
	target_link_libraries(kidletime ${X11_LIBRARIES})
	endif (Q_WS_X11)

	set_target_properties(kidletime PROPERTIES
	VERSION ${GENERIC_LIB_VERSION}
	SOVERSION ${GENERIC_LIB_SOVERSION})
	install( FILES
	${CMAKE_CURRENT_BINARY_DIR}/kidletime_export.h
	kidletime/kidletime.h
	DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)

	install(TARGETS kidletime ${INSTALL_TARGETS_DEFAULT_ARGS})


	########### kcmutils ###############
	set(kcmutils_LIB_SRCS
	kcmoduleinfo.cpp
	kcmoduleloader.cpp
	kcmultidialog.cpp
	kcmoduleproxy.cpp
	kpluginselector.cpp
	kcmodulecontainer.cpp
	ksettingswidgetadaptor.cpp
	ksettings/dispatcher.cpp
	ksettings/dialog.cpp
	ksettings/pluginpage.cpp
	ksettings/componentsdialog.cpp
	)

	kde4_add_library(kcmutils ${LIBRARY_TYPE} ${kcmutils_LIB_SRCS})
	generate_export_header(kcmutils)

	target_link_libraries(kcmutils ${KDE4_KDEUI_LIBS} kauth kcoreaddons )
	target_link_libraries(kcmutils LINK_INTERFACE_LIBRARIES kdecore kdeui ${QT_QTGUI_LIBRARY})
	set_target_properties(kcmutils PROPERTIES
	VERSION ${GENERIC_LIB_VERSION}
	SOVERSION ${GENERIC_LIB_SOVERSION})

	install( FILES
	${CMAKE_CURRENT_BINARY_DIR}/kcmutils_export.h
	kcmoduleinfo.h
	kcmoduleloader.h
	kcmultidialog.h
	kcmoduleproxy.h
	kpluginselector.h
	kcmodulecontainer.h
	DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)

	install(FILES
	ksettings/dispatcher.h
	ksettings/dialog.h
	ksettings/pluginpage.h
	DESTINATION ${INCLUDE_INSTALL_DIR}/ksettings
	COMPONENT Devel)

	install(TARGETS kcmutils ${INSTALL_TARGETS_DEFAULT_ARGS})


	########### kprintutils ###############
	set(kprintutils_LIB_SRCS
	kprintpreview.cpp
	)

	kde4_add_library(kprintutils ${LIBRARY_TYPE} ${kprintutils_LIB_SRCS})
	generate_export_header(kprintutils)

	target_link_libraries(kprintutils ${KDE4_KPARTS_LIBS} kcoreaddons)
	target_link_libraries(kprintutils LINK_INTERFACE_LIBRARIES kdecore kdeui ${QT_QTGUI_LIBRARY})
	set_target_properties(kprintutils PROPERTIES
	VERSION ${GENERIC_LIB_VERSION}
	SOVERSION ${GENERIC_LIB_SOVERSION})

	install( FILES
	${CMAKE_CURRENT_BINARY_DIR}/kprintutils_export.h
	kprintpreview.h
	DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)

	install(TARGETS kprintutils ${INSTALL_TARGETS_DEFAULT_ARGS})


	########### kutils ###############
	# This is only for backwards compatibility, don't use in new projects
	if(NOT KDE_PLATFORM_FEATURE_DISABLE_DEPRECATED)
	set(kutils_LIB_SRCS
	dummy.cpp
	)

	kde4_add_library(kutils ${LIBRARY_TYPE} ${kutils_LIB_SRCS})

	target_link_libraries(kutils kemoticons kidletime kcmutils kprintutils ${QT_QTCORE_LIBRARY})
	target_link_libraries(kutils LINK_INTERFACE_LIBRARIES kdecore kdeui ${QT_QTGUI_LIBRARY} kemoticons kidletime kcmutils kprintutils)
	set_target_properties(kutils PROPERTIES
	VERSION ${GENERIC_LIB_VERSION}
	SOVERSION ${GENERIC_LIB_SOVERSION})

	install(TARGETS kutils ${INSTALL_TARGETS_DEFAULT_ARGS})
	endif(NOT KDE_PLATFORM_FEATURE_DISABLE_DEPRECATED)

	diff --git a/kutils/ksettings/dialog.h b/kutils/ksettings/dialog.h
	index f8ce0b47cf..87fd48f437 100644
	--- a/kutils/ksettings/dialog.h
	+++ b/kutils/ksettings/dialog.h
	@@ -1,184 +1,184 @@
	/* This file is part of the KDE project
	Copyright (C) 2003 Matthias Kretz <kretz@kde.org>

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public
	License version 2 as published by the Free Software Foundation.

	This library 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
	Library General Public License for more details.

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

	*/

	#ifndef KSETTINGS_DIALOG_H
	#define KSETTINGS_DIALOG_H

	-#include "../kcmutils_export.h"
	-#include "../kcmultidialog.h"
	+#include <kcmutils_export.h>
	+#include <kcmultidialog.h>

	#include <kservice.h>
	#include <kplugininfo.h>

	template<class T> class QList;
	class KPluginInfo;
	class KCModuleInfo;

	namespace KSettings
	{
	class DialogPrivate;

	/**
	* @short Generic configuration dialog that works over component boundaries
	*
	* For more information see \ref KSettings.
	*
	* This class aims to standardize the use of configuration dialogs in KDE
	* applications. Especially when using KParts and/or Plugins you face problems
	* creating a consistent config dialog.
	*
	* To show a configuration dialog you only have to call the show method and be
	* done with it. A code example:
	*
	* You initialize \p m_cfgdlg with
	* \code
	* m_cfgdlg = new Dialog( this );
	* \endcode
	* If you use a KPart that was not especially designed for your app you can use
	* the second constructor:
	* \code
	* QStringList kpartslist;
	* for( all my kparts )
	* kpartslist += m_mypart->componentData().componentName();
	* m_cfgdlg = new Dialog( kpartslist, this );
	* \endcode
	* and the action for the config dialog is connected to the show slot:
	* \code
	* KStandardAction::preferences( m_cfgdlg, SLOT( show() ), actionCollection() );
	* \endcode
	*
	* If you need to be informed when the config was changed and applied in the
	* dialog you might want to take a look at Dispatcher.
	*
	* For more information see \ref KSettings.
	*
	* @author Matthias Kretz <kretz@kde.org>
	*/
	class KCMUTILS_EXPORT Dialog : public KCMultiDialog
	{
	friend class PageNode;
	Q_DECLARE_PRIVATE(Dialog)
	Q_OBJECT
	public:
	/**
	* Construct a new Preferences Dialog for the application. It uses all
	* KCMs with X-KDE-ParentApp set to KGlobal::mainComponent().componentName().
	*
	* @param content Select whether you want a static or configurable
	* config dialog.
	* @param parent The parent is only used as the parent for the
	* dialog - centering the dialog over the parent
	* widget.
	*/
	explicit Dialog(QWidget * parent = 0);

	/**
	* Construct a new Preferences Dialog with the pages for the selected
	* instance names. For example if you want to have the configuration
	* pages for the kviewviewer KPart you would pass a
	* QStringList consisting of only the name of the part "kviewviewer".
	*
	* @param components A list of the names of the components that your
	* config dialog should merge the config pages in.
	* @param parent The parent is only used as the parent for the
	* dialog - centering the dialog over the parent
	* widget.
	*/
	explicit Dialog(const QStringList & components, QWidget * parent = 0);

	~Dialog();

	/**
	* If you use a Configurable dialog you need to pass KPluginInfo
	* objects that the dialog should configure.
	*/
	void addPluginInfos(const QList<KPluginInfo> &plugininfos);

	/**
	* Sets the argument list that is given to all the KControlModule's when
	* they are created.
	* Use this if you have KControlModule's that need special arguments to
	* work
	*
	* Note that this function only works before showing the
	* KSettings::Dialog for the first time.
	* @param arguments The list of arguments passed to each KCM
	*/
	void setKCMArguments(const QStringList& arguments);

	/**
	* Set the blacklisted component list. Any KCM that lists one
	* of the components in the given blacklist is not loaded even if it
	* would fit otherwise. This is a way to explicitly prevent loading of
	* certain KControlModules.
	*
	* Note that this function only works before showing the
	* KSettings::Dialog for the first time.
	* @param blacklist the list of components that prevent a KCM from being
	* loaded
	*/
	void setComponentBlacklist(const QStringList& blacklist);

	/**
	* Tells the dialog whether the entries in the listview are all static
	* or whether it should add checkboxes to select which parts
	* of the optional functionality should be active or not.
	*
	* Note that this function only works before showing the dialog for the first time.
	*
	* Defaults to \p false.
	*
	* @param allowSelection \p true The user can select what functionality he wants.
	* @param allowSelection \p false While running no entries are added or deleted
	*/
	void setAllowComponentSelection(bool allowSelection);

	bool allowComponentSelection() const;

	/**
	* Returns a list of all KPluginInfo objects the dialog uses.
	*/
	QList<KPluginInfo> pluginInfos() const;

	protected:
	/**
	* Reimplemented to lazy create the dialog on first show.
	*/
	void showEvent(QShowEvent *);

	Q_SIGNALS:
	/**
	* If you use the dialog in Configurable mode and want to be notified
	* when the user changes the plugin selections use this signal. It's
	* emitted if the selection has changed and the user pressed Apply or
	* Ok. In the slot you would then load and unload the plugins as
	* requested.
	*/
	void pluginSelectionChanged();

	private:
	//Q_PRIVATE_SLOT(d_func(), void _k_configureTree())
	Q_PRIVATE_SLOT(d_func(), void _k_updateEnabledState(bool))
	Q_PRIVATE_SLOT(d_func(), void _k_syncConfiguration())
	Q_PRIVATE_SLOT(d_func(), void _k_reparseConfiguration(const QByteArray &))
	};

	}

	#endif // KSETTINGS_DIALOG_H

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 1, 9:25 AM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 10075815
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions