\section{NETRoot\-Info Class Reference}
\label{classNETRootInfo}\index{NETRootInfo@{NETRootInfo}}
Common API for root window properties/protocols.  


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

Inheritance diagram for NETRoot\-Info:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=57pt]{classNETRootInfo__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for NETRoot\-Info:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=55pt]{classNETRootInfo__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
enum \{ \par
{\bf PROTOCOLS}, 
{\bf WINDOW\_\-TYPES}, 
{\bf STATES}, 
{\bf PROTOCOLS2}, 
\par
{\bf ACTIONS}, 
{\bf PROPERTIES\_\-SIZE}
 \}
\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf NETRoot\-Info} (Display $\ast$display, Window support\-Window, const char $\ast$wm\-Name, const unsigned long properties[$\,$], int properties\_\-size, int screen=-1, bool do\-Activate=true)
\item 
{\bf NETRoot\-Info} (Display $\ast$display, Window support\-Window, const char $\ast$wm\-Name, unsigned long properties, int screen=-1, bool do\-Activate=true) KDE\_\-DEPRECATED
\item 
{\bf NETRoot\-Info} (Display $\ast$display, const unsigned long properties[$\,$], int properties\_\-size, int screen=-1, bool do\-Activate=true)
\item 
{\bf NETRoot\-Info} (Display $\ast$display, unsigned long properties, int screen=-1, bool do\-Activate=true)
\item 
{\bf NETRoot\-Info} (const {\bf NETRoot\-Info} \&rootinfo)
\item 
virtual {\bf $\sim$NETRoot\-Info} ()
\item 
Display $\ast$ {\bf x11Display} () const 
\item 
Window {\bf root\-Window} () const 
\item 
Window {\bf support\-Window} () const 
\item 
const char $\ast$ {\bf wm\-Name} () const 
\item 
int {\bf screen\-Number} () const 
\item 
bool {\bf is\-Supported} ({\bf NET::Property} property) const 
\item 
bool {\bf is\-Supported} ({\bf NET::Property2} property) const 
\item 
bool {\bf is\-Supported} ({\bf NET::Window\-Type} type) const 
\item 
bool {\bf is\-Supported} ({\bf NET::State} state) const 
\item 
bool {\bf is\-Supported} ({\bf NET::Action} action) const 
\item 
const unsigned long $\ast$ {\bf supported\-Properties} () const 
\item 
const unsigned long $\ast$ {\bf passed\-Properties} () const 
\item 
unsigned long {\bf supported} () const KDE\_\-DEPRECATED
\item 
const Window $\ast$ {\bf client\-List} () const 
\item 
int {\bf client\-List\-Count} () const 
\item 
const Window $\ast$ {\bf client\-List\-Stacking} () const 
\item 
int {\bf client\-List\-Stacking\-Count} () const 
\item 
const Window $\ast$ {\bf kde\-System\-Tray\-Windows} () const 
\item 
int {\bf kde\-System\-Tray\-Windows\-Count} () const 
\item 
{\bf NETSize} {\bf desktop\-Geometry} (int desktop) const 
\item 
{\bf NETPoint} {\bf desktop\-Viewport} (int desktop) const 
\item 
{\bf NETRect} {\bf work\-Area} (int desktop) const 
\item 
const char $\ast$ {\bf desktop\-Name} (int desktop) const 
\item 
const Window $\ast$ {\bf virtual\-Roots} () const 
\item 
int {\bf virtual\-Roots\-Count} () const 
\item 
int {\bf number\-Of\-Desktops} () const 
\item 
int {\bf current\-Desktop} () const 
\item 
Window {\bf active\-Window} () const 
\item 
void {\bf activate} ()
\item 
void {\bf set\-Client\-List} (Window $\ast$windows, unsigned int count)
\item 
void {\bf set\-Client\-List\-Stacking} (Window $\ast$windows, unsigned int count)
\item 
void {\bf set\-KDESystem\-Tray\-Windows} (Window $\ast$windows, unsigned int count)
\item 
void {\bf set\-Current\-Desktop} (int desktop)
\item 
void {\bf set\-Desktop\-Geometry} (int desktop, const {\bf NETSize} \&geometry)
\item 
void {\bf set\-Desktop\-Viewport} (int desktop, const {\bf NETPoint} \&viewport)
\item 
void {\bf set\-Number\-Of\-Desktops} (int number\-Of\-Desktops)
\item 
void {\bf set\-Desktop\-Name} (int desktop, const char $\ast$desktop\-Name)
\item 
void {\bf set\-Active\-Window} (Window window, {\bf NET::Request\-Source} src, Time timestamp, Window active\_\-window)
\item 
void {\bf set\-Active\-Window} (Window window)
\item 
void {\bf set\-Work\-Area} (int desktop, const {\bf NETRect} \&work\-Area)
\item 
void {\bf set\-Virtual\-Roots} (Window $\ast$windows, unsigned int count)
\item 
const {\bf NETRoot\-Info} \& {\bf operator=} (const {\bf NETRoot\-Info} \&rootinfo)
\item 
void {\bf close\-Window\-Request} (Window window)
\item 
void {\bf move\-Resize\-Request} (Window window, int x\_\-root, int y\_\-root, {\bf Direction} direction)
\item 
void {\bf move\-Resize\-Window\-Request} (Window window, int flags, int x, int y, int width, int height)
\item 
void {\bf restack\-Request} (Window window, {\bf Request\-Source} source, Window above, int detail, Time timestamp)
\item 
void {\bf restack\-Request} (Window window, Window above, int detail)
\item 
void {\bf event} (XEvent $\ast$event, unsigned long $\ast$properties, int properties\_\-size)
\item 
unsigned long {\bf event} (XEvent $\ast$event)
\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf add\-Client} (Window window)
\item 
virtual void {\bf remove\-Client} (Window window)
\item 
virtual void {\bf add\-System\-Tray\-Win} (Window window)
\item 
virtual void {\bf remove\-System\-Tray\-Win} (Window window)
\item 
virtual void {\bf change\-Number\-Of\-Desktops} (int number\-Of\-Desktops)
\item 
virtual void {\bf change\-Desktop\-Geometry} (int desktop, const {\bf NETSize} \&geom)
\item 
virtual void {\bf change\-Desktop\-Viewport} (int desktop, const {\bf NETPoint} \&viewport)
\item 
virtual void {\bf change\-Current\-Desktop} (int desktop)
\item 
virtual KDE\_\-DEPRECATED void {\bf change\-Active\-Window} (Window window)
\item 
virtual void {\bf close\-Window} (Window window)
\item 
virtual void {\bf move\-Resize} (Window window, int x\_\-root, int y\_\-root, unsigned long direction)
\item 
virtual void {\bf virtual\_\-hook} (int id, void $\ast$data)\label{classNETRootInfo_b11}

