\section{KMdi\-Main\-Frm Class Reference}
\label{classKMdiMainFrm}\index{KMdiMainFrm@{KMdiMainFrm}}
Base class for all your special main frames.  


{\tt \#include $<$kmdimainfrm.h$>$}

Collaboration diagram for KMdi\-Main\-Frm:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=356pt]{classKMdiMainFrm__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
enum {\bf Exists\-As} \{ {\bf Document\-View}, 
{\bf Tool\-View}, 
{\bf Any\-View}
 \}
\end{CompactItemize}
\subsection*{Public Slots}
\begin{CompactItemize}
\item 
{\bf KMdi\-Child\-View} $\ast$ {\bf create\-Wrapper} ({\bf QWidget} $\ast$view, const {\bf QString} \&name, const {\bf QString} \&short\-Name)
\item 
virtual void {\bf add\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-View, int flags=KMdi::Standard\-Add)
\item 
void {\bf add\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-View, int flags, int index)
\item 
virtual void {\bf add\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-View, {\bf QPoint} pos, int flags=KMdi::Standard\-Add)
\item 
virtual void {\bf add\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-View, {\bf QRect} rect\-Normal, int flags=KMdi::Standard\-Add)
\item 
virtual KMdi\-Tool\-View\-Accessor $\ast$ {\bf add\-Tool\-Window} ({\bf QWidget} $\ast$p\-Wnd, KDock\-Widget::Dock\-Position pos=KDock\-Widget::Dock\-None, {\bf QWidget} $\ast$p\-Target\-Wnd=0L, int percent=50, const {\bf QString} \&tab\-Tool\-Tip=0, const {\bf QString} \&tab\-Caption=0)
\item 
virtual void {\bf delete\-Tool\-Window} ({\bf QWidget} $\ast$p\-Wnd)\label{classKMdiMainFrm_i6}

\item 
virtual void {\bf delete\-Tool\-Window} (KMdi\-Tool\-View\-Accessor $\ast$accessor)\label{classKMdiMainFrm_i7}

\item 
KMdi\-Tool\-View\-Accessor $\ast$ {\bf create\-Tool\-Window} ()
\item 
virtual void {\bf remove\-Window\-From\-Mdi} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd)
\item 
virtual void {\bf close\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd, bool layout\-Task\-Bar=true)
\item 
virtual void {\bf slot\_\-toggle\-Task\-Bar} ()
\item 
virtual void {\bf attach\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd, bool b\-Show=true, bool b\-Automatic\-Resize=false)
\item 
virtual void {\bf detach\-Window} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd, bool b\-Show=true)
\item 
virtual void {\bf child\-Window\-Close\-Request} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd)
\item 
virtual void {\bf close\-All\-Views} ()
\item 
virtual void {\bf iconify\-All\-Views} ()
\item 
virtual void {\bf close\-Active\-View} ()
\item 
virtual void {\bf switch\-To\-Toplevel\-Mode} ()
\item 
virtual void {\bf finish\-Toplevel\-Mode} ()\label{classKMdiMainFrm_i19}

\item 
virtual void {\bf switch\-To\-Childframe\-Mode} ()
\item 
virtual void {\bf finish\-Childframe\-Mode} ()\label{classKMdiMainFrm_i21}

\item 
virtual void {\bf switch\-To\-Tab\-Page\-Mode} ()
\item 
virtual void {\bf finish\-Tab\-Page\-Mode} ()\label{classKMdiMainFrm_i23}

\item 
virtual void {\bf switch\-To\-IDEAl\-Mode} ()
\item 
virtual void {\bf finish\-IDEAl\-Mode} (bool full=true)\label{classKMdiMainFrm_i25}

\item 
void {\bf set\-IDEAl\-Mode\-Style} (int flags) KDE\_\-DEPRECATED
\item 
void {\bf set\-Toolview\-Style} (int flags)
\item 
bool {\bf is\-View\-Task\-Bar\-On} ()
\item 
virtual void {\bf show\-View\-Task\-Bar} ()
\item 
virtual void {\bf hide\-View\-Task\-Bar} ()
\item 
virtual void {\bf fill\-Window\-Menu} ()
\item 
virtual void {\bf cascade\-Windows} ()
\item 
virtual void {\bf cascade\-Maximized} ()
\item 
virtual void {\bf expand\-Vertical} ()
\item 
virtual void {\bf expand\-Horizontal} ()
\item 
virtual void {\bf tile\-Pragma} ()
\item 
virtual void {\bf tile\-Anodine} ()
\item 
virtual void {\bf tile\-Vertically} ()
\item 
virtual void {\bf set\-Frame\-Decor\-Of\-Attached\-Views} (int frame\-Decor)
\item 
virtual void {\bf set\-Enable\-Maximized\-Child\-Frm\-Mode} (bool b\-Enable)
\item 
virtual void {\bf activate\-Next\-Win} ()
\item 
virtual void {\bf activate\-Prev\-Win} ()
\item 
virtual void {\bf activate\-First\-Win} ()
\item 
virtual void {\bf activate\-Last\-Win} ()
\item 
virtual void {\bf activate\-View} (int index)
\item 
void {\bf prev\-Tool\-View\-In\-Dock} ()\label{classKMdiMainFrm_i46}

\item 
void {\bf next\-Tool\-View\-In\-Dock} ()\label{classKMdiMainFrm_i47}

\end{CompactItemize}
\subsection*{Signals}
\begin{CompactItemize}
\item 
void {\bf last\-Child\-Frm\-Closed} ()
\item 
void {\bf last\-Child\-View\-Closed} ()
\item 
void {\bf left\-Top\-Level\-Mode} ()
\item 
void {\bf child\-View\-Is\-Detached\-Now} ({\bf QWidget} $\ast$)
\item 
void {\bf collapse\-Overlap\-Containers} ()
\item 
void {\bf mdi\-Mode\-Has\-Been\-Changed\-To} (KMdi::Mdi\-Mode)
\item 
void {\bf view\-Activated} ({\bf KMdi\-Child\-View} $\ast$)\label{classKMdiMainFrm_l6}

\item 
void {\bf view\-Deactivated} ({\bf KMdi\-Child\-View} $\ast$)\label{classKMdiMainFrm_l7}

\item 
void {\bf toggle\-Top} ()\label{classKMdiMainFrm_l8}

\item 
void {\bf toggle\-Left} ()\label{classKMdiMainFrm_l9}

\item 
void {\bf toggle\-Right} ()\label{classKMdiMainFrm_l10}

\item 
void {\bf toggle\-Bottom} ()\label{classKMdiMainFrm_l11}

\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KMdi\-Main\-Frm} ({\bf QWidget} $\ast$parent\-Widget, const char $\ast$name=\char`\"{}\char`\"{}, KMdi::Mdi\-Mode mdi\-Mode=KMdi::Childframe\-Mode, WFlags flags=WType\_\-Top\-Level$|$WDestructive\-Close)\label{classKMdiMainFrm_a0}

\item 
void {\bf set\-Standard\-MDIMenu\-Enabled} (bool show\-Mode\-Menu=true)
\item 
void {\bf set\-Managed\-Dock\-Position\-Mode\-Enabled} (bool enabled)\label{classKMdiMainFrm_a3}

\item 
bool {\bf is\-In\-Maximized\-Child\-Frm\-Mode} ()
\item 
KMdi::Mdi\-Mode {\bf mdi\-Mode} ()
\item 
{\bf KMdi\-Child\-View} $\ast$ {\bf active\-Window} ()
\item 
virtual {\bf QPopup\-Menu} $\ast$ {\bf task\-Bar\-Popup} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd, bool b\-Include\-Window\-Popup=false)
\item 
virtual {\bf QPopup\-Menu} $\ast$ {\bf window\-Popup} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd, bool b\-Include\-Taskbar\-Popup=true)
\item 
virtual void {\bf apply\-Options} ()
\item 
{\bf KMdi\-Child\-View} $\ast$ {\bf find\-Window} (const {\bf QString} \&caption)
\item 
bool {\bf window\-Exists} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd, Exists\-As as)
\item 
virtual bool {\bf event} ({\bf QEvent} $\ast$e)
\item 
virtual void {\bf set\-Sys\-Buttons\-At\-Menu\-Position} ()
\item 
virtual int {\bf task\-Bar\-Height} ()
\item 
virtual void {\bf set\-Undock\-Positioning\-Offset} ({\bf QPoint} offset)
\item 
KMdi\-Iterator$<$ {\bf KMdi\-Child\-View} $\ast$ $>$ $\ast$ {\bf create\-Iterator} ()
\item 
void {\bf delete\-Iterator} (KMdi\-Iterator$<$ {\bf KMdi\-Child\-View} $\ast$ $>$ $\ast$p\-It)
\item 
{\bf QPopup\-Menu} $\ast$ {\bf window\-Menu} () const 
\item 
virtual void {\bf set\-Background\-Color} (const {\bf QColor} \&c)
\item 
virtual void {\bf set\-Background\-Pixmap} (const {\bf QPixmap} \&pm)
\item 
void {\bf set\-Default\-Child\-Frm\-Size} (const {\bf QSize} \&sz)
\item 
{\bf QSize} {\bf default\-Child\-Frm\-Size} ()
\item 
virtual void {\bf set\-Minimum\-Size} (int minw, int minh)
\item 
int {\bf child\-Frame\-Mode\-Height} ()
\item 
virtual void {\bf set\-Menu\-For\-SDIMode\-Sys\-Buttons} (KMenu\-Bar $\ast$menu\-Bar=0)
\item 
void {\bf fake\-SDIApplication} ()
\item 
bool {\bf is\-Faking\-SDIApplication} () const 
\item 
virtual bool {\bf event\-Filter} ({\bf QObject} $\ast$obj, {\bf QEvent} $\ast$e)
\item 
void {\bf find\-Root\-Dock\-Widgets} ({\bf QPtr\-List}$<$ KDock\-Widget $>$ $\ast$p\-Root\-Dock\-Widget\-List, {\bf QValue\-List}$<$ {\bf QRect} $>$ $\ast$p\-Position\-List)
\item 
void {\bf set\-Switching} (const bool switching)
\item 
bool {\bf switching} (void) const \label{classKMdiMainFrm_a31}

