You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
615 lines
19 KiB
615 lines
19 KiB
//----------------------------------------------------------------------------
|
|
// filename : tdemdichildview.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 TQt extension set of
|
|
// classes and a TQt-based library
|
|
// 2000-2003 maintained by the KDevelop project
|
|
// patches : 02/2000 by Massimo Morin (mmorin@schedsys.com)
|
|
// */2000 by Lars Beikirch (Lars.Beikirch@gmx.net)
|
|
// 02/2001 by Eva Brucherseifer (eva@rt.e-technik.tu-darmstadt.de)
|
|
// 01/2003 by Jens Zurheide (jens.zurheide@gmx.de)
|
|
//
|
|
// copyright : (C) 1999-2003 by Falk Brettschneider
|
|
// and
|
|
// Szymon Stefanek (stefanek@tin.it)
|
|
// email : falkbr@kdevelop.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 _TDEMDI_CHILD_VIEW_H_
|
|
#define _TDEMDI_CHILD_VIEW_H_
|
|
|
|
#include <tqwidget.h>
|
|
#include <tqpixmap.h>
|
|
#include <tqrect.h>
|
|
#include <tqapplication.h>
|
|
#include <tqdatetime.h>
|
|
|
|
#include "tdemdichildfrm.h"
|
|
|
|
class KMdiChildViewPrivate;
|
|
|
|
/**
|
|
* @short Base class for all your special view windows.
|
|
*
|
|
* Base class for all MDI view widgets. KMdi stores additional information in this class
|
|
* to handle the attach/detach mechanism and such things.
|
|
*
|
|
* All such windows 'lives' attached to a KMdiChildFrm widget
|
|
* managed by KMdiChildArea, or detached (managed by the window manager.)
|
|
* So remember that the KMdiChildView::parent pointer may change, and may be 0L, too.
|
|
*
|
|
* There are 2 possibilities for you to put your widgets under MDI control:
|
|
*
|
|
* Either you inherit all the views from KMdiChildView:
|
|
* \code
|
|
* class MyMdiWidget : public KMdiChildView
|
|
* { .... };
|
|
* ...
|
|
* MyMdiWidget w;
|
|
* mainframe->addWindow(w, flags);
|
|
* \endcode
|
|
*
|
|
* or you wrap them by a KMdiChildView somehow like this:
|
|
*
|
|
* \code
|
|
* void DocViewMan::addKMdiFrame(TQWidget* pNewView, bool bShow, const TQPixmap& icon)
|
|
* {
|
|
* // cover it by a KMdi childview and add that MDI system
|
|
* KMdiChildView* pMDICover = new KMdiChildView( pNewView->caption());
|
|
* pMDICover->setIcon(icon);
|
|
* m_MDICoverList.append( pMDICover);
|
|
* TQBoxLayout* pLayout = new TQHBoxLayout( pMDICover, 0, -1, "layout");
|
|
* pNewView->reparent( pMDICover, TQPoint(0,0));
|
|
* pLayout->addWidget( pNewView);
|
|
* pMDICover->setName( pNewView->name());
|
|
* // captions
|
|
* TQString shortName = pNewView->caption();
|
|
* int length = shortName.length();
|
|
* shortName = shortName.right(length - (shortName.findRev('/') +1));
|
|
* pMDICover->setTabCaption( shortName);
|
|
* pMDICover->setCaption(pNewView->caption());
|
|
*
|
|
* // fake a viewActivated to update the currentEditView/currentBrowserView pointers _before_ adding to MDI control
|
|
* slot_viewActivated( pMDICover);
|
|
*
|
|
* // take it under MDI mainframe control (note: this triggers also a setFocus())
|
|
* int flags;
|
|
* if (bShow) {
|
|
* flags = KMdi::StandardAdd;
|
|
* }
|
|
* else {
|
|
* flags = KMdi::Hide;
|
|
* }
|
|
* // set the accelerators for Toplevel MDI mode (each toplevel window needs its own accels
|
|
* connect( m_pParent, TQ_SIGNAL(childViewIsDetachedNow(TQWidget*)), this, TQ_SLOT(initKeyAccel(TQWidget*)) );
|
|
*
|
|
* m_pParent->addWindow( pMDICover, flags);
|
|
* // correct the default settings of KMdi ('cause we haven't a tab order for subwidget focuses)
|
|
* pMDICover->setFirstFocusableChildWidget(0L);
|
|
* pMDICover->setLastFocusableChildWidget(0L);
|
|
* }
|
|
* \endcode
|
|
*
|
|
*/
|
|
|
|
class KMDI_EXPORT KMdiChildView : public TQWidget
|
|
{
|
|
friend class KMdiMainFrm;
|
|
friend class KMdiChildFrm;
|
|
TQ_OBJECT
|
|
|
|
|
|
// attributes
|
|
protected:
|
|
/**
|
|
* See KMdiChildView::caption
|
|
*/
|
|
TQString m_szCaption;
|
|
|
|
/**
|
|
* See KMdiChildView::tabCaption
|
|
*/
|
|
TQString m_sTabCaption;
|
|
|
|
/**
|
|
* See KMdiChildView::focusedChildWidget
|
|
*/
|
|
TQWidget* m_focusedChildWidget;
|
|
|
|
/**
|
|
* See KMdiChildView::setFirstFocusableChildWidget
|
|
*/
|
|
TQWidget* m_firstFocusableChildWidget;
|
|
|
|
/**
|
|
* See KMdiChildView::setLastFocusableChildWidget
|
|
*/
|
|
TQWidget* m_lastFocusableChildWidget;
|
|
|
|
/**
|
|
* Every child view window has an temporary ID in the Window menu of the main frame.
|
|
*/
|
|
int m_windowMenuID;
|
|
|
|
/**
|
|
* Holds a temporary information about if the MDI view state has changed but is not processed yet (pending state).
|
|
* For example it could be that a 'maximize' is pending, if this variable is true.
|
|
*/
|
|
bool m_stateChanged;
|
|
|
|
/**
|
|
* Holds the time when this view was activated (not only displayed) for the last time.
|
|
*/
|
|
TQDateTime m_time;
|
|
|
|
private:
|
|
/**
|
|
* Internally used as indicator whether this KMdiChildView is treated as document view or as tool view.
|
|
*/
|
|
bool m_bToolView;
|
|
|
|
/**
|
|
* Internally used by KMdiMainFrm to store a temporary information that the method
|
|
* activate() is unnecessary and that it can by escaped.
|
|
* This saves from unnecessary calls when activate is called directly.
|
|
*/
|
|
bool m_bInterruptActivation;
|
|
|
|
/**
|
|
* Internally used to prevent cycles between KMdiMainFrm::activateView() and KMdiChildView::activate().
|
|
*/
|
|
bool m_bMainframesActivateViewIsPending;
|
|
|
|
/**
|
|
* Internally used to check if there is a focus in event pending
|
|
*/
|
|
bool m_bFocusInEventIsPending;
|
|
|
|
// methods
|
|
public:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
KMdiChildView( const TQString& caption, TQWidget* parentWidget = 0L, const char* name = 0L, WFlags f = 0 );
|
|
|
|
/**
|
|
* Constructor
|
|
* sets "Unnamed" as default caption
|
|
*/
|
|
KMdiChildView( TQWidget* parentWidget = 0L, const char* name = 0L, WFlags f = 0 );
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
~KMdiChildView();
|
|
|
|
/**
|
|
* This method does the same as focusInEvent(). That's why it is a replacement for the setFocus() call. It makes
|
|
* sense if you for instance want to focus (I mean raise and activate) this view although the real focus is
|
|
* in another toplevel widget. focusInEvent() will never get called in that case and your setFocus() call for this
|
|
* widget would fail without any effect.
|
|
* Use this method with caution, it always raises the view and pushes the taskbar button. Also when the focus is
|
|
* still on another MDI view in the same toplevel window where this is located!
|
|
*/
|
|
void activate();
|
|
|
|
/**
|
|
* Memorizes the first focusable child widget of this widget
|
|
*/
|
|
void setFirstFocusableChildWidget( TQWidget* );
|
|
|
|
/**
|
|
* Memorizes the last focusable child widget of this widget
|
|
*/
|
|
void setLastFocusableChildWidget( TQWidget* );
|
|
|
|
/**
|
|
* Returns the current focused child widget of this widget
|
|
*/
|
|
TQWidget* focusedChildWidget();
|
|
|
|
/**
|
|
* Returns true if the MDI view is a child window within the MDI mainframe widget
|
|
* or false if the MDI view is in toplevel mode
|
|
*/
|
|
bool isAttached() const { return ( mdiParent() != 0L ); }
|
|
|
|
/**
|
|
* Returns the caption of the child window (different from the caption on the button in the taskbar)
|
|
*/
|
|
const TQString& caption() const { return m_szCaption; }
|
|
|
|
/**
|
|
* Returns the caption of the button on the taskbar
|
|
*/
|
|
const TQString& tabCaption() const { return m_sTabCaption; }
|
|
|
|
/**
|
|
* Sets the window caption string...
|
|
* Calls updateButton on the taskbar button if it has been set.
|
|
*/
|
|
virtual void setCaption( const TQString& szCaption );
|
|
|
|
/**
|
|
* Sets the caption of the button referring to this window
|
|
*/
|
|
virtual void setTabCaption( const TQString& caption );
|
|
|
|
/**
|
|
* Sets the caption of both the window and the button on the taskbar
|
|
*/
|
|
virtual void setMDICaption( const TQString &caption );
|
|
|
|
/**
|
|
* Returns the KMdiChildFrm parent widget (or 0 if the window is not attached)
|
|
*/
|
|
KMdiChildFrm *mdiParent() const;
|
|
|
|
/**
|
|
* Tells if the window is minimized when attached to the Mdi manager,
|
|
* or if it is VISIBLE when 'floating'.
|
|
*/
|
|
bool isMinimized() const;
|
|
|
|
/**
|
|
* Tells if the window is minimized when attached to the Mdi manager,
|
|
* otherwise returns false.
|
|
*/
|
|
bool isMaximized() const;
|
|
|
|
/**
|
|
* Returns the geometry of this MDI child window as TQWidget::geometry() does.
|
|
*/
|
|
TQRect internalGeometry() const;
|
|
|
|
/**
|
|
* Sets the geometry of the client area of this MDI child window. The
|
|
* top left position of the argument is the position of the top left point
|
|
* of the client area in its parent coordinates and the arguments width
|
|
* and height is the width and height of the client area. Please note: This
|
|
* differs from the behavior of TQWidget::setGeometry()!
|
|
*/
|
|
void setInternalGeometry( const TQRect& newGeomety );
|
|
|
|
/**
|
|
* Returns the frame geometry of this window or of the parent if there is any...
|
|
*/
|
|
TQRect externalGeometry() const;
|
|
|
|
/**
|
|
* Sets the geometry of the frame of this MDI child window. The top left
|
|
* position of the argument is the position of the top left point of the
|
|
* frame in its parent coordinates and the arguments width and height is
|
|
* the width and height of the widget frame. Please note: This differs
|
|
* from the behavior of TQWidget::setGeometry()!
|
|
*/
|
|
void setExternalGeometry( const TQRect& newGeomety );
|
|
|
|
/**
|
|
* You should override this function in the derived class.
|
|
*/
|
|
virtual TQPixmap* myIconPtr();
|
|
|
|
/**
|
|
* Minimizes this window when it is attached to the Mdi manager.
|
|
* Otherwise has no effect
|
|
*/
|
|
virtual void minimize( bool bAnimate );
|
|
|
|
/**
|
|
* Maximizes this window when it is attached to the Mdi manager.
|
|
* Otherwise has no effect
|
|
*/
|
|
virtual void maximize( bool bAnimate );
|
|
|
|
/**
|
|
* Returns the geometry that will be restored by calling restore().
|
|
*/
|
|
TQRect restoreGeometry();
|
|
|
|
/**
|
|
* Sets the geometry that will be restored by calling restore().
|
|
*/
|
|
void setRestoreGeometry( const TQRect& newRestGeo );
|
|
|
|
/**
|
|
* Switches interposing in event loop of all current child widgets off.
|
|
*/
|
|
void removeEventFilterForAllChildren();
|
|
|
|
/**
|
|
* Internally used for setting an ID for the 'Window' menu entry
|
|
*/
|
|
void setWindowMenuID( int id );
|
|
|
|
/**
|
|
* Sets the minimum size of the widget to w by h pixels.
|
|
* It extends it base clase method in a way that the minimum size of
|
|
* its childframe (if there is one) will be set, additionally.
|
|
*/
|
|
virtual void setMinimumSize ( int minw, int minh );
|
|
|
|
/**
|
|
* Sets the maximum size of the widget to w by h pixels.
|
|
* It extends it base clase method in a way that the maximum size of
|
|
* its childframe (if there is one) will be set, additionally.
|
|
*/
|
|
virtual void setMaximumSize ( int maxw, int maxh );
|
|
|
|
/**
|
|
* Returns if this is added as MDI tool-view
|
|
*/
|
|
inline bool isToolView() const { return m_bToolView; }
|
|
|
|
/**
|
|
* Remember the current time
|
|
*/
|
|
inline void updateTimeStamp()
|
|
{
|
|
m_time.setDate( TQDate::currentDate() );
|
|
m_time.setTime( TQTime::currentTime() );
|
|
}
|
|
|
|
/**
|
|
* Recall a previously remembered time, i.e. the value of m_time
|
|
*/
|
|
inline const TQDateTime& getTimeStamp() const { return m_time; }
|
|
|
|
public slots:
|
|
/**
|
|
* Attaches this window to the Mdi manager.
|
|
* It calls the KMdiMainFrm attachWindow function , so if you have a pointer
|
|
* to this KMdiMainFrm you'll be faster calling that function.
|
|
*/
|
|
virtual void attach();
|
|
|
|
/**
|
|
* Detaches this window from the Mdi manager.
|
|
* It calls the KMdiMainFrm detachWindow function , so if you have a pointer
|
|
* to this KMdiMainFrm you'll be faster calling that function.
|
|
*/
|
|
virtual void detach();
|
|
|
|
/**
|
|
* Mimimizes the MDI view. If attached, the covering childframe widget is minimized (only a mini widget
|
|
* showing the caption bar and the system buttons will remain visible). If detached, it will use the
|
|
* minimize of the underlying system ( TQWidget::showMinimized ).
|
|
*/
|
|
virtual void minimize();
|
|
|
|
/**
|
|
* Maximizes the MDI view. If attached, this widget will fill the whole MDI view area widget. The system buttons
|
|
* move to the main menubar (if set by KMdiMainFrm::setMenuForSDIModeSysButtons ).
|
|
* If detached, it will use the minimize of the underlying system ( TQWidget::showMaximized ).
|
|
*/
|
|
virtual void maximize();
|
|
|
|
/**
|
|
* Restores this window to its normal size. Also known as 'normalize'.
|
|
*/
|
|
virtual void restore();
|
|
|
|
/**
|
|
* Internally called, if KMdiMainFrm::attach is called.
|
|
* Actually, only the caption of the covering childframe is set.
|
|
*/
|
|
virtual void youAreAttached( KMdiChildFrm *lpC );
|
|
|
|
/**
|
|
* Internally called, if KMdiMainFrm::detach is called.
|
|
* Some things for going toplevel will be done here.
|
|
*/
|
|
virtual void youAreDetached();
|
|
|
|
/**
|
|
* Called if someone click on the "Window" menu item for this child frame window
|
|
*/
|
|
virtual void slot_clickedInWindowMenu();
|
|
|
|
/**
|
|
* Called if someone click on the "Dock/Undock..." menu item for this child frame window
|
|
*/
|
|
virtual void slot_clickedInDockMenu();
|
|
|
|
/**
|
|
* Calls TQWidget::show but also for it's parent widget if attached
|
|
*/
|
|
virtual void show();
|
|
|
|
/**
|
|
* Calls TQWidget::hide() or it's parent widget hide() if attached
|
|
*/
|
|
virtual void hide();
|
|
|
|
/**
|
|
* Calls TQWidget::raise() or it's parent widget raise() if attached
|
|
*/
|
|
virtual void raise();
|
|
|
|
/**
|
|
* Overridden from its base class method. Emits a signal KMdiChildView::isMinimizedNow , additionally.
|
|
* Note that this method is not used by an external windows manager call on system minimizing.
|
|
*/
|
|
virtual void showMinimized();
|
|
|
|
/**
|
|
* Overridden from its base class method. Emits a signal KMdiChildView::isMaximizedNow , additionally.
|
|
* Note that this method is not used by an external windows manager call on system maximizing.
|
|
*/
|
|
virtual void showMaximized();
|
|
|
|
/**
|
|
* Overridden from its base class method. Emits a signal KMdiChildView::isRestoredNow , additionally.
|
|
* Note that this method is not used by an external windows manager call on system normalizing.
|
|
*/
|
|
virtual void showNormal();
|
|
|
|
|
|
protected:
|
|
/**
|
|
* Ignores the event and calls KMdiMainFrm::childWindowCloseRequest instead. This is because the
|
|
* mainframe has control over the views. Therefore the MDI view has to request the mainframe for a close.
|
|
*/
|
|
virtual void closeEvent( TQCloseEvent *e );
|
|
|
|
/**
|
|
* It only catches TQEvent::KeyPress events there. If a TQt::Key_Tab is pressed, the internal MDI focus
|
|
* handling is called. That means if the last focusable child widget of this is called, it will jump to the
|
|
* first focusable child widget of this.
|
|
* See KMdiChildView::setFirstFocusableChildWidget and KMdiChildView::lastFirstFocusableChildWidget
|
|
*/
|
|
virtual bool eventFilter( TQObject *obj, TQEvent *e );
|
|
|
|
/**
|
|
* If attached, the childframe will be activated and the MDI taskbar button will be pressed. Additionally, the
|
|
* memorized old focused child widget of this is focused again.
|
|
* Sends the focusInEventOccurs signal before changing the focus and the
|
|
* gotFocus signal after changing the focus.
|
|
*/
|
|
virtual void focusInEvent( TQFocusEvent *e );
|
|
|
|
/**
|
|
* Send the lostFocus signal
|
|
*/
|
|
virtual void focusOutEvent( TQFocusEvent *e );
|
|
|
|
/**
|
|
* Internally used for the minimize/maximize/restore mechanism when in attach mode.
|
|
*/
|
|
virtual void resizeEvent( TQResizeEvent *e );
|
|
|
|
void trackIconAndCaptionChanges( TQWidget *view );
|
|
|
|
protected slots:
|
|
void slot_childDestroyed();
|
|
|
|
signals:
|
|
/**
|
|
* Internally used by KMdiChildView::attach to send it as command to the mainframe.
|
|
*/
|
|
void attachWindow( KMdiChildView*, bool );
|
|
|
|
/**
|
|
* Internally used by KMdiChildView::detach to send it as command to the mainframe.
|
|
*/
|
|
void detachWindow( KMdiChildView*, bool );
|
|
|
|
/**
|
|
* Is sent when this MDI child view is going to receive focus (before actually changing the focus).
|
|
* Internally used to send information to the mainframe that this MDI child view is focused.
|
|
* See KMdiChildView::focusInEvent
|
|
*/
|
|
void focusInEventOccurs( KMdiChildView* );
|
|
|
|
/**
|
|
* Is sent when this MDI child has received the focus (after actually changing the focus).
|
|
* See KMdiChildView::focusInEvent
|
|
*/
|
|
void gotFocus( KMdiChildView* );
|
|
|
|
/**
|
|
* Is sent when this MDI child was set to the activate view of all MDI views (after actually changing the focus).
|
|
* See KMdiChildView::activate
|
|
*/
|
|
void activated( KMdiChildView* );
|
|
|
|
/** Is sent when this MDI child view has lost the focus (after actually changing the focus).
|
|
* See KMdiChildView::focusOutEvent
|
|
*/
|
|
void lostFocus( KMdiChildView* );
|
|
|
|
/** Is sent when this MDI child view was deactivated (after actually changing the focus).
|
|
* See KMdiChildView::focusOutEvent
|
|
*/
|
|
void deactivated( KMdiChildView* );
|
|
|
|
/**
|
|
* Internally used to send information to the mainframe that this MDI child view wants to be closed.
|
|
* See KMdiChildView::closeEvent and KMdiMainFrm::closeWindow
|
|
*/
|
|
void childWindowCloseRequest( KMdiChildView* );
|
|
|
|
/**
|
|
* Emitted when the window caption is changed via KMdiChildView::setCaption or KMdiChildView::setMDICaption
|
|
*/
|
|
void windowCaptionChanged( const TQString& );
|
|
|
|
/**
|
|
* Emitted when the window caption is changed via KMdiChildView::setTabCaption or KMdiChildView::setMDICaption
|
|
*/
|
|
void tabCaptionChanged( const TQString& );
|
|
|
|
/**
|
|
* Internally used to send information to the mainframe that this MDI view is maximized now.
|
|
* Usually, the mainframe switches system buttons.
|
|
*/
|
|
void mdiParentNowMaximized( bool );
|
|
|
|
/**
|
|
* Is automatically emitted when slot_clickedInWindowMenu is called
|
|
*/
|
|
void clickedInWindowMenu( int );
|
|
|
|
/**
|
|
* Is automatically emitted when slot_clickedInDockMenu is called
|
|
*/
|
|
void clickedInDockMenu( int );
|
|
|
|
/**
|
|
* Signals this has been maximized
|
|
*/
|
|
void isMaximizedNow();
|
|
|
|
/**
|
|
* Signals this has been minimized
|
|
*/
|
|
void isMinimizedNow();
|
|
|
|
/**
|
|
* Signals this has been restored (normalized)
|
|
*/
|
|
void isRestoredNow();
|
|
|
|
/**
|
|
* Signals this has been attached
|
|
*/
|
|
void isAttachedNow();
|
|
|
|
/**
|
|
* Signals this has been detached
|
|
*/
|
|
void isDetachedNow();
|
|
|
|
void iconUpdated( TQWidget*, TQPixmap );
|
|
void captionUpdated( TQWidget*, const TQString& );
|
|
|
|
|
|
private:
|
|
KMdiChildViewPrivate *d;
|
|
TQWidget *m_trackChanges;
|
|
};
|
|
|
|
inline KMdiChildFrm *KMdiChildView::mdiParent() const
|
|
{
|
|
TQWidget * pw = parentWidget();
|
|
if ( pw != 0L )
|
|
if ( pw->inherits( "KMdiChildFrm" ) )
|
|
return ( KMdiChildFrm * ) pw;
|
|
return 0L;
|
|
}
|
|
|
|
#endif //_TDEMDI_CHILD_VIEW_H_
|