\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf NETRoot\-Info2}\label{classNETRootInfo_n0}

\item 
class {\bf NETRoot\-Info3}\label{classNETRootInfo_n1}

\end{CompactItemize}


\subsection{Detailed Description}
Common API for root window properties/protocols. 

The NETRoot\-Info class provides a common API for clients and window managers to set/read/change properties on the root window as defined by the {\bf NET}{\rm (p.\,\pageref{classNET})} Window Manager Specification..

\begin{Desc}
\item[Author:]Bradley T. Hughes $<${\tt bhughes@trolltech.com}$>$ \end{Desc}
\begin{Desc}
\item[See also:]{\bf NET}{\rm (p.\,\pageref{classNET})} 

{\bf NETWin\-Info}{\rm (p.\,\pageref{classNETWinInfo})} 

KWin \end{Desc}




Definition at line 57 of file netwm.h.

\subsection{Member Enumeration Documentation}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}anonymous enum}\label{classNETRootInfo_w6}


Indexes for the properties array. 

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 64 of file netwm.h.

\subsection{Constructor \& Destructor Documentation}
\index{NETRootInfo@{NETRoot\-Info}!NETRootInfo@{NETRootInfo}}
\index{NETRootInfo@{NETRootInfo}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}NETRoot\-Info::NETRoot\-Info (Display $\ast$ {\em display}, Window {\em support\-Window}, const char $\ast$ {\em wm\-Name}, const unsigned long {\em properties}[$\,$], int {\em properties\_\-size}, int {\em screen} = {\tt -1}, bool {\em do\-Activate} = {\tt true})}\label{classNETRootInfo_a0}


Window Managers should use this constructor to create a NETRoot\-Info object, which will be used to set/update information stored on the root\-Window. 

The application role is automatically set to Window\-Manager when using this constructor.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em display}]An X11 Display struct.\item[{\em support\-Window}]The Window id of the support\-Window. The support\-Window must be created by the window manager as a child of the root\-Window. The support\-Window must not be destroyed until the Window Manager exits.\item[{\em wm\-Name}]A string which should be the window manager's name (ie. \char`\"{}KWin\char`\"{} or \char`\"{}Blackbox\char`\"{}).\item[{\em properties}]An array of elements listing all properties and protocols the window manager supports. The elements contain OR'ed values of constants from the {\bf NET}{\rm (p.\,\pageref{classNET})} base class, in the following order: [0]= {\bf NET::Property}{\rm (p.\,\pageref{classNET_w121})}, [1]= {\bf NET::Window\-Type\-Mask}{\rm (p.\,\pageref{classNET_w115})} (not {\bf NET::Window\-Type}{\rm (p.\,\pageref{classNET_w114})}!), [2]= {\bf NET::State}{\rm (p.\,\pageref{classNET_w117})}, [3]= {\bf NET::Property2}{\rm (p.\,\pageref{classNET_w122})}, [4]= {\bf NET::Action}{\rm (p.\,\pageref{classNET_w120})}. In future versions, the list may be extended. In case you pass less elements, the missing ones will be replaced with default values.\item[{\em properties\_\-size}]The number of elements in the properties array.\item[{\em screen}]For Window Managers that support multiple screen (ie. \char`\"{}multiheaded\char`\"{}) displays, the screen number may be explicitly defined. If this argument is omitted, the default screen will be used.\item[{\em do\-Activate}]true to activate the window\end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 562 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!NETRootInfo@{NETRootInfo}}
\index{NETRootInfo@{NETRootInfo}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}NETRoot\-Info::NETRoot\-Info (Display $\ast$ {\em display}, Window {\em support\-Window}, const char $\ast$ {\em wm\-Name}, unsigned long {\em properties}, int {\em screen} = {\tt -1}, bool {\em do\-Activate} = {\tt true})}\label{classNETRootInfo_a1}