\end{CompactItemize}
\subsection*{Static Public Member Functions}
\begin{CompactItemize}
\item 
static int {\bf frame\-Decor\-Of\-Attached\-Views} ()
\end{CompactItemize}
\subsection*{Protected Slots}
\begin{CompactItemize}
\item 
virtual void {\bf activate\-View} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd)
\item 
virtual void {\bf taskbar\-Button\-Right\-Clicked} ({\bf KMdi\-Child\-View} $\ast$p\-Wnd)
\item 
void {\bf switch\-Off\-Maximize\-Mode\-For\-Menu} ({\bf KMdi\-Child\-Frm} $\ast$old\-Child)
\item 
void {\bf update\-Sys\-Button\-Connections} ({\bf KMdi\-Child\-Frm} $\ast$old\-Child, {\bf KMdi\-Child\-Frm} $\ast$new\-Child)
\item 
void {\bf window\-Menu\-Item\-Activated} (int id)
\item 
void {\bf dock\-Menu\-Item\-Activated} (int id)
\item 
void {\bf popup\-Window\-Menu} ({\bf QPoint} p)
\item 
void {\bf drag\-End\-Time\-Out} ()
\item 
void {\bf close\-View\-Button\-Pressed} ()
\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf resize\-Event} ({\bf QResize\-Event} $\ast$)\label{classKMdiMainFrm_b0}

\item 
virtual void {\bf create\-Task\-Bar} ()
\item 
virtual void {\bf create\-Mdi\-Manager} ()
\item 
void {\bf block\-Clearing\-Of\-Window\-Menu} (bool b\-Blocked)
\item 
void {\bf find\-Tool\-Views\-Docked\-To\-Main} ({\bf QPtr\-List}$<$ KDock\-Widget $>$ $\ast$list, KDock\-Widget::Dock\-Position dprtmw)\label{classKMdiMainFrm_b4}

\item 
void {\bf dock\-Tool\-Views\-Into\-Containers} ({\bf QPtr\-List}$<$ KDock\-Widget $>$ \&widgets\-To\-Reparent, KDock\-Widget $\ast$container)\label{classKMdiMainFrm_b5}

\item 
{\bf QString\-List} {\bf prepare\-Ideal\-To\-Tabs} (KDock\-Widget $\ast$container)\label{classKMdiMainFrm_b6}

\item 
void {\bf ideal\-Tool\-Views\-To\-Standard\-Tabs} ({\bf QString\-List} widget\-Names, KDock\-Widget::Dock\-Position pos, int sizee)\label{classKMdiMainFrm_b7}

\item 
KMdi::Tab\-Widget\-Visibility {\bf tab\-Widget\-Visibility} ()
\item 
void {\bf set\-Tab\-Widget\-Visibility} (KMdi::Tab\-Widget\-Visibility)
\item 
KTab\-Widget $\ast$ {\bf tab\-Widget} () const 
\end{CompactItemize}
\subsection*{Protected Attributes}
\begin{CompactItemize}
\item 
KMdi::Mdi\-Mode {\bf m\_\-mdi\-Mode}\label{classKMdiMainFrm_p0}

\item 
{\bf KMdi\-Child\-Area} $\ast$ {\bf m\_\-p\-Mdi}\label{classKMdiMainFrm_p1}

\item 
{\bf KMdi\-Task\-Bar} $\ast$ {\bf m\_\-p\-Task\-Bar}\label{classKMdiMainFrm_p2}

\item 
{\bf QPtr\-List}$<$ {\bf KMdi\-Child\-View} $>$ $\ast$ {\bf m\_\-p\-Document\-Views}\label{classKMdiMainFrm_p3}

\item 
{\bf QMap}$<$ {\bf QWidget} $\ast$, KMdi\-Tool\-View\-Accessor $\ast$ $>$ $\ast$ {\bf m\_\-p\-Tool\-Views}\label{classKMdiMainFrm_p4}

\item 
{\bf KMdi\-Child\-View} $\ast$ {\bf m\_\-p\-Current\-Window}\label{classKMdiMainFrm_p5}

\item 
{\bf QPopup\-Menu} $\ast$ {\bf m\_\-p\-Window\-Popup}\label{classKMdiMainFrm_p6}

\item 
{\bf QPopup\-Menu} $\ast$ {\bf m\_\-p\-Task\-Bar\-Popup}\label{classKMdiMainFrm_p7}

\item 
{\bf QPopup\-Menu} $\ast$ {\bf m\_\-p\-Window\-Menu}\label{classKMdiMainFrm_p8}

\item 
{\bf QPopup\-Menu} $\ast$ {\bf m\_\-p\-Dock\-Menu}\label{classKMdiMainFrm_p9}

\item 
{\bf QPopup\-Menu} $\ast$ {\bf m\_\-p\-Mdi\-Mode\-Menu}\label{classKMdiMainFrm_p10}

\item 
{\bf QPopup\-Menu} $\ast$ {\bf m\_\-p\-Placing\-Menu}\label{classKMdiMainFrm_p11}

\item 
KMenu\-Bar $\ast$ {\bf m\_\-p\-Main\-Menu\-Bar}\label{classKMdiMainFrm_p12}

\item 
{\bf QPixmap} $\ast$ {\bf m\_\-p\-Undock\-Button\-Pixmap}\label{classKMdiMainFrm_p13}

\item 
{\bf QPixmap} $\ast$ {\bf m\_\-p\-Min\-Button\-Pixmap}\label{classKMdiMainFrm_p14}

\item 
{\bf QPixmap} $\ast$ {\bf m\_\-p\-Restore\-Button\-Pixmap}\label{classKMdiMainFrm_p15}

\item 
{\bf QPixmap} $\ast$ {\bf m\_\-p\-Close\-Button\-Pixmap}\label{classKMdiMainFrm_p16}

\item 
{\bf QTool\-Button} $\ast$ {\bf m\_\-p\-Undock}\label{classKMdiMainFrm_p17}

\item 
{\bf QTool\-Button} $\ast$ {\bf m\_\-p\-Minimize}\label{classKMdiMainFrm_p18}

\item 
{\bf QTool\-Button} $\ast$ {\bf m\_\-p\-Restore}\label{classKMdiMainFrm_p19}

\item 
{\bf QTool\-Button} $\ast$ {\bf m\_\-p\-Close}\label{classKMdiMainFrm_p20}

\item 
{\bf QPoint} {\bf m\_\-undock\-Positioning\-Offset}\label{classKMdiMainFrm_p21}

\item 
bool {\bf m\_\-b\-Maximized\-Child\-Frm\-Mode}\label{classKMdiMainFrm_p22}

\item 
int {\bf m\_\-old\-Main\-Frm\-Height}\label{classKMdiMainFrm_p23}

\item 
int {\bf m\_\-old\-Main\-Frm\-Min\-Height}\label{classKMdiMainFrm_p24}

\item 
int {\bf m\_\-old\-Main\-Frm\-Max\-Height}\label{classKMdiMainFrm_p25}

\item 
bool {\bf m\_\-b\-SDIApplication}\label{classKMdiMainFrm_p26}

\item 
KDock\-Widget $\ast$ {\bf m\_\-p\-Dockbase\-Area\-Of\-Document\-Views}\label{classKMdiMainFrm_p27}

\item 
{\bf QDom\-Document} $\ast$ {\bf m\_\-p\-Temp\-Dock\-Session}\label{classKMdiMainFrm_p28}

\item 
bool {\bf m\_\-b\-Clearing\-Of\-Window\-Menu\-Blocked}\label{classKMdiMainFrm_p29}

\item 
{\bf QTimer} $\ast$ {\bf m\_\-p\-Drag\-End\-Timer}\label{classKMdiMainFrm_p30}

\item 
bool {\bf m\_\-b\-Switching}\label{classKMdiMainFrm_p31}

\item 
KDock\-Widget $\ast$ {\bf m\_\-left\-Container}\label{classKMdiMainFrm_p32}

\item 
KDock\-Widget $\ast$ {\bf m\_\-right\-Container}\label{classKMdiMainFrm_p33}

\item 
KDock\-Widget $\ast$ {\bf m\_\-top\-Container}\label{classKMdiMainFrm_p34}

\item 
KDock\-Widget $\ast$ {\bf m\_\-bottom\-Container}\label{classKMdiMainFrm_p35}

\end{CompactItemize}
\subsection*{Static Protected Attributes}
\begin{CompactItemize}
\item 
static KMdi::Frame\-Decor {\bf m\_\-frame\-Decoration} = KMdi::KDELook\label{classKMdiMainFrm_t0}

\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf KMdi\-Child\-View}\label{classKMdiMainFrm_n0}

