TreeLayoutManager Class Reference

TreeLayoutManager class this class is a subclass of LayoutManager it handles the tree style layout When a client is added, it looks recursively for the biggest space and splits it in two placing the new client in the left space and the old client in the right space. More...

#include <TreeLayoutManager.hpp>

Inheritance diagram for TreeLayoutManager:

Collaboration diagram for TreeLayoutManager:

Public Member Functions
	TreeLayoutManager (Display *display, Window root, int sizeX, int sizeY, int posX, int posY, int borderSize, int gap, int barHeight)
	Construct a new Tree Layout Manager object the size and position of the root space should take account of the bar size and position and the border size. More...
	~TreeLayoutManager () override
	Destroy the Tree Layout Manager object. More...
void	updateGeometry (unsigned int sizeX, unsigned int sizeY, unsigned int posX, unsigned int posY) override
	update the geometry of the layout (resize) More...
void	reSize (const Point &size, const Point &pos) override
void	recursiveResize (const Point &size, const Point &pos, BinarySpace *space)
BinarySpace *	findSpace (Client *client)
	find the space containing the client it looks recursively for the space containing the client More...
BinarySpace *	findSpaceRecursive (Client *client, BinarySpace *space)
	recursive method to find the space containing the client More...
BinarySpace *	findSpace (int index)
void	addClient (std::shared_ptr< Client > client) override
	add a client to the layout it looks for the biggest space and splits it in two More...
void	addClientRecursive (std::shared_ptr< Client > client, BinarySpace *space)
void	placeClientInSpace (const std::shared_ptr< Client > &client, BinarySpace *space)
	place a client in a space moves and resizes the client window to fit the space restack the client window More...
void	splitSpace (const std::shared_ptr< Client > &client, BinarySpace *space, bool splitAlongX)
	split a space in two Move the client to the left space and the old client to the right space increase the subspaces counter of all the parent spaces More...
void	removeClient (Client *client) override
	remove a client from the layout use the recursive method to remove the client More...
void	removeClientRecursive (Client *client, BinarySpace *space)
	recursive method to add a client to the layout More...
void	growSpace (Client *client, int inc)
	grow the space of the client in the x axis More...
void	recursiveShrinkSiblingSpace (BinarySpace *space, int inc, bool vertical)

Protected Attributes
int	screen_width_
int	screen_height_
int	gap_
int	border_size_
int	space_count_
Display *	display_
Window	rootWindow_

Private Member Functions
void	deleteSpace (BinarySpace *space)

Private Attributes
std::unique_ptr< BinarySpace >	rootSpace_

Detailed Description

TreeLayoutManager class this class is a subclass of LayoutManager it handles the tree style layout When a client is added, it looks recursively for the biggest space and splits it in two placing the new client in the left space and the old client in the right space.

Constructor & Destructor Documentation

TreeLayoutManager()

TreeLayoutManager::TreeLayoutManager	(	Display *	display,
		Window	root,
		int	sizeX,
		int	sizeY,
		int	posX,
		int	posY,
		int	borderSize,
		int	gap,
		int	barHeight
	)

Construct a new Tree Layout Manager object the size and position of the root space should take account of the bar size and position and the border size.

Parameters

display
root
sizeX
sizeY
posX
posY
borderSize
gap
barHeight

                                                    :
    LayoutManager(display, root, sizeX, sizeY, posX, posY, gap, barHeight) {
    Point pos(posX, posY);
    Point size(sizeX - borderSize, sizeY - borderSize);
    this->rootSpace_ = std::make_unique<BinarySpace>(pos, size, 0);
}

References rootSpace_.

~TreeLayoutManager()

TreeLayoutManager::~TreeLayoutManager ( )

override

Destroy the Tree Layout Manager object.

{}

Member Function Documentation

addClient()

void TreeLayoutManager::addClient ( std::shared_ptr< Client >  client )

overridevirtual

add a client to the layout it looks for the biggest space and splits it in two

Parameters

client

See also

addClientRecursive

placeClientInSpace

Implements LayoutManager.

                                                              {
    addClientRecursive(client, rootSpace_.get());
}

References addClientRecursive(), and rootSpace_.

Here is the call graph for this function:

addClientRecursive()

void TreeLayoutManager::addClientRecursive	(	std::shared_ptr< Client >	client,
		BinarySpace *	space
	)

                                                                                           {
    if (space->getClient() == nullptr && space->getLeft() == nullptr && space->getRight() == nullptr ) {
        placeClientInSpace(client, space);
        return;
    }
    if (space->getLeft() != nullptr && space->getRight() != nullptr) {
        if (space->getLeft()->getSubspaceCount() > space->getRight()->getSubspaceCount()) {
            addClientRecursive(client, space->getRight().get());
        } else {
            addClientRecursive(client, space->getLeft().get());
        }
        return;
    }
    if (space->getSize().x > space->getSize().y) {
        splitSpace(client, space, true);
    } else {
        splitSpace(client, space, false);
    }
}