\begin{Desc}
\item[{\bf Deprecated}]This constructor differs from the above one only in the way it accepts the list of supported properties. The properties argument is equivalent to the first element of the properties array in the above constructor. \end{Desc}


Definition at line 611 of file netwm.cpp.

References activate(), and wm\-Name().\index{NETRootInfo@{NETRoot\-Info}!NETRootInfo@{NETRootInfo}}
\index{NETRootInfo@{NETRootInfo}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}NETRoot\-Info::NETRoot\-Info (Display $\ast$ {\em display}, const unsigned long {\em properties}[$\,$], int {\em properties\_\-size}, int {\em screen} = {\tt -1}, bool {\em do\-Activate} = {\tt true})}\label{classNETRootInfo_a2}


Clients should use this constructor to create a NETRoot\-Info object, which will be used to query information set on the root window. 

The application role is automatically set to Client when using this constructor.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em display}]An X11 Display struct.\item[{\em properties}]An array of elements listing all protocols the client is interested in. The elements contain OR'ed values of constants from the {\bf NET}{\rm (p.\,\pageref{classNET})} base class, in the following order: [0]= {\bf NET::Property}{\rm (p.\,\pageref{classNET_w121})}, [1]= {\bf NET::Property2}{\rm (p.\,\pageref{classNET_w122})}.\item[{\em properties\_\-size}]The number of elements in the properties array.\item[{\em screen}]For Clients that support multiple screen (ie. \char`\"{}multiheaded\char`\"{}) displays, the screen number may be explicitly defined. If this argument is omitted, the default screen will be used.\item[{\em do\-Activate}]true to activate the window\end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 655 of file netwm.cpp.

References activate().\index{NETRootInfo@{NETRoot\-Info}!NETRootInfo@{NETRootInfo}}
\index{NETRootInfo@{NETRootInfo}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}NETRoot\-Info::NETRoot\-Info (Display $\ast$ {\em display}, unsigned long {\em properties}, int {\em screen} = {\tt -1}, bool {\em do\-Activate} = {\tt true})}\label{classNETRootInfo_a3}


This constructor differs from the above one only in the way it accepts the list of supported properties. 

The properties argument is equivalent to the first element of the properties array in the above constructor, and therefore you cannot read all root window properties using it. 

Definition at line 712 of file netwm.cpp.

References activate().\index{NETRootInfo@{NETRoot\-Info}!NETRootInfo@{NETRootInfo}}
\index{NETRootInfo@{NETRootInfo}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}NETRoot\-Info::NETRoot\-Info (const {\bf NETRoot\-Info} \& {\em rootinfo})}\label{classNETRootInfo_a4}


Creates a shared copy of the specified NETRoot\-Info object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rootinfo}]the NETRoot\-Info object to copy \end{description}
\end{Desc}


Definition at line 775 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!~NETRootInfo@{$\sim$NETRootInfo}}
\index{~NETRootInfo@{$\sim$NETRootInfo}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}NETRoot\-Info::$\sim${\bf NETRoot\-Info} ()\hspace{0.3cm}{\tt  [virtual]}}\label{classNETRootInfo_a5}


Destroys the NETRoot\-Info object. 



Definition at line 790 of file netwm.cpp.

\subsection{Member Function Documentation}
\index{NETRootInfo@{NETRoot\-Info}!x11Display@{x11Display}}
\index{x11Display@{x11Display}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Display $\ast$ NETRoot\-Info::x11Display () const}\label{classNETRootInfo_a6}


Returns the X11 Display struct used. 

\begin{Desc}
\item[Returns:]the X11 Display \end{Desc}


Definition at line 2428 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!rootWindow@{rootWindow}}
\index{rootWindow@{rootWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Window NETRoot\-Info::root\-Window () const}\label{classNETRootInfo_a7}


Returns the Window id of the root\-Window. 

\begin{Desc}
\item[Returns:]the id of the root window \end{Desc}


Definition at line 2433 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!supportWindow@{supportWindow}}
\index{supportWindow@{supportWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Window NETRoot\-Info::support\-Window () const}\label{classNETRootInfo_a8}


Returns the Window id of the support\-Window. 

\begin{Desc}
\item[Returns:]the id of the support window \end{Desc}


Definition at line 2438 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!wmName@{wmName}}
\index{wmName@{wmName}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const char $\ast$ NETRoot\-Info::wm\-Name () const}\label{classNETRootInfo_a9}


Returns the name of the Window Manager. 

\begin{Desc}
\item[Returns:]the name of the window manager \end{Desc}


Definition at line 2443 of file netwm.cpp.

Referenced by NETRoot\-Info().\index{NETRootInfo@{NETRoot\-Info}!screenNumber@{screenNumber}}
\index{screenNumber@{screenNumber}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::screen\-Number () const}\label{classNETRootInfo_a10}


Returns the screen\-Number. 

\begin{Desc}
\item[Returns:]the screen number \end{Desc}


Definition at line 2447 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!isSupported@{isSupported}}
\index{isSupported@{isSupported}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool NETRoot\-Info::is\-Supported ({\bf NET::Property} {\em property}) const}\label{classNETRootInfo_a11}


Returns true if the given property is supported by the window manager. 