\item 
class {\bf KMdi\-Task\-Bar}\label{classKMdiMainFrm_n1}

\item 
class {\bf KMdi\-Tool\-View\-Accessor}\label{classKMdiMainFrm_n2}

\end{CompactItemize}


\subsection{Detailed Description}
Base class for all your special main frames. 

It contains the child frame area (QMain\-Window'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 {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})}.

\begin{Desc}
\item[General usage]\end{Desc}
Your program mainwidget should inherit KMdi\-Main\-Frm. Then usually you'll just need {\bf add\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i1})} and {\bf remove\-Window\-From\-Mdi()}{\rm (p.\,\pageref{classKMdiMainFrm_i9})} to control the views. 

\footnotesize\begin{verbatim}        class MyMainWindow : public KMdiMainFrm
        { .... };
\end{verbatim}
\normalsize


to define your main window class and



\footnotesize\begin{verbatim}        MyMainWindow mainframe;
        qApp->setMainWidget(&mainframe);
        mainframe->addWindow(view1); // put it under MDI control
        mainframe->addWindow(view2);
\end{verbatim}
\normalsize


when you wish to use your main window class. The above example also adds a few windows to the frame.

KMdi\-Main\-Frm will provide the \char`\"{}Window\char`\"{} menu needed in common MDI applications. Just insert it in your main menu:



\footnotesize\begin{verbatim}        if ( !isFakingSDIApplication() )
        {
            menuBar()->insertItem( i18n( "&Window" ), windowMenu() );
        }
\end{verbatim}
\normalsize


To synchronize the positions of the MDI control buttons inserted in your mainmenu: 

\footnotesize\begin{verbatim}        void B_MainModuleWidget::initMenuBar()
        {
            setMenuForSDIModeSysButtons( menuBar() );
        }
        ...
        void B_MainModuleWidget::resizeEvent ( QResizeEvent *e )
        {
            KMdiMainFrm::resizeEvent( e );
            setSysButtonsAtMenuPosition();
        }
\end{verbatim}
\normalsize


\begin{Desc}
\item[Dynamic mode switching]\end{Desc}
Dynamic switching of the MDI mode can be done via the following functions:\begin{itemize}
\item {\bf switch\-To\-Childframe\-Mode()}{\rm (p.\,\pageref{classKMdiMainFrm_i20})}\item {\bf switch\-To\-Toplevel\-Mode()}{\rm (p.\,\pageref{classKMdiMainFrm_i18})}\item {\bf switch\-To\-Tab\-Page\-Mode()}{\rm (p.\,\pageref{classKMdiMainFrm_i22})}\item {\bf switch\-To\-IDEAl\-Mode()}{\rm (p.\,\pageref{classKMdiMainFrm_i24})}\end{itemize}


The MDI mode can be gotten using {\bf mdi\-Mode()}{\rm (p.\,\pageref{classKMdiMainFrm_a5})}. If you need to fake the look of an SDI application use {\bf fake\-SDIApplication()}{\rm (p.\,\pageref{classKMdiMainFrm_a26})} to fake it and {\bf is\-Faking\-SDIApplication()}{\rm (p.\,\pageref{classKMdiMainFrm_a27})} to query whether or not an SDI interface is being faked.

You can dynamically change the shape of the attached MDI views using {\bf set\-Frame\-Decor\-Of\-Attached\-Views()}{\rm (p.\,\pageref{classKMdiMainFrm_i39})}.

Additionally, here's a hint how to restore the mainframe's settings from config file: 

\footnotesize\begin{verbatim}    // 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);
\end{verbatim}
\normalsize
 The maximized-Childframe mode means that currently all views are maximized in Childframe mode's application desktop.

\begin{Desc}
\item[Managing views]\end{Desc}
This class provides placing algorithms in Childframe mode. The following is a list of the window placement functions\begin{itemize}
\item {\bf tile\-Pragma()}{\rm (p.\,\pageref{classKMdiMainFrm_i36})} - Tile the windows and allow them to overlap\item {\bf tile\-Anodine()}{\rm (p.\,\pageref{classKMdiMainFrm_i37})} - Tile the windows but don't allow them to overlap\item {\bf tile\-Vertically()}{\rm (p.\,\pageref{classKMdiMainFrm_i38})} - Tile the windows vertically\item {\bf cascade\-Windows()}{\rm (p.\,\pageref{classKMdiMainFrm_i32})} - cascade windows\item {\bf cascade\-Maximized()}{\rm (p.\,\pageref{classKMdiMainFrm_i33})} - cascade windows and maximize their viewing area\item {\bf expand\-Vertical()}{\rm (p.\,\pageref{classKMdiMainFrm_i34})} - expand all the windows to use the most amount of vertical space\item {\bf expand\-Horizontal()}{\rm (p.\,\pageref{classKMdiMainFrm_i35})} - expand all the windows to use the most amount of horizontal space\end{itemize}


{\bf activate\-View(KMdi\-Child\-View$\ast$)}{\rm (p.\,\pageref{classKMdiMainFrm_j0})} and {\bf activate\-View(int index)}{\rm (p.\,\pageref{classKMdiMainFrm_i45})} 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 active\-View() to find out what the current MDI view is.

Use {\bf detach\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i13})} and {\bf attach\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i12})} for docking the MDI views to desktop and back.

Connect accels of your program with {\bf activate\-Prev\-Win()}{\rm (p.\,\pageref{classKMdiMainFrm_i42})}, {\bf activate\-Next\-Win()}{\rm (p.\,\pageref{classKMdiMainFrm_i41})} and {\bf activate\-View(int index)}{\rm (p.\,\pageref{classKMdiMainFrm_i45})}.

Note: KMdi\-Child\-Views 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 {\bf close\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i10})}. Otherwise the mainframe class will not get noticed about the deleted view and a dangling pointer will remain in the MDI control. The {\bf close\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i10})} or the {\bf remove\-Window\-From\-Mdi()}{\rm (p.\,\pageref{classKMdiMainFrm_i9})} method is for that issue. The difference is {\bf close\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i10})} deletes the view object. So if your application wants to control that by itself, call {\bf remove\-Window\-From\-Mdi()}{\rm (p.\,\pageref{classKMdiMainFrm_i9})} and call delete by yourself. See also {\bf KMdi\-Child\-View::close\-Event()}{\rm (p.\,\pageref{classKMdiChildView_b0})} for that issue.

Here's an example how you can suggest things for the adding of views to the MDI control via flags: 

\footnotesize\begin{verbatim}        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, QPoint(20, 20), KMdi::AddWindowFlags(mdiFlags));
            return;
        }
        m_pMdiMainFrm->addWindow( pWnd, KMdi::AddWindowFlags(mdiFlags));
\end{verbatim}
\normalsize
 



Definition at line 239 of file kmdimainfrm.h.

\subsection{Member Function Documentation}
\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setStandardMDIMenuEnabled@{setStandardMDIMenuEnabled}}
\index{setStandardMDIMenuEnabled@{setStandardMDIMenuEnabled}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Standard\-MDIMenu\-Enabled (bool {\em show\-Mode\-Menu} = {\tt true})}\label{classKMdiMainFrm_a2}


Control whether or not the standard MDI menu is displayed when a context menu is displayed. 



Definition at line 275 of file kmdimainfrm.cpp.

References mdi\-Mode\-Has\-Been\-Changed\-To().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!isInMaximizedChildFrmMode@{isInMaximizedChildFrmMode}}
\index{isInMaximizedChildFrmMode@{isInMaximizedChildFrmMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Main\-Frm::is\-In\-Maximized\-Child\-Frm\-Mode ()\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a4}


Returns whether the application's MDI views are in maximized state or not. 



Definition at line 313 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!mdiMode@{mdiMode}}
\index{mdiMode@{mdiMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi::Mdi\-Mode KMdi\-Main\-Frm::mdi\-Mode ()\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a5}


Returns the MDI mode. 

This can be one of the enumerations KMdi::Mdi\-Mode.

Definition at line 318 of file kmdimainfrm.h.

Referenced by detach\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activeWindow@{activeWindow}}
\index{activeWindow@{activeWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KMdi\-Child\-View} $\ast$ KMdi\-Main\-Frm::active\-Window ()}\label{classKMdiMainFrm_a6}


Returns the focused attached MDI view. 



Definition at line 956 of file kmdimainfrm.cpp.

Referenced by activate\-First\-Win(), activate\-Last\-Win(), activate\-Next\-Win(), activate\-Prev\-Win(), close\-View\-Button\-Pressed(), and event\-Filter().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!taskBarPopup@{taskBarPopup}}
\index{taskBarPopup@{taskBarPopup}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPopup\-Menu} $\ast$ KMdi\-Main\-Frm::task\-Bar\-Popup ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd}, bool {\em b\-Include\-Window\-Popup} = {\tt false})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a7}


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 ( {\bf window\-Popup()}{\rm (p.\,\pageref{classKMdiMainFrm_a8})} ) menu called Operations.

Definition at line 990 of file kmdimainfrm.cpp.

References QPopup\-Menu::clear(), QPopup\-Menu::insert\-Item(), QPopup\-Menu::insert\-Separator(), and window\-Popup().

Referenced by taskbar\-Button\-Right\-Clicked(), and window\-Popup().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!windowPopup@{windowPopup}}
\index{windowPopup@{windowPopup}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPopup\-Menu} $\ast$ KMdi\-Main\-Frm::window\-Popup ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd}, bool {\em b\-Include\-Taskbar\-Popup} = {\tt true})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a8}