References BinarySpace::getClient(), BinarySpace::getLeft(), BinarySpace::getRight(), BinarySpace::getSize(), placeClientInSpace(), splitSpace(), Point::x, and Point::y.

Referenced by addClient().

Here is the call graph for this function:

Here is the caller graph for this function:

deleteSpace()

void TreeLayoutManager::deleteSpace ( BinarySpace *  space )

private

                                                      {
    if (space->getLeft() != nullptr) {
        deleteSpace(space->getLeft().get());
    }
    if (space->getRight() != nullptr) {
        deleteSpace(space->getRight().get());
    }
    delete space;
}

References BinarySpace::getLeft(), and BinarySpace::getRight().

Here is the call graph for this function:

findSpace() [1/2]

BinarySpace * TreeLayoutManager::findSpace

(

Client *

client

)

find the space containing the client it looks recursively for the space containing the client

Parameters

client

Returns

                                                         {
    BinarySpace* space = rootSpace_.get();
    return findSpaceRecursive(client, space);
}

References findSpaceRecursive(), and rootSpace_.

Referenced by growSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

findSpace() [2/2]

BinarySpace * TreeLayoutManager::findSpace

(

int

index

)

                                                    {
    return nullptr;
}

findSpaceRecursive()

BinarySpace * TreeLayoutManager::findSpaceRecursive	(	Client *	client,
		BinarySpace *	space
	)

recursive method to find the space containing the client

Parameters

client
space

Returns

                                                                         {
    if (space->getClient().get() == client) {
        return space;
    }
    if (space->getLeft() != nullptr) {
        BinarySpace * leftSpace = findSpaceRecursive(client, space->getLeft().get());
        if (leftSpace != nullptr) {
            return leftSpace;
        }
    }
    if (space->getRight() != nullptr) {
        BinarySpace * rightSpace = findSpaceRecursive(client, space->getRight().get());
        if (rightSpace != nullptr) {
            return rightSpace;
        }
    }
    return nullptr;
}

References BinarySpace::getClient(), BinarySpace::getLeft(), and BinarySpace::getRight().

Referenced by findSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

growSpace()

void TreeLayoutManager::growSpace	(	Client *	client,
		int	inc
	)

grow the space of the client in the x axis

Todo:

this method is not implemented yet

Parameters

client

                                                         {
    BinarySpace *space = findSpace(client);
    if (space == nullptr || space == rootSpace_.get()) {
        return;
    }
    bool isLeftChild = (space->getParent()->getLeft().get() == space);
    int dx = std::abs((int)space->getSize().x - (int)space->getParent()->getSize().x);
    int dy = std::abs((int)space->getSize().y - (int)space->getParent()->getSize().y);
    bool vertical;
    if (std::max(dx, dy) == dx) {
        vertical = false;
    } else {
        vertical = true;
    }
    BinarySpace *siblingSpace = isLeftChild ? space->getParent()->getRight().get()
                                            : space->getParent()->getLeft().get();
    space->setSize(vertical ? Point(space->getSize().x, space->getSize().y + inc) : Point(space->getSize().x + inc,
                                                                                          space->getSize().y));
    if (!isLeftChild) {
        space->setPos(vertical ? Point(space->getPos().x, space->getPos().y - inc) : Point(space->getPos().x - inc,
                                                                                          space->getPos().y));
    } else {
        siblingSpace->setPos(vertical ? Point(siblingSpace->getPos().x, siblingSpace->getPos().y + inc) : Point(
                siblingSpace->getPos().x + inc, siblingSpace->getPos().y));
    }
    if (space->getClient() != nullptr) {
        placeClientInSpace(space->getClient(), space);
    }
    siblingSpace->setSize(vertical ? Point(siblingSpace->getSize().x, siblingSpace->getSize().y - inc) : Point(
            siblingSpace->getSize().x - inc, siblingSpace->getSize().y));
    if (siblingSpace->getClient() != nullptr) {
        placeClientInSpace(siblingSpace->getClient(), siblingSpace);
    } else {
        recursiveShrinkSiblingSpace(siblingSpace, inc, vertical);
    }
}

References findSpace(), BinarySpace::getClient(), BinarySpace::getLeft(), BinarySpace::getParent(), BinarySpace::getPos(), BinarySpace::getRight(), BinarySpace::getSize(), placeClientInSpace(), recursiveShrinkSiblingSpace(), rootSpace_, BinarySpace::setPos(), BinarySpace::setSize(), Point::x, and Point::y.

