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