• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

kdeui

kdockwidget.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:
   -------------------------
   - KDockWidgetAbstractHeader     - minor helper class
   - KDockWidgetAbstractHeaderDrag - minor helper class
   - KDockWidgetHeaderDrag         - drag panel in a dockwidget title bar
   - KDockWidgetHeader             - dockwidget title bar containing the drag panel
   - KDockTabGroup                 - minor helper class
   - KDockWidget                   - IMPORTANT CLASS: the one and only dockwidget class
   - KDockManager                  - helper class
   - KDockMainWindow               - IMPORTANT CLASS: a special KMainWindow that can have dockwidgets
   - KDockArea                     - like KDockMainWindow 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 <qpoint.h>
#include <qptrlist.h>
#include <qframe.h>
#include <qdom.h>
#include <qtabwidget.h>

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

#include <qmainwindow.h>
#include "exportdockclass.h"
#include "dummykmainwindow.h"
#endif

class KDockSplitter;
class KDockManager;
class KDockMoveManager;
class KDockWidget;
class KDockButton_Private;
class KDockWidgetPrivate;
class KDockWidgetHeaderPrivate;
class KDockArea;

class QObjectList;
class QPopupMenu;
class QVBoxLayout;
class QHBoxLayout;
class QPixmap;

#ifndef NO_KDE2
class KToolBar;
class KConfig;
#else
class QToolBar;
#endif

class KDockContainer;

namespace KMDI
{
  class MainWindow;
}

class KDEUI_EXPORT KDockWidgetAbstractHeader : public QFrame
{
  Q_OBJECT
public:

  KDockWidgetAbstractHeader( KDockWidget* parent, const char* name = 0L );

  virtual ~KDockWidgetAbstractHeader(){}

  virtual void setTopLevel( bool ){}

#ifndef NO_KDE2

  virtual void saveConfig( KConfig* ){}

  virtual void loadConfig( KConfig* ){}
#endif

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

class KDEUI_EXPORT KDockWidgetAbstractHeaderDrag : public QFrame
{
  Q_OBJECT
public:

  KDockWidgetAbstractHeaderDrag( KDockWidgetAbstractHeader* parent,
                                 KDockWidget* dock, const char* name = 0L );

  virtual ~KDockWidgetAbstractHeaderDrag(){}

  KDockWidget* dockWidget() const { return dw; }

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

class KDEUI_EXPORT KDockWidgetHeaderDrag : public KDockWidgetAbstractHeaderDrag
{
  Q_OBJECT
public:

  KDockWidgetHeaderDrag( KDockWidgetAbstractHeader* parent, KDockWidget* dock,
                         const char* name = 0L );

  virtual ~KDockWidgetHeaderDrag(){}

protected:

  virtual void paintEvent( QPaintEvent* );

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

class KDEUI_EXPORT KDockWidgetHeader : public KDockWidgetAbstractHeader
{
  Q_OBJECT
public:

  KDockWidgetHeader( KDockWidget* parent, const char* name = 0L );

  virtual ~KDockWidgetHeader(){}

  virtual void setTopLevel( bool t);

  void setDragPanel( KDockWidgetHeaderDrag* nd );

   KDockWidgetHeaderDrag *dragPanel();

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

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

  virtual void saveConfig( KConfig* c);

  virtual void loadConfig( KConfig* c);
#endif

   /*@since 3.2
    * add an arbitrary button to the dockwidget header
    * NOT PART OF THE PUBLIC API (you don't have access the class defintion anyways, without special
    * header file copying. (don't do it))
    */
    void addButton(KDockButton_Private*);

   /*@since 3.2
    * remove an arbtrary button from the dockwidget header
    * NOT PART OF THE PUBLIC API (you don't have access the class defintion anyways, without special
    * header file copying. (don't do it))
    */
    void removeButton(KDockButton_Private*);



protected slots:
  void slotStayClicked();

protected:

  QHBoxLayout* layout;

  KDockButton_Private* closeButton;

  KDockButton_Private* stayButton;

  KDockButton_Private* dockbackButton;

