k3dockwidget.h

Go to the documentation of this file.

/* This file is part of the KDE libraries
   Copyright (C) 2000 Max Judin <novaprint@mtu-net.ru>
   Copyright (C) 2000 Falk Brettschneider <falk@kdevelop.org>
   Copyright (C) 2002,2003 Joseph Wenninger <jowenn@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.
*/

/*
   activities:
   -----------
   05/2001 -               : useful patches, bugfixes by Christoph Cullmann <crossfire@babylon2k.de>,
                             Joseph Wenninger <jowenn@bigfoot.com> and  Falk Brettschneider
   03/2001 - 05/2001       : maintained and enhanced by Falk Brettschneider <falk@kdevelop.org>
   03/2000                 : class documentation added by Falk Brettschneider <gigafalk@yahoo.com>
   10/1999 - 03/2000       : programmed by Max Judin <novaprint@mtu-net.ru>

   C++ classes in this file:
   -------------------------
   - K3DockWidgetAbstractHeader     - minor helper class
   - K3DockWidgetAbstractHeaderDrag - minor helper class
   - K3DockWidgetHeaderDrag         - drag panel in a dockwidget title bar
   - K3DockWidgetHeader             - dockwidget title bar containing the drag panel
   - K3DockTabGroup                 - minor helper class
   - K3DockWidget                   - IMPORTANT CLASS: the one and only dockwidget class
   - K3DockManager                  - helper class
   - K3DockMainWindow               - IMPORTANT CLASS: a special KMainWindow that can have dockwidgets
   - K3DockArea                     - like K3DockMainWindow but inherits just QWidget

   IMPORTANT Note: This file compiles also in Qt-only mode by using the NO_KDE2 precompiler definition!
*/


#ifndef KDOCKWIDGET_H
#define KDOCKWIDGET_H

#define _KDOCKWIDGET_2_2_

#include <kde3support_export.h>
#include <QtCore/QPoint>
#include <Qt3Support/Q3PtrList>
#include <QtGui/QFrame>
#include <QtXml/QDomElement>
#include <QtGui/QTabWidget>

#ifndef NO_KDE2
#include <kxmlguiwindow.h>
#include <netwm_def.h>
#else

#include <Qt3Support/Q3MainWindow>
#include "exportdockclass.h"
#include "dummykmainwindow.h"
#endif

class K3DockSplitter;
class K3DockManager;
class K3DockWidget;
class K3DockButton_Private;
class K3DockWidgetPrivate;
class K3DockWidgetHeaderPrivate;
class K3DockArea;

class Q3PopupMenu;
class QVBoxLayout;
class QHBoxLayout;
class QPixmap;

#ifndef NO_KDE2
class KConfigGroup;
#else
#endif

class K3DockContainer;

namespace K3MDI
{
  class MainWindow;
}

class KDE3SUPPORT_EXPORT K3DockWidgetAbstractHeader : public QFrame
{
  Q_OBJECT
public:

  K3DockWidgetAbstractHeader( K3DockWidget* parent, const char* name = 0L );

  virtual ~K3DockWidgetAbstractHeader(){}

  virtual void setTopLevel( bool ){}

#ifndef NO_KDE2

  virtual void saveConfig( KConfigGroup* ){}