Returns a popup menu with only a title \char`\"{}Window\char`\"{}. 

You can fill it with own operations entries on the MDI view. This popup menu is inserted as last menu item in {\bf task\-Bar\-Popup()}{\rm (p.\,\pageref{classKMdiMainFrm_a7})} .

Definition at line 978 of file kmdimainfrm.cpp.

References QPopup\-Menu::clear(), QPopup\-Menu::insert\-Item(), QPopup\-Menu::insert\-Separator(), and task\-Bar\-Popup().

Referenced by task\-Bar\-Popup().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!applyOptions@{applyOptions}}
\index{applyOptions@{applyOptions}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::apply\-Options ()\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a9}


Called in the constructor (forces a resize of all MDI views). 



Definition at line 340 of file kmdimainfrm.cpp.

References QWidget::height(), QWidget::resize(), and QWidget::width().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!findWindow@{findWindow}}
\index{findWindow@{findWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KMdi\-Child\-View} $\ast$ KMdi\-Main\-Frm::find\-Window (const {\bf QString} \& {\em caption})}\label{classKMdiMainFrm_a10}


Returns the {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} belonging to the given caption string. 



Definition at line 944 of file kmdimainfrm.cpp.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!windowExists@{windowExists}}
\index{windowExists@{windowExists}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Main\-Frm::window\-Exists ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd}, Exists\-As {\em as})}\label{classKMdiMainFrm_a11}


Returns whether this MDI child view is under MDI control (using {\bf add\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i1})} ) or not. 



Definition at line 962 of file kmdimainfrm.cpp.

References QMap::contains(), and QPtr\-List::find\-Ref().

Referenced by add\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!event@{event}}
\index{event@{event}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Main\-Frm::event ({\bf QEvent} $\ast$ {\em e})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a12}


Catches certain {\bf Qt} events and processes it here. 

Currently, here this catches only the {\bf KMdi\-View\-Close\-Event}{\rm (p.\,\pageref{classKMdiViewCloseEvent})} (a {\bf KMdi}{\rm (p.\,\pageref{namespaceKMdi})} user event) which is sent from itself in {\bf child\-Window\-Close\-Request()}{\rm (p.\,\pageref{classKMdiMainFrm_i14})} right after a {\bf KMdi\-Child\-View::close\-Event()}{\rm (p.\,\pageref{classKMdiChildView_b0})} . The reason for this event to itself is simple: It just wants to break the function call stack. It continues the processing with calling {\bf close\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i10})} . You see, a close() is translated to a {\bf close\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i10})} . 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 QMain\-Window::event , additionally.

Definition at line 1123 of file kmdimainfrm.cpp.

References close\-Window(), QTimer::is\-Active(), QApplication::send\-Event(), QTimer::start(), and QTimer::stop().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setSysButtonsAtMenuPosition@{setSysButtonsAtMenuPosition}}
\index{setSysButtonsAtMenuPosition@{setSysButtonsAtMenuPosition}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Sys\-Buttons\-At\-Menu\-Position ()\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a13}


If there's a main menubar given, it will create the 4 maximize mode buttons there (undock, minimize, restore, close). 



Definition at line 2265 of file kmdimainfrm.cpp.

References frame\-Decor\-Of\-Attached\-Views().

Referenced by set\-Menu\-For\-SDIMode\-Sys\-Buttons().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!taskBarHeight@{taskBarHeight}}
\index{taskBarHeight@{taskBarHeight}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual int KMdi\-Main\-Frm::task\-Bar\-Height ()\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKMdiMainFrm_a14}


Returns the height of the taskbar. 



Definition at line 378 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setUndockPositioningOffset@{setUndockPositioningOffset}}
\index{setUndockPositioningOffset@{setUndockPositioningOffset}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::set\-Undock\-Positioning\-Offset ({\bf QPoint} {\em offset})\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKMdiMainFrm_a15}


Sets an offset value that is used on {\bf detach\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i13})} . 

The undocked window is visually moved on the desktop by this offset.

Definition at line 384 of file kmdimainfrm.h.

Referenced by switch\-To\-Toplevel\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!createIterator@{createIterator}}
\index{createIterator@{createIterator}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi\-Iterator$<${\bf KMdi\-Child\-View}$\ast$$>$$\ast$ KMdi\-Main\-Frm::create\-Iterator ()\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a16}


If you don't want to know about the inner structure of the {\bf KMdi}{\rm (p.\,\pageref{namespaceKMdi})} 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 {\bf KMdi}{\rm (p.\,\pageref{namespaceKMdi})}.

Definition at line 392 of file kmdimainfrm.h.

Referenced by activate\-First\-Win(), activate\-Last\-Win(), activate\-Next\-Win(), and activate\-Prev\-Win().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!deleteIterator@{deleteIterator}}
\index{deleteIterator@{deleteIterator}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::delete\-Iterator (KMdi\-Iterator$<$ {\bf KMdi\-Child\-View} $\ast$ $>$ $\ast$ {\em p\-It})\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a17}


Deletes an KMdi\-Iterator created in the {\bf KMdi}{\rm (p.\,\pageref{namespaceKMdi})} library (needed for the windows dll problem). 



Definition at line 407 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!windowMenu@{windowMenu}}
\index{windowMenu@{windowMenu}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPopup\-Menu}$\ast$ KMdi\-Main\-Frm::window\-Menu () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a18}


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 \char`\"{}Window\char`\"{} menu.

Definition at line 417 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setBackgroundColor@{setBackgroundColor}}
\index{setBackgroundColor@{setBackgroundColor}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::set\-Background\-Color (const {\bf QColor} \& {\em c})\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKMdiMainFrm_a19}


Sets a background color for the MDI view area widget. 



Definition at line 422 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setBackgroundPixmap@{setBackgroundPixmap}}
\index{setBackgroundPixmap@{setBackgroundPixmap}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::set\-Background\-Pixmap (const {\bf QPixmap} \& {\em pm})\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKMdiMainFrm_a20}


Sets a background pixmap for the MDI view area widget. 



Definition at line 427 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setDefaultChildFrmSize@{setDefaultChildFrmSize}}
\index{setDefaultChildFrmSize@{setDefaultChildFrmSize}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Default\-Child\-Frm\-Size (const {\bf QSize} \& {\em sz})\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a21}


Sets a size that is used as the default size for a newly to the MDI system added {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} . 

By default this size is 600x400. So all non-resized added MDI views appear in that size.

Definition at line 433 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!defaultChildFrmSize@{defaultChildFrmSize}}
\index{defaultChildFrmSize@{defaultChildFrmSize}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QSize} KMdi\-Main\-Frm::default\-Child\-Frm\-Size ()\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a22}


Returns the default size for a newly added {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})}. 

See {\bf set\-Default\-Child\-Frm\-Size()}{\rm (p.\,\pageref{classKMdiMainFrm_a21})} .

Definition at line 438 of file kmdimainfrm.h.

Referenced by detach\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setMinimumSize@{setMinimumSize}}
\index{setMinimumSize@{setMinimumSize}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Minimum\-Size (int {\em minw}, int {\em minh})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a23}


Do nothing when in Toplevel mode. 



Definition at line 411 of file kmdimainfrm.cpp.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!childFrameModeHeight@{childFrameModeHeight}}
\index{childFrameModeHeight@{childFrameModeHeight}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KMdi\-Main\-Frm::child\-Frame\-Mode\-Height ()\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a24}


Returns the Childframe mode height of this. 

Makes only sense when in Toplevel mode.

Definition at line 448 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setMenuForSDIModeSysButtons@{setMenuForSDIModeSysButtons}}
\index{setMenuForSDIModeSysButtons@{setMenuForSDIModeSysButtons}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Menu\-For\-SDIMode\-Sys\-Buttons (KMenu\-Bar $\ast$ {\em menu\-Bar} = {\tt 0})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a25}


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, {\bf KMdi}{\rm (p.\,\pageref{namespaceKMdi})} simply overlays the buttons at the upper right-hand side of the main widget.

Definition at line 2192 of file kmdimainfrm.cpp.

References frame\-Decor\-Of\-Attached\-Views(), QTool\-Button::set\-Auto\-Raise(), and set\-Sys\-Buttons\-At\-Menu\-Position().

Referenced by set\-Frame\-Decor\-Of\-Attached\-Views().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!frameDecorOfAttachedViews@{frameDecorOfAttachedViews}}
\index{frameDecorOfAttachedViews@{frameDecorOfAttachedViews}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}static int KMdi\-Main\-Frm::frame\-Decor\-Of\-Attached\-Views ()\hspace{0.3cm}{\tt  [inline, static]}}\label{classKMdiMainFrm_e0}


\begin{Desc}
\item[Returns:]the decoration of the window frame of docked (attached) MDI views\end{Desc}


Definition at line 460 of file kmdimainfrm.h.

Referenced by set\-Enable\-Maximized\-Child\-Frm\-Mode(), set\-Menu\-For\-SDIMode\-Sys\-Buttons(), set\-Sys\-Buttons\-At\-Menu\-Position(), and update\-Sys\-Button\-Connections().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!fakeSDIApplication@{fakeSDIApplication}}
\index{fakeSDIApplication@{fakeSDIApplication}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::fake\-SDIApplication ()}\label{classKMdiMainFrm_a26}


