\section{KMdi\-Child\-View Class Reference}
\label{classKMdiChildView}\index{KMdiChildView@{KMdiChildView}}
Base class for all your special view windows.  


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

Inheritance diagram for KMdi\-Child\-View:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=59pt]{classKMdiChildView__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for KMdi\-Child\-View:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=202pt]{classKMdiChildView__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Slots}
\begin{CompactItemize}
\item 
virtual void {\bf attach} ()
\item 
virtual void {\bf detach} ()
\item 
virtual void {\bf minimize} ()
\item 
virtual void {\bf maximize} ()
\item 
virtual void {\bf restore} ()
\item 
virtual void {\bf you\-Are\-Attached} ({\bf KMdi\-Child\-Frm} $\ast$lp\-C)
\item 
virtual void {\bf you\-Are\-Detached} ()
\item 
virtual void {\bf slot\_\-clicked\-In\-Window\-Menu} ()
\item 
virtual void {\bf slot\_\-clicked\-In\-Dock\-Menu} ()
\item 
virtual void {\bf show} ()
\item 
virtual void {\bf hide} ()
\item 
virtual void {\bf raise} ()
\item 
virtual void {\bf show\-Minimized} ()
\item 
virtual void {\bf show\-Maximized} ()
\item 
virtual void {\bf show\-Normal} ()
\end{CompactItemize}
\subsection*{Signals}
\begin{CompactItemize}
\item 
void {\bf attach\-Window} ({\bf KMdi\-Child\-View} $\ast$, bool)
\item 
void {\bf detach\-Window} ({\bf KMdi\-Child\-View} $\ast$, bool)
\item 
void {\bf focus\-In\-Event\-Occurs} ({\bf KMdi\-Child\-View} $\ast$)
\item 
void {\bf got\-Focus} ({\bf KMdi\-Child\-View} $\ast$)
\item 
void {\bf activated} ({\bf KMdi\-Child\-View} $\ast$)
\item 
void {\bf lost\-Focus} ({\bf KMdi\-Child\-View} $\ast$)
\item 
void {\bf deactivated} ({\bf KMdi\-Child\-View} $\ast$)
\item 
void {\bf child\-Window\-Close\-Request} ({\bf KMdi\-Child\-View} $\ast$)
\item 
void {\bf window\-Caption\-Changed} (const {\bf QString} \&)
\item 
void {\bf tab\-Caption\-Changed} (const {\bf QString} \&)
\item 
void {\bf mdi\-Parent\-Now\-Maximized} (bool)
\item 
void {\bf clicked\-In\-Window\-Menu} (int)
\item 
void {\bf clicked\-In\-Dock\-Menu} (int)
\item 
void {\bf is\-Maximized\-Now} ()
\item 
void {\bf is\-Minimized\-Now} ()
\item 
void {\bf is\-Restored\-Now} ()
\item 
void {\bf is\-Attached\-Now} ()
\item 
void {\bf is\-Detached\-Now} ()
\item 
void {\bf icon\-Updated} ({\bf QWidget} $\ast$, {\bf QPixmap})\label{classKMdiChildView_l18}

\item 
void {\bf caption\-Updated} ({\bf QWidget} $\ast$, const {\bf QString} \&)\label{classKMdiChildView_l19}

\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KMdi\-Child\-View} (const {\bf QString} \&caption, {\bf QWidget} $\ast${\bf parent\-Widget}=0L, const char $\ast$name=0L, WFlags f=0)
\item 
{\bf KMdi\-Child\-View} ({\bf QWidget} $\ast${\bf parent\-Widget}=0L, const char $\ast$name=0L, WFlags f=0)
\item 
{\bf $\sim$KMdi\-Child\-View} ()
\item 
void {\bf activate} ()
\item 
void {\bf set\-First\-Focusable\-Child\-Widget} ({\bf QWidget} $\ast$)
\item 
void {\bf set\-Last\-Focusable\-Child\-Widget} ({\bf QWidget} $\ast$)
\item 
{\bf QWidget} $\ast$ {\bf focused\-Child\-Widget} ()
\item 
bool {\bf is\-Attached} () const 
\item 
const {\bf QString} \& {\bf caption} () const 
\item 
const {\bf QString} \& {\bf tab\-Caption} () const 
\item 
virtual void {\bf set\-Caption} (const {\bf QString} \&sz\-Caption)
\item 
virtual void {\bf set\-Tab\-Caption} (const {\bf QString} \&caption)
\item 
virtual void {\bf set\-MDICaption} (const {\bf QString} \&caption)
\item 
{\bf KMdi\-Child\-Frm} $\ast$ {\bf mdi\-Parent} () const 
\item 
bool {\bf is\-Minimized} () const 
\item 
bool {\bf is\-Maximized} () const 
\item 
{\bf QRect} {\bf internal\-Geometry} () const 
\item 
void {\bf set\-Internal\-Geometry} (const {\bf QRect} \&new\-Geomety)
\item 
{\bf QRect} {\bf external\-Geometry} () const 
\item 
void {\bf set\-External\-Geometry} (const {\bf QRect} \&new\-Geomety)
\item 
virtual {\bf QPixmap} $\ast$ {\bf my\-Icon\-Ptr} ()
\item 
virtual void {\bf minimize} (bool b\-Animate)
\item 
virtual void {\bf maximize} (bool b\-Animate)
\item 
{\bf QRect} {\bf restore\-Geometry} ()
\item 
void {\bf set\-Restore\-Geometry} (const {\bf QRect} \&new\-Rest\-Geo)
\item 
void {\bf remove\-Event\-Filter\-For\-All\-Children} ()
\item 
void {\bf set\-Window\-Menu\-ID} (int id)
\item 
virtual void {\bf set\-Minimum\-Size} (int minw, int minh)
\item 
virtual void {\bf set\-Maximum\-Size} (int maxw, int maxh)
\item 
bool {\bf is\-Tool\-View} () const 
\item 
void {\bf update\-Time\-Stamp} ()
\item 
const {\bf QDate\-Time} \& {\bf get\-Time\-Stamp} () const 
\end{CompactItemize}
\subsection*{Protected Slots}
\begin{CompactItemize}
\item 
void {\bf slot\_\-child\-Destroyed} ()\label{classKMdiChildView_j0}

\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf close\-Event} ({\bf QClose\-Event} $\ast$e)
\item 
virtual bool {\bf event\-Filter} ({\bf QObject} $\ast$obj, {\bf QEvent} $\ast$e)
\item 
virtual void {\bf focus\-In\-Event} ({\bf QFocus\-Event} $\ast$e)
\item 
virtual void {\bf focus\-Out\-Event} ({\bf QFocus\-Event} $\ast$e)
\item 
virtual void {\bf resize\-Event} ({\bf QResize\-Event} $\ast$e)
\item 
void {\bf track\-Icon\-And\-Caption\-Changes} ({\bf QWidget} $\ast$view)\label{classKMdiChildView_b5}