  virtual void loadConfig( KConfigGroup* ){}
#endif

protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockWidgetAbstractHeaderPrivate;
  K3DockWidgetAbstractHeaderPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockWidgetAbstractHeaderDrag : public QFrame
{
  Q_OBJECT
public:

  K3DockWidgetAbstractHeaderDrag( K3DockWidgetAbstractHeader* parent,
                                 K3DockWidget* dock, const char* name = 0L );

  virtual ~K3DockWidgetAbstractHeaderDrag();

  K3DockWidget* dockWidget() const;

private:
  K3DockWidget* dw;
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockWidgetAbstractHeaderDragPrivate;
  K3DockWidgetAbstractHeaderDragPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockWidgetHeaderDrag : public K3DockWidgetAbstractHeaderDrag
{
  Q_OBJECT
public:

  K3DockWidgetHeaderDrag( K3DockWidgetAbstractHeader* parent, K3DockWidget* dock,
                         const char* name = 0L );

  virtual ~K3DockWidgetHeaderDrag();

protected:

  virtual void paintEvent( QPaintEvent* );

protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockWidgetHeaderDragPrivate;
  K3DockWidgetHeaderDragPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockWidgetHeader : public K3DockWidgetAbstractHeader
{
  Q_OBJECT
public:

  K3DockWidgetHeader( K3DockWidget* parent, const char* name = 0L );

  virtual ~K3DockWidgetHeader();

  virtual void setTopLevel( bool t);

  void setDragPanel( K3DockWidgetHeaderDrag* nd );

   K3DockWidgetHeaderDrag *dragPanel();

  bool dragEnabled() const;
  void setDragEnabled(bool b);
  void showUndockButton(bool show);

  void forceCloseButtonHidden(bool enable=true);
#ifndef NO_KDE2

  virtual void saveConfig( KConfigGroup* c);

  virtual void loadConfig( KConfigGroup* c);
#endif

    void addButton(K3DockButton_Private*);

    void removeButton(K3DockButton_Private*);



protected Q_SLOTS:
  void slotStayClicked();

protected:

  QHBoxLayout* layout;

  K3DockButton_Private* closeButton;

  K3DockButton_Private* stayButton;

  K3DockButton_Private* dockbackButton;

  K3DockWidgetHeaderDrag* drag;

protected:
  virtual void virtual_hook( int id, void* data );
private:
  K3DockWidgetHeaderPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockTabGroup : public QTabWidget
{
  Q_OBJECT
public:
  K3DockTabGroup( QWidget *parent = 0, const char *name = 0 );

  virtual ~K3DockTabGroup();

  QWidget *transientTo();
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockTabGroupPrivate;
  K3DockTabGroupPrivate *d;
};


class KDE3SUPPORT_EXPORT K3DockWidget: public QWidget
{
  Q_OBJECT
friend class K3DockManager;
friend class K3DockSplitter;
friend class K3DockMainWindow;
friend class K3DockArea;

public:
  K3DockWidget( K3DockManager* dockManager, const char* name,
               const QPixmap &pixmap, QWidget* parent = 0L, const QString& strCaption = QString(),
               const QString& strTabPageLabel = QLatin1String( " " ), Qt::WindowFlags f = 0);

  virtual ~K3DockWidget();

  enum DockPosition
  {
    DockNone   = 0,
    DockTop    = 0x0001,
    DockLeft   = 0x0002,
    DockRight  = 0x0004,
    DockBottom = 0x0008,
    DockCenter = 0x0010,
    DockDesktop= 0x0020,
    DockToSpecialSites=0x0040,
    DockCorner = DockTop | DockLeft | DockRight | DockBottom,
    DockFullSite = DockCorner | DockCenter,
    DockFullDocking = DockFullSite | DockDesktop
  };

  K3DockWidget* manualDock( K3DockWidget* target, DockPosition dockPos, int spliPos = 50, QPoint pos = QPoint(0,0), bool check = false, int tabIndex = -1);

  void setEnableDocking( int pos );

  int enableDocking() const;

  void setDockSite( int pos );

  int dockSite() const;

  void setWidget( QWidget* w);

  QWidget* getWidget() const;

  void setHeader( K3DockWidgetAbstractHeader* ah);

  K3DockWidgetAbstractHeader *getHeader();

  void makeDockVisible();

  bool mayBeHide() const;

  bool mayBeShow() const;

  K3DockManager* dockManager() const;

  void setToolTipString(const QString& ttStr);

  const QString& toolTipString() const;

  bool isDockBackPossible() const;

  void setTabPageLabel( const QString& label);

  const QString& tabPageLabel() const;

  virtual bool event( QEvent * );

  virtual void show();
  K3DockTabGroup* parentDockTabGroup() const;

  QWidget *parentDockContainer() const;

#ifndef NO_KDE2

  void setDockWindowType (NET::WindowType windowType);

#endif

  void setDockWindowTransient (QWidget *parent, bool transientEnabled);

   QWidget *transientTo();

  K3DockWidget *findNearestDockWidget(DockPosition pos);

   void setPixmap(const QPixmap& pixmap=QPixmap());

   const QPixmap& pixmap() const;

  K3DockWidget::DockPosition currentDockPosition() const;

public Q_SLOTS:
  void setForcedFixedWidth(int);
  void setForcedFixedHeight(int);
  void restoreFromForcedFixedSize();

  int forcedFixedWidth();
  int forcedFixedHeight();

  void dockBack();

  void changeHideShowState();

  void undock();

  void toDesktop( );

protected:
  friend class K3MdiMainFrm;
  friend class K3MDI::MainWindow;
  void updateHeader();

  void setLatestK3DockContainer(QWidget *);
  QWidget *latestK3DockContainer();

  void setFormerBrotherDockWidget(K3DockWidget *);

Q_SIGNALS:
   void widgetSet(QWidget*);

  void docking( K3DockWidget* dw, K3DockWidget::DockPosition dp);

  void setDockDefaultPos();

  void headerCloseButtonClicked();

  void headerDockbackButtonClicked();

  void iMBeingClosed();
  void hasUndocked();

protected Q_SLOTS:

  void loseFormerBrotherDockWidget();

  virtual void paintEvent(QPaintEvent*);

  virtual void mousePressEvent(QMouseEvent*);
  virtual void mouseReleaseEvent(QMouseEvent*);
  virtual void mouseMoveEvent(QMouseEvent*);
  virtual void leaveEvent(QEvent*);
protected:
  friend class K3DockWidgetHeader;
  K3DockWidget* formerBrotherDockWidget;
  DockPosition currentDockPos;
  DockPosition formerDockPos;
  QString toolTipStr;
  QString tabPageTitle;

private:
  void setDockTabName( K3DockTabGroup* g);

  void applyToWidget( QWidget* s, const QPoint& p  = QPoint(0,0) );

  K3DockWidgetAbstractHeader* header;

  QWidget* widget;

  QVBoxLayout* layout;

  K3DockManager* manager;

  QPixmap* pix;

  int eDocking;

  int sDocking;

  K3DockWidget::DockPosition prevSideDockPosBeforeDrag;

  // GROUP data
  QString firstName;
  QString lastName;
  Qt::Orientation splitterOrientation;
  bool isGroup;
  bool isTabGroup;
protected:
  virtual void virtual_hook( int id, void* data );
private:
  K3DockWidgetPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockManager: public QObject
{
  Q_OBJECT
friend class K3DockWidget;
friend class K3DockMainWindow;

public:
    enum EnReadDockConfigMode {
        Unknown,
        WrapExistingWidgetsOnly,
        RestoreAllDockwidgets
    };

public:
  K3DockManager( QWidget* mainWindow, const char* name = 0L );

  virtual ~K3DockManager();

  void dumpDockWidgets();

#ifndef NO_KDE2

  void writeConfig( KConfig* c = 0L, const QString &group = QString() );

  void readConfig ( KConfig* c = 0L, const QString &group = QString() );
#endif

  void setMainDockWidget2(K3DockWidget *);

  void writeConfig(QDomElement &base);
  void readConfig(QDomElement &base);

  void activate();

  virtual bool eventFilter( QObject * object, QEvent * event );

  K3DockWidget* findWidgetParentDock( QWidget* w) const;

  void makeWidgetDockVisible( QWidget* w );

  Q3PopupMenu* dockHideShowMenu() const;

  K3DockWidget* getDockWidgetFromName( const QString& dockName );

  void setSplitterOpaqueResize(bool b=true);

  bool splitterOpaqueResize() const;

  void setSplitterKeepSize(bool b=true);

  bool splitterKeepSize() const;

  void setSplitterHighResolution(bool b=true);

  bool splitterHighResolution() const;

  void setSpecialLeftDockContainer(K3DockWidget* container);
  void setSpecialTopDockContainer(K3DockWidget* container);
  void setSpecialRightDockContainer(K3DockWidget* container);
  void setSpecialBottomDockContainer(K3DockWidget* container);

  void removeFromAutoCreateList(K3DockWidget* pDockWidget);
  void finishReadDockConfig();
  void setReadDockConfigMode(int mode);

Q_SIGNALS:

  void change();

  void replaceDock( K3DockWidget* oldDock, K3DockWidget* newDock );

  void setDockDefaultPos( K3DockWidget* );

private Q_SLOTS:

  void slotMenuPopup();

  void slotMenuActivated( int id);

  /* clears the old drawn drag rectangle (oldDragRect) from screen and
   * draws the new current drag rectangle (dragRect) depending on the current mouse position.
   * This highlights the dockwidget which is the currently chosen target during a dock action.
   */
  void drawDragRectangle();

private:

  struct MenuDockData
  {
    MenuDockData( K3DockWidget* _dock, bool _hide )
    {
      dock = _dock;
      hide = _hide;
    }
    ~MenuDockData(){}

    K3DockWidget* dock;
    bool hide;
  };

  K3DockWidget* findDockWidgetAt( const QPoint& pos );

  void findChildDockWidget( QWidget*& w, const QWidget* p, const QPoint& pos );

  void findChildDockWidget( const QWidget* p, QWidgetList*& l);

  void startDrag( K3DockWidget* );

  void dragMove( K3DockWidget* d, QPoint pos );

  void cancelDrop();

  void drop();

// class members

  QWidget* main;

  K3DockWidget* currentDragWidget;

  K3DockWidget* currentMoveWidget; // widget where mouse moving

  QWidgetList* childDockWidgetList;

  K3DockWidget::DockPosition curPos;

  QObjectList* childDock;

  QObjectList* autoCreateDock;

  int storeW;

  int storeH;

  bool dragging;

  bool undockProcess;

  bool dropCancel;

  Q3PopupMenu* menu;

  Q3PtrList<MenuDockData> *menuData;

protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockManagerPrivate;
  K3DockManagerPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockMainWindow : public KXmlGuiWindow
{
  Q_OBJECT

friend class K3DockManager;

public:

  K3DockMainWindow( QWidget* parent = 0L, const char *name = 0L, Qt::WindowFlags f = Qt::Window);

  virtual ~K3DockMainWindow();

  K3DockManager* manager() const;

  void setMainDockWidget( K3DockWidget* dockwidget);

  K3DockWidget* getMainDockWidget() const;

  K3DockWidget* createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent = 0L,
    const QString& strCaption = QString(), const QString& strTabPageLabel = QLatin1String( " " ) );

  void writeDockConfig(QDomElement &base);
  void readDockConfig(QDomElement &base);

#ifndef NO_KDE2

  void writeDockConfig( KConfig* c = 0L, const QString &group = QString() );

  void readDockConfig ( KConfig* c = 0L, const QString &group = QString() );
#endif

  void activateDock();

  Q3PopupMenu* dockHideShowMenu() const;

  void makeDockVisible( K3DockWidget* dock );

  void makeDockInvisible( K3DockWidget* dock );

  void makeWidgetDockVisible( QWidget* widget );

  void setView( QWidget * widget );

Q_SIGNALS:
  void dockWidgetHasUndocked(K3DockWidget*);

protected:

  K3DockWidget* mainDockWidget;

  K3DockManager* dockManager;

protected Q_SLOTS:
  void slotDockWidgetUndocked();

protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockMainWindowPrivate;
  K3DockMainWindowPrivate *d;
};

class KDE3SUPPORT_EXPORT K3DockArea : public QWidget
{
  Q_OBJECT

friend class K3DockManager;

public:


  K3DockArea( QWidget* parent = 0L, const char *name = 0L);

  virtual ~K3DockArea();

  K3DockManager* manager();


  void setMainDockWidget( K3DockWidget* );
  K3DockWidget* getMainDockWidget();

  K3DockWidget* createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent = 0L,
    const QString& strCaption = QString(), const QString& strTabPageLabel = QLatin1String( " " ) );

  void writeDockConfig(QDomElement &base);
  void readDockConfig(QDomElement &base);

#ifndef NO_KDE2
  void writeDockConfig( KConfig* c = 0L, const QString &group = QString() );
  void readDockConfig ( KConfig* c = 0L, const QString &group = QString() );
#endif



  void activateDock();
  Q3PopupMenu* dockHideShowMenu();
  void makeDockVisible( K3DockWidget* dock );
  void makeDockInvisible( K3DockWidget* dock );
  void makeWidgetDockVisible( QWidget* widget );
  //void setView( QWidget* );

Q_SIGNALS:
  void dockWidgetHasUndocked(K3DockWidget*);

protected:

  K3DockWidget* mainDockWidget;
  K3DockManager* dockManager;

protected Q_SLOTS:
  void slotDockWidgetUndocked();

public:
    virtual void resizeEvent(QResizeEvent *);

protected:
  virtual void virtual_hook( int id, void* data );
private:
  class K3DockMainWindowPrivate;
  K3DockMainWindowPrivate *d;
};


#endif