part.h

/* 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 <tqstring.h>
#include <tqdom.h>
#include <tqguardedptr.h>
#include <kurl.h>
 
#include <kxmlguiclient.h>
 
class TDEInstance;
class TQWidget;
class TDEAction;
class TDEActionCollection;
class TQEvent;
struct QUnknownInterface;
 
namespace TDEIO {
  class Job;
}
 
namespace KParts
{
 
class PartManager;
class Plugin;
class PartPrivate;
class PartActivateEvent;
class PartSelectEvent;
class GUIActivateEvent;
class PartBasePrivate;

class TDEPARTS_EXPORT PartBase : virtual public KXMLGUIClient
{
    friend class PartBasePrivate;
public:

  PartBase();

  virtual ~PartBase();

  void setPartObject( TQObject *object );
  TQObject *partObject() const;
 
protected:
  virtual void setInstance( TDEInstance *instance );

  virtual void setInstance( TDEInstance *instance, bool loadPlugins );

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

  void loadPlugins( TQObject *parent, KXMLGUIClient *parentGUIClient, TDEInstance *instance );

  void setPluginLoadingMode( PluginLoadingMode loadingMode );
 
private:
    PartBasePrivate *d;
    TQObject *m_obj;
};

class TDEPARTS_EXPORT Part : public TQObject, public PartBase
{
    TQ_OBJECT
 
public:

    Part( TQObject *parent = 0, const char* name = 0 );

    virtual ~Part();

    virtual void embed( TQWidget * parentWidget );

    virtual TQWidget *widget();

    virtual void setManager( PartManager * manager );

    PartManager * manager() const;

    virtual Part *hitTest( TQWidget *widget, const TQPoint &globalPos );

    virtual void setSelectable( bool selectable );

    bool isSelectable() const;
 
signals:
    void setWindowCaption( const TQString & caption );
    void setStatusBarText( const TQString & text );
 
protected:

    virtual void setWidget( TQWidget * widget );

    virtual void customEvent( TQCustomEvent *event );

    virtual void partActivateEvent( PartActivateEvent *event );

    virtual void partSelectEvent( PartSelectEvent *event );

    virtual void guiActivateEvent( GUIActivateEvent *event );

    TQWidget *hostContainer( const TQString &containerName );
 
private slots:
    void slotWidgetDestroyed();
 
private:
    TQGuardedPtr<TQWidget> m_widget;
 
    PartManager * m_manager;
 
    PartPrivate *d;
};
 
class ReadWritePart;
class ReadOnlyPartPrivate;

class TDEPARTS_EXPORT ReadOnlyPart : public Part
{
  TQ_OBJECT
  friend class ReadWritePart;
public:
  ReadOnlyPart( TQObject *parent = 0, const char *name = 0 );

  virtual ~ReadOnlyPart();

  void setProgressInfoEnabled( bool show );

  bool isProgressInfoEnabled() const;
 
#ifndef KDE_NO_COMPAT
  void showProgressInfo( bool show );
#endif
 
public slots:
  virtual bool openURL( const KURL &url );
 
public:
  KURL url() const { return m_url; }

  virtual bool closeURL();
 
public:
  bool openStream( const TQString& mimeType, const KURL& url );

  bool writeStream( const TQByteArray& data );

  bool closeStream();
 
private: // Makes no sense for inherited classes to call those. But make it protected there.

  virtual bool doOpenStream( const TQString& /*mimeType*/ ) { return false; }
  virtual bool doWriteStream( const TQByteArray& /*data*/ ) { return false; }
  virtual bool doCloseStream() { return false; }
 
signals:
  void started( TDEIO::Job * );

  void completed();

  void completed( bool pendingAction );

  void canceled( const TQString &errMsg );
 
protected slots:
  void slotJobFinished( TDEIO::Job * job );
 
protected:
  virtual bool openFile() = 0;

  void abortLoad();

  virtual void guiActivateEvent( GUIActivateEvent *event );

  KURL m_url;
  TQString m_file;
  bool m_bTemp;
 
private:
  ReadOnlyPartPrivate *d;
};

class TDEPARTS_EXPORT ReadWritePart : public ReadOnlyPart
{
  TQ_OBJECT
public:
  ReadWritePart( TQObject *parent = 0, const char *name = 0 );
  virtual ~ReadWritePart();

  bool isReadWrite() const { return m_bReadWrite; }

  virtual void setReadWrite ( bool readwrite = true );

  bool isModified() const { return m_bModified; }

  // TODO: Make virtual for KDE 4
  bool queryClose();

  virtual bool closeURL();

  // TODO: Make virtual for KDE 4
  bool closeURL( bool promptToSave );

  virtual bool saveAs( const KURL &url );

  virtual void setModified( bool modified );
 
signals:
   void sigQueryClose(bool *handled, bool* abortClosing);
 
public slots:
  virtual void setModified();

  virtual bool save();

  bool waitSaveComplete();
 
protected:
  virtual bool saveFile() = 0;

  virtual bool saveToURL();
 
protected slots:
  void slotUploadFinished( TDEIO::Job * job );
 
private:
  void prepareSaving();
 
private:
  bool m_bModified;
  bool m_bReadWrite;
  bool m_bClosing;
};
 
} // namespace
 
#endif