\end{CompactItemize}
\subsection*{Protected Attributes}
\begin{CompactItemize}
\item 
{\bf QString} {\bf m\_\-sz\-Caption}
\item 
{\bf QString} {\bf m\_\-s\-Tab\-Caption}
\item 
{\bf QWidget} $\ast$ {\bf m\_\-focused\-Child\-Widget}
\item 
{\bf QWidget} $\ast$ {\bf m\_\-first\-Focusable\-Child\-Widget}
\item 
{\bf QWidget} $\ast$ {\bf m\_\-last\-Focusable\-Child\-Widget}
\item 
int {\bf m\_\-window\-Menu\-ID}
\item 
bool {\bf m\_\-state\-Changed}
\item 
{\bf QDate\-Time} {\bf m\_\-time}
\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf KMdi\-Main\-Frm}\label{classKMdiChildView_n0}

\item 
class {\bf KMdi\-Child\-Frm}\label{classKMdiChildView_n1}

\end{CompactItemize}


\subsection{Detailed Description}
Base class for all your special view windows. 

Base class for all MDI view widgets. {\bf KMdi}{\rm (p.\,\pageref{namespaceKMdi})} stores additional information in this class to handle the attach/detach mechanism and such things.

All such windows 'lives' attached to a {\bf KMdi\-Child\-Frm}{\rm (p.\,\pageref{classKMdiChildFrm})} widget managed by {\bf KMdi\-Child\-Area}{\rm (p.\,\pageref{classKMdiChildArea})}, or detached (managed by the window manager.) So remember that the KMdi\-Child\-View::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 KMdi\-Child\-View: 

\footnotesize\begin{verbatim}   class MyMdiWidget : public KMdiChildView
   { .... };
   ...
   MyMdiWidget w;
   mainframe->addWindow(w, flags);
\end{verbatim}
\normalsize


or you wrap them by a KMdi\-Child\-View somehow like this:



\footnotesize\begin{verbatim} void DocViewMan::addKMdiFrame(QWidget* pNewView, bool bShow, const QPixmap& icon)
 {
   // cover it by a KMdi childview and add that MDI system
   KMdiChildView* pMDICover = new KMdiChildView( pNewView->caption());
   pMDICover->setIcon(icon);
   m_MDICoverList.append( pMDICover);
   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 = KMdi::StandardAdd;
   }
   else {
     flags = KMdi::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 KMdi ('cause we haven't a tab order for subwidget focuses)
   pMDICover->setFirstFocusableChildWidget(0L);
   pMDICover->setLastFocusableChildWidget(0L);
 }
\end{verbatim}
\normalsize
 



Definition at line 108 of file kmdichildview.h.

\subsection{Constructor \& Destructor Documentation}
\index{KMdiChildView@{KMdi\-Child\-View}!KMdiChildView@{KMdiChildView}}
\index{KMdiChildView@{KMdiChildView}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi\-Child\-View::KMdi\-Child\-View (const {\bf QString} \& {\em caption}, {\bf QWidget} $\ast$ {\em parent\-Widget} = {\tt 0L}, const char $\ast$ {\em name} = {\tt 0L}, WFlags {\em f} = {\tt 0})}\label{classKMdiChildView_a0}


Constructor. 



Definition at line 47 of file kmdichildview.cpp.

References caption(), m\_\-s\-Tab\-Caption, m\_\-sz\-Caption, QWidget::set\-Focus\-Policy(), QWidget::set\-Geometry(), and update\-Time\-Stamp().\index{KMdiChildView@{KMdi\-Child\-View}!KMdiChildView@{KMdiChildView}}
\index{KMdiChildView@{KMdiChildView}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi\-Child\-View::KMdi\-Child\-View ({\bf QWidget} $\ast$ {\em parent\-Widget} = {\tt 0L}, const char $\ast$ {\em name} = {\tt 0L}, WFlags {\em f} = {\tt 0})}\label{classKMdiChildView_a1}


Constructor sets \char`\"{}Unnamed\char`\"{} as default caption. 



Definition at line 76 of file kmdichildview.cpp.

References m\_\-s\-Tab\-Caption, m\_\-sz\-Caption, QWidget::set\-Focus\-Policy(), QWidget::set\-Geometry(), and update\-Time\-Stamp().\index{KMdiChildView@{KMdi\-Child\-View}!~KMdiChildView@{$\sim$KMdiChildView}}
\index{~KMdiChildView@{$\sim$KMdiChildView}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KMdi\-Child\-View::$\sim${\bf KMdi\-Child\-View} ()}\label{classKMdiChildView_a2}


Destructor. 



Definition at line 100 of file kmdichildview.cpp.

\subsection{Member Function Documentation}
\index{KMdiChildView@{KMdi\-Child\-View}!activate@{activate}}
\index{activate@{activate}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::activate ()}\label{classKMdiChildView_a3}


This method does the same as {\bf focus\-In\-Event()}{\rm (p.\,\pageref{classKMdiChildView_b2})}. 

That's why it is a replacement for the {\bf set\-Focus()} 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. {\bf focus\-In\-Event()}{\rm (p.\,\pageref{classKMdiChildView_b2})} will never get called in that case and your {\bf set\-Focus()} 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!

Definition at line 420 of file kmdichildview.cpp.

References activated(), focus\-In\-Event\-Occurs(), m\_\-first\-Focusable\-Child\-Widget, m\_\-focused\-Child\-Widget, and QWidget::set\-Focus().

Referenced by KMdi\-Main\-Frm::activate\-View(), KMdi\-Main\-Frm::close\-Window(), event\-Filter(), focus\-In\-Event(), KMdi\-Child\-Area::focus\-Top\-Child(), KMdi\-Main\-Frm::remove\-Window\-From\-Mdi(), KMdi\-Child\-Area::tile\-All\-Internal(), KMdi\-Child\-Area::tile\-Anodine(), and KMdi\-Child\-Area::tile\-Vertically().\index{KMdiChildView@{KMdi\-Child\-View}!setFirstFocusableChildWidget@{setFirstFocusableChildWidget}}
\index{setFirstFocusableChildWidget@{setFirstFocusableChildWidget}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-First\-Focusable\-Child\-Widget ({\bf QWidget} $\ast$)}\label{classKMdiChildView_a4}


Memorizes the first focusable child widget of this widget. 