Note that for Client mode, NET::Supported needs to be passed in the properties argument for this to work. \begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2468 of file netwm.cpp.

Referenced by KStartup\-Info::set\-New\-Startup\-Id().\index{NETRootInfo@{NETRoot\-Info}!isSupported@{isSupported}}
\index{isSupported@{isSupported}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool NETRoot\-Info::is\-Supported ({\bf NET::Property2} {\em property}) const}\label{classNETRootInfo_a12}


This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2472 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!isSupported@{isSupported}}
\index{isSupported@{isSupported}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool NETRoot\-Info::is\-Supported ({\bf NET::Window\-Type} {\em type}) const}\label{classNETRootInfo_a13}


This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2476 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!isSupported@{isSupported}}
\index{isSupported@{isSupported}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool NETRoot\-Info::is\-Supported ({\bf NET::State} {\em state}) const}\label{classNETRootInfo_a14}


This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2480 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!isSupported@{isSupported}}
\index{isSupported@{isSupported}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool NETRoot\-Info::is\-Supported ({\bf NET::Action} {\em action}) const}\label{classNETRootInfo_a15}


This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2484 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!supportedProperties@{supportedProperties}}
\index{supportedProperties@{supportedProperties}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const unsigned long $\ast$ NETRoot\-Info::supported\-Properties () const}\label{classNETRootInfo_a16}


In the Window Manager mode, this is equivalent to the properties argument passed to the constructor. 

In the Client mode, if NET::Supported was passed in the properties argument, the returned value is array of all protocols and properties supported by the Window Manager. The elements of the array are the same as they would be passed to the Window Manager mode constructor, the size is the maximum array size the constructor accepts.

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2458 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!passedProperties@{passedProperties}}
\index{passedProperties@{passedProperties}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const unsigned long $\ast$ NETRoot\-Info::passed\-Properties () const}\label{classNETRootInfo_a17}


Returns the properties argument passed to the constructor. 

The size is the maximum array size the constructor accepts.

\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 2462 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!supported@{supported}}
\index{supported@{supported}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned long NETRoot\-Info::supported () const}\label{classNETRootInfo_a18}


\begin{Desc}
\item[{\bf Deprecated}]\end{Desc}
Returns an OR'ed list of protocols passed to the constructor. For the constructor used by Window Managers, this is equivalent to the first element of the properties argument, for the constructor for Clients, it's the properties argument.

Clients willing to find out all properties and protocols supported by the Window\-Manager should use {\bf supported\-Properties()}{\rm (p.\,\pageref{classNETRootInfo_a16})}.

\begin{Desc}
\item[Returns:]an OR'ed list of protocols\end{Desc}
\begin{Desc}
\item[See also:]{\bf NET::Property}{\rm (p.\,\pageref{classNET_w121})} \end{Desc}


Definition at line 2452 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!clientList@{clientList}}
\index{clientList@{clientList}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Window $\ast$ NETRoot\-Info::client\-List () const}\label{classNETRootInfo_a19}


Returns an array of Window id's, which contain all managed windows. 

\begin{Desc}
\item[Returns:]the array of Window id's\end{Desc}
\begin{Desc}
\item[See also:]{\bf client\-List\-Count()}{\rm (p.\,\pageref{classNETRootInfo_a20})} \end{Desc}


Definition at line 2488 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!clientListCount@{clientListCount}}
\index{clientListCount@{clientListCount}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::client\-List\-Count () const}\label{classNETRootInfo_a20}


Returns the number of managed windows in client\-List array. 

\begin{Desc}
\item[Returns:]the number of managed windows in the client\-List array\end{Desc}
\begin{Desc}
\item[See also:]{\bf client\-List()}{\rm (p.\,\pageref{classNETRootInfo_a19})} \end{Desc}


Definition at line 2493 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!clientListStacking@{clientListStacking}}
\index{clientListStacking@{clientListStacking}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Window $\ast$ NETRoot\-Info::client\-List\-Stacking () const}\label{classNETRootInfo_a21}


Returns an array of Window id's, which contain all managed windows in stacking order. 

\begin{Desc}
\item[Returns:]the array of Window id's in stacking order\end{Desc}
\begin{Desc}
\item[See also:]{\bf client\-List\-Stacking\-Count()}{\rm (p.\,\pageref{classNETRootInfo_a22})} \end{Desc}


Definition at line 2498 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!clientListStackingCount@{clientListStackingCount}}
\index{clientListStackingCount@{clientListStackingCount}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::client\-List\-Stacking\-Count () const}\label{classNETRootInfo_a22}


Returns the number of managed windows in the client\-List\-Stacking array. 

\begin{Desc}
\item[Returns:]the number of Window id's in the client list\end{Desc}
\begin{Desc}
\item[See also:]{\bf client\-List\-Stacking()}{\rm (p.\,\pageref{classNETRootInfo_a21})} \end{Desc}


Definition at line 2503 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!kdeSystemTrayWindows@{kdeSystemTrayWindows}}
\index{kdeSystemTrayWindows@{kdeSystemTrayWindows}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Window $\ast$ NETRoot\-Info::kde\-System\-Tray\-Windows () const}\label{classNETRootInfo_a23}


Returns an array of Window id's, which contain all {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} system tray windows. 

