part.h

Go to the documentation of this file.

/* This file is part of the KDE project
   Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
             (C) 1999 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.
*/
#ifndef _KPART_H
#define _KPART_H

#include <QtCore/QPointer>
#include <QtCore/QEvent>
#include <QtCore/QSharedDataPointer>
#include <QtXml/QDomElement> // KDE5: remove

#include <kurl.h>
#include <kxmlguiclient.h>

#include <kparts/kparts_export.h>

#define KPARTS_DECLARE_PRIVATE(Class) \
    inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(PartBase::d_ptr); } \
    inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(PartBase::d_ptr); } \
    friend class Class##Private;

class KIconLoader;
class KComponentData;
class QWidget;
class QEvent;
class QPoint;
struct QUnknownInterface;

class KJob;
namespace KIO {
  class Job;
}

namespace KParts
{

class PartManager;
class Plugin;
class PartPrivate;
class PartActivateEvent;
class PartSelectEvent;
class GUIActivateEvent;
class PartBasePrivate;

class KPARTS_EXPORT PartBase : virtual public KXMLGUIClient
{
    KPARTS_DECLARE_PRIVATE(PartBase)

public:

  PartBase();

  virtual ~PartBase();

  void setPartObject( QObject *object );
  QObject *partObject() const;

protected:
  virtual void setComponentData(const KComponentData &componentData);

  virtual void setComponentData(const KComponentData &componentData, bool loadPlugins);
  // TODO KDE5: merge the above two methods, using loadPlugins=true. Or better, remove loadPlugins
  // altogether and change plugins to call loadPlugins() manually at the end of their ctor.
    // In the case of KParts MainWindows, plugins are automatically loaded in createGUI anyway,
    // so setComponentData() should really not load the plugins.

  enum PluginLoadingMode {
    DoNotLoadPlugins = 0,
    LoadPlugins = 1,
    LoadPluginsIfEnabled = 2
  };

  void loadPlugins(QObject *parent, KXMLGUIClient *parentGUIClient, const KComponentData &componentData);

  void setPluginLoadingMode( PluginLoadingMode loadingMode );

  void setPluginInterfaceVersion( int version );

protected:
  PartBase(PartBasePrivate &dd);

  PartBasePrivate *d_ptr;

private:
  Q_DISABLE_COPY(PartBase)
};

class KPARTS_EXPORT Part : public QObject, public PartBase
{
    Q_OBJECT

    KPARTS_DECLARE_PRIVATE(Part)

public:

    explicit Part( QObject *parent = 0 );

    virtual ~Part();

    virtual void embed( QWidget * parentWidget );

    virtual QWidget *widget();

    virtual void setManager( PartManager * manager );

    PartManager * manager() const;

    void setAutoDeleteWidget(bool autoDeleteWidget);

    void setAutoDeletePart(bool autoDeletePart);

    virtual Part *hitTest( QWidget *widget, const QPoint &globalPos );

    virtual void setSelectable( bool selectable );

    bool isSelectable() const;

    KIconLoader* iconLoader();

Q_SIGNALS:
    void setWindowCaption( const QString & caption );
    void setStatusBarText( const QString & text );

protected:
    virtual void setWidget( QWidget * widget );

    virtual void customEvent( QEvent *event );

    virtual void partActivateEvent( PartActivateEvent *event );

    virtual void partSelectEvent( PartSelectEvent *event );

    virtual void guiActivateEvent( GUIActivateEvent *event );

    QWidget *hostContainer( const QString &containerName );

    void loadPlugins();
    using PartBase::loadPlugins;

protected Q_SLOTS:
    void slotWidgetDestroyed();

protected:
    Part(PartPrivate &dd, QObject *parent);

private:
    Q_DISABLE_COPY(Part)
};

class ReadWritePart;
class ReadOnlyPartPrivate;
class BrowserExtension;
class OpenUrlArgumentsPrivate;

class KPARTS_EXPORT OpenUrlArguments
{
public:
    OpenUrlArguments();
    OpenUrlArguments(const OpenUrlArguments &other);
    OpenUrlArguments &operator=( const OpenUrlArguments &other);
    ~OpenUrlArguments();

    bool reload() const;
    void setReload(bool b);

    int xOffset() const;
    void setXOffset(int x);

    int yOffset() const;
    void setYOffset(int y);