Definition at line 667 of file kmdichildview.cpp.

References m\_\-first\-Focusable\-Child\-Widget.

Referenced by KMdi\-Child\-Frm::unset\-Client().\index{KMdiChildView@{KMdi\-Child\-View}!setLastFocusableChildWidget@{setLastFocusableChildWidget}}
\index{setLastFocusableChildWidget@{setLastFocusableChildWidget}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Last\-Focusable\-Child\-Widget ({\bf QWidget} $\ast$)}\label{classKMdiChildView_a5}


Memorizes the last focusable child widget of this widget. 



Definition at line 672 of file kmdichildview.cpp.

References m\_\-last\-Focusable\-Child\-Widget.

Referenced by KMdi\-Child\-Frm::unset\-Client().\index{KMdiChildView@{KMdi\-Child\-View}!focusedChildWidget@{focusedChildWidget}}
\index{focusedChildWidget@{focusedChildWidget}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QWidget} $\ast$ KMdi\-Child\-View::focused\-Child\-Widget ()}\label{classKMdiChildView_a6}


Returns the current focused child widget of this widget. 



Definition at line 662 of file kmdichildview.cpp.

References m\_\-focused\-Child\-Widget.

Referenced by KMdi\-Child\-Frm::unset\-Client().\index{KMdiChildView@{KMdi\-Child\-View}!isAttached@{isAttached}}
\index{isAttached@{isAttached}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Child\-View::is\-Attached () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a7}


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. 



Definition at line 227 of file kmdichildview.h.

Referenced by KMdi\-Main\-Frm::dock\-Menu\-Item\-Activated(), KMdi\-Main\-Frm::event\-Filter(), event\-Filter(), KMdi\-Main\-Frm::fill\-Window\-Menu(), KMdi\-Main\-Frm::set\-Frame\-Decor\-Of\-Attached\-Views(), KMdi\-Main\-Frm::switch\-To\-Childframe\-Mode(), and KMdi\-Main\-Frm::window\-Menu\-Item\-Activated().\index{KMdiChildView@{KMdi\-Child\-View}!caption@{caption}}
\index{caption@{caption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const {\bf QString}\& KMdi\-Child\-View::caption () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a8}


Returns the caption of the child window (different from the caption on the button in the taskbar). 



Reimplemented from {\bf QWidget}.

Definition at line 232 of file kmdichildview.h.

Referenced by event\-Filter(), KMdi\-Main\-Frm::fill\-Window\-Menu(), KMdi\-Child\-View(), and set\-MDICaption().\index{KMdiChildView@{KMdi\-Child\-View}!tabCaption@{tabCaption}}
\index{tabCaption@{tabCaption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const {\bf QString}\& KMdi\-Child\-View::tab\-Caption () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a9}


Returns the caption of the button on the taskbar. 



Definition at line 237 of file kmdichildview.h.\index{KMdiChildView@{KMdi\-Child\-View}!setCaption@{setCaption}}
\index{setCaption@{setCaption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Caption (const {\bf QString} \& {\em sz\-Caption})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a10}


Sets the window caption string... 

Calls update\-Button on the taskbar button if it has been set.

Reimplemented from {\bf QWidget}.

Definition at line 373 of file kmdichildview.cpp.

References m\_\-sz\-Caption, mdi\-Parent(), QWidget::set\-Caption(), KMdi\-Child\-Frm::set\-Caption(), and window\-Caption\-Changed().

Referenced by KMdi\-Main\-Frm::create\-Wrapper(), set\-MDICaption(), and you\-Are\-Detached().\index{KMdiChildView@{KMdi\-Child\-View}!setTabCaption@{setTabCaption}}
\index{setTabCaption@{setTabCaption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Tab\-Caption (const {\bf QString} \& {\em stb\-Caption})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a11}


Sets the caption of the button referring to this window. 



Definition at line 678 of file kmdichildview.cpp.

References m\_\-s\-Tab\-Caption, and tab\-Caption\-Changed().

Referenced by KMdi\-Main\-Frm::create\-Wrapper(), set\-MDICaption(), and you\-Are\-Detached().\index{KMdiChildView@{KMdi\-Child\-View}!setMDICaption@{setMDICaption}}
\index{setMDICaption@{setMDICaption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-MDICaption (const {\bf QString} \& {\em caption})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a12}


Sets the caption of both the window and the button on the taskbar. 



Definition at line 684 of file kmdichildview.cpp.

References caption(), set\-Caption(), and set\-Tab\-Caption().\index{KMdiChildView@{KMdi\-Child\-View}!mdiParent@{mdiParent}}
\index{mdiParent@{mdiParent}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KMdi\-Child\-Frm} $\ast$ KMdi\-Child\-View::mdi\-Parent () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a13}


Returns the {\bf KMdi\-Child\-Frm}{\rm (p.\,\pageref{classKMdiChildFrm})} parent widget (or 0 if the window is not attached). 



Definition at line 604 of file kmdichildview.h.

References QWidget::parent\-Widget().

Referenced by KMdi\-Main\-Frm::detach\-Window(), external\-Geometry(), hide(), internal\-Geometry(), is\-Maximized(), is\-Minimized(), maximize(), minimize(), raise(), restore(), restore\-Geometry(), set\-Caption(), set\-External\-Geometry(), KMdi\-Main\-Frm::set\-Frame\-Decor\-Of\-Attached\-Views(), set\-Internal\-Geometry(), set\-Maximum\-Size(), set\-Minimum\-Size(), set\-Restore\-Geometry(), and show().\index{KMdiChildView@{KMdi\-Child\-View}!isMinimized@{isMinimized}}
\index{isMinimized@{isMinimized}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Child\-View::is\-Minimized () const}\label{classKMdiChildView_a14}


Tells if the window is minimized when attached to the Mdi manager, or if it is VISIBLE when 'floating'. 



Reimplemented from {\bf QWidget}.

Definition at line 308 of file kmdichildview.cpp.

References QWidget::is\-Minimized(), and mdi\-Parent().

Referenced by KMdi\-Main\-Frm::dock\-Menu\-Item\-Activated(), KMdi\-Main\-Frm::fill\-Window\-Menu(), minimize(), resize\-Event(), restore(), and KMdi\-Main\-Frm::window\-Menu\-Item\-Activated().\index{KMdiChildView@{KMdi\-Child\-View}!isMaximized@{isMaximized}}
\index{isMaximized@{isMaximized}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Child\-View::is\-Maximized () const}\label{classKMdiChildView_a15}


Tells if the window is minimized when attached to the Mdi manager, otherwise returns false. 



Reimplemented from {\bf QWidget}.

Definition at line 318 of file kmdichildview.cpp.

References QWidget::is\-Maximized(), and mdi\-Parent().

Referenced by maximize(), resize\-Event(), restore(), and KMdi\-Child\-Frm::set\-State().\index{KMdiChildView@{KMdi\-Child\-View}!internalGeometry@{internalGeometry}}
\index{internalGeometry@{internalGeometry}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QRect} KMdi\-Child\-View::internal\-Geometry () const}\label{classKMdiChildView_a16}


Returns the geometry of this MDI child window as {\bf QWidget::geometry()} does. 



Definition at line 113 of file kmdichildview.cpp.

References external\-Geometry(), QWidget::geometry(), QRect::height(), mdi\-Parent(), QWidget::size(), QRect::top\-Left(), QRect::width(), QRect::x(), and QRect::y().

Referenced by set\-External\-Geometry(), and set\-Internal\-Geometry().\index{KMdiChildView@{KMdi\-Child\-View}!setInternalGeometry@{setInternalGeometry}}
\index{setInternalGeometry@{setInternalGeometry}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Internal\-Geometry (const {\bf QRect} \& {\em new\-Geomety})}\label{classKMdiChildView_a17}


Sets the geometry of the client area of this MDI child window. 

The top left position of the argument is the position of the top left point of the client area in its parent coordinates and the arguments width and height is the width and height of the client area. Please note: This differs from the behavior of {\bf QWidget::set\-Geometry()}!

Definition at line 136 of file kmdichildview.cpp.

References external\-Geometry(), internal\-Geometry(), mdi\-Parent(), QWidget::set\-Geometry(), QRect::set\-Height(), QRect::set\-Width(), QRect::set\-X(), QRect::set\-Y(), QRect::x(), and QRect::y().\index{KMdiChildView@{KMdi\-Child\-View}!externalGeometry@{externalGeometry}}
\index{externalGeometry@{externalGeometry}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QRect} KMdi\-Child\-View::external\-Geometry () const}\label{classKMdiChildView_a18}


Returns the frame geometry of this window or of the parent if there is any... 



Definition at line 183 of file kmdichildview.cpp.

References QWidget::frame\-Geometry(), and mdi\-Parent().

Referenced by internal\-Geometry(), set\-External\-Geometry(), and set\-Internal\-Geometry().\index{KMdiChildView@{KMdi\-Child\-View}!setExternalGeometry@{setExternalGeometry}}
\index{setExternalGeometry@{setExternalGeometry}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-External\-Geometry (const {\bf QRect} \& {\em new\-Geomety})}\label{classKMdiChildView_a19}


Sets the geometry of the frame of this MDI child window. 

The top left position of the argument is the position of the top left point of the frame in its parent coordinates and the arguments width and height is the width and height of the widget frame. Please note: This differs from the behavior of {\bf QWidget::set\-Geometry()}!

Definition at line 190 of file kmdichildview.cpp.

References external\-Geometry(), QRect::height(), internal\-Geometry(), mdi\-Parent(), QWidget::set\-Geometry(), QRect::set\-Height(), QRect::set\-Width(), QRect::set\-X(), QRect::set\-Y(), QRect::width(), QRect::x(), and QRect::y().\index{KMdiChildView@{KMdi\-Child\-View}!myIconPtr@{myIconPtr}}
\index{myIconPtr@{myIconPtr}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPixmap} $\ast$ KMdi\-Child\-View::my\-Icon\-Ptr ()\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a20}


You should override this function in the derived class. 



Definition at line 395 of file kmdichildview.cpp.

Referenced by you\-Are\-Detached().\index{KMdiChildView@{KMdi\-Child\-View}!minimize@{minimize}}
\index{minimize@{minimize}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::minimize (bool {\em b\-Animate})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a21}


Minimizes this window when it is attached to the Mdi manager. 

Otherwise has no effect

Definition at line 221 of file kmdichildview.cpp.

References is\-Minimized(), mdi\-Parent(), KMdi\-Child\-Frm::set\-State(), and show\-Minimized().

Referenced by KMdi\-Main\-Frm::dock\-Menu\-Item\-Activated(), and KMdi\-Main\-Frm::window\-Menu\-Item\-Activated().\index{KMdiChildView@{KMdi\-Child\-View}!maximize@{maximize}}
\index{maximize@{maximize}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::maximize (bool {\em b\-Animate})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a22}


Maximizes this window when it is attached to the Mdi manager. 

Otherwise has no effect

Definition at line 248 of file kmdichildview.cpp.

References is\-Maximized(), mdi\-Parent(), mdi\-Parent\-Now\-Maximized(), KMdi\-Child\-Frm::set\-State(), and show\-Maximized().\index{KMdiChildView@{KMdi\-Child\-View}!restoreGeometry@{restoreGeometry}}
\index{restoreGeometry@{restoreGeometry}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QRect} KMdi\-Child\-View::restore\-Geometry ()}\label{classKMdiChildView_a23}


