Client Class Reference

The Client class is responsible for managing the client windows. It creates a frame around the client window, Map the frame, Add the window to the save set, Reparent it, grab the buttons It also unframe the client window by removing the frame and reparenting the window to the root window It also move, resize, restack the client window. More...

#include <Client.hpp>

Collaboration diagram for Client:

Public Member Functions
	Client (Display *display, Window root, Window window, std::shared_ptr< Group > group, unsigned long inActiveColor, int borderSize, std::shared_ptr< BaseX11Wrapper > wrapper)
	Client constructor.get window class and title. More...
	~Client ()
	Client destructor Destroy the Client object & the Frame Window it needed. More...
void	frame ()
	Client::frame create a frame around the client window, Map the frame, Add the window to the save set Reparent it, grab the buttons. More...
void	unframe ()
	Client::unframe unframe the client window by removing the frame and reparenting the window to the root window. More...
Window	getWindow () const
	Client::getWindow return the window attribute of the client. More...
std::shared_ptr< Group >	getGroup () const
	return the group of the client More...
void	move (int x, int y)
	: Client::move move the client window to the given position More...
void	resize (unsigned int width, unsigned int height)
	Client::resize resize the client window to the given size. More...
bool	isFramed () const
	Client::isFramed() check if the client is framed. More...
void	setMapped (bool mapped)
	Client::setMapped() set the mapped status of the client. More...
bool	isMapped () const
	Client::isMapped() check if the client is mapped. More...
const std::string &	getTitle () const
	Client::getTitle() return the title of the client, the title is get during the construction of the client. More...
const std::string &	getClass () const
	Client::getClass() return the class of the client, the class is get during the construction of the client. More...
Window	getFrame () const
	Client::getFrame() return the frame Window of the client. More...
void	restack ()
	Client::restack() restack the client window to avoid the frame to get in front of the client. More...
void	setGroup (std::shared_ptr< Group > g)

Private Attributes
Display *	display_
Window	root_
Window	window_
Window	frame_
unsigned int	border_width
unsigned long	border_color
bool	framed
bool	mapped {}
std::string	title_
std::string	class_
std::weak_ptr< Group >	group_
std::shared_ptr< BaseX11Wrapper >	wrapper

Detailed Description

The Client class is responsible for managing the client windows. It creates a frame around the client window, Map the frame, Add the window to the save set, Reparent it, grab the buttons It also unframe the client window by removing the frame and reparenting the window to the root window It also move, resize, restack the client window.

Constructor & Destructor Documentation

Client()

Client::Client	(	Display *	display,
		Window	root,
		Window	window,
		std::shared_ptr< Group >	group,
		unsigned long	inActiveColor,
		int	borderSize,
		std::shared_ptr< BaseX11Wrapper >	wrapper
	)

Client constructor.get window class and title.

Parameters

display	X11 display
root	root window
window	window to manage
layout_manager	Reference to the layout manager
inActiveColor	color of the border
borderSize	size of the border
wrapper	X11 wrapper

        : display_(display),
          root_(root),
          group_(std::weak_ptr<Group>(g)),
          window_(window),
          frame_(0),
          border_width(borderSize),
          border_color(inActiveColor),
          framed(false),
          mapped(false),
          wrapper(x11Wrapper)
{
    Atom wmClassAtom = wrapper->internAtom(display, "WM_CLASS", False);
    Atom actualType = 0;
    int actualFormat = 0;
    unsigned long nItems = 0, bytesAfter = 0;
    unsigned char* propData = 0;
    wrapper->getWindowProperty(display,
                                   window,
                                   wmClassAtom,
                                   0,
                                   1024,
                                   False,
                                   AnyPropertyType,
                                   &actualType,
                                   &actualFormat,
                                   &nItems,
                                   &bytesAfter,
                                   &propData);
    if (actualType == XA_STRING && actualFormat == 8 && nItems > 1) {
        char* instanceName = reinterpret_cast<char*>(propData);
        char* className = instanceName + strlen(instanceName) + 1;
        this->class_ = className;
        this->title_ = instanceName;
    } else {
        Logger::GetInstance()->Log("Failed to get WM_CLASS property", L_ERROR);
        this->class_ = "Unknown";
        this->title_ = "Unknown";
    }
    wrapper->freeX(propData);
}