An SDI application user interface is faked: \begin{itemize}
\item an opened view is always maximized \item buttons for maximized childframe mode aren't inserted in the main menubar \item taskbar and windowmenu are not created/updated. \end{itemize}




Definition at line 2837 of file kmdimainfrm.cpp.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!isFakingSDIApplication@{isFakingSDIApplication}}
\index{isFakingSDIApplication@{isFakingSDIApplication}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Main\-Frm::is\-Faking\-SDIApplication () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a27}


\begin{Desc}
\item[Returns:]if we are faking an SDI application ({\bf fake\-SDIApplication()}{\rm (p.\,\pageref{classKMdiMainFrm_a26})})\end{Desc}


Definition at line 473 of file kmdimainfrm.h.

Referenced by popup\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!eventFilter@{eventFilter}}
\index{eventFilter@{eventFilter}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Main\-Frm::event\-Filter ({\bf QObject} $\ast$ {\em obj}, {\bf QEvent} $\ast$ {\em e})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiMainFrm_a28}


these are quite some assumptions: The key combination uses exactly one modifier key The WIN button in KDE is the meta button in {\bf Qt} 

Definition at line 1169 of file kmdimainfrm.cpp.

References active\-Window(), KMdi\-Child\-Area::focus\-Top\-Child(), KMdi\-Child\-View::is\-Attached(), QWidget::is\-Hidden(), QFocus\-Event::reason(), set\-Switching(), KMdi\-Child\-Area::top\-Child(), and KMdi\-Child\-View::update\-Time\-Stamp().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!findRootDockWidgets@{findRootDockWidgets}}
\index{findRootDockWidgets@{findRootDockWidgets}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::find\-Root\-Dock\-Widgets ({\bf QPtr\-List}$<$ KDock\-Widget $>$ $\ast$ {\em root\-Dock\-Widget\-List}, {\bf QValue\-List}$<$ {\bf QRect} $>$ $\ast$ {\em position\-List})}\label{classKMdiMainFrm_a29}


find the root dockwidgets and store their geometry 



Definition at line 1277 of file kmdimainfrm.cpp.

References QPtr\-List\-Iterator::current(), QWidget::is\-Top\-Level(), QPoint::x(), and QPoint::y().

Referenced by switch\-To\-Childframe\-Mode(), and switch\-To\-Toplevel\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setSwitching@{setSwitching}}
\index{setSwitching@{setSwitching}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Switching (const bool {\em switching})\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiMainFrm_a30}


We're switching something. 



Definition at line 479 of file kmdimainfrm.h.

Referenced by event\-Filter().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!createWrapper@{createWrapper}}
\index{createWrapper@{createWrapper}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KMdi\-Child\-View} $\ast$ KMdi\-Main\-Frm::create\-Wrapper ({\bf QWidget} $\ast$ {\em view}, const {\bf QString} \& {\em name}, const {\bf QString} \& {\em short\-Name})\hspace{0.3cm}{\tt  [slot]}}\label{classKMdiMainFrm_i0}


add\-Window demands a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})}. 

This method wraps every {\bf QWidget} in such an object and this way you can put every widget under MDI control.

Definition at line 420 of file kmdimainfrm.cpp.

References QBox\-Layout::add\-Widget(), QWidget::icon(), QWidget::reparent(), KMdi\-Child\-View::set\-Caption(), QWidget::set\-Icon(), KMdi\-Child\-View::set\-Tab\-Caption(), and KMdi\-Child\-View::track\-Icon\-And\-Caption\-Changes().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!addWindow@{addWindow}}
\index{addWindow@{addWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::add\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-View}, int {\em flags} = {\tt KMdi::StandardAdd})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i1}


Adds a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} to the MDI system. 

The main frame takes control of it. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em flags}]the flags for the view such as: \begin{itemize}
\item whether the view should be attached or detached. \item whether the view should be shown or hidden \item whether the view should be maximized, minimized or restored (normalized) \item whether the view should be added as tool view (stay-on-top and toplevel) or added as document-type view.\end{itemize}
\end{description}
\end{Desc}


Definition at line 443 of file kmdimainfrm.cpp.

Referenced by add\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!addWindow@{addWindow}}
\index{addWindow@{addWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::add\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-View}, int {\em flags}, int {\em index})\hspace{0.3cm}{\tt  [slot]}}\label{classKMdiMainFrm_i2}


Adds a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} to the MDI system. 

The main frame takes control of it. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em 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. \item[{\em flags}]You can specify here whether: \begin{itemize}
\item the view should be attached or detached. \item shown or hidden \item maximized, minimized or restored (normalized) \item added as tool view (stay-on-top and toplevel) or added as document-type view. \end{itemize}
\end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.3\end{Desc}


Definition at line 448 of file kmdimainfrm.cpp.

References activate\-View(), add\-Tool\-Window(), KMdi\-Task\-Bar::add\-Win\-Button(), QPtr\-List::append(), attach\-Window(), child\-View\-Is\-Detached\-Now(), child\-Window\-Close\-Request(), QObject::connect(), detach\-Window(), dock\-Menu\-Item\-Activated(), KMdi\-Child\-Area::get\-Cascade\-Point(), QPtr\-List::insert(), KMdi\-Document\-View\-Tab\-Widget::insert\-Tab(), QWidget::move(), QWidget::set\-Enabled(), window\-Exists(), and window\-Menu\-Item\-Activated().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!addWindow@{addWindow}}
\index{addWindow@{addWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::add\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-View}, {\bf QPoint} {\em pos}, int {\em flags} = {\tt KMdi::StandardAdd})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i3}


Adds a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} to the MDI system. 

The main frame takes control of it. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em pos}]move the child view to the specified position \item[{\em flags}]the flags for the view such as: \begin{itemize}
\item whether the view should be attached or detached. \item whether the view should be shown or hidden \item whether the view should be maximized, minimized or restored (normalized) \item whether the view should be added as tool view (stay-on-top and toplevel) or added as document-type view.\end{itemize}
\end{description}
\end{Desc}


Definition at line 541 of file kmdimainfrm.cpp.

References add\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!addWindow@{addWindow}}
\index{addWindow@{addWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::add\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-View}, {\bf QRect} {\em rect\-Normal}, int {\em flags} = {\tt KMdi::StandardAdd})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i4}


Adds a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} to the MDI system. 

The main frame takes control of it. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rect\-Normal}]Sets the geometry for this child view \item[{\em flags}]the flags for the view such as: \begin{itemize}
\item whether the view should be attached or detached. \item whether the view should be shown or hidden \item whether the view should be maximized, minimized or restored (normalized) \item whether the view should be added as tool view (stay-on-top and toplevel) or added as document-type view.\end{itemize}
\end{description}
\end{Desc}


Definition at line 531 of file kmdimainfrm.cpp.

References add\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!addToolWindow@{addToolWindow}}
\index{addToolWindow@{addToolWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi\-Tool\-View\-Accessor $\ast$ KMdi\-Main\-Frm::add\-Tool\-Window ({\bf QWidget} $\ast$ {\em p\-Wnd}, KDock\-Widget::Dock\-Position {\em pos} = {\tt KDockWidget::DockNone}, {\bf QWidget} $\ast$ {\em p\-Target\-Wnd} = {\tt 0L}, int {\em percent} = {\tt 50}, const {\bf QString} \& {\em tab\-Tool\-Tip} = {\tt 0}, const {\bf QString} \& {\em tab\-Caption} = {\tt 0})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i5}


Usually called from {\bf add\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i1})} when adding a tool view window. 

It reparents the given widget as toplevel and stay-on-top on the application's main widget.

Definition at line 570 of file kmdimainfrm.cpp.

References QMap::insert(), and QRect::top\-Left().

Referenced by add\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!createToolWindow@{createToolWindow}}
\index{createToolWindow@{createToolWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi\-Tool\-View\-Accessor $\ast$ KMdi\-Main\-Frm::create\-Tool\-Window ()\hspace{0.3cm}{\tt  [slot]}}\label{classKMdiMainFrm_i8}


Using this method you have to use the set\-Widget method of the access object, and it is very recommendet, that you use the widget\-Container() method for the parent of your newly created widget. 



Definition at line 552 of file kmdimainfrm.cpp.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!removeWindowFromMdi@{removeWindowFromMdi}}
\index{removeWindowFromMdi@{removeWindowFromMdi}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::remove\-Window\-From\-Mdi ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i9}


Removes a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} 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

Definition at line 732 of file kmdimainfrm.cpp.

References KMdi\-Child\-View::activate(), activate\-View(), attach\-Window(), child\-Window\-Close\-Request(), QTab\-Widget::count(), KMdi\-Child\-Area::destroy\-Child\-But\-Not\-Its\-View(), detach\-Window(), QObject::disconnect(), dock\-Menu\-Item\-Activated(), KMdi\-Task\-Bar::get\-Button(), KMdi\-Child\-Area::get\-Visible\-Child\-Count(), last\-Child\-View\-Closed(), KMdi\-Child\-View::m\_\-b\-Tool\-View, KMdi\-Child\-Frm::m\_\-p\-Client, QTab\-Widget::page(), KMdi\-Task\-Bar::remove\-Win\-Button(), KMdi\-Child\-Area::top\-Child(), and window\-Menu\-Item\-Activated().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!closeWindow@{closeWindow}}
\index{closeWindow@{closeWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::close\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd}, bool {\em layout\-Task\-Bar} = {\tt true})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i10}