Returns the geometry that will be restored by calling {\bf restore()}{\rm (p.\,\pageref{classKMdiChildView_i4})}. 



Definition at line 276 of file kmdichildview.cpp.

References QWidget::geometry(), mdi\-Parent(), and KMdi\-Child\-Frm::restore\-Geometry().\index{KMdiChildView@{KMdi\-Child\-View}!setRestoreGeometry@{setRestoreGeometry}}
\index{setRestoreGeometry@{setRestoreGeometry}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Restore\-Geometry (const {\bf QRect} \& {\em new\-Rest\-Geo})}\label{classKMdiChildView_a24}


Sets the geometry that will be restored by calling {\bf restore()}{\rm (p.\,\pageref{classKMdiChildView_i4})}. 



Definition at line 286 of file kmdichildview.cpp.

References mdi\-Parent(), and KMdi\-Child\-Frm::set\-Restore\-Geometry().\index{KMdiChildView@{KMdi\-Child\-View}!removeEventFilterForAllChildren@{removeEventFilterForAllChildren}}
\index{removeEventFilterForAllChildren@{removeEventFilterForAllChildren}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::remove\-Event\-Filter\-For\-All\-Children ()}\label{classKMdiChildView_a25}


Switches interposing in event loop of all current child widgets off. 



Definition at line 648 of file kmdichildview.cpp.\index{KMdiChildView@{KMdi\-Child\-View}!setWindowMenuID@{setWindowMenuID}}
\index{setWindowMenuID@{setWindowMenuID}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Window\-Menu\-ID (int {\em id})}\label{classKMdiChildView_a26}


Internally used for setting an ID for the 'Window' menu entry. 



Definition at line 691 of file kmdichildview.cpp.