    QString mimeType() const;
    void setMimeType(const QString& mime);

    bool actionRequestedByUser() const;
    void setActionRequestedByUser(bool userRequested);

    QMap<QString, QString> &metaData();
    const QMap<QString, QString> &metaData() const;

private:
    QSharedDataPointer<OpenUrlArgumentsPrivate> d;
};


class KPARTS_EXPORT ReadOnlyPart : public Part
{
    Q_OBJECT

    Q_PROPERTY( KUrl url READ url )

    KPARTS_DECLARE_PRIVATE(ReadOnlyPart)

public:
    explicit ReadOnlyPart( QObject *parent = 0 );

    virtual ~ReadOnlyPart();

    void setProgressInfoEnabled( bool show );

    bool isProgressInfoEnabled() const;

#ifndef KDE_NO_COMPAT
    void showProgressInfo( bool show );
#endif

public Q_SLOTS:
    virtual bool openUrl( const KUrl &url );

public:
    KUrl url() const;

    virtual bool closeUrl();

    BrowserExtension* browserExtension() const;

    void setArguments(const OpenUrlArguments& arguments);
    // TODO to avoid problems with the case where the loading fails, this could also be a openUrl() argument (heavy porting!).
    // However we need to have setArguments in any case for updated made by the part, see e.g. KHTMLPart::openUrl.
    // Well, maybe we should have setArguments (affects next openurl call) and updateArguments?


    OpenUrlArguments arguments() const;

public:
    bool openStream( const QString& mimeType, const KUrl& url );

    bool writeStream( const QByteArray& data );

    bool closeStream();

private: // Makes no sense for inherited classes to call those. But make it protected there.

    virtual bool doOpenStream( const QString& /*mimeType*/ ) { return false; }
    virtual bool doWriteStream( const QByteArray& /*data*/ ) { return false; }
    virtual bool doCloseStream() { return false; }

Q_SIGNALS:
    void started( KIO::Job * );

    void completed();

    void completed( bool pendingAction );

    void canceled( const QString &errMsg );

    void urlChanged( const KUrl & url );

protected:
    virtual bool openFile();

    void abortLoad();

    virtual void guiActivateEvent( GUIActivateEvent *event );

#ifndef KDE_NO_DEPRECATED
    KDE_DEPRECATED bool isLocalFileTemporary() const;
#endif

#ifndef KDE_NO_DEPRECATED
    KDE_DEPRECATED void setLocalFileTemporary( bool temp );
#endif

    void setUrl(const KUrl &url);

    QString localFilePath() const;

    void setLocalFilePath( const QString &localFilePath );

protected:
    ReadOnlyPart(ReadOnlyPartPrivate &dd, QObject *parent);

private:
    Q_PRIVATE_SLOT(d_func(), void _k_slotJobFinished( KJob * job ))
    Q_PRIVATE_SLOT(d_func(), void _k_slotStatJobFinished(KJob*))
    Q_PRIVATE_SLOT(d_func(), void _k_slotGotMimeType(KIO::Job *job, const QString &mime))

    Q_DISABLE_COPY(ReadOnlyPart)
};
class ReadWritePartPrivate;

class KPARTS_EXPORT ReadWritePart : public ReadOnlyPart
{
    Q_OBJECT

    KPARTS_DECLARE_PRIVATE(ReadWritePart)

public:
    explicit ReadWritePart( QObject *parent = 0 );
    virtual ~ReadWritePart();

    bool isReadWrite() const;

    virtual void setReadWrite ( bool readwrite = true );

    bool isModified() const;

    virtual bool queryClose();

    virtual bool closeUrl();

    virtual bool closeUrl( bool promptToSave );

    virtual bool saveAs( const KUrl &url );

    virtual void setModified( bool modified );

Q_SIGNALS:
    void sigQueryClose(bool *handled, bool* abortClosing);

public Q_SLOTS:
    void setModified();

    virtual bool save();

    bool waitSaveComplete();

protected:
    virtual bool saveFile() = 0;

    virtual bool saveToUrl();

private:
    Q_PRIVATE_SLOT(d_func(), void _k_slotUploadFinished( KJob * job ))

    Q_DISABLE_COPY(ReadWritePart)
};

} // namespace


#undef KPARTS_DECLARE_PRIVATE

#endif