\begin{Desc}
\item[Returns:]the array of Window id's of system tray windows\end{Desc}
\begin{Desc}
\item[See also:]{\bf kde\-System\-Tray\-Windows\-Count()}{\rm (p.\,\pageref{classNETRootInfo_a24})} \end{Desc}


Definition at line 2508 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!kdeSystemTrayWindowsCount@{kdeSystemTrayWindowsCount}}
\index{kdeSystemTrayWindowsCount@{kdeSystemTrayWindowsCount}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::kde\-System\-Tray\-Windows\-Count () const}\label{classNETRootInfo_a24}


Returns the number of windows in the kde\-System\-Tray\-Windows array. 

\begin{Desc}
\item[Returns:]the number of Window id's in the system tray list\end{Desc}
\begin{Desc}
\item[See also:]{\bf kde\-System\-Tray\-Windows()}{\rm (p.\,\pageref{classNETRootInfo_a23})} \end{Desc}


Definition at line 2513 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!desktopGeometry@{desktopGeometry}}
\index{desktopGeometry@{desktopGeometry}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf NETSize} NETRoot\-Info::desktop\-Geometry (int {\em desktop}) const}\label{classNETRootInfo_a25}


Returns the desktop geometry size. 

The desktop argument is ignored. Early drafts of the {\bf NET}{\rm (p.\,\pageref{classNET})} WM Specification were unclear about the semantics of this property.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the size of the desktop \end{Desc}


Definition at line 2518 of file netwm.cpp.

References NETSize::width.\index{NETRootInfo@{NETRoot\-Info}!desktopViewport@{desktopViewport}}
\index{desktopViewport@{desktopViewport}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf NETPoint} NETRoot\-Info::desktop\-Viewport (int {\em desktop}) const}\label{classNETRootInfo_a26}


Returns the viewport of the specified desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the position of the desktop's viewport \end{Desc}


Definition at line 2523 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!workArea@{workArea}}
\index{workArea@{workArea}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf NETRect} NETRoot\-Info::work\-Area (int {\em desktop}) const}\label{classNETRootInfo_a27}


Returns the work\-Area for the specified desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the size of the work area \end{Desc}


Definition at line 2533 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!desktopName@{desktopName}}
\index{desktopName@{desktopName}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const char $\ast$ NETRoot\-Info::desktop\-Name (int {\em desktop}) const}\label{classNETRootInfo_a28}


Returns the name for the specified desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the name of the desktop \end{Desc}


Definition at line 2543 of file netwm.cpp.

Referenced by set\-Desktop\-Name().\index{NETRootInfo@{NETRoot\-Info}!virtualRoots@{virtualRoots}}
\index{virtualRoots@{virtualRoots}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Window $\ast$ NETRoot\-Info::virtual\-Roots () const}\label{classNETRootInfo_a29}


Returns an array of Window id's, which contain the virtual root windows. 

\begin{Desc}
\item[Returns:]the array of Window id's\end{Desc}
\begin{Desc}
\item[See also:]{\bf virtual\-Roots\-Count()}{\rm (p.\,\pageref{classNETRootInfo_a30})} \end{Desc}


Definition at line 2552 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!virtualRootsCount@{virtualRootsCount}}
\index{virtualRootsCount@{virtualRootsCount}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::virtual\-Roots\-Count () const}\label{classNETRootInfo_a30}


Returns the number of window in the virtual\-Roots array. 

\begin{Desc}
\item[Returns:]the number of Window id's in the virtual root array\end{Desc}
\begin{Desc}
\item[See also:]{\bf virtual\-Roots()}{\rm (p.\,\pageref{classNETRootInfo_a29})} \end{Desc}


Definition at line 2557 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!numberOfDesktops@{numberOfDesktops}}
\index{numberOfDesktops@{numberOfDesktops}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::number\-Of\-Desktops () const}\label{classNETRootInfo_a31}


Returns the number of desktops. 

\begin{Desc}
\item[Returns:]the number of desktops \end{Desc}


Definition at line 2562 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!currentDesktop@{currentDesktop}}
\index{currentDesktop@{currentDesktop}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int NETRoot\-Info::current\-Desktop () const}\label{classNETRootInfo_a32}


Returns the current desktop. 

\begin{Desc}
\item[Returns:]the number of the current desktop \end{Desc}


Definition at line 2567 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!activeWindow@{activeWindow}}
\index{activeWindow@{activeWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Window NETRoot\-Info::active\-Window () const}\label{classNETRootInfo_a33}


Returns the active (focused) window. 

\begin{Desc}
\item[Returns:]the id of the active window \end{Desc}


Definition at line 2572 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!activate@{activate}}
\index{activate@{activate}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::activate ()}\label{classNETRootInfo_a34}


Window Managers must call this after creating the NETRoot\-Info object, and before using any other method in the class. 

This method sets initial data on the root window and does other post-construction duties.

Clients must also call this after creating the object to do an initial data read/update. 

Definition at line 813 of file netwm.cpp.

Referenced by NETRoot\-Info().\index{NETRootInfo@{NETRoot\-Info}!setClientList@{setClientList}}
\index{setClientList@{setClientList}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Client\-List (Window $\ast$ {\em windows}, unsigned int {\em count})}\label{classNETRootInfo_a35}


Sets the list of managed windows on the Root/Desktop window. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em windows}]The array of Window id's\item[{\em count}]The number of windows in the array \end{description}
\end{Desc}