  KDockWidgetHeaderDrag* drag;

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

class KDEUI_EXPORT KDockTabGroup : public QTabWidget
{
  Q_OBJECT
public:
  KDockTabGroup( QWidget *parent = 0, const char *name = 0 )
  :QTabWidget( parent, name ){}

  virtual ~KDockTabGroup(){}

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


class KDEUI_EXPORT KDockWidget: public QWidget
{
  Q_OBJECT
friend class KDockManager;
friend class KDockSplitter;
friend class KDockMainWindow;
friend class KDockArea;

public:
  KDockWidget( KDockManager* dockManager, const char* name,
               const QPixmap &pixmap, QWidget* parent = 0L, const QString& strCaption = QString::null,
               const QString& strTabPageLabel = QString::fromLatin1( " " ), WFlags f = 0);

  virtual ~KDockWidget();

  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
  };

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

  void setEnableDocking( int pos );

  int enableDocking() const { return eDocking; }

  void setDockSite( int pos ){ sDocking = pos;}

  int dockSite() const { return sDocking; }

  void setWidget( QWidget* w);

  QWidget* getWidget() const { return widget; }

  void setHeader( KDockWidgetAbstractHeader* ah);

  KDockWidgetAbstractHeader *getHeader();

  void makeDockVisible();

  bool mayBeHide() const;

  bool mayBeShow() const;

  KDockManager* dockManager() const { return manager; }

  void setToolTipString(const QString& ttStr) { toolTipStr = ttStr; }

  const QString& toolTipString() const { return toolTipStr; }

  bool isDockBackPossible() const;

  void setTabPageLabel( const QString& label) { tabPageTitle = label; }

  const QString& tabPageLabel() const { return tabPageTitle; }

  virtual bool event( QEvent * );

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

  QWidget *parentDockContainer() const;

#ifndef NO_KDE2

  void setDockWindowType (NET::WindowType windowType);

#endif

  void setDockWindowTransient (QWidget *parent, bool transientEnabled);

   QWidget *transientTo();

  KDockWidget *findNearestDockWidget(DockPosition pos);

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

   const QPixmap& pixmap() const;

  KDockWidget::DockPosition currentDockPosition() const;

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

  int forcedFixedWidth();
  int forcedFixedHeight();

  void dockBack();

  void changeHideShowState();

  void undock();

  void toDesktop( );

protected:
  friend class KMdiMainFrm;
  friend class KMDI::MainWindow;
  void updateHeader();

  void setLatestKDockContainer(QWidget *);
  QWidget *latestKDockContainer();

  void setFormerBrotherDockWidget(KDockWidget *);

signals:
   void widgetSet(QWidget*);

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

  void setDockDefaultPos();

  void headerCloseButtonClicked();

  void headerDockbackButtonClicked();

  void iMBeingClosed();
  void hasUndocked();

protected 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 KDockWidgetHeader;
  KDockWidget* formerBrotherDockWidget;
  DockPosition currentDockPos;
  DockPosition formerDockPos;
  QString toolTipStr;
  QString tabPageTitle;

private:
  void setDockTabName( KDockTabGroup* g);

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

  KDockWidgetAbstractHeader* header;

  QWidget* widget;

  QVBoxLayout* layout;

  KDockManager* manager;

  QPixmap* pix;

  int eDocking;

  int sDocking;

  KDockWidget::DockPosition prevSideDockPosBeforeDrag;

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

class KDEUI_EXPORT KDockManager: public QObject
{
  Q_OBJECT
friend class KDockWidget;
friend class KDockMainWindow;

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

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

  virtual ~KDockManager();

  void dumpDockWidgets();

#ifndef NO_KDE2

  void writeConfig( KConfig* c = 0L, QString group = QString::null );

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

  void setMainDockWidget2(KDockWidget *);

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

  void activate();

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

  KDockWidget* findWidgetParentDock( QWidget* w) const;

  void makeWidgetDockVisible( QWidget* w ){ findWidgetParentDock(w)->makeDockVisible(); }

  QPopupMenu* dockHideShowMenu() const { return menu; }

