browserextension.h

/* 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 __tdeparts_browserextension_h__
#define __tdeparts_browserextension_h__
 
#include <sys/types.h>
 
#include <tqpoint.h>
#include <tqptrlist.h>
#include <tqdatastream.h>
#include <tqstringlist.h>
#include <tqpair.h>
 
#include <tdeparts/part.h>
#include <tdeparts/event.h>
 
class KFileItem;
typedef TQPtrList<KFileItem> KFileItemList;
class TQString;
 
namespace KParts {
 
class BrowserInterface;
 
struct URLArgsPrivate;
 
struct TDEPARTS_EXPORT URLArgs
{
  URLArgs();
  URLArgs( const URLArgs &args );
  URLArgs &operator=( const URLArgs &args);
 
  URLArgs( bool reload, int xOffset, int yOffset, const TQString &serviceType = TQString::null );
  virtual ~URLArgs();
 
  TQStringList docState;
 
  bool reload;
  int xOffset;
  int yOffset;
  TQString serviceType;
 
  TQByteArray postData;
 
  void setContentType( const TQString & contentType );
  TQString contentType() const;
  void setDoPost( bool enable );
 
  bool doPost() const;
 
  void setLockHistory( bool lock );
  bool lockHistory() const;
 
  void setNewTab( bool newTab );
  bool newTab() const;
 
  TQMap<TQString, TQString> &metaData();
 
  TQString frameName;
 
  bool trustedSource;
 
  bool redirectedRequest () const;
 
  void setRedirectedRequest(bool redirected);
 
  void setForcesNewWindow( bool forcesNewWindow );
 
  bool forcesNewWindow() const;
 
  URLArgsPrivate *d;
};
 
struct WindowArgsPrivate;
 
struct TDEPARTS_EXPORT WindowArgs
{
    WindowArgs();
    ~WindowArgs();
    WindowArgs( const WindowArgs &args );
    WindowArgs &operator=( const WindowArgs &args );
    WindowArgs( const TQRect &_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 );
 
    // Position
    int x;
    int y;
    // Size
    int width;
    int height;
    bool fullscreen; //defaults to false
    bool menuBarVisible; //defaults to true
    bool toolBarsVisible; //defaults to true
    bool statusBarVisible; //defaults to true
    bool resizable; //defaults to true
 
    bool lowerWindow; //defaults to false
    bool scrollBarsVisible; //defaults to true
 
    WindowArgsPrivate *d; // don't use before KDE4, many KDE-3.x didn't have an explicit destructor
};
 
class TDEPARTS_EXPORT OpenURLEvent : public Event
{
public:
  OpenURLEvent( ReadOnlyPart *part, const KURL &url, const URLArgs &args = URLArgs() );
  virtual ~OpenURLEvent();
 
  ReadOnlyPart *part() const { return m_part; }
  KURL url() const { return m_url; }
  URLArgs args() const { return m_args; }
 
  static bool test( const TQEvent *event ) { return Event::test( event, s_strOpenURLEvent ); }
 
private:
  static const char *s_strOpenURLEvent;
  ReadOnlyPart *m_part;
  KURL m_url;
  URLArgs m_args;
 
  class OpenURLEventPrivate;
  OpenURLEventPrivate *d;
};
 
class BrowserExtensionPrivate;
 
class TDEPARTS_EXPORT BrowserExtension : public TQObject
{
  TQ_OBJECT
  TQ_PROPERTY( bool urlDropHandling READ isURLDropHandlingEnabled WRITE setURLDropHandlingEnabled )
public:
  BrowserExtension( KParts::ReadOnlyPart *parent,
                    const char *name = 0L );
 
 
  virtual ~BrowserExtension();
 
  typedef uint PopupFlags;
 
  enum { DefaultPopupItems=0x0000, ShowNavigationItems=0x0001,
         ShowUp=0x0002, ShowReload=0x0004, ShowBookmark=0x0008,
         ShowCreateDirectory=0x0010, ShowTextSelectionItems=0x0020,
         NoDeletion=0x0040 
       };
 
 
  virtual void setURLArgs( const URLArgs &args );
 
  URLArgs urlArgs() const;
 
  virtual int xOffset();
  virtual int yOffset();
 
  virtual void saveState( TQDataStream &stream );
 
  virtual void restoreState( TQDataStream &stream );
 
  bool isURLDropHandlingEnabled() const;
 
  void setURLDropHandlingEnabled( bool enable );
 
  void setBrowserInterface( BrowserInterface *impl );
  BrowserInterface *browserInterface() const;
 
  bool isActionEnabled( const char * name ) const;
 
  TQString actionText( const char * name ) const;
 
  typedef TQMap<TQCString,TQCString> ActionSlotMap;
  static ActionSlotMap actionSlotMap();
 
  static ActionSlotMap * actionSlotMapPtr();
 
  static BrowserExtension *childObject( TQObject *obj );
 
  void pasteRequest();
 
// KDE invents support for public signals...
#undef signals
#define signals public
signals:
#undef signals
#define signals protected
  void enableAction( const char * name, bool enabled );
 
  void setActionText( const char * name, const TQString& text );
 
  void openURLRequest( const KURL &url, const KParts::URLArgs &args = KParts::URLArgs() );
 
  void openURLRequestDelayed( const KURL &url, const KParts::URLArgs &args = KParts::URLArgs() );
 
  void openURLNotify();
 
  void setLocationBarURL( const TQString &url );
 
  void setIconURL( const KURL &url );
 
  void createNewWindow( const KURL &url, const KParts::URLArgs &args = KParts::URLArgs() );
 
  void createNewWindow( const KURL &url, const KParts::URLArgs &args,
                        const KParts::WindowArgs &windowArgs, KParts::ReadOnlyPart *&part );
 
  void loadingProgress( int percent );
  void speedProgress( int bytesPerSecond );
 
  void infoMessage( const TQString & );
 
  void popupMenu( const TQPoint &global, const KFileItemList &items );
 
  void popupMenu( KXMLGUIClient *client, const TQPoint &global, const KFileItemList &items );
 
  void popupMenu( KXMLGUIClient *client, const TQPoint &global, const KFileItemList &items, const KParts::URLArgs &args, KParts::BrowserExtension::PopupFlags i );
 
  void popupMenu( const TQPoint &global, const KURL &url,
                  const TQString &mimeType, mode_t mode = (mode_t)-1 );
 
  void popupMenu( KXMLGUIClient *client,
                  const TQPoint &global, const KURL &url,
                  const TQString &mimeType, mode_t mode = (mode_t)-1 );
 
  void popupMenu( KXMLGUIClient *client,
                  const TQPoint &global, const KURL &url,
                  const KParts::URLArgs &args, KParts::BrowserExtension::PopupFlags i, mode_t mode = (mode_t)-1 );
 
  void selectionInfo( const KFileItemList &items );
  void selectionInfo( const TQString &text );
  void selectionInfo( const KURL::List &urls );
 
  void mouseOverInfo( const KFileItem* item );
 
  void addWebSideBar(const KURL &url, const TQString& name);
 
  void moveTopLevelWidget( int x, int y );
 
  void resizeTopLevelWidget( int w, int h );
 
  void requestFocus(KParts::ReadOnlyPart *part);
 
  void setPageSecurity( int );
 
#define TDEPARTS_BROWSEREXTENSION_HAS_ITEMS_REMOVED
  void itemsRemoved( const KFileItemList &items );
 
private slots:
  void slotCompleted();
  void slotOpenURLRequest( const KURL &url, const KParts::URLArgs &args );
  void slotEmitOpenURLRequestDelayed();
  void slotEnableAction( const char *, bool );
  void slotSetActionText( const char*, const TQString& );
 
private:
  KParts::ReadOnlyPart *m_part;
  URLArgs m_args;
public:
  typedef TQMap<TQCString,int> ActionNumberMap;
 
private:
  static ActionNumberMap * s_actionNumberMap;
  static ActionSlotMap * s_actionSlotMap;
  static void createActionSlotMap();
protected:
  virtual void virtual_hook( int id, void* data );
private:
  BrowserExtensionPrivate *d;
};
 
class TDEPARTS_EXPORT BrowserHostExtension : public TQObject
{
  TQ_OBJECT
public:
  BrowserHostExtension( KParts::ReadOnlyPart *parent,
                        const char *name = 0L );
 
  virtual ~BrowserHostExtension();
 
  virtual TQStringList frameNames() const;
 
  virtual const TQPtrList<KParts::ReadOnlyPart> frames() const;
 
  BrowserHostExtension *findFrameParent(KParts::ReadOnlyPart *callingPart, const TQString &frame);
 
  virtual bool openURLInFrame( const KURL &url, const KParts::URLArgs &urlArgs );
 
  static BrowserHostExtension *childObject( TQObject *obj );
 
protected:
  enum { VIRTUAL_FIND_FRAME_PARENT = 0x10 };
  struct FindFrameParentParams
  {
      BrowserHostExtension *parent;
      KParts::ReadOnlyPart *callingPart;
      TQString frame;
  };
 
  virtual void virtual_hook( int id, void* data );
private:
  class BrowserHostExtensionPrivate;
  BrowserHostExtensionPrivate *d;
};
 
class TDEPARTS_EXPORT LiveConnectExtension : public TQObject
{
  TQ_OBJECT
public:
  enum Type {
      TypeVoid=0, TypeBool, TypeFunction, TypeNumber, TypeObject, TypeString
  };
  typedef TQValueList<TQPair<Type, TQString> > ArgList;
 
  LiveConnectExtension( KParts::ReadOnlyPart *parent, const char *name = 0L );
 
  virtual ~LiveConnectExtension() {}
  virtual bool get( const unsigned long objid, const TQString & field, Type & type, unsigned long & retobjid, TQString & value );
  virtual bool put( const unsigned long objid, const TQString & field, const TQString & value );
  virtual bool call( const unsigned long objid, const TQString & func, const TQStringList & args, Type & type, unsigned long & retobjid, TQString & value );
  virtual void unregister( const unsigned long objid );
 
  static LiveConnectExtension *childObject( TQObject *obj );
signals:
  virtual void partEvent( const unsigned long objid, const TQString & event, const ArgList & args );
};
 
}
 
#endif