Referenced by Grow::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

placeClientInSpace()

void TreeLayoutManager::placeClientInSpace	(	const std::shared_ptr< Client > &	client,
		BinarySpace *	space
	)

place a client in a space moves and resizes the client window to fit the space restack the client window

Parameters

client
space

                                                                                                  {
    client->move(static_cast<int>(space->getPos().x) + border_size_ + gap_ / 2,static_cast<int>(space->getPos().y) + border_size_ + gap_ / 2);
    client->resize(space->getSize().x - (border_size_ * 2)- gap_, space->getSize().y - (border_size_ * 2) - gap_);
    client->restack();
    if (space->getClient().get() != client.get())
        space->setClient(client);
}

References LayoutManager::border_size_, LayoutManager::gap_, BinarySpace::getClient(), BinarySpace::getPos(), BinarySpace::getSize(), BinarySpace::setClient(), Point::x, and Point::y.

Referenced by addClientRecursive(), growSpace(), recursiveResize(), recursiveShrinkSiblingSpace(), removeClientRecursive(), and splitSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

recursiveResize()

void TreeLayoutManager::recursiveResize	(	const Point &	size,
		const Point &	pos,
		BinarySpace *	space
	)

                                                             {
    Point oldSize = space->getSize();
    space->setSize(size);
    space->setPos(pos);
    if (space->getClient() != nullptr) {
        placeClientInSpace(space->getClient(), space);
    }
    if (space->getLeft() != nullptr) {
        Point leftPos = pos;
        Point leftSize = size;
        Point rightPos = pos;
        Point rightSize = size;
        if (space->getLeft()->getSize().x == oldSize.x) {
            leftSize.y = size.y / 2;
            rightSize.y = size.y - leftSize.y;
            rightPos.y = pos.y + leftSize.y;
        } else {
            leftSize.x = size.x / 2;
            rightSize.x = size.x - leftSize.x;
            rightPos.x = pos.x + leftSize.x;
        }
        recursiveResize(leftSize, leftPos, space->getLeft().get());
        recursiveResize(rightSize, rightPos, space->getRight().get());
    } 
}

References BinarySpace::getClient(), BinarySpace::getLeft(), BinarySpace::getRight(), BinarySpace::getSize(), placeClientInSpace(), BinarySpace::setPos(), BinarySpace::setSize(), Point::x, and Point::y.

Referenced by reSize().

Here is the call graph for this function:

Here is the caller graph for this function:

recursiveShrinkSiblingSpace()

void TreeLayoutManager::recursiveShrinkSiblingSpace	(	BinarySpace *	space,
		int	inc,
		bool	vertical
	)

                                                                                              {
    if (space->getLeft() != nullptr) {
        recursiveShrinkSiblingSpace(space->getLeft().get(), inc, vertical);
    }
    if (space->getRight() != nullptr) {
        recursiveShrinkSiblingSpace(space->getRight().get(), inc, vertical);
    }
    space->setSize(vertical ? Point(space->getSize().x, space->getSize().y - inc) : Point(space->getSize().x - inc,
                                                                                          space->getSize().y));
    if (space->getClient() != nullptr) {
        placeClientInSpace(space->getClient(), space);
    }
}

References BinarySpace::getClient(), BinarySpace::getLeft(), BinarySpace::getRight(), BinarySpace::getSize(), placeClientInSpace(), BinarySpace::setSize(), Point::x, and Point::y.

Referenced by growSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

removeClient()

void TreeLayoutManager::removeClient ( Client *  client )

overridevirtual

remove a client from the layout use the recursive method to remove the client

Parameters

client

Implements LayoutManager.

                                                   {
    removeClientRecursive(client, rootSpace_.get());
}

References removeClientRecursive(), and rootSpace_.

Here is the call graph for this function:

removeClientRecursive()

void TreeLayoutManager::removeClientRecursive	(	Client *	client,
		BinarySpace *	space
	)

recursive method to add a client to the layout

recursive method to remove a client from the layout

Parameters

client
space

                                                                                {
    if (space->getClient().get() == client) {
        space->setClient(nullptr);
        if (space != rootSpace_.get()) {
            bool isLeftChild = (space->getParent()->getLeft().get() == space);
            BinarySpace* siblingSpace = isLeftChild ? space->getParent()->getRight().get() : space->getParent()->getLeft().get();
            if (siblingSpace->getClient() != nullptr) {
                placeClientInSpace(siblingSpace->getClient(), space->getParent());
                siblingSpace->setClient(nullptr);
            }
            if (isLeftChild) {
                space->getParent()->setLeft(nullptr);
            } else {
                space->getParent()->setRight(nullptr);
            }
        }
        return;
    }
    if (space->getLeft() != nullptr) {
        removeClientRecursive(client, space->getLeft().get());
    }
    if (space->getRight() != nullptr) {
        removeClientRecursive(client, space->getRight().get());
    }
}

