Source: include/qextmdichildview.h

# Source: include/qextmdichildview.h |
Annotated List
Files
Globals
Hierarchy
Index

    //----------------------------------------------------------------------------
    //    filename             : qextmdichildview.h
    //----------------------------------------------------------------------------
    //    Project              : Qt 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
    //    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)
    //
    //    copyright            : (C) 1999-2001 by Falk Brettschneider
    //                                         and
    //                                         Szymon Stefanek (stefanek@tin.it)
    //    email                :  gigafalk@yahoo.com (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 _QEXTMDICHILDVIEW_H_
    #define _QEXTMDICHILDVIEW_H_

    #include
    #include
    #include
    #include

    #include "qextmdichildfrm.h"

    /**
      * @short Base class for all your special view windows.
      *
      * Base class for all MDI view widgets. QextMDI stores additional information in this class
      * to handle the attach/detach mechanism and such things.
      *
      * All such windows 'lives' attached to a QextMdiChildFrm widget
      * managed by QextMdiChildArea, or detached (managed by the window manager.)
      * So remember that the @ref QextMdiChildView::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 QextMdiChildView:
      *   class MyMdiWidget : public QextMdiChildView
      *   { .... };
      *   ...
      *   MyMdiWidget w;
      *   mainframe->addWindow(w, flags);
      *
      * or you wrap them by a QextMdiChildView somehow like this:
      *
      * void DocViewMan::addQExtMDIFrame(QWidget* pNewView, bool bShow, const QPixmap& icon)
      * {
      *   // cover it by a QextMDI childview and add that MDI system
      *   QextMdiChildView* pMDICover = new QextMdiChildView( pNewView->caption());
      *   pMDICover->setIcon(icon);
      *   m_MDICoverList.append( pMDICover);
      *   QBoxLayout* pLayout = new QHBoxLayout( pMDICover, 0, -1, "layout");
      *   pNewView->reparent( pMDICover, QPoint(0,0));
      *   pLayout->addWidget( pNewView);
      *   pMDICover->setName( pNewView->name());
      *   // captions
      *   QString 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 = QextMdi::StandardAdd;
      *   }
      *   else {
      *     flags = QextMdi::Hide;
      *   }
      *   // set the accelerators for Toplevel MDI mode (each toplevel window needs its own accels
      *   connect( m_pParent, SIGNAL(childViewIsDetachedNow(QWidget*)), this, SLOT(initKeyAccel(QWidget*)) );
      *
      *   m_pParent->addWindow( pMDICover, flags);
      *   // correct the default settings of QextMDI ('cause we haven't a tab order for subwidget focuses)
      *   pMDICover->setFirstFocusableChildWidget(0L);
      *   pMDICover->setLastFocusableChildWidget(0L);
      * }
      *
      */

    class DLL_IMP_EXP_QEXTMDICLASS QextMdiChildView : public QWidget
    {
       friend class QextMdiMainFrm;
       friend class QextMdiChildFrm;
       Q_OBJECT

    // attributes
    protected:
       /**
       * See @ref QextMdiChildView::caption
       */
       QString     m_szCaption;
       /**
       * See @ref QextMdiChildView::tabCaption
       */
       QString     m_sTabCaption;
       /**
       * See @ref QextMdiChildView::focusedChildWidget
       */
       QWidget*    m_focusedChildWidget;
       /**
       * See @ref QextMdiChildView::setFirstFocusableChildWidget
       */
       QWidget*    m_firstFocusableChildWidget;
       /**
       * See @ref QextMdiChildView::setLastFocusableChildWidget
       */
       QWidget*    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;

    private:
       /**
       * Internally used as indicator whether this QextMdiChildView is treated as document view or as tool view.
       */
       bool  m_bToolView;
       /**
       * Internally used by QextMdiMainFrm 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 QextMdiMainFrm::activateView() and QextMdiChildView::activate().
       */
       bool m_bMainframesActivateViewIsPending;
       /**
       *
       */
       bool m_bFocusInEventIsPending;

    // methods
    public:
       /**
       * Constructor
       */
       QextMdiChildView( const QString& caption, QWidget* parentWidget = 0L, const char* name = 0L, WFlags f=0);
       /**
       * Constructor 2 (sets "Unnamed" as default caption)
       */
       QextMdiChildView( QWidget* parentWidget = 0L, const char* name = 0L, WFlags f=0);
       /**
       * Destructor
       */
       ~QextMdiChildView();
       /**
       * 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(QWidget*);
       /**
       * Memorizes the last focusable child widget of this widget
       */
       void setLastFocusableChildWidget(QWidget*);
       /**
       * Returns the current focused child widget of this widget
       */
       QWidget* 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 QString& caption() const { return m_szCaption; };
       /**
       * Returns the caption of the button on the taskbar
       */
       const QString& 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 QString& szCaption);
       /**
       * Sets the caption of the button referring to this window
       */
       virtual void setTabCaption(const QString& caption);
       /**
       * Sets the caption of both, window and button on the taskbar (they are going to be the same)
       */
       virtual void setMDICaption(const QString &caption);
       /**
       * Returns the QextMdiChildFrm parent widget (or 0 if the window is not attached)
       */
       QextMdiChildFrm *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 QWidget::geometry() does.
        */
       QRect 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 behaviour of QWidget::setGeometry()!
       */
       void setInternalGeometry(const QRect& newGeomety);
       /**
       * Returns the frame geometry of this window or of the parent if there is any...
       */
       QRect 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 behaviour of QWidget::setGeometry()!
       */
       void setExternalGeometry(const QRect& newGeomety);
       /**
       * You should override this function in the derived class.
       */
       virtual QPixmap* 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().
       */
       QRect restoreGeometry();
       /**
       * Sets the geometry that will be restored by calling restore().
       */
       void  setRestoreGeometry(const QRect& 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
       */
       bool isToolView() const { return m_bToolView; };

    public slots:
       /**
       * Attaches this window to the Mdi manager.
       * It calls the QextMdiMainFrm attachWindow function , so if you have a pointer
       * to this QextMdiMainFrm you'll be faster calling that function.
       * Useful as slot.
       */
       virtual void attach();
       /**
       * Detaches this window from the Mdi manager.
       * It calls the QextMdiMainFrm detachWindow function , so if you have a pointer
       * to this QextMdiMainFrm you'll be faster calling that function.
       * Useful as slot.
       */
       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 ( @ref QWidget::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 @ref QextMdiMainFrm::setMenuForSDIModeSysButtons ).
       * If detached, it will use the minimize of the underlying system (@ref QWidget::showMaximized ).
       */
       virtual void maximize();
       /**
       * Restores this window to its normal size. Also known as 'normalize'.
       */
       virtual void restore();
       /**
       * Internally called, if @ref QextMdiMainFrm::attach is called.
       * Actually, only the caption of the covering childframe is set.
       */
       virtual void youAreAttached(QextMdiChildFrm *lpC);
       /**
       * Internally called, if @ref QextMdiMainFrm::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 QWidget::show but also for it's parent widget if attached
       */
       virtual void show();
       /**
       * Calls QWidget::hide() or it's parent widget hide() if attached
       */
       virtual void hide();
       /**
       * Overridden from its base class method. Emits a signal @ref QextMdiChildView::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 @ref QextMdiChildView::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 @ref QextMdiChildView::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 @ref QextMdiMainFrm::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(QCloseEvent *e);
       /**
       * It only catches @ref QEvent::KeyPress events there. If a Qt::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 @ref QextMdiChildView::setFirstFocusableChildWidget and @ref QextMdiChildView::lastFirstFocusableChildWidget
       */
       virtual bool eventFilter(QObject *obj, QEvent *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 befor changing the focus and the
       * gotFocus signal after changing the focus.
       */
       virtual void focusInEvent(QFocusEvent *e);
       /**
       * Send the lostFocus signal
       */
       virtual void focusOutEvent(QFocusEvent *e);
       /**
       * Internally used for the minimize/maximize/restore mechanism when in attach mode.
       */
       virtual void resizeEvent(QResizeEvent *e);

    protected slots:
       void slot_childDestroyed();

    signals:
       /**
       * Internally used by @ref QextMdiChildView::attach to send it as command to the mainframe.
       */
       void attachWindow( QextMdiChildView*,bool);
       /**
       * Internally used by @ref QextMdiChildView::detach to send it as command to the mainframe.
       */
       void detachWindow( QextMdiChildView*,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 @ref QextMdiChildView::focusInEvent
       */
       void focusInEventOccurs( QextMdiChildView*);
       /**
       * Is sent when this MDI child has received the focus (after actually changing the focus).
       * See @ref QextMdiChildView::focusInEvent
       */
       void gotFocus( QextMdiChildView*);
       /**
       * Is sent when this MDI child was set to the activate view of all MDI views (after actually changing the focus).
       * See @ref QextMdiChildView::activate
       */
       void activated( QextMdiChildView*);
       /** Is sent when this MDI child view has lost the focus (after actually changing the focus).
        *  See @ref QextMdiChildView::focusOutEvent
        */
       void lostFocus( QextMdiChildView*);
       /** Is sent when this MDI child view was deactivated (after actually changing the focus).
        *  See @ref QextMdiChildView::focusOutEvent
        */
       void deactivated( QextMdiChildView*);
       /**
       * Internally used to send information to the mainframe that this MDI child view wants to be closed.
       * See @ref QextMdiChildView::closeEvent and @ref QextMdiMainFrm::closeWindow
       */
       void childWindowCloseRequest( QextMdiChildView*);
       /**
       * Emitted when the window caption is changed via @ref QextMdiChildView::setCaption or @ref QextMdiChildView::setMDICaption
       */
       void windowCaptionChanged( const QString&);
       /**
       * Emitted  when the window caption is changed via @ref QextMdiChildView::setTabCaption or @ref QextMdiChildView::setMDICaption
       */
       void tabCaptionChanged( const QString&);
       /**
       * 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();
    };

    inline QextMdiChildFrm *QextMdiChildView::mdiParent() const
    {
       QWidget* pw = parentWidget();
       if( pw != 0L)
          if( pw->inherits("QextMdiChildFrm"))
             return (QextMdiChildFrm *)pw;
       return 0L;
    }

    #endif //_QEXTMDICHILDVIEW_H_

Generated by: falk on pc9 on Fri Nov 30 14:44:26 2001, using kdoc 2.0a53.