Removes a {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} from the MDI system and from the main frame`s control. 

Note: The view will be deleted!

Definition at line 832 of file kmdimainfrm.cpp.

References KMdi\-Child\-View::activate(), QTab\-Widget::count(), QPtr\-List::count(), QPtr\-List::current(), KMdi\-Child\-Area::destroy\-Child(), KMdi\-Child\-Area::get\-Visible\-Child\-Count(), QPtr\-List::last(), last\-Child\-View\-Closed(), KMdi\-Child\-Frm::m\_\-p\-Client, QTab\-Widget::page(), QPtr\-List::remove\-Ref(), KMdi\-Task\-Bar::remove\-Win\-Button(), and KMdi\-Child\-Area::top\-Child().

Referenced by event().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!slot_toggleTaskBar@{slot\_\-toggleTaskBar}}
\index{slot_toggleTaskBar@{slot\_\-toggleTaskBar}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::slot\_\-toggle\-Task\-Bar ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i11}


Switches the {\bf KMdi\-Task\-Bar}{\rm (p.\,\pageref{classKMdiTaskBar})} on and off. 



Definition at line 389 of file kmdimainfrm.cpp.

References KMdi\-Task\-Bar::is\-Switched\-On(), and KMdi\-Task\-Bar::switch\-On().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!attachWindow@{attachWindow}}
\index{attachWindow@{attachWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::attach\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd}, bool {\em b\-Show} = {\tt true}, bool {\em b\-Automatic\-Resize} = {\tt false})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i12}


Makes a main frame controlled undocked {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} docked. 

Doesn't work on {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} which aren't added to the MDI system. Use {\bf add\-Window()}{\rm (p.\,\pageref{classKMdiMainFrm_i1})} for that.

Definition at line 607 of file kmdimainfrm.cpp.

References KMdi\-Child\-Frm::caption\-Height(), QRect::height(), KMdi\-Child\-Frm::m\_\-p\-Client, KMdi\-Child\-Area::manage\-Child(), QApplication::send\-Event(), QApplication::send\-Posted\-Events(), KMdi\-Child\-Frm::set\-Client(), KMdi\-Child\-Frm::set\-Restore\-Geometry(), switch\-To\-Childframe\-Mode(), KMdi\-Child\-Area::top\-Child(), QRect::width(), QWidget::x(), QPoint::x(), QWidget::y(), and QPoint::y().

Referenced by add\-Window(), dock\-Menu\-Item\-Activated(), remove\-Window\-From\-Mdi(), and switch\-To\-Childframe\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!detachWindow@{detachWindow}}
\index{detachWindow@{detachWindow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::detach\-Window ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd}, bool {\em b\-Show} = {\tt true})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i13}


Makes a docked {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} undocked. 

The view window still remains under the main frame's MDI control.

Definition at line 666 of file kmdimainfrm.cpp.

References activate\-View(), KMdi\-Child\-Frm::caption(), child\-View\-Is\-Detached\-Now(), QPtr\-List::count(), default\-Child\-Frm\-Size(), KMdi\-Child\-Area::destroy\-Child\-But\-Not\-Its\-View(), KMdi\-Child\-Area::get\-Cascade\-Point(), KMdi\-Child\-Frm::icon(), mdi\-Mode(), KMdi\-Child\-View::mdi\-Parent(), KMdi\-Child\-Frm::set\-Icon(), QWidget::size(), KMdi\-Child\-Frm::unset\-Client(), and KMdi\-Child\-View::you\-Are\-Detached().

Referenced by add\-Window(), dock\-Menu\-Item\-Activated(), and remove\-Window\-From\-Mdi().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!childWindowCloseRequest@{childWindowCloseRequest}}
\index{childWindowCloseRequest@{childWindowCloseRequest}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::child\-Window\-Close\-Request ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i14}


Someone wants that the MDI view to be closed. 

This method sends a {\bf KMdi\-View\-Close\-Event}{\rm (p.\,\pageref{classKMdiViewCloseEvent})} to itself to break the function call stack. See also {\bf event()}{\rm (p.\,\pageref{classKMdiMainFrm_a12})} .

Definition at line 1117 of file kmdimainfrm.cpp.

References QApplication::post\-Event().

Referenced by add\-Window(), and remove\-Window\-From\-Mdi().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!closeAllViews@{closeAllViews}}
\index{closeAllViews@{closeAllViews}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::close\-All\-Views ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i15}


Close all views. 



Definition at line 1239 of file kmdimainfrm.cpp.

References QValue\-List::append(), QValue\-List::begin(), QValue\-List::end(), QPtr\-List::first(), and QPtr\-List::next().

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!iconifyAllViews@{iconifyAllViews}}
\index{iconifyAllViews@{iconifyAllViews}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::iconify\-All\-Views ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i16}


Iconfiy all views. 



Definition at line 1258 of file kmdimainfrm.cpp.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!closeActiveView@{closeActiveView}}
\index{closeActiveView@{closeActiveView}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::close\-Active\-View ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i17}


Closes the view of the active (topchild) window. 



Definition at line 1269 of file kmdimainfrm.cpp.

References QWidget::close().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!switchToToplevelMode@{switchToToplevelMode}}
\index{switchToToplevelMode@{switchToToplevelMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::switch\-To\-Toplevel\-Mode ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i18}


Undocks all view windows (unix-like). 



Definition at line 1347 of file kmdimainfrm.cpp.

References QValue\-List::begin(), QPtr\-List::count(), QValue\-List::end(), find\-Root\-Dock\-Widgets(), mdi\-Mode\-Has\-Been\-Changed\-To(), set\-Undock\-Positioning\-Offset(), and QPtr\-List\-Iterator::to\-First().

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!switchToChildframeMode@{switchToChildframeMode}}
\index{switchToChildframeMode@{switchToChildframeMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::switch\-To\-Childframe\-Mode ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i20}


Docks all view windows (Windows-like). 



Definition at line 1459 of file kmdimainfrm.cpp.

References attach\-Window(), QPtr\-List::count(), find\-Root\-Dock\-Widgets(), KMdi\-Child\-View::is\-Attached(), KMdi\-Child\-View::is\-Tool\-View(), left\-Top\-Level\-Mode(), mdi\-Mode\-Has\-Been\-Changed\-To(), KMdi\-Child\-View::show(), and QPtr\-List\-Iterator::to\-First().

Referenced by attach\-Window(), and fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!switchToTabPageMode@{switchToTabPageMode}}
\index{switchToTabPageMode@{switchToTabPageMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::switch\-To\-Tab\-Page\-Mode ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i22}


Docks all view windows (Windows-like). 



Definition at line 1605 of file kmdimainfrm.cpp.

References close\-View\-Button\-Pressed(), QObject::connect(), QPtr\-List::count(), mdi\-Mode\-Has\-Been\-Changed\-To(), QWidget::set\-Focus(), and KMdi\-Task\-Bar::switch\-On().

Referenced by fill\-Window\-Menu(), and set\-Toolview\-Style().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!switchToIDEAlMode@{switchToIDEAlMode}}
\index{switchToIDEAlMode@{switchToIDEAlMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::switch\-To\-IDEAl\-Mode ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i24}


Docks all view windows. 

Toolviews use dockcontainers

Definition at line 1826 of file kmdimainfrm.cpp.

References close\-View\-Button\-Pressed(), QObject::connect(), QPtr\-List::count(), mdi\-Mode\-Has\-Been\-Changed\-To(), QWidget::set\-Focus(), and KMdi\-Task\-Bar::switch\-On().

Referenced by fill\-Window\-Menu(), and set\-Toolview\-Style().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setIDEAlModeStyle@{setIDEAlModeStyle}}
\index{setIDEAlModeStyle@{setIDEAlModeStyle}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-IDEAl\-Mode\-Style (int {\em flags})\hspace{0.3cm}{\tt  [slot]}}\label{classKMdiMainFrm_i26}


Sets the appearance of the IDEAl mode. 

See KMulti\-Tab\-Bar styles for the first 3 bits. 

\begin{Desc}
\item[{\bf Deprecated}]use {\bf set\-Toolview\-Style(int flags)}{\rm (p.\,\pageref{classKMdiMainFrm_i27})} instead \end{Desc}


Definition at line 1741 of file kmdimainfrm.cpp.

Referenced by set\-Toolview\-Style().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setToolviewStyle@{setToolviewStyle}}
\index{setToolviewStyle@{setToolviewStyle}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Toolview\-Style (int {\em flags})\hspace{0.3cm}{\tt  [slot]}}\label{classKMdiMainFrm_i27}


Sets the appearance of the toolview tabs. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em flags}]See {\bf KMdi::Toolview\-Style}{\rm (p.\,\pageref{namespaceKMdi_a33})}. \end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.3\end{Desc}


Definition at line 1773 of file kmdimainfrm.cpp.

References QMap::begin(), QMap::end(), set\-IDEAl\-Mode\-Style(), switch\-To\-IDEAl\-Mode(), and switch\-To\-Tab\-Page\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!isViewTaskBarOn@{isViewTaskBarOn}}
\index{isViewTaskBarOn@{isViewTaskBarOn}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Main\-Frm::is\-View\-Task\-Bar\-On ()\hspace{0.3cm}{\tt  [slot]}}\label{classKMdiMainFrm_i28}


Shows the view taskbar. 

\begin{Desc}
\item[Returns:]if the view taskbar should be shown if there are MDI views\end{Desc}


Definition at line 2538 of file kmdimainfrm.cpp.

References KMdi\-Task\-Bar::is\-Switched\-On().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!showViewTaskBar@{showViewTaskBar}}
\index{showViewTaskBar@{showViewTaskBar}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::show\-View\-Task\-Bar ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i29}


Shows the view taskbar. 

This should be connected with your \char`\"{}View\char`\"{} menu.