References BinarySpace::getClient(), BinarySpace::getLeft(), BinarySpace::getParent(), BinarySpace::getRight(), placeClientInSpace(), rootSpace_, BinarySpace::setClient(), BinarySpace::setLeft(), and BinarySpace::setRight().

Referenced by removeClient().

Here is the call graph for this function:

Here is the caller graph for this function:

reSize()

void TreeLayoutManager::reSize ( const Point &  size, const Point &  pos  )

overridevirtual

Implements LayoutManager.

                                                 {
    if (rootSpace_->getSize().x == size.x && rootSpace_->getSize().y == size.y) {
        return;
    }
    recursiveResize(size, pos,rootSpace_.get());
}

References recursiveResize(), rootSpace_, Point::x, and Point::y.

Referenced by updateGeometry().

Here is the call graph for this function:

Here is the caller graph for this function:

splitSpace()

void TreeLayoutManager::splitSpace	(	const std::shared_ptr< Client > &	client,
		BinarySpace *	space,
		bool	splitAlongX
	)

split a space in two Move the client to the left space and the old client to the right space increase the subspaces counter of all the parent spaces

Parameters

client
space
splitAlongX

                                                                                                            {
    Point sizeLeft, sizeRight;
    Point posRight;
    if (splitAlongX) {
        sizeLeft = Point(space->getSize().x / 2, space->getSize().y);
        sizeRight = Point(space->getSize().x - sizeLeft.x, space->getSize().y);
        posRight = Point(space->getPos().x + sizeLeft.x, space->getPos().y);
    } else {
        sizeLeft = Point(space->getSize().x, space->getSize().y / 2);
        sizeRight = Point(space->getSize().x, space->getSize().y - sizeLeft.y);
        posRight = Point(space->getPos().x, space->getPos().y + sizeLeft.y);
    }
    auto leftSpace = std::make_unique<BinarySpace>(space->getPos(), sizeLeft, space_count_++, space);
    auto rightSpace = std::make_unique<BinarySpace>(posRight, sizeRight, space_count_++, space);
    placeClientInSpace(space->getClient(), leftSpace.get());
    placeClientInSpace(client, rightSpace.get());
    space->setLeft(std::move(leftSpace));
    space->setRight(std::move(rightSpace));
    space->setClient(nullptr);
    space->incSubSpaceCount();
    while(space->getParent() != nullptr) {
        space->getParent()->incSubSpaceCount();
        space = space->getParent();
    }
}

References BinarySpace::getClient(), BinarySpace::getParent(), BinarySpace::getPos(), BinarySpace::getSize(), BinarySpace::incSubSpaceCount(), placeClientInSpace(), BinarySpace::setClient(), BinarySpace::setLeft(), BinarySpace::setRight(), LayoutManager::space_count_, Point::x, and Point::y.

Referenced by addClientRecursive().

Here is the call graph for this function:

Here is the caller graph for this function:

updateGeometry()

void TreeLayoutManager::updateGeometry ( unsigned int  sizeX, unsigned int  sizeY, unsigned int  posX, unsigned int  posY  )

overridevirtual

update the geometry of the layout (resize)

Implements LayoutManager.

                                                                                                                   {
    reSize(Point(sizeX,sizeY),Point(posX,posY));
}

References reSize().

Here is the call graph for this function:

Member Data Documentation

border_size_

int LayoutManager::border_size_

protectedinherited

Referenced by placeClientInSpace().

display_

Display* LayoutManager::display_

protectedinherited

gap_

int LayoutManager::gap_

protectedinherited

Referenced by placeClientInSpace().

rootSpace_

std::unique_ptr<BinarySpace> TreeLayoutManager::rootSpace_

private

Referenced by addClient(), findSpace(), growSpace(), removeClient(), removeClientRecursive(), reSize(), and TreeLayoutManager().

rootWindow_

Window LayoutManager::rootWindow_

protectedinherited

screen_height_

int LayoutManager::screen_height_

protectedinherited

screen_width_

int LayoutManager::screen_width_

protectedinherited

space_count_

int LayoutManager::space_count_

protectedinherited

Referenced by splitSpace().

---

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

• inc/Layouts/TreeLayoutManager.hpp
• src/Layouts/TreeLayoutManager.cpp