References class_, Logger::GetInstance(), L_ERROR, Logger::Log(), title_, and wrapper.

Here is the call graph for this function:

~Client()

Client::~Client

(

)

Client destructor Destroy the Client object & the Frame Window it needed.

                {
    try {
        if (this->framed) {
            wrapper->destroyWindow(display_, frame_);
        }
    } catch (const X11Exception &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
    Logger::GetInstance()->Log("Client destroyed :" + title_, L_INFO);
}

References display_, frame_, framed, Logger::GetInstance(), L_ERROR, L_INFO, Logger::Log(), title_, and wrapper.

Here is the call graph for this function:

Member Function Documentation

frame()

void Client::frame

(

)

Client::frame create a frame around the client window, Map the frame, Add the window to the save set Reparent it, grab the buttons.

                   {
    const unsigned long BG_COLOR = 0x000000;
    auto g = group_.lock();
    if (g) {
        border_width = g->getBorderSize();
        border_color = g->getInactiveColor();
    } else {
        throw YggdrasilException("Group no longer exists");
    }
    if (this->framed)
        throw YggdrasilException("Client is already framed");
    XWindowAttributes x_window_attrs;
    wrapper->getWindowAttributes(display_, window_, &x_window_attrs);
    if (x_window_attrs.override_redirect)
        throw YggdrasilException("ignoring window with override redirect attribute.");
    this->frame_ = wrapper->createSimpleWindow(
            display_,
            root_,
            x_window_attrs.x,
            x_window_attrs.y,
            x_window_attrs.width,
            x_window_attrs.height,
            border_width,
            border_color,
            BG_COLOR
            );
    wrapper->selectInput(
            display_,
            this->frame_,
            SubstructureRedirectMask | SubstructureNotifyMask | FocusChangeMask | ClientMessage);
    wrapper->addToSaveSet(display_,window_);
    wrapper->reparentWindow(
            display_,
            window_,
            frame_,
            0,0
            );
    wrapper->mapWindow(display_,frame_);
    //   a. Move windows with alt + left button.
    wrapper->grabButton(
            display_,
            Button1,
            Mod1Mask,
            window_,
            false,
            ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
            GrabModeAsync,
            GrabModeAsync,
            None,
            None);
    try {
        ConfigHandler::GetInstance().getConfigData<ConfigDataBindings>()->grabKeys(display_, window_);
    } catch (const std::exception &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
    this->framed = true;
//  this->group_->addClient(window_, this);
}

References border_color, border_width, display_, frame_, framed, ConfigHandler::getConfigData(), ConfigHandler::GetInstance(), Logger::GetInstance(), group_, L_ERROR, Logger::Log(), root_, window_, and wrapper.

Here is the call graph for this function:

getClass()

const std::string & Client::getClass

(

)

const

Client::getClass() return the class of the client, the class is get during the construction of the client.

Returns

{ return class_; }

References class_.

getFrame()

Window Client::getFrame

(

)

const

Client::getFrame() return the frame Window of the client.

Returns

Window (frame)

{return frame_; }

References frame_.

Referenced by EventHandler::handleFocusIn(), EventHandler::handleFocusOut(), and EventHandler::handleMapNotify().

Here is the caller graph for this function:

getGroup()

Group * Client::getGroup

(

)

const

return the group of the client

Returns

{ return group_.lock(); }

References group_.

Referenced by EventHandler::handleFocusIn(), and EventHandler::handleFocusOut().

Here is the caller graph for this function:

getTitle()

const std::string & Client::getTitle

(

)

const

Client::getTitle() return the title of the client, the title is get during the construction of the client.

Returns

std::string

{ return title_; }

References title_.

Referenced by EventHandler::handleFocusIn(), EventHandler::handleFocusOut(), and EventHandler::handleMapNotify().

Here is the caller graph for this function:

getWindow()

Window Client::getWindow

(

)

const

Client::getWindow return the window attribute of the client.

Returns

Window

                               {
    return this->window_;
}

References window_.

Referenced by Group::removeClient(), and WindowManager::setFocus().

Here is the caller graph for this function:

isFramed()

bool Client::isFramed

(

)

const

Client::isFramed() check if the client is framed.

Returns

{   return framed; }

References framed.

isMapped()

bool Client::isMapped

(

)

const

Client::isMapped() check if the client is mapped.

Returns

bool

{ return mapped; }

References mapped.

move()

void Client::move	(	int	x,
		int	y
	)

: Client::move move the client window to the given position

Parameters

x
y

                              {
    try {
        if (this->framed) {
            wrapper->moveWindow(display_, frame_, x, y);
        } else {
            wrapper->moveWindow(display_, window_, x + (int) border_width / 2, y + (int) border_width / 2);
        }
    } catch (const X11Exception &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
}

References border_width, display_, frame_, framed, Logger::GetInstance(), L_ERROR, Logger::Log(), window_, and wrapper.

Here is the call graph for this function:

resize()

void Client::resize	(	unsigned int	width,
		unsigned int	height
	)

Client::resize resize the client window to the given size.

Parameters

width
height

                                                          {
    try {
        if (this->framed) {
            wrapper->resizeWindow(display_, frame_, width, height);
        }
        wrapper->resizeWindow(display_, window_, width - border_width, height - border_width);
    } catch (const X11Exception &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
}

References border_width, display_, frame_, framed, Logger::GetInstance(), L_ERROR, Logger::Log(), window_, and wrapper.

Here is the call graph for this function:

restack()

void Client::restack

(

)

Client::restack() restack the client window to avoid the frame to get in front of the client.

                     {
    try {
        if (this->framed) {
            wrapper->raiseWindow(display_, frame_);
        }
        wrapper->raiseWindow(display_, window_);
    } catch (const X11Exception &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
}

References display_, frame_, framed, Logger::GetInstance(), L_ERROR, Logger::Log(), window_, and wrapper.

Referenced by EventHandler::handleMapNotify().

Here is the call graph for this function:

Here is the caller graph for this function:

setGroup()

void Client::setGroup

(

std::shared_ptr< Group >

g

)

{ this->group_ = std::weak_ptr<Group>(g);}

References group_.

setMapped()

void Client::setMapped

(

bool

mapped

)

Client::setMapped() set the mapped status of the client.

Parameters

mapped

{ Client::mapped = m; }

References mapped.

Referenced by EventHandler::handleMapNotify().

Here is the caller graph for this function:

unframe()

void Client::unframe

(

)

Client::unframe unframe the client window by removing the frame and reparenting the window to the root window.

                     {
    if (!this->framed)
        throw YggdrasilException("Client is not framed");
    try {
        wrapper->destroyWindow(display_,frame_);
    } catch (const std::exception &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
    this->framed = false;
    this->frame_ = 0;
}

References display_, frame_, framed, Logger::GetInstance(), L_ERROR, Logger::Log(), and wrapper.

Here is the call graph for this function:

Member Data Documentation

border_color

unsigned long Client::border_color

private

Referenced by frame().

border_width

unsigned int Client::border_width

private

Referenced by frame(), move(), and resize().

class_

std::string Client::class_

private

Referenced by Client(), and getClass().

display_

Display* Client::display_

private

Referenced by frame(), move(), resize(), restack(), unframe(), and ~Client().

frame_

Window Client::frame_

private

Referenced by frame(), getFrame(), move(), resize(), restack(), unframe(), and ~Client().

framed

bool Client::framed

private

Referenced by frame(), isFramed(), move(), resize(), restack(), unframe(), and ~Client().

group_

std::weak_ptr<Group> Client::group_

private

Referenced by frame(), getGroup(), and setGroup().

mapped

bool Client::mapped {}

private

Referenced by isMapped(), and setMapped().

root_

Window Client::root_

private

Referenced by frame().

title_

std::string Client::title_

private

Referenced by Client(), getTitle(), and ~Client().

window_

Window Client::window_

private

Referenced by frame(), getWindow(), move(), resize(), and restack().

wrapper

std::shared_ptr<BaseX11Wrapper> Client::wrapper

private

Referenced by Client(), frame(), move(), resize(), restack(), unframe(), and ~Client().

---

The documentation for this class was generated from the following files:

• inc/Client.hpp
• src/Client.cpp