Definition at line 833 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setClientListStacking@{setClientListStacking}}
\index{setClientListStacking@{setClientListStacking}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Client\-List\-Stacking (Window $\ast$ {\em windows}, unsigned int {\em count})}\label{classNETRootInfo_a36}


Sets the list of managed windows in stacking order on the Root/Desktop window. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em windows}]The array of Window id's\item[{\em count}]The number of windows in the array. \end{description}
\end{Desc}


Definition at line 852 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setKDESystemTrayWindows@{setKDESystemTrayWindows}}
\index{setKDESystemTrayWindows@{setKDESystemTrayWindows}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-KDESystem\-Tray\-Windows (Window $\ast$ {\em windows}, unsigned int {\em count})}\label{classNETRootInfo_a37}


Sets the list of {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} system tray windows on the root window. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em windows}]The array of window id's\item[{\em count}]The number of windows in the array. \end{description}
\end{Desc}


Definition at line 871 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setCurrentDesktop@{setCurrentDesktop}}
\index{setCurrentDesktop@{setCurrentDesktop}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Current\-Desktop (int {\em desktop})}\label{classNETRootInfo_a38}


Sets the current desktop to the specified desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop \end{description}
\end{Desc}


Definition at line 923 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setDesktopGeometry@{setDesktopGeometry}}
\index{setDesktopGeometry@{setDesktopGeometry}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Desktop\-Geometry (int {\em desktop}, const {\bf NETSize} \& {\em geometry})}\label{classNETRootInfo_a39}


Sets the desktop geometry to the specified geometry. 

The desktop argument is ignored. Early drafts of the {\bf NET}{\rm (p.\,\pageref{classNET})} WM Specification were unclear about the semantics of this property.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\item[{\em geometry}]the new size of the desktop \end{description}
\end{Desc}


Definition at line 991 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setDesktopViewport@{setDesktopViewport}}
\index{setDesktopViewport@{setDesktopViewport}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Desktop\-Viewport (int {\em desktop}, const {\bf NETPoint} \& {\em viewport})}\label{classNETRootInfo_a40}


Sets the viewport for the current desktop to the specified point. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\item[{\em viewport}]the new position of the desktop's viewport \end{description}
\end{Desc}


Definition at line 1026 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setNumberOfDesktops@{setNumberOfDesktops}}
\index{setNumberOfDesktops@{setNumberOfDesktops}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Number\-Of\-Desktops (int {\em number\-Of\-Desktops})}\label{classNETRootInfo_a41}


Sets the number of desktops the the specified number. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em number\-Of\-Desktops}]the number of desktops \end{description}
\end{Desc}


Definition at line 891 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setDesktopName@{setDesktopName}}
\index{setDesktopName@{setDesktopName}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Desktop\-Name (int {\em desktop}, const char $\ast$ {\em desktop\-Name})}\label{classNETRootInfo_a42}


Sets the name of the specified desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\item[{\em desktop\-Name}]the new name of the desktop \end{description}
\end{Desc}


Definition at line 955 of file netwm.cpp.

References desktop\-Name().\index{NETRootInfo@{NETRoot\-Info}!setActiveWindow@{setActiveWindow}}
\index{setActiveWindow@{setActiveWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Active\-Window (Window {\em window}, {\bf NET::Request\-Source} {\em src}, Time {\em timestamp}, Window {\em active\_\-window})}\label{classNETRootInfo_a43}


Requests that the specified window becomes the active (focused) one. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the new active window \item[{\em src}]whether the request comes from normal application or from a pager or similar tool \item[{\em timestamp}]X server timestamp of the user action that caused the request \item[{\em active\_\-window}]active window of the requesting application, if any\end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1491 of file netwm.cpp.

Referenced by set\-Active\-Window().\index{NETRootInfo@{NETRoot\-Info}!setActiveWindow@{setActiveWindow}}
\index{setActiveWindow@{setActiveWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Active\-Window (Window {\em window})}\label{classNETRootInfo_a44}


Sets the active (focused) window the specified window. 

This should be used only in the window manager mode.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the if of the new active window \end{description}
\end{Desc}


Definition at line 1487 of file netwm.cpp.

References set\-Active\-Window().\index{NETRootInfo@{NETRoot\-Info}!setWorkArea@{setWorkArea}}
\index{setWorkArea@{setWorkArea}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Work\-Area (int {\em desktop}, const {\bf NETRect} \& {\em work\-Area})}\label{classNETRootInfo_a45}


Sets the workarea for the specified desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\item[{\em work\-Area}]the new work area of the desktop \end{description}
\end{Desc}


Definition at line 1522 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!setVirtualRoots@{setVirtualRoots}}
\index{setVirtualRoots@{setVirtualRoots}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::set\-Virtual\-Roots (Window $\ast$ {\em windows}, unsigned int {\em count})}\label{classNETRootInfo_a46}


Sets the list of virtual root windows on the root window. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em windows}]The array of Window id's\item[{\em count}]The number of windows in the array. \end{description}
\end{Desc}


Definition at line 1551 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!operator=@{operator=}}
\index{operator=@{operator=}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const {\bf NETRoot\-Info} \& NETRoot\-Info::operator= (const {\bf NETRoot\-Info} \& {\em rootinfo})}\label{classNETRootInfo_a47}


Assignment operator. 

