browserextension.h

Go to the documentation of this file.

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

#include <sys/types.h>

#include <kparts/part.h>
#include <kparts/event.h>

#include <QtCore/QSharedDataPointer>

template <class T1, class T2> struct QPair;
template<typename T> class Q3PtrList;
template <class Key, class T> class QMap;
template<typename T> class QList;

class KFileItem;
class KFileItemList;
class QDataStream;
class QPoint;
class QString;
class QStringList;

namespace KParts {

class BrowserInterface;

struct BrowserArgumentsPrivate;

struct KPARTS_EXPORT BrowserArguments
{
  BrowserArguments();
  BrowserArguments( const BrowserArguments &args );
  BrowserArguments &operator=( const BrowserArguments &args);

  virtual ~BrowserArguments();

  // KDE4: a struct has the problem that the stuff added after BC-freeze uses methods
  // so it looks inconsistent with the member vars. -> better use methods for everything,
  // even if they are inline.


  QStringList docState;

  bool softReload;

  QByteArray postData;

  void setContentType( const QString & contentType );
  QString contentType() const;
  void setDoPost( bool enable );

  bool doPost() const;

  void setLockHistory( bool lock );
  bool lockHistory() const;

  void setNewTab( bool newTab );
  bool newTab() const;

  QString frameName;

  bool trustedSource;

  bool redirectedRequest () const;

  void setRedirectedRequest(bool redirected);

  void setForcesNewWindow( bool forcesNewWindow );

  bool forcesNewWindow() const;

private:
  BrowserArgumentsPrivate *d;
};

class WindowArgsPrivate;

class KPARTS_EXPORT WindowArgs
{
public:
    WindowArgs();
    ~WindowArgs();
    WindowArgs( const WindowArgs &args );
    WindowArgs &operator=( const WindowArgs &args );
    WindowArgs( const QRect &_geometry, bool _fullscreen, bool _menuBarVisible,
                bool _toolBarsVisible, bool _statusBarVisible, bool _resizable );
    WindowArgs( int _x, int _y, int _width, int _height, bool _fullscreen,
                bool _menuBarVisible, bool _toolBarsVisible,
                bool _statusBarVisible, bool _resizable );

    void setX(int x);
    int x() const;

    void setY(int y);
    int y() const;

    void setWidth(int w);
    int width() const;

    void setHeight(int h);
    int height() const;

    void setFullScreen(bool fs);
    bool isFullScreen() const;

    void setMenuBarVisible(bool visible);
    bool isMenuBarVisible() const;

    void setToolBarsVisible(bool visible);
    bool toolBarsVisible() const;

    void setStatusBarVisible(bool visible);
    bool isStatusBarVisible() const;

    void setResizable(bool resizable);
    bool isResizable() const;

    void setLowerWindow(bool lower);
    bool lowerWindow() const;

    void setScrollBarsVisible(bool visible);
    bool scrollBarsVisible() const;

private:
    QSharedDataPointer<WindowArgsPrivate> d;
};

class KPARTS_EXPORT OpenUrlEvent : public Event
{
public:
  OpenUrlEvent( ReadOnlyPart *part, const KUrl &url,
                const OpenUrlArguments& args = OpenUrlArguments(),
                const BrowserArguments& browserArgs = BrowserArguments() );
  virtual ~OpenUrlEvent();

  ReadOnlyPart *part() const;
  KUrl url() const;
  OpenUrlArguments arguments() const;
  BrowserArguments browserArguments() const;

  static bool test( const QEvent *event );

private:
  class OpenUrlEventPrivate;
  OpenUrlEventPrivate * const d;
};

class KPARTS_EXPORT BrowserExtension : public QObject
{
  Q_OBJECT
  Q_PROPERTY( bool urlDropHandling READ isURLDropHandlingEnabled WRITE setURLDropHandlingEnabled )
public:
  explicit BrowserExtension( KParts::ReadOnlyPart *parent );


  virtual ~BrowserExtension();

  enum PopupFlag {
      DefaultPopupItems=0x0000, 
      ShowNavigationItems=0x0001, 
      ShowUp=0x0002, 
      ShowReload=0x0004, 
      ShowBookmark=0x0008, 
      ShowCreateDirectory=0x0010, 
      ShowTextSelectionItems=0x0020, 
      NoDeletion=0x0040, 
      IsLink=0x0080, 
      ShowUrlOperations=0x0100, 
      ShowProperties=0x200     
  };

  Q_DECLARE_FLAGS( PopupFlags, PopupFlag )

  
  virtual void setBrowserArguments( const BrowserArguments &args );

  BrowserArguments browserArguments() const;

  virtual int xOffset();
  virtual int yOffset();

  virtual void saveState( QDataStream &stream );

  virtual void restoreState( QDataStream &stream );

  bool isURLDropHandlingEnabled() const;

  void setURLDropHandlingEnabled( bool enable );

  void setBrowserInterface( BrowserInterface *impl );
  BrowserInterface *browserInterface() const;

  bool isActionEnabled( const char * name ) const;

  QString actionText( const char * name ) const;

  typedef QMap<QByteArray,QByteArray> ActionSlotMap;
  static ActionSlotMap actionSlotMap();

  static ActionSlotMap * actionSlotMapPtr();

  static BrowserExtension *childObject( QObject *obj );

  void pasteRequest();

    typedef QMap<QString, QList<QAction *> > ActionGroupMap;

Q_SIGNALS:
#if !defined(Q_MOC_RUN) && !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(IN_IDE_PARSER)
public:  // yes, those signals are public; don't tell moc, doxygen or kdevelop :)
#endif

