kdockwidget.h

/* 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 TDEMainWindow that can have dockwidgets
   - KDockArea                     - like KDockMainWindow but inherits just TQWidget
 
   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 <tqpoint.h>
#include <tqptrlist.h>
#include <tqframe.h>
#include <tqdom.h>
#include <tqtabwidget.h>
 
#ifndef NO_KDE2
#include <tdemainwindow.h>
#include <netwm_def.h>
#else
 
#include <tqmainwindow.h>
#include "exportdockclass.h"
#include "dummytdemainwindow.h"
#endif
 
class KDockSplitter;
class KDockManager;
class KDockMoveManager;
class KDockWidget;
class KDockButton_Private;
class KDockWidgetPrivate;
class KDockWidgetHeaderPrivate;
class KDockArea;
 
class TQObjectList;
class TQPopupMenu;
class TQVBoxLayout;
class TQHBoxLayout;
class TQPixmap;
 
#ifndef NO_KDE2
class TDEToolBar;
class TDEConfig;
#else
class TQToolBar;
#endif
 
class KDockContainer;
 
namespace KMDI
{
  class MainWindow;
}
 
class TDEUI_EXPORT KDockWidgetAbstractHeader : public TQFrame
{
  TQ_OBJECT
  
public:
 
  KDockWidgetAbstractHeader( KDockWidget* parent, const char* name = 0L );
 
  virtual ~KDockWidgetAbstractHeader(){}
 
  virtual void setTopLevel( bool ){}
 
#ifndef NO_KDE2
  virtual void saveConfig( TDEConfig* ){}
 
  virtual void loadConfig( TDEConfig* ){}
#endif
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class KDockWidgetAbstractHeaderPrivate;
  KDockWidgetAbstractHeaderPrivate *d;
};
 
class TDEUI_EXPORT KDockWidgetAbstractHeaderDrag : public TQFrame
{
  TQ_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 TDEUI_EXPORT KDockWidgetHeaderDrag : public KDockWidgetAbstractHeaderDrag
{
  TQ_OBJECT
  
public:
 
  KDockWidgetHeaderDrag( KDockWidgetAbstractHeader* parent, KDockWidget* dock,
                         const char* name = 0L );
 
  virtual ~KDockWidgetHeaderDrag(){}
 
protected:
 
  virtual void paintEvent( TQPaintEvent* );
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class KDockWidgetHeaderDragPrivate;
  KDockWidgetHeaderDragPrivate *d;
};
 
class TDEUI_EXPORT KDockWidgetHeader : public KDockWidgetAbstractHeader
{
  TQ_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( TDEConfig* c);
 
  virtual void loadConfig( TDEConfig* 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:
 
  TQHBoxLayout* 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 TDEUI_EXPORT KDockTabGroup : public TQTabWidget
{
  TQ_OBJECT
  
public:
  KDockTabGroup( TQWidget *parent = 0, const char *name = 0 )
  :TQTabWidget( parent, name ){}
 
  virtual ~KDockTabGroup(){}
 
  TQWidget *transientTo();
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class KDockTabGroupPrivate;
  KDockTabGroupPrivate *d;
};
 
 
class TDEUI_EXPORT KDockWidget: public TQWidget
{
  TQ_OBJECT
  
friend class KDockManager;
friend class KDockSplitter;
friend class KDockMainWindow;
friend class KDockArea;
 
public:
  KDockWidget( KDockManager* dockManager, const char* name,
               const TQPixmap &pixmap, TQWidget* parent = 0L, const TQString& strCaption = TQString::null,
               const TQString& strTabPageLabel = TQString::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, TQPoint pos = TQPoint(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( TQWidget* w);
 
  TQWidget* 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 TQString& ttStr) { toolTipStr = ttStr; }
 
  const TQString& toolTipString() const { return toolTipStr; }
 
  bool isDockBackPossible() const;
 
  void setTabPageLabel( const TQString& label) { tabPageTitle = label; }
 
  const TQString& tabPageLabel() const { return tabPageTitle; }
 
  virtual bool event( TQEvent * );
 
  virtual void show();
  KDockTabGroup* parentDockTabGroup() const;
 
  TQWidget *parentDockContainer() const;
 
#ifndef NO_KDE2
 
  void setDockWindowType (NET::WindowType windowType);
 
#endif
 
  void setDockWindowTransient (TQWidget *parent, bool transientEnabled);
 
   TQWidget *transientTo();
 
  KDockWidget *findNearestDockWidget(DockPosition pos);
 
   void setPixmap(const TQPixmap& pixmap=TQPixmap());
 
   const TQPixmap& 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(TQWidget *);
  TQWidget *latestKDockContainer();
 
  void setFormerBrotherDockWidget(KDockWidget *);
 
signals:
   void widgetSet(TQWidget*);
 
  void docking( KDockWidget* dw, KDockWidget::DockPosition dp);
 
  void setDockDefaultPos();
 
  void headerCloseButtonClicked();
 
  void headerDockbackButtonClicked();
 
  void iMBeingClosed();
  void hasUndocked();
 
protected slots:
 
  void loseFormerBrotherDockWidget();
 
  virtual void paintEvent(TQPaintEvent*);
 
  virtual void mousePressEvent(TQMouseEvent*);
  virtual void mouseReleaseEvent(TQMouseEvent*);
  virtual void mouseMoveEvent(TQMouseEvent*);
  virtual void leaveEvent(TQEvent*);
protected:
  friend class KDockWidgetHeader;
  KDockWidget* formerBrotherDockWidget;
  DockPosition currentDockPos;
  DockPosition formerDockPos;
  TQString toolTipStr;
  TQString tabPageTitle;
 
private:
  void setDockTabName( KDockTabGroup* g);
 
  void applyToWidget( TQWidget* s, const TQPoint& p  = TQPoint(0,0) );
 
  KDockWidgetAbstractHeader* header;
 
  TQWidget* widget;
 
  TQVBoxLayout* layout;
 
  KDockManager* manager;
 
  TQPixmap* pix;
 
  int eDocking;
 
  int sDocking;
 
  KDockWidget::DockPosition prevSideDockPosBeforeDrag;
 
  // GROUP data
  TQString firstName;
  TQString lastName;
  Orientation splitterOrientation;
  bool isGroup;
  bool isTabGroup;
protected:
  virtual void virtual_hook( int id, void* data );
private:
  KDockWidgetPrivate *d;
};
 
class TDEUI_EXPORT KDockManager: public TQObject
{
  TQ_OBJECT
  
friend class KDockWidget;
friend class KDockMainWindow;
 
public:
    enum EnReadDockConfigMode {
        Unknown,
        WrapExistingWidgetsOnly,
        RestoreAllDockwidgets
    };
 
public:
  KDockManager( TQWidget* mainWindow, const char* name = 0L );
 
  virtual ~KDockManager();
 
  void dumpDockWidgets();
 
#ifndef NO_KDE2
  void writeConfig( TDEConfig* c = 0L, TQString group = TQString::null );
 
  void readConfig ( TDEConfig* c = 0L, TQString group = TQString::null );
#endif
 
  void setMainDockWidget2(KDockWidget *);
 
  void writeConfig(TQDomElement &base);
  void readConfig(TQDomElement &base);
 
  void activate();
 
  virtual bool eventFilter( TQObject * object, TQEvent * event );
 
  KDockWidget* findWidgetParentDock( TQWidget* w) const;
 
  void makeWidgetDockVisible( TQWidget* w ){ findWidgetParentDock(w)->makeDockVisible(); }
 
  TQPopupMenu* dockHideShowMenu() const { return menu; }
 
  KDockWidget* getDockWidgetFromName( const TQString& 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 TQPoint& pos );
 
  void findChildDockWidget( TQWidget*& w, const TQWidget* p, const TQPoint& pos );
 
  void findChildDockWidget( const TQWidget* p, TQWidgetList*& l);
 
  void startDrag( KDockWidget* );
 
  void dragMove( KDockWidget* d, TQPoint pos );
 
  void cancelDrop();
 
  void drop();
 
// class members
 
  TQWidget* main;
 
  KDockWidget* currentDragWidget;
 
  KDockWidget* currentMoveWidget; // widget where mouse moving
 
  TQWidgetList* childDockWidgetList;
 
  KDockWidget::DockPosition curPos;
 
  TQObjectList* childDock;
 
  TQObjectList* autoCreateDock;
 
  int storeW;
 
  int storeH;
 
  bool dragging;
 
  bool undockProcess;
 
  bool dropCancel;
 
  TQPopupMenu* menu;
 
  TQPtrList<MenuDockData> *menuData;
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class KDockManagerPrivate;
  KDockManagerPrivate *d;
};
 
class TDEUI_EXPORT KDockMainWindow : public TDEMainWindow
{
  TQ_OBJECT
  
 
friend class KDockManager;
 
public:
 
#ifdef qdoc
  KDockMainWindow( TQWidget* parent = 0L, const char *name = 0L, WFlags f = WType_TopLevel | WDestructiveClose );
#else
  KDockMainWindow( TQWidget* parent = 0L, const char *name = 0L, WFlags f = (WFlags)(WType_TopLevel | WDestructiveClose) );
#endif
 
  virtual ~KDockMainWindow();
 
  KDockManager* manager() const { return dockManager; }
 
  void setMainDockWidget( KDockWidget* dockwidget);
 
  KDockWidget* getMainDockWidget() const { return mainDockWidget; }
 
  KDockWidget* createDockWidget( const TQString& name, const TQPixmap &pixmap, TQWidget* parent = 0L,
    const TQString& strCaption = TQString::null, const TQString& strTabPageLabel = TQString::fromLatin1( " " ) );
 
  void writeDockConfig(TQDomElement &base);
  void readDockConfig(TQDomElement &base);
 
#ifndef NO_KDE2
  void writeDockConfig( TDEConfig* c = 0L, TQString group = TQString::null );
 
  void readDockConfig ( TDEConfig* c = 0L, TQString group = TQString::null );
#endif
 
  void activateDock(){ dockManager->activate(); }
 
  TQPopupMenu* dockHideShowMenu() const { return dockManager->dockHideShowMenu(); }
 
  void makeDockVisible( KDockWidget* dock );
 
  void makeDockInvisible( KDockWidget* dock );
 
  void makeWidgetDockVisible( TQWidget* widget );
 
  void setView( TQWidget * 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 TDEUI_EXPORT KDockArea : public TQWidget
{
  TQ_OBJECT
  
 
friend class KDockManager;
 
public:
 
 
  KDockArea( TQWidget* parent = 0L, const char *name = 0L);
 
  virtual ~KDockArea();
 
  KDockManager* manager(){ return dockManager; }
 
 
  void setMainDockWidget( KDockWidget* );
  KDockWidget* getMainDockWidget(){ return mainDockWidget; }
 
  KDockWidget* createDockWidget( const TQString& name, const TQPixmap &pixmap, TQWidget* parent = 0L,
    const TQString& strCaption = TQString::null, const TQString& strTabPageLabel = TQString::fromLatin1( " " ) );
 
  void writeDockConfig(TQDomElement &base);
  void readDockConfig(TQDomElement &base);
 
#ifndef NO_KDE2
  void writeDockConfig( TDEConfig* c = 0L, TQString group = TQString::null );
  void readDockConfig ( TDEConfig* c = 0L, TQString group = TQString::null );
#endif
 
 
 
  void activateDock(){ dockManager->activate(); }
  TQPopupMenu* dockHideShowMenu(){ return dockManager->dockHideShowMenu(); }
  void makeDockVisible( KDockWidget* dock );
  void makeDockInvisible( KDockWidget* dock );
  void makeWidgetDockVisible( TQWidget* widget );
  //void setView( TQWidget* );
 
signals:
  void dockWidgetHasUndocked(KDockWidget*);
 
protected:
 
  KDockWidget* mainDockWidget;
  KDockManager* dockManager;
 
protected slots:
  void slotDockWidgetUndocked();
 
public:
    virtual void resizeEvent(TQResizeEvent *);
 
protected:
  virtual void virtual_hook( int id, void* data );
private:
  class KDockMainWindowPrivate;
  KDockMainWindowPrivate *d;
};
 
 
#endif