Ensures that the shared data reference counts are correct. 

Definition at line 1720 of file netwm.cpp.

References p, and role.\index{NETRootInfo@{NETRoot\-Info}!closeWindowRequest@{closeWindowRequest}}
\index{closeWindowRequest@{closeWindowRequest}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::close\-Window\-Request (Window {\em window})}\label{classNETRootInfo_a48}


Clients (such as pagers/taskbars) that wish to close a window should call this function. 

This will send a request to the Window Manager, which usually can usually decide how to react to such requests.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to close \end{description}
\end{Desc}


Definition at line 1568 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!moveResizeRequest@{moveResizeRequest}}
\index{moveResizeRequest@{moveResizeRequest}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::move\-Resize\-Request (Window {\em window}, int {\em x\_\-root}, int {\em y\_\-root}, {\bf Direction} {\em direction})}\label{classNETRootInfo_a49}


Clients (such as pagers/taskbars) that wish to start a WMMove\-Resize (where the window manager controls the resize/movement, i.e. 

\_\-NET\_\-WM\_\-MOVERESIZE) should call this function. This will send a request to the Window Manager.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]The client window that would be resized/moved.\item[{\em x\_\-root}]X position of the cursor relative to the root window.\item[{\em y\_\-root}]Y position of the cursor relative to the root window.\item[{\em direction}]One of {\bf NET::Direction}{\rm (p.\,\pageref{classNET_w118})} (see base class documentation for a description of the different directions). \end{description}
\end{Desc}


Definition at line 1592 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!moveResizeWindowRequest@{moveResizeWindowRequest}}
\index{moveResizeWindowRequest@{moveResizeWindowRequest}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::move\-Resize\-Window\-Request (Window {\em window}, int {\em flags}, int {\em x}, int {\em y}, int {\em width}, int {\em height})}\label{classNETRootInfo_a50}


Clients (such as pagers/taskbars) that wish to move/resize a window using WM2Move\-Resize\-Window (\_\-NET\_\-MOVERESIZE\_\-WINDOW) should call this function. 

This will send a request to the Window Manager. See \_\-NET\_\-MOVERESIZE\_\-WINDOW description for details.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]The client window that would be resized/moved. \item[{\em flags}]Flags specifying the operation (see \_\-NET\_\-MOVERESIZE\_\-WINDOW description) \item[{\em x}]Requested X position for the window \item[{\em y}]Requested Y position for the window \item[{\em width}]Requested width for the window \item[{\em height}]Requested height for the window\end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1618 of file netwm.cpp.\index{NETRootInfo@{NETRoot\-Info}!restackRequest@{restackRequest}}
\index{restackRequest@{restackRequest}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::restack\-Request (Window {\em window}, {\bf Request\-Source} {\em source}, Window {\em above}, int {\em detail}, Time {\em timestamp})}\label{classNETRootInfo_a51}


Sends the \_\-NET\_\-RESTACK\_\-WINDOW request. 

\begin{Desc}
\item[Since:]3.3 \end{Desc}


Definition at line 1648 of file netwm.cpp.

Referenced by restack\-Request().\index{NETRootInfo@{NETRoot\-Info}!restackRequest@{restackRequest}}
\index{restackRequest@{restackRequest}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::restack\-Request (Window {\em window}, Window {\em above}, int {\em detail})}\label{classNETRootInfo_a52}


\begin{Desc}
\item[{\bf Deprecated}]\begin{Desc}
\item[Since:]3.2 \end{Desc}
\end{Desc}


Definition at line 1643 of file netwm.cpp.

References restack\-Request().\index{NETRootInfo@{NETRoot\-Info}!event@{event}}
\index{event@{event}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void NETRoot\-Info::event (XEvent $\ast$ {\em event}, unsigned long $\ast$ {\em properties}, int {\em properties\_\-size})}\label{classNETRootInfo_a53}


This function takes the passed XEvent and returns an OR'ed list of NETRoot\-Info properties that have changed in the properties argument. 

The new information will be read immediately by the class. The elements of the properties argument are as they would be passed to the constructor, if the array is not large enough, changed properties that don't fit in it won't be listed there (they'll be updated in the class though).

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em event}]the event \item[{\em properties}]properties that changed \item[{\em properties\_\-size}]size of the passed properties array \end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1746 of file netwm.cpp.

References NETRoot\-Info2::change\-Active\-Window(), change\-Active\-Window(), change\-Current\-Desktop(), change\-Desktop\-Geometry(), change\-Desktop\-Viewport(), change\-Number\-Of\-Desktops(), close\-Window(), event(), NETRoot\-Info2::got\-Ping(), NETRoot\-Info3::got\-Take\-Activity(), NETSize::height, move\-Resize(), NETRoot\-Info2::move\-Resize\-Window(), NETRoot\-Info2::restack\-Window(), NETRoot\-Info3::restack\-Window(), NETSize::width, NETPoint::x, and NETPoint::y.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!event@{event}}
\index{event@{event}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned long NETRoot\-Info::event (XEvent $\ast$ {\em event})}\label{classNETRootInfo_a54}


This function takes the passed XEvent and returns an OR'ed list of NETRoot\-Info properties that have changed. 

The new information will be read immediately by the class. This overloaded version returns only a single mask, and therefore cannot check state of all properties like the other variant.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em event}]the event\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the properties \end{Desc}


