summaryrefslogtreecommitdiffstats
path: root/tdemdi/tdemdimainfrm.h
diff options
context:
space:
mode:
Diffstat (limited to 'tdemdi/tdemdimainfrm.h')
-rw-r--r--tdemdi/tdemdimainfrm.h884
1 files changed, 884 insertions, 0 deletions
diff --git a/tdemdi/tdemdimainfrm.h b/tdemdi/tdemdimainfrm.h
new file mode 100644
index 000000000..08dc83db9
--- /dev/null
+++ b/tdemdi/tdemdimainfrm.h
@@ -0,0 +1,884 @@
+//----------------------------------------------------------------------------
+// filename : tdemdimainfrm.h
+//----------------------------------------------------------------------------
+// Project : KDE MDI extension
+//
+// begin : 07/1999 by Szymon Stefanek as part of kvirc
+// (an IRC application)
+// changes : 09/1999 by Falk Brettschneider to create an
+// - 06/2000 stand-alone Qt extension set of
+// classes and a Qt-based library
+// : 02/2000 by Massimo Morin (mmorin@schedsys.com)
+// 2000-2003 maintained by the KDevelop project
+// patches : */2000 by Lars Beikirch (Lars.Beikirch@gmx.net)
+// : 01/2003 by Jens Zurheide (jens.zurheide@gmx.de)
+//
+// copyright : (C) 1999-2003 by Falk Brettschneider
+// and
+// Szymon Stefanek (stefanek@tin.it)
+// email : falkbr@tdevelop.org (Falk Brettschneider)
+//----------------------------------------------------------------------------
+//
+//----------------------------------------------------------------------------
+//
+// This program 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.
+//
+//----------------------------------------------------------------------------
+
+#ifndef _KMDIMAINFRM_H_
+#define _KMDIMAINFRM_H_
+
+#include <tdeparts/dockmainwindow.h>
+#include <kmenubar.h>
+#include <kpopupmenu.h>
+
+#include <tqptrlist.h>
+#include <tqrect.h>
+#include <tqapplication.h>
+#include <tqdom.h>
+#include <tqguardedptr.h>
+
+#include "tdemditaskbar.h"
+#include "tdemdichildarea.h"
+#include "tdemdichildview.h"
+#include "tdemdiiterator.h"
+#include "tdemdilistiterator.h"
+#include "tdemdinulliterator.h"
+#include "tdemditoolviewaccessor.h"
+
+class TQTimer;
+class TQPopupMenu;
+class TQMenuBar;
+
+
+class TQToolButton;
+
+namespace KMDIPrivate
+{
+class KMDIGUIClient;
+}
+
+class KMdiDockContainer;
+class KMdiMainFrmPrivate;
+
+/**
+ * @short Internal class
+ *
+ * This special event is needed because the view has to inform the main frame that it`s being closed.
+ */
+class KMDI_EXPORT KMdiViewCloseEvent : public TQCustomEvent
+{
+public:
+ KMdiViewCloseEvent( KMdiChildView* pWnd ) : TQCustomEvent( TQEvent::User, pWnd ) {}
+};
+
+/**
+ * \short Base class for all your special main frames.
+ *
+ * It contains the child frame area (QMainWindow's central widget) and a child view taskbar
+ * for switching the MDI views. Most methods are virtual functions for later overriding.
+ *
+ * Basically, this class provides functionality for docking/undocking view windows and
+ * manages the taskbar. Usually a developer will only need to know about this class and
+ * \ref KMdiChildView.
+ *
+ * \par General usage
+ *
+ * Your program mainwidget should inherit KMdiMainFrm. Then usually you'll just need
+ * addWindow() and removeWindowFromMdi() to control the views.
+ * \code
+ * class MyMainWindow : public KMdiMainFrm
+ * { .... };
+ * \endcode
+ *
+ * to define your main window class and
+ *
+ * \code
+ * MyMainWindow mainframe;
+ * tqApp->setMainWidget(&mainframe);
+ * mainframe->addWindow(view1); // put it under MDI control
+ * mainframe->addWindow(view2);
+ * \endcode
+ *
+ * when you wish to use your main window class. The above example also adds a few windows
+ * to the frame.
+ *
+ * KMdiMainFrm will provide the "Window" menu needed in common MDI applications. Just
+ * insert it in your main menu:
+ *
+ * \code
+ * if ( !isFakingSDIApplication() )
+ * {
+ * menuBar()->insertItem( i18n( "&Window" ), windowMenu() );
+ * }
+ * \endcode
+ *
+ * To synchronize the positions of the MDI control buttons inserted in your mainmenu:
+ * \code
+ * void B_MainModuleWidget::initMenuBar()
+ * {
+ * setMenuForSDIModeSysButtons( menuBar() );
+ * }
+ * ...
+ * void B_MainModuleWidget::resizeEvent ( TQResizeEvent *e )
+ * {
+ * KMdiMainFrm::resizeEvent( e );
+ * setSysButtonsAtMenuPosition();
+ * }
+ * \endcode
+ *
+ * \par Dynamic mode switching
+ *
+ * Dynamic switching of the MDI mode can be done via the following functions:
+ * - switchToChildframeMode()
+ * - switchToToplevelMode()
+ * - switchToTabPageMode()
+ * - switchToIDEAlMode()
+ *
+ * The MDI mode can be gotten using mdiMode(). If you need to fake the look of an SDI application
+ * use fakeSDIApplication() to fake it and isFakingSDIApplication() to query whether or not an SDI
+ * interface is being faked.
+ *
+ * You can dynamically change the shape of the attached MDI views using setFrameDecorOfAttachedViews().
+ *
+ * Additionally, here's a hint how to restore the mainframe's settings from config file:
+ * \code
+ *
+ * // restore MDI mode (toplevel, childframe, tabpage)
+ * int mdiMode = config->readIntEntry( "mainmodule session", "MDI mode", KMdi::ChildframeMode);
+ * switch (mdiMode) {
+ * case KMdi::ToplevelMode:
+ * {
+ * int childFrmModeHt = config->readIntEntry( "mainmodule session", "Childframe mode height", desktop()->height() - 50);
+ * mainframe->resize( m_pMdiMainFrm->width(), childFrmModeHt);
+ * mainframe->switchToToplevelMode();
+ * }
+ * break;
+ * case KMdi::ChildframeMode:
+ * break;
+ * case KMdi::TabPageMode:
+ * {
+ * int childFrmModeHt = m_pCfgFileManager->readIntEntry( "mainmodule session", "Childframe mode height", desktop()->height() - 50);
+ * mainframe->resize( m_pMdiMainFrm->width(), childFrmModeHt);
+ * mainframe->switchToTabPageMode();
+ * }
+ * break;
+ * default:
+ * break;
+ * }
+ *
+ * // restore a possible maximized Childframe mode
+ * bool maxChildFrmMode = config->readBoolEntry( "mainmodule session", "maximized childframes", true);
+ * mainframe->setEnableMaximizedChildFrmMode(maxChildFrmMode);
+ * \endcode
+ * The maximized-Childframe mode means that currently all views are maximized in Childframe mode's application desktop.
+ *
+ * \par Managing views
+ *
+ * This class provides placing algorithms in Childframe mode. The following is a list of the window placement functions
+ * - tilePragma() - Tile the windows and allow them to overlap
+ * - tileAnodine() - Tile the windows but don't allow them to overlap
+ * - tileVertically() - Tile the windows vertically
+ * - cascadeWindows() - cascade windows
+ * - cascadeMaximized() - cascade windows and maximize their viewing area
+ * - expandVertical() - expand all the windows to use the most amount of vertical space
+ * - expandHorizontal() - expand all the windows to use the most amount of horizontal space
+ *
+ * activateView(KMdiChildView*) and activateView(int index) set the appropriate MDI child view as the active
+ * one. It will be raised, will get an active MDI frame and will get the focus. Call activeView() to find out what the
+ * current MDI view is.
+ *
+ * Use detachWindow() and attachWindow() for docking the MDI views to desktop and back.
+ *
+ * Connect accels of your program with activatePrevWin(), activateNextWin() and activateView(int index).
+ *
+ * Note: KMdiChildViews can be added in 2 meanings: Either as a normal child view (usually containing
+ * user document views) or as a tool-view (usually containing status, info or control widgets).
+ * The tool-views can be added as floating dockwidgets or as stay-on-top desktop windows in tool style.
+ *
+ * Also, pay attention to the fact that when you click on the close button of MDI views that their
+ * close event should be redirected to closeWindow(). Otherwise the mainframe class will
+ * not get noticed about the deleted view and a dangling pointer will remain in the MDI control. The
+ * closeWindow() or the removeWindowFromMdi() method is for that issue. The difference is closeWindow()
+ * deletes the view object. So if your application wants to control that by itself, call removeWindowFromMdi()
+ * and call delete by yourself. See also KMdiChildView::closeEvent() for that issue.
+ *
+ * Here's an example how you can suggest things for the adding of views to the MDI control via flags:
+ * \code
+ * m_mapOfMdiWidgets.insert( pWnd, mh );
+ * unsigned int mdiFlags = KMdi::StandardAdd;
+ *
+ * if ( !show )
+ * mdiFlags |= KMdi::Hide;
+ *
+ * if ( !attach )
+ * mdiFlags |= KMdi::Detach;
+ *
+ * if ( minimize )
+ * mdiFlags |= KMdi::Minimize;
+ *
+ * if ( bToolWindow)
+ * mdiFlags |= KMdi::ToolWindow;
+ *
+ * if ( m_pMdiMainFrm->isFakingSDIApplication() )
+ * {
+ * if ( attach ) //fake an SDI app
+ * mdiFlags |= KMdi::Maximize;
+ * }
+ * else
+ * {
+ * m_pMdiMainFrm->addWindow( pWnd, TQPoint(20, 20), KMdi::AddWindowFlags(mdiFlags));
+ * return;
+ * }
+ * m_pMdiMainFrm->addWindow( pWnd, KMdi::AddWindowFlags(mdiFlags));
+ * \endcode
+ */
+class KMDI_EXPORT KMdiMainFrm : public KParts::DockMainWindow
+{
+ friend class KMdiChildView;
+ friend class KMdiTaskBar;
+ Q_OBJECT
+
+ friend class KMdiToolViewAccessor;
+ // attributes
+protected:
+ KMdi::MdiMode m_mdiMode;
+ KMdiChildArea *m_pMdi;
+ KMdiTaskBar *m_pTaskBar;
+ TQPtrList<KMdiChildView> *m_pDocumentViews;
+ TQMap<TQWidget*, KMdiToolViewAccessor*> *m_pToolViews;
+ KMdiChildView *m_pCurrentWindow;
+ TQPopupMenu *m_pWindowPopup;
+ TQPopupMenu *m_pTaskBarPopup;
+ TQPopupMenu *m_pWindowMenu;
+ TQPopupMenu *m_pDockMenu;
+ TQPopupMenu *m_pMdiModeMenu;
+ TQPopupMenu *m_pPlacingMenu;
+ KMenuBar *m_pMainMenuBar;
+
+ TQPixmap *m_pUndockButtonPixmap;
+ TQPixmap *m_pMinButtonPixmap;
+ TQPixmap *m_pRestoreButtonPixmap;
+ TQPixmap *m_pCloseButtonPixmap;
+
+ TQToolButton *m_pUndock;
+ TQToolButton *m_pMinimize;
+ TQToolButton *m_pRestore;
+ TQToolButton *m_pClose;
+ TQPoint m_undockPositioningOffset;
+ bool m_bMaximizedChildFrmMode;
+ int m_oldMainFrmHeight;
+ int m_oldMainFrmMinHeight;
+ int m_oldMainFrmMaxHeight;
+ static KMdi::FrameDecor m_frameDecoration;
+ bool m_bSDIApplication;
+ KDockWidget* m_pDockbaseAreaOfDocumentViews;
+ TQDomDocument* m_pTempDockSession;
+ bool m_bClearingOfWindowMenuBlocked;
+
+ TQTimer* m_pDragEndTimer;
+
+ bool m_bSwitching;
+
+ KDockWidget* m_leftContainer;
+ KDockWidget* m_rightContainer;
+ KDockWidget* m_topContainer;
+ KDockWidget* m_bottomContainer;
+
+
+private:
+ KMdiMainFrmPrivate* d;
+ KMDIPrivate::KMDIGUIClient* m_mdiGUIClient;
+ bool m_managedDockPositionMode;
+
+ // methods
+public:
+#ifdef qdoc
+ KMdiMainFrm( TQWidget* parentWidget, const char* name = "", KMdi::MdiMode mdiMode = KMdi::ChildframeMode, WFlags flags = WType_TopLevel | WDestructiveClose );
+#else
+ KMdiMainFrm( TQWidget* parentWidget, const char* name = "", KMdi::MdiMode mdiMode = KMdi::ChildframeMode, WFlags flags = (WFlags)(WType_TopLevel | WDestructiveClose) );
+#endif
+ virtual ~KMdiMainFrm();
+
+ /**
+ * Control whether or not the standard MDI menu is displayed
+ * when a context menu is displayed
+ */
+ void setStandardMDIMenuEnabled( bool showModeMenu = true );
+
+ void setManagedDockPositionModeEnabled( bool enabled );
+
+ /**
+ * Returns whether the application's MDI views are in maximized state or not.
+ */
+ bool isInMaximizedChildFrmMode() { return m_bMaximizedChildFrmMode; }
+
+ /**
+ * Returns the MDI mode. This can be one of the enumerations KMdi::MdiMode.
+ */
+ KMdi::MdiMode mdiMode() { return m_mdiMode; }
+
+ /**
+ * Returns the focused attached MDI view.
+ */
+ KMdiChildView* activeWindow();
+
+ /**
+ * Returns a popup menu filled according to the MDI view state. You can override this
+ * method to insert additional entries there. The popup menu is usually popuped when the user
+ * clicks with the right mouse button on a taskbar entry. The default entries are:
+ * Undock/Dock, Restore/Maximize/Minimize, Close and an empty sub-popup ( windowPopup() )
+ * menu called Operations.
+ */
+ virtual TQPopupMenu * taskBarPopup( KMdiChildView *pWnd, bool bIncludeWindowPopup = false );
+
+ /**
+ * Returns a popup menu with only a title "Window". You can fill it with own operations entries
+ * on the MDI view. This popup menu is inserted as last menu item in taskBarPopup() .
+ */
+ virtual TQPopupMenu * windowPopup( KMdiChildView *pWnd, bool bIncludeTaskbarPopup = true );
+
+ /**
+ * Called in the constructor (forces a resize of all MDI views)
+ */
+ virtual void applyOptions();
+
+ /**
+ * Returns the KMdiChildView belonging to the given caption string.
+ */
+ KMdiChildView * findWindow( const TQString& caption );
+
+ enum ExistsAs {DocumentView, ToolView, AnyView};
+ /**
+ * Returns whether this MDI child view is under MDI control (using addWindow() ) or not.
+ */
+ bool windowExists( KMdiChildView *pWnd, ExistsAs as );
+
+ /**
+ * Catches certain Qt events and processes it here.
+ * Currently, here this catches only the KMdiViewCloseEvent (a KMdi user event) which is sent
+ * from itself in childWindowCloseRequest() right after a KMdiChildView::closeEvent() .
+ * The reason for this event to itself is simple: It just wants to break the function call stack.
+ * It continues the processing with calling closeWindow() .
+ * You see, a close() is translated to a closeWindow() .
+ * It is necessary that the main frame has to start an MDI view close action because it must
+ * remove the MDI view from MDI control, additionally.
+ *
+ * This method calls TQMainWindow::event , additionally.
+ */
+ virtual bool event( TQEvent* e );
+
+ /**
+ * If there's a main menubar given, it will create the 4 maximize mode buttons there (undock, minimize, restore, close).
+ */
+ virtual void setSysButtonsAtMenuPosition();
+
+ /**
+ * Returns the height of the taskbar.
+ */
+ virtual int taskBarHeight() { return m_pTaskBar ? m_pTaskBar->height() : 0; }
+
+ /**
+ * Sets an offset value that is used on detachWindow() . The undocked window
+ * is visually moved on the desktop by this offset.
+ */
+ virtual void setUndockPositioningOffset( TQPoint offset ) { m_undockPositioningOffset = offset; }
+
+ /**
+ * If you don't want to know about the inner structure of the KMdi system, you can use
+ * this iterator to handle with the MDI view list in a more abstract way.
+ * The iterator hides what special data structure is used in KMdi.
+ * The caller must delete the iterator once he does not need it anymore.
+ */
+ // FIXME And what exactly are we supposed to fix? -mattr
+ KMdiIterator<KMdiChildView*>* createIterator()
+ {
+ if ( m_pDocumentViews == 0L )
+ {
+ return new KMdiNullIterator<KMdiChildView*>();
+ }
+ else
+ {
+ return new KMdiListIterator<KMdiChildView>( *m_pDocumentViews );
+ }
+ }
+
+ /**
+ * Deletes an KMdiIterator created in the KMdi library (needed for the windows dll problem).
+ */
+ void deleteIterator( KMdiIterator<KMdiChildView*>* pIt )
+ {
+ delete pIt;
+ }
+
+ /**
+ * Returns a popup menu that contains the MDI controlled view list.
+ * Additionally, this menu provides some placing actions for these views.
+ * Usually, you insert this popup menu in your main menubar as "Window" menu.
+ */
+ TQPopupMenu* windowMenu() const { return m_pWindowMenu; };
+
+ /**
+ * Sets a background color for the MDI view area widget.
+ */
+ virtual void setBackgroundColor( const TQColor &c ) { m_pMdi->setBackgroundColor( c ); }
+
+ /**
+ * Sets a background pixmap for the MDI view area widget.
+ */
+ virtual void setBackgroundPixmap( const TQPixmap &pm ) { m_pMdi->setBackgroundPixmap( pm ); }
+
+ /**
+ * Sets a size that is used as the default size for a newly to the MDI system added KMdiChildView .
+ * By default this size is 600x400. So all non-resized added MDI views appear in that size.
+ */
+ void setDefaultChildFrmSize( const TQSize& sz ) { m_pMdi->m_defaultChildFrmSize = sz; }
+
+ /**
+ * Returns the default size for a newly added KMdiChildView. See setDefaultChildFrmSize() .
+ */
+ TQSize defaultChildFrmSize() { return m_pMdi->m_defaultChildFrmSize; }
+
+ /**
+ * Do nothing when in Toplevel mode
+ */
+ virtual void setMinimumSize( int minw, int minh );
+
+ /**
+ * Returns the Childframe mode height of this. Makes only sense when in Toplevel mode.
+ */
+ int childFrameModeHeight() { return m_oldMainFrmHeight; };
+ /**
+ * Tells the MDI system a QMenu where it can insert buttons for
+ * the system menu, undock, minimize, restore actions.
+ * If no such menu is given, KMdi simply overlays the buttons
+ * at the upper right-hand side of the main widget.
+ */
+ virtual void setMenuForSDIModeSysButtons( KMenuBar* menuBar = 0 );
+
+ /**
+ * @return the decoration of the window frame of docked (attached) MDI views
+ */
+ static int frameDecorOfAttachedViews() { return m_frameDecoration; }
+
+ /**
+ * An SDI application user interface is faked:
+ * @li an opened view is always maximized
+ * @li buttons for maximized childframe mode aren't inserted in the main menubar
+ * @li taskbar and windowmenu are not created/updated
+ */
+ void fakeSDIApplication();
+
+ /**
+ * @returns if we are faking an SDI application (fakeSDIApplication())
+ */
+ bool isFakingSDIApplication() const { return m_bSDIApplication; }
+
+ virtual bool eventFilter( TQObject *obj, TQEvent *e );
+ void findRootDockWidgets( TQPtrList<KDockWidget>* pRootDockWidgetList, TQValueList<TQRect>* pPositionList );
+
+ /** We're switching something.*/
+ void setSwitching( const bool switching ) { m_bSwitching = switching; }
+ bool switching( void ) const { return m_bSwitching; }
+
+public slots:
+ /**
+ * addWindow demands a KMdiChildView. This method wraps every TQWidget in such an object and
+ * this way you can put every widget under MDI control.
+ */
+ KMdiChildView* createWrapper( TQWidget *view, const TQString& name, const TQString& shortName );
+
+ /**
+ * Adds a KMdiChildView to the MDI system. The main frame takes control of it.
+ * \param pWnd the parent view.
+ * \param flags the flags for the view such as:
+ * \li whether the view should be attached or detached.
+ * \li whether the view should be shown or hidden
+ * \li whether the view should be maximized, minimized or restored (normalized)
+ * \li whether the view should be added as tool view (stay-on-top and toplevel) or added as document-type view.
+ */
+ virtual void addWindow( KMdiChildView* pWnd, int flags = KMdi::StandardAdd );
+
+ //KDE4: merge the two methods
+ /**
+ * Adds a KMdiChildView to the MDI system. The main frame takes control of it.
+ * \param pWnd the parent view.
+ * \param flags
+ * You can specify here whether:
+ * \li the view should be attached or detached.
+ * \li shown or hidden
+ * \li maximized, minimized or restored (normalized)
+ * \li added as tool view (stay-on-top and toplevel) or added as
+ * document-type view.
+ * \param index the index of the tab we should insert the new tab after.
+ * If index == -1 then the tab will just be appended to the end.
+ * Using this parameter in childview mode has no effect.
+ * \since 3.3
+ */
+ void addWindow( KMdiChildView* pWnd, int flags, int index );
+
+ /**
+ * Adds a KMdiChildView to the MDI system. The main frame takes control of it.
+ * \param pWnd the parent view.
+ * \param pos move the child view to the specified position
+ * \param flags the flags for the view such as:
+ * \li whether the view should be attached or detached.
+ * \li whether the view should be shown or hidden
+ * \li whether the view should be maximized, minimized or restored (normalized)
+ * \li whether the view should be added as tool view (stay-on-top and toplevel) or
+ * added as document-type view.
+ */
+ virtual void addWindow( KMdiChildView* pWnd, TQPoint pos, int flags = KMdi::StandardAdd );
+
+ /**
+ * Adds a KMdiChildView to the MDI system. The main frame takes control of it.
+ * \param pWnd the parent view.
+ * \param rectNormal Sets the geometry for this child view
+ * \param flags the flags for the view such as:
+ * \li whether the view should be attached or detached.
+ * \li whether the view should be shown or hidden
+ * \li whether the view should be maximized, minimized or restored (normalized)
+ * \li whether the view should be added as tool view (stay-on-top and toplevel) or
+ * added as document-type view.
+ */
+ virtual void addWindow( KMdiChildView* pWnd, TQRect rectNormal, int flags = KMdi::StandardAdd );
+
+ /**
+ * Usually called from addWindow() when adding a tool view window. It reparents the given widget
+ * as toplevel and stay-on-top on the application's main widget.
+ */
+ virtual KMdiToolViewAccessor *addToolWindow( TQWidget* pWnd, KDockWidget::DockPosition pos = KDockWidget::DockNone,
+ TQWidget* pTargetWnd = 0L, int percent = 50, const TQString& tabToolTip = 0,
+ const TQString& tabCaption = 0 );
+
+ virtual void deleteToolWindow( TQWidget* pWnd );
+ virtual void deleteToolWindow( KMdiToolViewAccessor *accessor );
+
+ /**
+ * Using this method you have to use the setWidget method of the access object, and it is very recommendet, that you use
+ * the widgetContainer() method for the parent of your newly created widget
+ */
+ KMdiToolViewAccessor *createToolWindow();
+
+ /**
+ * Removes a KMdiChildView from the MDI system and from the main frame`s control.
+ * The caller is responsible for deleting the view. If the view is not deleted it will
+ * be reparented to 0
+ */
+ virtual void removeWindowFromMdi( KMdiChildView *pWnd );
+
+ /**
+ * Removes a KMdiChildView from the MDI system and from the main frame`s control.
+ * Note: The view will be deleted!
+ */
+ virtual void closeWindow( KMdiChildView *pWnd, bool layoutTaskBar = true );
+
+ /**
+ * Switches the KMdiTaskBar on and off.
+ */
+ virtual void slot_toggleTaskBar();
+
+ /**
+ * Makes a main frame controlled undocked KMdiChildView docked.
+ * Doesn't work on KMdiChildView which aren't added to the MDI system.
+ * Use addWindow() for that.
+ */
+ virtual void attachWindow( KMdiChildView *pWnd, bool bShow = true, bool bAutomaticResize = false );
+
+ /**
+ * Makes a docked KMdiChildView undocked.
+ * The view window still remains under the main frame's MDI control.
+ */
+ virtual void detachWindow( KMdiChildView *pWnd, bool bShow = true );
+
+ /**
+ * Someone wants that the MDI view to be closed. This method sends a KMdiViewCloseEvent to itself
+ * to break the function call stack. See also event() .
+ */
+ virtual void childWindowCloseRequest( KMdiChildView *pWnd );
+
+ /**
+ * Close all views
+ */
+ virtual void closeAllViews();
+
+ /**
+ * Iconfiy all views
+ */
+ virtual void iconifyAllViews();
+
+ /**
+ * Closes the view of the active (topchild) window
+ */
+ virtual void closeActiveView();
+
+ /**
+ * Undocks all view windows (unix-like)
+ */
+ virtual void switchToToplevelMode();
+ virtual void finishToplevelMode();
+
+ /**
+ * Docks all view windows (Windows-like)
+ */
+ virtual void switchToChildframeMode();
+ virtual void finishChildframeMode();
+
+ /**
+ * Docks all view windows (Windows-like)
+ */
+ virtual void switchToTabPageMode();
+ virtual void finishTabPageMode();
+
+ /**
+ * Docks all view windows. Toolviews use dockcontainers
+ */
+ virtual void switchToIDEAlMode();
+ virtual void finishIDEAlMode( bool full = true );
+
+ /**
+ * Sets the appearance of the IDEAl mode. See KMultiTabBar styles for the first 3 bits.
+ * @deprecated use setToolviewStyle(int flags) instead
+ */
+ void setIDEAlModeStyle( int flags ) KDE_DEPRECATED;
+ //KDE4: Get rid of the above.
+ /**
+ * Sets the appearance of the toolview tabs.
+ * @param flags See KMdi::ToolviewStyle.
+ * @since 3.3
+ */
+ void setToolviewStyle( int flags );
+ /**
+ * @return if the view taskbar should be shown if there are MDI views
+ */
+ bool isViewTaskBarOn();
+
+ /**
+ * Shows the view taskbar. This should be connected with your "View" menu.
+ */
+ virtual void showViewTaskBar();
+
+ /**
+ * Hides the view taskbar. This should be connected with your "View" menu.
+ */
+ virtual void hideViewTaskBar();
+
+ /**
+ * Update of the window menu contents.
+ */
+ virtual void fillWindowMenu();
+
+ /**
+ * Cascades the windows without resizing them.
+ */
+ virtual void cascadeWindows() { m_pMdi->cascadeWindows(); }
+
+ /**
+ * Cascades the windows resizing them to the maximum available size.
+ */
+ virtual void cascadeMaximized() { m_pMdi->cascadeMaximized(); }
+
+ /**
+ * Maximizes only in vertical direction.
+ */
+ virtual void expandVertical() { m_pMdi->expandVertical(); }
+
+ /**
+ * Maximizes only in horizontal direction.
+ */
+ virtual void expandHorizontal() { m_pMdi->expandHorizontal(); }
+
+ /**
+ * Tile Pragma
+ */
+ virtual void tilePragma() { m_pMdi->tilePragma(); }
+
+ /**
+ * Tile Anodine
+ */
+ virtual void tileAnodine() { m_pMdi->tileAnodine(); }
+
+ /**
+ * Tile Vertically
+ */
+ virtual void tileVertically() { m_pMdi->tileVertically(); }
+
+ /**
+ * Sets the decoration of the window frame of docked (attached) MDI views
+ * @deprecated Will be removed in KDE 4
+ */
+ virtual void setFrameDecorOfAttachedViews( int frameDecor );
+
+ /**
+ * If in Childframe mode, we can switch between maximized or restored shown MDI views
+ */
+ virtual void setEnableMaximizedChildFrmMode( bool bEnable );
+
+ /**
+ * Activates the next open view
+ */
+ virtual void activateNextWin();
+
+ /**
+ * Activates the previous open view
+ */
+ virtual void activatePrevWin();
+
+ /**
+ * Activates the view first viewed concerning to the access time.
+ */
+ virtual void activateFirstWin();
+
+ /**
+ * Activates the view last viewed concerning to the access time.
+ */
+ virtual void activateLastWin();
+
+ /**
+ * Activates the view with the tab page index (TabPage mode only)
+ */
+ virtual void activateView( int index );
+
+private:
+ void setupToolViewsForIDEALMode();
+ void setupTabbedDocumentViewSpace();
+ class KMdiDocumentViewTabWidget * m_documentTabWidget;
+
+protected:
+
+ virtual void resizeEvent( TQResizeEvent * );
+
+ /**
+ * Creates a new MDI taskbar (showing the MDI views as taskbar entries) and shows it.
+ */
+ virtual void createTaskBar();
+
+ /**
+ * Creates the MDI view area and connects some signals and slots with the KMdiMainFrm widget.
+ */
+ virtual void createMdiManager();
+
+ /**
+ * prevents fillWindowMenu() from m_pWindowMenu->clear(). You have to care for it by yourself.
+ * This is useful if you want to add some actions in your overridden fillWindowMenu() method.
+ */
+ void blockClearingOfWindowMenu( bool bBlocked ) { m_bClearingOfWindowMenuBlocked = bBlocked; }
+
+ void findToolViewsDockedToMain( TQPtrList<KDockWidget>* list, KDockWidget::DockPosition dprtmw );
+ void dockToolViewsIntoContainers( TQPtrList<KDockWidget>& widgetsToReparent, KDockWidget *container );
+ TQStringList prepareIdealToTabs( KDockWidget* container );
+ void idealToolViewsToStandardTabs( TQStringList widgetNames, KDockWidget::DockPosition pos, int sizee );
+
+ /** Get tabwidget visibility */
+ KMdi::TabWidgetVisibility tabWidgetVisibility();
+
+ /** Set tabwidget visibility */
+ void setTabWidgetVisibility( KMdi::TabWidgetVisibility );
+
+ /** Returns the tabwidget used in IDEAl and Tabbed modes. Returns 0 in other modes. */
+ class KTabWidget * tabWidget() const;
+
+
+protected slots: // Protected slots
+ /**
+ * Sets the focus to this MDI view, raises it, activates its taskbar button and updates
+ * the system buttons in the main menubar when in maximized (Maximize mode).
+ */
+ virtual void activateView( KMdiChildView *pWnd );
+
+ /**
+ * Activates the MDI view (see activateView() ) and popups the taskBar popup menu (see taskBarPopup() ).
+ */
+ virtual void taskbarButtonRightClicked( KMdiChildView *pWnd );
+
+ /**
+ * Turns the system buttons for maximize mode (SDI mode) off, and disconnects them
+ */
+ void switchOffMaximizeModeForMenu( KMdiChildFrm* oldChild );
+
+ /**
+ * Reconnects the system buttons form maximize mode (SDI mode) with the new child frame
+ */
+ void updateSysButtonConnections( KMdiChildFrm* oldChild, KMdiChildFrm* newChild );
+
+ /**
+ * Usually called when the user clicks an MDI view item in the "Window" menu.
+ */
+ void windowMenuItemActivated( int id );
+
+ /**
+ * Usually called when the user clicks an MDI view item in the sub-popup menu "Docking" of the "Window" menu.
+ */
+ void dockMenuItemActivated( int id );
+
+ /**
+ * Popups the "Window" menu. See also windowPopup() .
+ */
+ void popupWindowMenu( TQPoint p );
+
+ /**
+ * The timer for main widget moving has elapsed -> send drag end to all concerned views.
+ */
+ void dragEndTimeOut();
+
+ /**
+ * internally used to handle click on view close button (TabPage mode, only)
+ */
+ void closeViewButtonPressed();
+
+signals:
+ /**
+ * Signals the last attached KMdiChildView has been closed
+ */
+ void lastChildFrmClosed();
+
+ /**
+ * Signals the last KMdiChildView (that is under MDI control) has been closed
+ */
+ void lastChildViewClosed();
+
+ /**
+ * Signals that the Toplevel mode has been left
+ */
+ void leftTopLevelMode();
+
+ /**
+ * Signals that a child view has been detached (undocked to desktop)
+ */
+ void childViewIsDetachedNow( TQWidget* );
+
+ /** Signals we need to collapse the overlapped containers */
+ void collapseOverlapContainers();
+
+ /** Signals the MDI mode has been changed */
+ void mdiModeHasBeenChangedTo( KMdi::MdiMode );
+
+ void viewActivated( KMdiChildView* );
+ void viewDeactivated( KMdiChildView* );
+
+public slots:
+ void prevToolViewInDock();
+ void nextToolViewInDock();
+
+private slots:
+ void setActiveToolDock( KMdiDockContainer* );
+ void removeFromActiveDockList( KMdiDockContainer* );
+ void slotDocCurrentChanged( TQWidget* );
+ void verifyToplevelHeight();
+#define protected public
+signals:
+#undef protected
+
+ void toggleTop();
+ void toggleLeft();
+ void toggleRight();
+ void toggleBottom();
+};
+
+#endif //_KMDIMAINFRM_H_
+
+// kate: space-indent off; tab-width 4; replace-tabs off; indent-mode csands;
+