References m\_\-window\-Menu\-ID.

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


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.

Reimplemented from {\bf QWidget}.

Definition at line 715 of file kmdichildview.cpp.

References mdi\-Parent(), KMdi\-Child\-Frm::set\-Minimum\-Size(), and QWidget::set\-Minimum\-Size().

Referenced by KMdi\-Child\-Frm::set\-State(), and KMdi\-Child\-Frm::unset\-Client().\index{KMdiChildView@{KMdi\-Child\-View}!setMaximumSize@{setMaximumSize}}
\index{setMaximumSize@{setMaximumSize}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::set\-Maximum\-Size (int {\em maxw}, int {\em maxh})\hspace{0.3cm}{\tt  [virtual]}}\label{classKMdiChildView_a28}


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.

Reimplemented from {\bf QWidget}.

Definition at line 727 of file kmdichildview.cpp.

References KMdi\-Child\-Frm::caption\-Height(), mdi\-Parent(), and QWidget::set\-Maximum\-Size().

Referenced by KMdi\-Child\-Frm::set\-State(), and KMdi\-Child\-Frm::unset\-Client().\index{KMdiChildView@{KMdi\-Child\-View}!isToolView@{isToolView}}
\index{isToolView@{isToolView}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Child\-View::is\-Tool\-View () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a29}


Returns if this is added as MDI tool-view. 



Definition at line 354 of file kmdichildview.h.

Referenced by KMdi\-Main\-Frm::fill\-Window\-Menu(), KMdi\-Main\-Frm::set\-Frame\-Decor\-Of\-Attached\-Views(), and KMdi\-Main\-Frm::switch\-To\-Childframe\-Mode().\index{KMdiChildView@{KMdi\-Child\-View}!updateTimeStamp@{updateTimeStamp}}
\index{updateTimeStamp@{updateTimeStamp}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::update\-Time\-Stamp ()\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a30}


Remember the current time. 



Definition at line 359 of file kmdichildview.h.

Referenced by KMdi\-Main\-Frm::event\-Filter(), KMdi\-Child\-View(), and slot\_\-clicked\-In\-Window\-Menu().\index{KMdiChildView@{KMdi\-Child\-View}!getTimeStamp@{getTimeStamp}}
\index{getTimeStamp@{getTimeStamp}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const {\bf QDate\-Time}\& KMdi\-Child\-View::get\-Time\-Stamp () const\hspace{0.3cm}{\tt  [inline]}}\label{classKMdiChildView_a31}


Recall a previously remembered time, i.e. 

the value of m\_\-time

Definition at line 368 of file kmdichildview.h.

Referenced by KMdi\-Main\-Frm::activate\-First\-Win(), KMdi\-Main\-Frm::activate\-Last\-Win(), and KMdi\-Main\-Frm::fill\-Window\-Menu().\index{KMdiChildView@{KMdi\-Child\-View}!attach@{attach}}
\index{attach@{attach}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::attach ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i0}


Attaches this window to the Mdi manager. 

It calls the {\bf KMdi\-Main\-Frm}{\rm (p.\,\pageref{classKMdiMainFrm})} attach\-Window function , so if you have a pointer to this {\bf KMdi\-Main\-Frm}{\rm (p.\,\pageref{classKMdiMainFrm})} you'll be faster calling that function.

Definition at line 294 of file kmdichildview.cpp.

References attach\-Window().\index{KMdiChildView@{KMdi\-Child\-View}!detach@{detach}}
\index{detach@{detach}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::detach ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i1}


Detaches this window from the Mdi manager. 

It calls the {\bf KMdi\-Main\-Frm}{\rm (p.\,\pageref{classKMdiMainFrm})} detach\-Window function , so if you have a pointer to this {\bf KMdi\-Main\-Frm}{\rm (p.\,\pageref{classKMdiMainFrm})} you'll be faster calling that function.

Definition at line 301 of file kmdichildview.cpp.

References detach\-Window().

Referenced by KMdi\-Child\-Frm::undock\-Pressed().\index{KMdiChildView@{KMdi\-Child\-View}!minimize@{minimize}}
\index{minimize@{minimize}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::minimize ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i2}


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 ( {\bf QWidget::show\-Minimized} ).

Definition at line 241 of file kmdichildview.cpp.\index{KMdiChildView@{KMdi\-Child\-View}!maximize@{maximize}}
\index{maximize@{maximize}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::maximize ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i3}


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 {\bf KMdi\-Main\-Frm::set\-Menu\-For\-SDIMode\-Sys\-Buttons}{\rm (p.\,\pageref{classKMdiMainFrm_a25})} ). If detached, it will use the minimize of the underlying system ( {\bf QWidget::show\-Maximized} ).

Definition at line 269 of file kmdichildview.cpp.\index{KMdiChildView@{KMdi\-Child\-View}!restore@{restore}}
\index{restore@{restore}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::restore ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i4}


Restores this window to its normal size. 

Also known as 'normalize'.

Definition at line 328 of file kmdichildview.cpp.

References is\-Maximized(), is\-Minimized(), mdi\-Parent(), mdi\-Parent\-Now\-Maximized(), KMdi\-Child\-Frm::set\-State(), and show\-Normal().

Referenced by KMdi\-Main\-Frm::set\-Enable\-Maximized\-Child\-Frm\-Mode().\index{KMdiChildView@{KMdi\-Child\-View}!youAreAttached@{youAreAttached}}
\index{youAreAttached@{youAreAttached}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::you\-Are\-Attached ({\bf KMdi\-Child\-Frm} $\ast$ {\em lp\-C})\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i5}


Internally called, if KMdi\-Main\-Frm::attach is called. 

Actually, only the caption of the covering childframe is set.

Definition at line 350 of file kmdichildview.cpp.

References is\-Attached\-Now(), m\_\-sz\-Caption, and KMdi\-Child\-Frm::set\-Caption().\index{KMdiChildView@{KMdi\-Child\-View}!youAreDetached@{youAreDetached}}
\index{youAreDetached@{youAreDetached}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::you\-Are\-Detached ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i6}


Internally called, if KMdi\-Main\-Frm::detach is called. 

Some things for going toplevel will be done here.

Definition at line 358 of file kmdichildview.cpp.

References is\-Detached\-Now(), m\_\-s\-Tab\-Caption, m\_\-sz\-Caption, my\-Icon\-Ptr(), set\-Caption(), QWidget::set\-Focus\-Policy(), QWidget::set\-Icon(), and set\-Tab\-Caption().