  void enableAction( const char * name, bool enabled );

  void setActionText( const char * name, const QString& text );

  void openUrlRequest( const KUrl &url,
                       const KParts::OpenUrlArguments& arguments = KParts::OpenUrlArguments(),
                       const KParts::BrowserArguments &browserArguments = KParts::BrowserArguments() );

  void openUrlRequestDelayed( const KUrl &url,
                              const KParts::OpenUrlArguments& arguments,
                              const KParts::BrowserArguments &browserArguments );

  void openUrlNotify();

  void setLocationBarUrl( const QString &url );

  void setIconUrl( const KUrl &url );

    void createNewWindow( const KUrl &url,
                          const KParts::OpenUrlArguments& arguments = KParts::OpenUrlArguments(),
                          const KParts::BrowserArguments &browserArguments = KParts::BrowserArguments(),
                          const KParts::WindowArgs &windowArgs = KParts::WindowArgs(),
                          KParts::ReadOnlyPart** part = 0 ); // TODO consider moving to BrowserHostExtension?

  void loadingProgress( int percent );
  void speedProgress( int bytesPerSecond );

  void infoMessage( const QString & );

  void popupMenu( const QPoint &global, const KFileItemList &items,
                  const KParts::OpenUrlArguments &args = KParts::OpenUrlArguments(),
                  const KParts::BrowserArguments &browserArgs = KParts::BrowserArguments(),
                  KParts::BrowserExtension::PopupFlags flags = KParts::BrowserExtension::DefaultPopupItems,
                  const KParts::BrowserExtension::ActionGroupMap& actionGroups = ActionGroupMap() );

  void popupMenu( const QPoint &global, const KUrl &url,
                  mode_t mode = static_cast<mode_t>(-1),
                  const KParts::OpenUrlArguments &args = KParts::OpenUrlArguments(),
                  const KParts::BrowserArguments &browserArgs = KParts::BrowserArguments(),
                  KParts::BrowserExtension::PopupFlags flags = KParts::BrowserExtension::DefaultPopupItems,
                  const KParts::BrowserExtension::ActionGroupMap& actionGroups = ActionGroupMap() );

  void selectionInfo( const KFileItemList& items );
  void selectionInfo( const QString &text );
  void selectionInfo( const KUrl::List &urls );

  void mouseOverInfo( const KFileItem& item );

  void addWebSideBar(const KUrl &url, const QString& name);

  void moveTopLevelWidget( int x, int y );

  void resizeTopLevelWidget( int w, int h );

  void requestFocus(KParts::ReadOnlyPart *part);

  void setPageSecurity( int );

  void itemsRemoved( const KFileItemList &items );

private Q_SLOTS:
  void slotCompleted();
  void slotOpenUrlRequest( const KUrl &url,
                           const KParts::OpenUrlArguments& arguments = KParts::OpenUrlArguments(),
                           const KParts::BrowserArguments &browserArguments = KParts::BrowserArguments() );

  void slotEmitOpenUrlRequestDelayed();
  void slotEnableAction( const char *, bool );
  void slotSetActionText( const char*, const QString& );

public:
  typedef QMap<QByteArray,int> ActionNumberMap;

private:
  class BrowserExtensionPrivate;
  BrowserExtensionPrivate * const d;
};

class KPARTS_EXPORT BrowserHostExtension : public QObject
{
  Q_OBJECT
public:
  BrowserHostExtension( KParts::ReadOnlyPart *parent );

  virtual ~BrowserHostExtension();

  virtual QStringList frameNames() const;

  virtual const QList<KParts::ReadOnlyPart*> frames() const;

  virtual BrowserHostExtension *findFrameParent(KParts::ReadOnlyPart *callingPart, const QString &frame);

  virtual bool openUrlInFrame( const KUrl &url,
                               const KParts::OpenUrlArguments& arguments,
                               const KParts::BrowserArguments &browserArguments );

  static BrowserHostExtension *childObject( QObject *obj );

private:
  class BrowserHostExtensionPrivate;
  BrowserHostExtensionPrivate * const d;
};

class KPARTS_EXPORT LiveConnectExtension : public QObject
{
  Q_OBJECT
public:
  enum Type {
      TypeVoid=0, TypeBool, TypeFunction, TypeNumber, TypeObject, TypeString
  };
  typedef QList<QPair<Type, QString> > ArgList;

  LiveConnectExtension( KParts::ReadOnlyPart *parent );

  virtual ~LiveConnectExtension();
  virtual bool get( const unsigned long objid, const QString & field, Type & type, unsigned long & retobjid, QString & value );
  virtual bool put( const unsigned long objid, const QString & field, const QString & value );
  virtual bool call( const unsigned long objid, const QString & func, const QStringList & args, Type & type, unsigned long & retobjid, QString & value );
  virtual void unregister( const unsigned long objid );

  static LiveConnectExtension *childObject( QObject *obj );
Q_SIGNALS:
#if !defined(Q_MOC_RUN) && !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(IN_IDE_PARSER)
public:  // yes, those signals are public; don't tell moc, doxygen or kdevelop :)
#endif

  void partEvent( const unsigned long objid, const QString & event, const KParts::LiveConnectExtension::ArgList & args );

private:
  class LiveConnectExtensionPrivate;
  LiveConnectExtensionPrivate * const d;
};

}

Q_DECLARE_OPERATORS_FOR_FLAGS( KParts::BrowserExtension::PopupFlags )

#endif