Definition at line 2547 of file kmdimainfrm.cpp.

References KMdi\-Task\-Bar::switch\-On().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!hideViewTaskBar@{hideViewTaskBar}}
\index{hideViewTaskBar@{hideViewTaskBar}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::hide\-View\-Task\-Bar ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i30}


Hides the view taskbar. 

This should be connected with your \char`\"{}View\char`\"{} menu.

Definition at line 2554 of file kmdimainfrm.cpp.

References KMdi\-Task\-Bar::switch\-On().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!fillWindowMenu@{fillWindowMenu}}
\index{fillWindowMenu@{fillWindowMenu}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::fill\-Window\-Menu ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i31}


Update of the window menu contents. 



Definition at line 2561 of file kmdimainfrm.cpp.

References QValue\-List::begin(), KMdi\-Child\-View::caption(), cascade\-Maximized(), cascade\-Windows(), QPopup\-Menu::clear(), close\-All\-Views(), QPtr\-List\-Iterator::current(), expand\-Horizontal(), expand\-Vertical(), KMdi\-Child\-View::get\-Time\-Stamp(), iconify\-All\-Views(), QPopup\-Menu::id\-At(), QValue\-List::insert(), QPopup\-Menu::insert\-Item(), QPopup\-Menu::insert\-Separator(), KMdi\-Child\-View::is\-Attached(), QPtr\-List::is\-Empty(), KMdi\-Child\-View::is\-Minimized(), KMdi\-Child\-View::is\-Tool\-View(), QPopup\-Menu::set\-Item\-Checked(), QPopup\-Menu::set\-Item\-Enabled(), KMdi\-Child\-View::set\-Window\-Menu\-ID(), switch\-To\-Childframe\-Mode(), switch\-To\-IDEAl\-Mode(), switch\-To\-Tab\-Page\-Mode(), switch\-To\-Toplevel\-Mode(), tile\-Anodine(), tile\-Pragma(), and tile\-Vertically().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!cascadeWindows@{cascadeWindows}}
\index{cascadeWindows@{cascadeWindows}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::cascade\-Windows ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i32}


Cascades the windows without resizing them. 



Definition at line 666 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!cascadeMaximized@{cascadeMaximized}}
\index{cascadeMaximized@{cascadeMaximized}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::cascade\-Maximized ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i33}


Cascades the windows resizing them to the maximum available size. 



Definition at line 671 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!expandVertical@{expandVertical}}
\index{expandVertical@{expandVertical}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::expand\-Vertical ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i34}


Maximizes only in vertical direction. 



Definition at line 676 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!expandHorizontal@{expandHorizontal}}
\index{expandHorizontal@{expandHorizontal}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::expand\-Horizontal ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i35}


Maximizes only in horizontal direction. 



Definition at line 681 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!tilePragma@{tilePragma}}
\index{tilePragma@{tilePragma}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::tile\-Pragma ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i36}


Tile Pragma. 



Definition at line 686 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!tileAnodine@{tileAnodine}}
\index{tileAnodine@{tileAnodine}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::tile\-Anodine ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i37}


Tile Anodine. 



Definition at line 691 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!tileVertically@{tileVertically}}
\index{tileVertically@{tileVertically}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KMdi\-Main\-Frm::tile\-Vertically ()\hspace{0.3cm}{\tt  [inline, virtual, slot]}}\label{classKMdiMainFrm_i38}


Tile Vertically. 



Definition at line 696 of file kmdimainfrm.h.

Referenced by fill\-Window\-Menu().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setFrameDecorOfAttachedViews@{setFrameDecorOfAttachedViews}}
\index{setFrameDecorOfAttachedViews@{setFrameDecorOfAttachedViews}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Frame\-Decor\-Of\-Attached\-Views (int {\em frame\-Decor})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i39}


Sets the decoration of the window frame of docked (attached) MDI views. 

\begin{Desc}
\item[{\bf Deprecated}]Will be removed in KDE 4 \end{Desc}


Definition at line 2805 of file kmdimainfrm.cpp.

References QPtr\-List\-Iterator::current(), KMdi\-Child\-View::is\-Attached(), KMdi\-Child\-View::is\-Tool\-View(), KMdi\-Child\-View::mdi\-Parent(), KMdi\-Child\-Frm::redecorate\-Buttons(), and set\-Menu\-For\-SDIMode\-Sys\-Buttons().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setEnableMaximizedChildFrmMode@{setEnableMaximizedChildFrmMode}}
\index{setEnableMaximizedChildFrmMode@{setEnableMaximizedChildFrmMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Enable\-Maximized\-Child\-Frm\-Mode (bool {\em enable\-Max\-Child\-Frame\-Mode})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i40}


If in Childframe mode, we can switch between maximized or restored shown MDI views. 



Definition at line 2426 of file kmdimainfrm.cpp.

References QObject::connect(), frame\-Decor\-Of\-Attached\-Views(), KMdi\-Child\-Frm::icon(), KMdi\-Child\-Frm::m\_\-p\-Client, KMdi\-Child\-View::restore(), KMdi\-Child\-Frm::state(), switch\-Off\-Maximize\-Mode\-For\-Menu(), KMdi\-Child\-Frm::system\-Menu(), and KMdi\-Child\-Area::top\-Child().

Referenced by create\-Mdi\-Manager().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activateNextWin@{activateNextWin}}
\index{activateNextWin@{activateNextWin}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::activate\-Next\-Win ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i41}


Activates the next open view. 



Definition at line 2302 of file kmdimainfrm.cpp.

References activate\-View(), active\-Window(), and create\-Iterator().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activatePrevWin@{activatePrevWin}}
\index{activatePrevWin@{activatePrevWin}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::activate\-Prev\-Win ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i42}


Activates the previous open view. 



Definition at line 2326 of file kmdimainfrm.cpp.

References activate\-View(), active\-Window(), and create\-Iterator().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activateFirstWin@{activateFirstWin}}
\index{activateFirstWin@{activateFirstWin}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::activate\-First\-Win ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i43}


Activates the view first viewed concerning to the access time. 



Definition at line 2350 of file kmdimainfrm.cpp.

References activate\-View(), active\-Window(), QMap::begin(), create\-Iterator(), QMap::end(), QMap::find(), KMdi\-Child\-View::get\-Time\-Stamp(), and QMap::insert().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activateLastWin@{activateLastWin}}
\index{activateLastWin@{activateLastWin}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::activate\-Last\-Win ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i44}


Activates the view last viewed concerning to the access time. 



Definition at line 2383 of file kmdimainfrm.cpp.

References activate\-View(), active\-Window(), QMap::begin(), create\-Iterator(), QMap::end(), QMap::find(), KMdi\-Child\-View::get\-Time\-Stamp(), and QMap::insert().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activateView@{activateView}}
\index{activateView@{activateView}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::activate\-View (int {\em index})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiMainFrm_i45}


Activates the view with the tab page index (Tab\-Page mode only). 



Definition at line 2412 of file kmdimainfrm.cpp.

References KMdi\-Child\-View::activate(), QPtr\-List::first(), and QPtr\-List::next().

Referenced by activate\-First\-Win(), activate\-Last\-Win(), activate\-Next\-Win(), activate\-Prev\-Win(), add\-Window(), detach\-Window(), remove\-Window\-From\-Mdi(), taskbar\-Button\-Right\-Clicked(), and window\-Menu\-Item\-Activated().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!createTaskBar@{createTaskBar}}
\index{createTaskBar@{createTaskBar}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::create\-Task\-Bar ()\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiMainFrm_b1}


Creates a new MDI taskbar (showing the MDI views as taskbar entries) and shows it. 



Definition at line 383 of file kmdimainfrm.cpp.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!createMdiManager@{createMdiManager}}
\index{createMdiManager@{createMdiManager}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::create\-Mdi\-Manager ()\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiMainFrm_b2}


Creates the MDI view area and connects some signals and slots with the KMdi\-Main\-Frm widget. 



Definition at line 365 of file kmdimainfrm.cpp.

References QObject::connect(), last\-Child\-Frm\-Closed(), popup\-Window\-Menu(), set\-Enable\-Maximized\-Child\-Frm\-Mode(), switch\-Off\-Maximize\-Mode\-For\-Menu(), and update\-Sys\-Button\-Connections().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!blockClearingOfWindowMenu@{blockClearingOfWindowMenu}}
\index{blockClearingOfWindowMenu@{blockClearingOfWindowMenu}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::block\-Clearing\-Of\-Window\-Menu (bool {\em b\-Blocked})\hspace{0.3cm}{\tt  [inline, protected]}}\label{classKMdiMainFrm_b3}


prevents {\bf fill\-Window\-Menu()}{\rm (p.\,\pageref{classKMdiMainFrm_i31})} from m\_\-p\-Window\-Menu-$>$clear(). 

You have to care for it by yourself. This is useful if you want to add some actions in your overridden {\bf fill\-Window\-Menu()}{\rm (p.\,\pageref{classKMdiMainFrm_i31})} method.

Definition at line 757 of file kmdimainfrm.h.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!tabWidgetVisibility@{tabWidgetVisibility}}
\index{tabWidgetVisibility@{tabWidgetVisibility}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi::Tab\-Widget\-Visibility KMdi\-Main\-Frm::tab\-Widget\-Visibility ()\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiMainFrm_b8}