Referenced by KMdi\-Main\-Frm::detach\-Window().\index{KMdiChildView@{KMdi\-Child\-View}!slot_clickedInWindowMenu@{slot\_\-clickedInWindowMenu}}
\index{slot_clickedInWindowMenu@{slot\_\-clickedInWindowMenu}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::slot\_\-clicked\-In\-Window\-Menu ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i7}


Called if someone click on the \char`\"{}Window\char`\"{} menu item for this child frame window. 



Definition at line 699 of file kmdichildview.cpp.

References clicked\-In\-Window\-Menu(), m\_\-window\-Menu\-ID, and update\-Time\-Stamp().\index{KMdiChildView@{KMdi\-Child\-View}!slot_clickedInDockMenu@{slot\_\-clickedInDockMenu}}
\index{slot_clickedInDockMenu@{slot\_\-clickedInDockMenu}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::slot\_\-clicked\-In\-Dock\-Menu ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i8}


Called if someone click on the \char`\"{}Dock/Undock...\char`\"{} menu item for this child frame window. 



Definition at line 708 of file kmdichildview.cpp.

References clicked\-In\-Dock\-Menu(), and m\_\-window\-Menu\-ID.\index{KMdiChildView@{KMdi\-Child\-View}!show@{show}}
\index{show@{show}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::show ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i9}


Calls {\bf QWidget::show} but also for it's parent widget if attached. 



Reimplemented from {\bf QWidget}.

Definition at line 746 of file kmdichildview.cpp.

References mdi\-Parent(), and QWidget::show().

Referenced by KMdi\-Main\-Frm::switch\-To\-Childframe\-Mode().\index{KMdiChildView@{KMdi\-Child\-View}!hide@{hide}}
\index{hide@{hide}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::hide ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i10}


Calls {\bf QWidget::hide()} or it's parent widget {\bf hide()}{\rm (p.\,\pageref{classKMdiChildView_i10})} if attached. 



Reimplemented from {\bf QWidget}.

Definition at line 756 of file kmdichildview.cpp.

References QWidget::hide(), and mdi\-Parent().\index{KMdiChildView@{KMdi\-Child\-View}!raise@{raise}}
\index{raise@{raise}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::raise ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i11}


Calls {\bf QWidget::raise()} or it's parent widget {\bf raise()}{\rm (p.\,\pageref{classKMdiChildView_i11})} if attached. 



Reimplemented from {\bf QWidget}.

Definition at line 766 of file kmdichildview.cpp.

References mdi\-Parent(), and QWidget::raise().\index{KMdiChildView@{KMdi\-Child\-View}!showMinimized@{showMinimized}}
\index{showMinimized@{showMinimized}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::show\-Minimized ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i12}


Overridden from its base class method. 

Emits a signal {\bf KMdi\-Child\-View::is\-Minimized\-Now}{\rm (p.\,\pageref{classKMdiChildView_l14})} , additionally. Note that this method is not used by an external windows manager call on system minimizing.

Reimplemented from {\bf QWidget}.

Definition at line 234 of file kmdichildview.cpp.

References is\-Minimized\-Now(), and QWidget::show\-Minimized().

Referenced by minimize().\index{KMdiChildView@{KMdi\-Child\-View}!showMaximized@{showMaximized}}
\index{showMaximized@{showMaximized}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::show\-Maximized ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i13}


Overridden from its base class method. 

Emits a signal {\bf KMdi\-Child\-View::is\-Maximized\-Now}{\rm (p.\,\pageref{classKMdiChildView_l13})} , additionally. Note that this method is not used by an external windows manager call on system maximizing.

Reimplemented from {\bf QWidget}.

Definition at line 262 of file kmdichildview.cpp.

References is\-Maximized\-Now(), and QWidget::show\-Maximized().

Referenced by maximize().\index{KMdiChildView@{KMdi\-Child\-View}!showNormal@{showNormal}}
\index{showNormal@{showNormal}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::show\-Normal ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classKMdiChildView_i14}


Overridden from its base class method. 

Emits a signal {\bf KMdi\-Child\-View::is\-Restored\-Now}{\rm (p.\,\pageref{classKMdiChildView_l15})} , additionally. Note that this method is not used by an external windows manager call on system normalizing.

Reimplemented from {\bf QWidget}.

Definition at line 342 of file kmdichildview.cpp.

References is\-Restored\-Now(), and QWidget::show\-Normal().

Referenced by restore().\index{KMdiChildView@{KMdi\-Child\-View}!closeEvent@{closeEvent}}
\index{closeEvent@{closeEvent}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::close\-Event ({\bf QClose\-Event} $\ast$ {\em e})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiChildView_b0}


Ignores the event and calls {\bf KMdi\-Main\-Frm::child\-Window\-Close\-Request}{\rm (p.\,\pageref{classKMdiMainFrm_i14})} instead. 

This is because the mainframe has control over the views. Therefore the MDI view has to request the mainframe for a close.

Reimplemented from {\bf QWidget}.

Definition at line 387 of file kmdichildview.cpp.

References child\-Window\-Close\-Request().\index{KMdiChildView@{KMdi\-Child\-View}!eventFilter@{eventFilter}}
\index{eventFilter@{eventFilter}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KMdi\-Child\-View::event\-Filter ({\bf QObject} $\ast$ {\em obj}, {\bf QEvent} $\ast$ {\em e})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiChildView_b1}


It only catches QEvent::Key\-Press 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 {\bf KMdi\-Child\-View::set\-First\-Focusable\-Child\-Widget}{\rm (p.\,\pageref{classKMdiChildView_a4})} and KMdi\-Child\-View::last\-First\-Focusable\-Child\-Widget

Definition at line 522 of file kmdichildview.cpp.

References activate(), caption(), QObject::child(), QWidget::focus\-Policy(), QWidget::icon(), is\-Attached(), QObject::is\-Widget\-Type(), QKey\-Event::key(), m\_\-first\-Focusable\-Child\-Widget, m\_\-focused\-Child\-Widget, m\_\-last\-Focusable\-Child\-Widget, QObject::query\-List(), QWidget::set\-Focus(), QWidget::set\-Icon(), and QWidget::test\-WFlags().\index{KMdiChildView@{KMdi\-Child\-View}!focusInEvent@{focusInEvent}}
\index{focusInEvent@{focusInEvent}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::focus\-In\-Event ({\bf QFocus\-Event} $\ast$ {\em e})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiChildView_b2}


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 focus\-In\-Event\-Occurs signal before changing the focus and the got\-Focus signal after changing the focus.

Reimplemented from {\bf QWidget}.

Definition at line 402 of file kmdichildview.cpp.