Definition at line 1739 of file netwm.cpp.

References event().\index{NETRootInfo@{NETRoot\-Info}!addClient@{addClient}}
\index{addClient@{addClient}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::add\-Client (Window {\em window})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b0}


A Client should subclass NETRoot\-Info and reimplement this function when it wants to know when a window has been added. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to add \end{description}
\end{Desc}


Definition at line 618 of file netwm.h.\index{NETRootInfo@{NETRoot\-Info}!removeClient@{removeClient}}
\index{removeClient@{removeClient}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::remove\-Client (Window {\em window})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b1}


A Client should subclass NETRoot\-Info and reimplement this function when it wants to know when a window has been removed. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to remove \end{description}
\end{Desc}


Definition at line 626 of file netwm.h.\index{NETRootInfo@{NETRoot\-Info}!addSystemTrayWin@{addSystemTrayWin}}
\index{addSystemTrayWin@{addSystemTrayWin}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::add\-System\-Tray\-Win (Window {\em window})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b2}


A Client should subclass NETRoot\-Info and reimplement this function when it wants to know when a system tray window has been added. 

This is a {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} 2.0 extension.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to add \end{description}
\end{Desc}


Definition at line 635 of file netwm.h.\index{NETRootInfo@{NETRoot\-Info}!removeSystemTrayWin@{removeSystemTrayWin}}
\index{removeSystemTrayWin@{removeSystemTrayWin}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::remove\-System\-Tray\-Win (Window {\em window})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b3}


A Client should subclass NETRoot\-Info and reimplement this function when it wants to know when a system tray window has been removed. 

This is a {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} 2.0 extension.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to remove \end{description}
\end{Desc}


Definition at line 644 of file netwm.h.\index{NETRootInfo@{NETRoot\-Info}!changeNumberOfDesktops@{changeNumberOfDesktops}}
\index{changeNumberOfDesktops@{changeNumberOfDesktops}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::change\-Number\-Of\-Desktops (int {\em number\-Of\-Desktops})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b4}


A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to change the number of desktops. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em number\-Of\-Desktops}]the new number of desktops \end{description}
\end{Desc}


Definition at line 653 of file netwm.h.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!changeDesktopGeometry@{changeDesktopGeometry}}
\index{changeDesktopGeometry@{changeDesktopGeometry}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::change\-Desktop\-Geometry (int {\em desktop}, const {\bf NETSize} \& {\em geom})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b5}


A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to change the specified desktop geometry. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\item[{\em geom}]the new size \end{description}
\end{Desc}


Definition at line 664 of file netwm.h.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!changeDesktopViewport@{changeDesktopViewport}}
\index{changeDesktopViewport@{changeDesktopViewport}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::change\-Desktop\-Viewport (int {\em desktop}, const {\bf NETPoint} \& {\em viewport})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b6}


A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to change the specified desktop viewport. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop\item[{\em viewport}]the new position of the viewport \end{description}
\end{Desc}


Definition at line 675 of file netwm.h.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!changeCurrentDesktop@{changeCurrentDesktop}}
\index{changeCurrentDesktop@{changeCurrentDesktop}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::change\-Current\-Desktop (int {\em desktop})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b7}


A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to change the current desktop. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em desktop}]the number of the desktop \end{description}
\end{Desc}


Definition at line 684 of file netwm.h.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!changeActiveWindow@{changeActiveWindow}}
\index{changeActiveWindow@{changeActiveWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual KDE\_\-DEPRECATED void NETRoot\-Info::change\-Active\-Window (Window {\em window})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b8}


\begin{Desc}
\item[{\bf Deprecated}]Use {\bf NETRoot\-Info2::change\-Active\-Window()}{\rm (p.\,\pageref{classNETRootInfo2_b1})} instead. A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to change the active (focused) window. The {\bf change\-Active\-Window()}{\rm (p.\,\pageref{classNETRootInfo_b8})} method in {\bf NETRoot\-Info2}{\rm (p.\,\pageref{classNETRootInfo2})} should be used instead. \end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to activate \end{description}
\end{Desc}


Definition at line 695 of file netwm.h.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!closeWindow@{closeWindow}}
\index{closeWindow@{closeWindow}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::close\-Window (Window {\em window})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b9}


A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to close a window. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]the id of the window to close \end{description}
\end{Desc}


Definition at line 703 of file netwm.h.

Referenced by event().\index{NETRootInfo@{NETRoot\-Info}!moveResize@{moveResize}}
\index{moveResize@{moveResize}!NETRootInfo@{NETRoot\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void NETRoot\-Info::move\-Resize (Window {\em window}, int {\em x\_\-root}, int {\em y\_\-root}, unsigned long {\em direction})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classNETRootInfo_b10}


A Window Manager should subclass NETRoot\-Info and reimplement this function when it wants to know when a Client made a request to start a move/resize. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em window}]The window that wants to move/resize\item[{\em x\_\-root}]X position of the cursor relative to the root window.\item[{\em y\_\-root}]Y position of the cursor relative to the root window.\item[{\em direction}]One of {\bf NET::Direction}{\rm (p.\,\pageref{classNET_w118})} (see base class documentation for a description of the different directions). \end{description}
\end{Desc}


Definition at line 718 of file netwm.h.

Referenced by event().

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