Get tabwidget visibility. 



Definition at line 2919 of file kmdimainfrm.cpp.

References KMdi\-Document\-View\-Tab\-Widget::tab\-Widget\-Visibility().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!setTabWidgetVisibility@{setTabWidgetVisibility}}
\index{setTabWidgetVisibility@{setTabWidgetVisibility}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::set\-Tab\-Widget\-Visibility (KMdi::Tab\-Widget\-Visibility)\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiMainFrm_b9}


Set tabwidget visibility. 



Definition at line 2927 of file kmdimainfrm.cpp.

References KMdi\-Document\-View\-Tab\-Widget::set\-Tab\-Widget\-Visibility().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!tabWidget@{tabWidget}}
\index{tabWidget@{tabWidget}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KTab\-Widget $\ast$ KMdi\-Main\-Frm::tab\-Widget () const\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiMainFrm_b10}


Returns the tabwidget used in IDEAl and Tabbed modes. 

Returns 0 in other modes. 

Definition at line 2933 of file kmdimainfrm.cpp.\index{KMdiMainFrm@{KMdi\-Main\-Frm}!activateView@{activateView}}
\index{activateView@{activateView}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::activate\-View ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd})\hspace{0.3cm}{\tt  [protected, virtual, slot]}}\label{classKMdiMainFrm_j0}


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). 



Definition at line 1060 of file kmdimainfrm.cpp.

References collapse\-Overlap\-Containers(), KMdi\-Child\-View::m\_\-b\-Interrupt\-Activation, KMdi\-Child\-View::m\_\-b\-Mainframes\-Activate\-View\-Is\-Pending, KMdi\-Task\-Bar::set\-Active\-Button(), KMdi\-Child\-Area::set\-Top\-Child(), and KMdi\-Child\-Area::top\-Child().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!taskbarButtonRightClicked@{taskbarButtonRightClicked}}
\index{taskbarButtonRightClicked@{taskbarButtonRightClicked}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::taskbar\-Button\-Right\-Clicked ({\bf KMdi\-Child\-View} $\ast$ {\em p\-Wnd})\hspace{0.3cm}{\tt  [protected, virtual, slot]}}\label{classKMdiMainFrm_j1}


Activates the MDI view (see {\bf activate\-View()}{\rm (p.\,\pageref{classKMdiMainFrm_i45})} ) and popups the task\-Bar popup menu (see {\bf task\-Bar\-Popup()}{\rm (p.\,\pageref{classKMdiMainFrm_a7})} ). 



Definition at line 1110 of file kmdimainfrm.cpp.

References activate\-View(), QPopup\-Menu::popup(), and task\-Bar\-Popup().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!switchOffMaximizeModeForMenu@{switchOffMaximizeModeForMenu}}
\index{switchOffMaximizeModeForMenu@{switchOffMaximizeModeForMenu}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::switch\-Off\-Maximize\-Mode\-For\-Menu ({\bf KMdi\-Child\-Frm} $\ast$ {\em old\-Child})\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j2}


Turns the system buttons for maximize mode (SDI mode) off, and disconnects them. 



Definition at line 2480 of file kmdimainfrm.cpp.

References QObject::disconnect().

Referenced by create\-Mdi\-Manager(), and set\-Enable\-Maximized\-Child\-Frm\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!updateSysButtonConnections@{updateSysButtonConnections}}
\index{updateSysButtonConnections@{updateSysButtonConnections}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::update\-Sys\-Button\-Connections ({\bf KMdi\-Child\-Frm} $\ast$ {\em old\-Child}, {\bf KMdi\-Child\-Frm} $\ast$ {\em new\-Child})\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j3}


Reconnects the system buttons form maximize mode (SDI mode) with the new child frame. 



Definition at line 2503 of file kmdimainfrm.cpp.

References QObject::connect(), QObject::disconnect(), and frame\-Decor\-Of\-Attached\-Views().

Referenced by create\-Mdi\-Manager().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!windowMenuItemActivated@{windowMenuItemActivated}}
\index{windowMenuItemActivated@{windowMenuItemActivated}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::window\-Menu\-Item\-Activated (int {\em id})\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j4}


Usually called when the user clicks an MDI view item in the \char`\"{}Window\char`\"{} menu. 



Definition at line 2735 of file kmdimainfrm.cpp.

References activate\-View(), QPtr\-List::at(), KMdi\-Child\-View::is\-Attached(), KMdi\-Child\-View::is\-Minimized(), KMdi\-Child\-Frm::m\_\-p\-Client, KMdi\-Child\-View::minimize(), and KMdi\-Child\-Area::top\-Child().

Referenced by add\-Window(), and remove\-Window\-From\-Mdi().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!dockMenuItemActivated@{dockMenuItemActivated}}
\index{dockMenuItemActivated@{dockMenuItemActivated}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::dock\-Menu\-Item\-Activated (int {\em id})\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j5}


Usually called when the user clicks an MDI view item in the sub-popup menu \char`\"{}Docking\char`\"{} of the \char`\"{}Window\char`\"{} menu. 



Definition at line 2761 of file kmdimainfrm.cpp.

References QPtr\-List::at(), attach\-Window(), detach\-Window(), KMdi\-Child\-View::is\-Attached(), KMdi\-Child\-View::is\-Minimized(), and KMdi\-Child\-View::minimize().

Referenced by add\-Window(), and remove\-Window\-From\-Mdi().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!popupWindowMenu@{popupWindowMenu}}
\index{popupWindowMenu@{popupWindowMenu}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::popup\-Window\-Menu ({\bf QPoint} {\em p})\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j6}


Popups the \char`\"{}Window\char`\"{} menu. 

See also {\bf window\-Popup()}{\rm (p.\,\pageref{classKMdiMainFrm_a8})} .

Definition at line 2783 of file kmdimainfrm.cpp.

References is\-Faking\-SDIApplication(), and QPopup\-Menu::popup().

Referenced by create\-Mdi\-Manager().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!dragEndTimeOut@{dragEndTimeOut}}
\index{dragEndTimeOut@{dragEndTimeOut}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::drag\-End\-Time\-Out ()\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j7}


The timer for main widget moving has elapsed -$>$ send drag end to all concerned views. 



Definition at line 2792 of file kmdimainfrm.cpp.

References QPtr\-List::current(), QPtr\-List::first(), QPtr\-List::next(), and QApplication::send\-Event().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!closeViewButtonPressed@{closeViewButtonPressed}}
\index{closeViewButtonPressed@{closeViewButtonPressed}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::close\-View\-Button\-Pressed ()\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKMdiMainFrm_j8}


internally used to handle click on view close button (Tab\-Page mode, only) 



Definition at line 2845 of file kmdimainfrm.cpp.

References active\-Window(), and QWidget::close().

Referenced by switch\-To\-IDEAl\-Mode(), and switch\-To\-Tab\-Page\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!lastChildFrmClosed@{lastChildFrmClosed}}
\index{lastChildFrmClosed@{lastChildFrmClosed}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::last\-Child\-Frm\-Closed ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiMainFrm_l0}


Signals the last attached {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} has been closed. 



Referenced by create\-Mdi\-Manager().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!lastChildViewClosed@{lastChildViewClosed}}
\index{lastChildViewClosed@{lastChildViewClosed}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::last\-Child\-View\-Closed ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiMainFrm_l1}


Signals the last {\bf KMdi\-Child\-View}{\rm (p.\,\pageref{classKMdiChildView})} (that is under MDI control) has been closed. 



Referenced by close\-Window(), and remove\-Window\-From\-Mdi().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!leftTopLevelMode@{leftTopLevelMode}}
\index{leftTopLevelMode@{leftTopLevelMode}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::left\-Top\-Level\-Mode ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiMainFrm_l2}


Signals that the Toplevel mode has been left. 



Referenced by switch\-To\-Childframe\-Mode().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!childViewIsDetachedNow@{childViewIsDetachedNow}}
\index{childViewIsDetachedNow@{childViewIsDetachedNow}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::child\-View\-Is\-Detached\-Now ({\bf QWidget} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiMainFrm_l3}


Signals that a child view has been detached (undocked to desktop). 



Referenced by add\-Window(), and detach\-Window().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!collapseOverlapContainers@{collapseOverlapContainers}}
\index{collapseOverlapContainers@{collapseOverlapContainers}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::collapse\-Overlap\-Containers ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiMainFrm_l4}


Signals we need to collapse the overlapped containers. 



Referenced by activate\-View().\index{KMdiMainFrm@{KMdi\-Main\-Frm}!mdiModeHasBeenChangedTo@{mdiModeHasBeenChangedTo}}
\index{mdiModeHasBeenChangedTo@{mdiModeHasBeenChangedTo}!KMdiMainFrm@{KMdi\-Main\-Frm}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Main\-Frm::mdi\-Mode\-Has\-Been\-Changed\-To (KMdi::Mdi\-Mode)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiMainFrm_l5}


Signals the MDI mode has been changed. 



Referenced by set\-Standard\-MDIMenu\-Enabled(), switch\-To\-Childframe\-Mode(), switch\-To\-IDEAl\-Mode(), switch\-To\-Tab\-Page\-Mode(), and switch\-To\-Toplevel\-Mode().

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
kmdimainfrm.h\item 
kmdimainfrm.cpp\end{CompactItemize}