References activate(), QWidget::focus\-In\-Event(), and got\-Focus().\index{KMdiChildView@{KMdi\-Child\-View}!focusOutEvent@{focusOutEvent}}
\index{focusOutEvent@{focusOutEvent}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::focus\-Out\-Event ({\bf QFocus\-Event} $\ast$ {\em e})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiChildView_b3}


Send the lost\-Focus signal. 



Reimplemented from {\bf QWidget}.

Definition at line 460 of file kmdichildview.cpp.

References QWidget::focus\-Out\-Event(), and lost\-Focus().\index{KMdiChildView@{KMdi\-Child\-View}!resizeEvent@{resizeEvent}}
\index{resizeEvent@{resizeEvent}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::resize\-Event ({\bf QResize\-Event} $\ast$ {\em e})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKMdiChildView_b4}


Internally used for the minimize/maximize/restore mechanism when in attach mode. 



Reimplemented from {\bf QWidget}.

Definition at line 468 of file kmdichildview.cpp.

References is\-Maximized(), is\-Maximized\-Now(), is\-Minimized(), is\-Minimized\-Now(), is\-Restored\-Now(), m\_\-state\-Changed, and QWidget::resize\-Event().\index{KMdiChildView@{KMdi\-Child\-View}!attachWindow@{attachWindow}}
\index{attachWindow@{attachWindow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::attach\-Window ({\bf KMdi\-Child\-View} $\ast$, bool)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l0}


Internally used by {\bf KMdi\-Child\-View::attach}{\rm (p.\,\pageref{classKMdiChildView_i0})} to send it as command to the mainframe. 



Referenced by attach().\index{KMdiChildView@{KMdi\-Child\-View}!detachWindow@{detachWindow}}
\index{detachWindow@{detachWindow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::detach\-Window ({\bf KMdi\-Child\-View} $\ast$, bool)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l1}


Internally used by {\bf KMdi\-Child\-View::detach}{\rm (p.\,\pageref{classKMdiChildView_i1})} to send it as command to the mainframe. 



Referenced by detach().\index{KMdiChildView@{KMdi\-Child\-View}!focusInEventOccurs@{focusInEventOccurs}}
\index{focusInEventOccurs@{focusInEventOccurs}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::focus\-In\-Event\-Occurs ({\bf KMdi\-Child\-View} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l2}


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 {\bf KMdi\-Child\-View::focus\-In\-Event}{\rm (p.\,\pageref{classKMdiChildView_b2})}

Referenced by activate().\index{KMdiChildView@{KMdi\-Child\-View}!gotFocus@{gotFocus}}
\index{gotFocus@{gotFocus}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::got\-Focus ({\bf KMdi\-Child\-View} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l3}


Is sent when this MDI child has received the focus (after actually changing the focus). 

See {\bf KMdi\-Child\-View::focus\-In\-Event}{\rm (p.\,\pageref{classKMdiChildView_b2})}

Referenced by focus\-In\-Event().\index{KMdiChildView@{KMdi\-Child\-View}!activated@{activated}}
\index{activated@{activated}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::activated ({\bf KMdi\-Child\-View} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l4}


Is sent when this MDI child was set to the activate view of all MDI views (after actually changing the focus). 

See {\bf KMdi\-Child\-View::activate}{\rm (p.\,\pageref{classKMdiChildView_a3})}

Referenced by activate().\index{KMdiChildView@{KMdi\-Child\-View}!lostFocus@{lostFocus}}
\index{lostFocus@{lostFocus}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::lost\-Focus ({\bf KMdi\-Child\-View} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l5}


Is sent when this MDI child view has lost the focus (after actually changing the focus). 

See {\bf KMdi\-Child\-View::focus\-Out\-Event}{\rm (p.\,\pageref{classKMdiChildView_b3})}

Referenced by focus\-Out\-Event().\index{KMdiChildView@{KMdi\-Child\-View}!deactivated@{deactivated}}
\index{deactivated@{deactivated}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::deactivated ({\bf KMdi\-Child\-View} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l6}


Is sent when this MDI child view was deactivated (after actually changing the focus). 

See {\bf KMdi\-Child\-View::focus\-Out\-Event}{\rm (p.\,\pageref{classKMdiChildView_b3})}\index{KMdiChildView@{KMdi\-Child\-View}!childWindowCloseRequest@{childWindowCloseRequest}}
\index{childWindowCloseRequest@{childWindowCloseRequest}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::child\-Window\-Close\-Request ({\bf KMdi\-Child\-View} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l7}


Internally used to send information to the mainframe that this MDI child view wants to be closed. 

See {\bf KMdi\-Child\-View::close\-Event}{\rm (p.\,\pageref{classKMdiChildView_b0})} and {\bf KMdi\-Main\-Frm::close\-Window}{\rm (p.\,\pageref{classKMdiMainFrm_i10})}

Referenced by close\-Event().\index{KMdiChildView@{KMdi\-Child\-View}!windowCaptionChanged@{windowCaptionChanged}}
\index{windowCaptionChanged@{windowCaptionChanged}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::window\-Caption\-Changed (const {\bf QString} \&)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l8}


Emitted when the window caption is changed via {\bf KMdi\-Child\-View::set\-Caption}{\rm (p.\,\pageref{classKMdiChildView_a10})} or {\bf KMdi\-Child\-View::set\-MDICaption}{\rm (p.\,\pageref{classKMdiChildView_a12})}. 



Referenced by set\-Caption().\index{KMdiChildView@{KMdi\-Child\-View}!tabCaptionChanged@{tabCaptionChanged}}
\index{tabCaptionChanged@{tabCaptionChanged}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::tab\-Caption\-Changed (const {\bf QString} \&)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l9}


Emitted when the window caption is changed via {\bf KMdi\-Child\-View::set\-Tab\-Caption}{\rm (p.\,\pageref{classKMdiChildView_a11})} or {\bf KMdi\-Child\-View::set\-MDICaption}{\rm (p.\,\pageref{classKMdiChildView_a12})}. 



Referenced by set\-Tab\-Caption().\index{KMdiChildView@{KMdi\-Child\-View}!mdiParentNowMaximized@{mdiParentNowMaximized}}
\index{mdiParentNowMaximized@{mdiParentNowMaximized}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::mdi\-Parent\-Now\-Maximized (bool)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l10}


Internally used to send information to the mainframe that this MDI view is maximized now. 

Usually, the mainframe switches system buttons.

Referenced by maximize(), and restore().\index{KMdiChildView@{KMdi\-Child\-View}!clickedInWindowMenu@{clickedInWindowMenu}}
\index{clickedInWindowMenu@{clickedInWindowMenu}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::clicked\-In\-Window\-Menu (int)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l11}


Is automatically emitted when slot\_\-clicked\-In\-Window\-Menu is called. 



Referenced by slot\_\-clicked\-In\-Window\-Menu().\index{KMdiChildView@{KMdi\-Child\-View}!clickedInDockMenu@{clickedInDockMenu}}
\index{clickedInDockMenu@{clickedInDockMenu}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::clicked\-In\-Dock\-Menu (int)\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l12}


Is automatically emitted when slot\_\-clicked\-In\-Dock\-Menu is called. 



Referenced by slot\_\-clicked\-In\-Dock\-Menu().\index{KMdiChildView@{KMdi\-Child\-View}!isMaximizedNow@{isMaximizedNow}}
\index{isMaximizedNow@{isMaximizedNow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::is\-Maximized\-Now ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l13}


Signals this has been maximized. 



Referenced by resize\-Event(), and show\-Maximized().\index{KMdiChildView@{KMdi\-Child\-View}!isMinimizedNow@{isMinimizedNow}}
\index{isMinimizedNow@{isMinimizedNow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::is\-Minimized\-Now ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l14}


Signals this has been minimized. 



Referenced by resize\-Event(), and show\-Minimized().\index{KMdiChildView@{KMdi\-Child\-View}!isRestoredNow@{isRestoredNow}}
\index{isRestoredNow@{isRestoredNow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::is\-Restored\-Now ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l15}


Signals this has been restored (normalized). 



Referenced by resize\-Event(), and show\-Normal().\index{KMdiChildView@{KMdi\-Child\-View}!isAttachedNow@{isAttachedNow}}
\index{isAttachedNow@{isAttachedNow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::is\-Attached\-Now ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l16}


Signals this has been attached. 



Referenced by you\-Are\-Attached().\index{KMdiChildView@{KMdi\-Child\-View}!isDetachedNow@{isDetachedNow}}
\index{isDetachedNow@{isDetachedNow}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KMdi\-Child\-View::is\-Detached\-Now ()\hspace{0.3cm}{\tt  [signal]}}\label{classKMdiChildView_l17}


Signals this has been detached. 



Referenced by you\-Are\-Detached().

\subsection{Member Data Documentation}
\index{KMdiChildView@{KMdi\-Child\-View}!m_szCaption@{m\_\-szCaption}}
\index{m_szCaption@{m\_\-szCaption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} {\bf KMdi\-Child\-View::m\_\-sz\-Caption}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p0}


See {\bf KMdi\-Child\-View::caption}{\rm (p.\,\pageref{classKMdiChildView_a8})}. 



Definition at line 119 of file kmdichildview.h.

Referenced by KMdi\-Child\-View(), set\-Caption(), you\-Are\-Attached(), and you\-Are\-Detached().\index{KMdiChildView@{KMdi\-Child\-View}!m_sTabCaption@{m\_\-sTabCaption}}
\index{m_sTabCaption@{m\_\-sTabCaption}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} {\bf KMdi\-Child\-View::m\_\-s\-Tab\-Caption}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p1}


See {\bf KMdi\-Child\-View::tab\-Caption}{\rm (p.\,\pageref{classKMdiChildView_a9})}. 



Definition at line 124 of file kmdichildview.h.

Referenced by KMdi\-Child\-View(), set\-Tab\-Caption(), and you\-Are\-Detached().\index{KMdiChildView@{KMdi\-Child\-View}!m_focusedChildWidget@{m\_\-focusedChildWidget}}
\index{m_focusedChildWidget@{m\_\-focusedChildWidget}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QWidget}$\ast$ {\bf KMdi\-Child\-View::m\_\-focused\-Child\-Widget}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p2}


See {\bf KMdi\-Child\-View::focused\-Child\-Widget}{\rm (p.\,\pageref{classKMdiChildView_a6})}. 



Definition at line 129 of file kmdichildview.h.

Referenced by activate(), event\-Filter(), and focused\-Child\-Widget().\index{KMdiChildView@{KMdi\-Child\-View}!m_firstFocusableChildWidget@{m\_\-firstFocusableChildWidget}}
\index{m_firstFocusableChildWidget@{m\_\-firstFocusableChildWidget}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QWidget}$\ast$ {\bf KMdi\-Child\-View::m\_\-first\-Focusable\-Child\-Widget}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p3}


See {\bf KMdi\-Child\-View::set\-First\-Focusable\-Child\-Widget}{\rm (p.\,\pageref{classKMdiChildView_a4})}. 



Definition at line 134 of file kmdichildview.h.

Referenced by activate(), event\-Filter(), and set\-First\-Focusable\-Child\-Widget().\index{KMdiChildView@{KMdi\-Child\-View}!m_lastFocusableChildWidget@{m\_\-lastFocusableChildWidget}}
\index{m_lastFocusableChildWidget@{m\_\-lastFocusableChildWidget}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QWidget}$\ast$ {\bf KMdi\-Child\-View::m\_\-last\-Focusable\-Child\-Widget}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p4}


See {\bf KMdi\-Child\-View::set\-Last\-Focusable\-Child\-Widget}{\rm (p.\,\pageref{classKMdiChildView_a5})}. 



Definition at line 139 of file kmdichildview.h.

Referenced by event\-Filter(), and set\-Last\-Focusable\-Child\-Widget().\index{KMdiChildView@{KMdi\-Child\-View}!m_windowMenuID@{m\_\-windowMenuID}}
\index{m_windowMenuID@{m\_\-windowMenuID}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int {\bf KMdi\-Child\-View::m\_\-window\-Menu\-ID}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p5}


Every child view window has an temporary ID in the Window menu of the main frame. 



Definition at line 144 of file kmdichildview.h.

Referenced by set\-Window\-Menu\-ID(), slot\_\-clicked\-In\-Dock\-Menu(), and slot\_\-clicked\-In\-Window\-Menu().\index{KMdiChildView@{KMdi\-Child\-View}!m_stateChanged@{m\_\-stateChanged}}
\index{m_stateChanged@{m\_\-stateChanged}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool {\bf KMdi\-Child\-View::m\_\-state\-Changed}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p6}


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.

Definition at line 150 of file kmdichildview.h.

Referenced by resize\-Event(), and KMdi\-Child\-Frm::set\-State().\index{KMdiChildView@{KMdi\-Child\-View}!m_time@{m\_\-time}}
\index{m_time@{m\_\-time}!KMdiChildView@{KMdi\-Child\-View}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QDate\-Time} {\bf KMdi\-Child\-View::m\_\-time}\hspace{0.3cm}{\tt  [protected]}}\label{classKMdiChildView_p7}


Holds the time when this view was activated (not only displayed) for the last time. 



Definition at line 155 of file kmdichildview.h.

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