  KDockWidget* 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(KDockWidget* container);
  void setSpecialTopDockContainer(KDockWidget* container);
  void setSpecialRightDockContainer(KDockWidget* container);
  void setSpecialBottomDockContainer(KDockWidget* container);

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

signals:

  void change();

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

  void setDockDefaultPos( KDockWidget* );

private 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( KDockWidget* _dock, bool _hide )
    {
      dock = _dock;
      hide = _hide;
    }
    ~MenuDockData(){}

    KDockWidget* dock;
    bool hide;
  };

  KDockWidget* findDockWidgetAt( const QPoint& pos );

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

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

  void startDrag( KDockWidget* );

  void dragMove( KDockWidget* d, QPoint pos );

  void cancelDrop();

  void drop();

// class members

  QWidget* main;

  KDockWidget* currentDragWidget;

  KDockWidget* currentMoveWidget; // widget where mouse moving

  QWidgetList* childDockWidgetList;

  KDockWidget::DockPosition curPos;

  QObjectList* childDock;

  QObjectList* autoCreateDock;

  int storeW;

  int storeH;

  bool dragging;

  bool undockProcess;

  bool dropCancel;

  QPopupMenu* menu;

  QPtrList<MenuDockData> *menuData;

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

class KDEUI_EXPORT KDockMainWindow : public KMainWindow
{
  Q_OBJECT

friend class KDockManager;

public:

  KDockMainWindow( QWidget* parent = 0L, const char *name = 0L, WFlags f = WType_TopLevel | WDestructiveClose );

  virtual ~KDockMainWindow();

  KDockManager* manager() const { return dockManager; }

  void setMainDockWidget( KDockWidget* dockwidget);

  KDockWidget* getMainDockWidget() const { return mainDockWidget; }

  KDockWidget* createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent = 0L,
    const QString& strCaption = QString::null, const QString& strTabPageLabel = QString::fromLatin1( " " ) );

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

#ifndef NO_KDE2

  void writeDockConfig( KConfig* c = 0L, QString group = QString::null );

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

  void activateDock(){ dockManager->activate(); }

  QPopupMenu* dockHideShowMenu() const { return dockManager->dockHideShowMenu(); }

  void makeDockVisible( KDockWidget* dock );

  void makeDockInvisible( KDockWidget* dock );

  void makeWidgetDockVisible( QWidget* widget );

  void setView( QWidget * widget );

signals:
  void dockWidgetHasUndocked(KDockWidget*);

protected:

  KDockWidget* mainDockWidget;

  KDockManager* dockManager;

protected slots:
  void slotDockWidgetUndocked();

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

class KDEUI_EXPORT KDockArea : public QWidget
{
  Q_OBJECT

friend class KDockManager;

public:


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

  virtual ~KDockArea();

  KDockManager* manager(){ return dockManager; }


  void setMainDockWidget( KDockWidget* );
  KDockWidget* getMainDockWidget(){ return mainDockWidget; }

  KDockWidget* createDockWidget( const QString& name, const QPixmap &pixmap, QWidget* parent = 0L,
    const QString& strCaption = QString::null, const QString& strTabPageLabel = QString::fromLatin1( " " ) );

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

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



  void activateDock(){ dockManager->activate(); }
  QPopupMenu* dockHideShowMenu(){ return dockManager->dockHideShowMenu(); }
  void makeDockVisible( KDockWidget* dock );
  void makeDockInvisible( KDockWidget* dock );
  void makeWidgetDockVisible( QWidget* widget );
  //void setView( QWidget* );

signals:
  void dockWidgetHasUndocked(KDockWidget*);

protected:

  KDockWidget* mainDockWidget;
  KDockManager* dockManager;

protected slots:
  void slotDockWidgetUndocked();

public:
    virtual void resizeEvent(QResizeEvent *);

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


#endif

kdeui

Skip menu "kdeui"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• dcop
• DNSSD
• interfaces
• Kate
• kconf_update
• KDECore
• KDED
• kdefx
• KDEsu
• kdeui
• KDocTools
• KHTML
• KImgIO
• KInit
• kio
• kioslave
• KJS
• KNewStuff
• KParts
• KUtils

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal