WindowManager Class Reference

WindowManager class This class is responsible for managing the windows.in an X11 session. It is the main class of the project. It should be instantiated only via the static create function. You must use the init function to initialize the WindowManager. The Run function is the main loop of the WindowManager. More...

#include <WindowManager.hpp>

Collaboration diagram for WindowManager:

Public Member Functions
	WindowManager (const WindowManager &)=delete
WindowManager &	operator= (const WindowManager &)=delete
	~WindowManager ()
	Destroy the WindowManager object i have yet to find a clean way to close the window manager. More...
void	init ()
	Initialize the WindowManager set the event select mask on the root window creates clients for the existing top level windows and launch the bar window. More...
void	Run ()
	Run the window manager. More...
Display *	getDisplay () const
	Get the Display object. More...
Window	getRoot () const
	Get the Root Window pointer. More...
std::unordered_map< Window, std::shared_ptr< Client > > &	getClients ()
	Get the Clients map. More...
std::shared_ptr< Client >	getClient (Window window)
	Get the Client by window ptr or frame ptr. More...
std::shared_ptr< Client >	getClientRef (Window window)
	Get a ref to the Client by window ptr does not look for frames and throws if not found. More...
unsigned long	getClientCount ()
	Get the number of clients. More...
void	setFocus (Client *client)
	Set the focus to a client. More...
void	insertClient (Window window)
	Insert a client in the clients map. More...
void	Stop ()
	Stop the window manager. More...
const std::vector< std::shared_ptr< Group > > &	getGroups () const
	Get the Groups vector this function returns the groups vector the groups vector contains all the groups the groups are the workspaces of the window manager the active group is the one that is currently displayed the groups are created from the config file the active group is set to the first group in the vector the active group can be changed by the user. More...
std::shared_ptr< Group >	getActiveGroup () const
	get the current Active Group More...
bool	getRunning () const
	Get the Running status. More...
void	setActiveGroup (std::shared_ptr< Group > activeGroup)
void	setActiveGroup (Group *activeGroup)
	set the current active group More...
void	testRun ()
	test function this function is used for testing purposes it is not used in the normal operation of the window manager More...
unsigned int	getGeometryX () const
	Get the Geometry X this function returns the width of the screen. More...
unsigned int	getGeometryY () const
	Get the Geometry Y. More...
Window	getActiveWindow () const
	Get the Active Window. More...
void	setActiveWindow (Window activeWindow)
	set the Active Window More...
const std::shared_ptr< BaseX11Wrapper > &	getX11Wrapper () const
	get the X11 Wrapper object More...

Static Public Member Functions
static void	create (std::shared_ptr< BaseX11Wrapper > wrapper, const std::string &displayStr=std::string())
	create a WindowManager object More...
static WindowManager *	getInstance ()
	Get the WindowManager instance this is a singleton class this function returns the instance of the WindowManager if it does not exist, it creates it. More...
static void	Destroy ()
	Destroy the WindowManager instance this function destroys the WindowManager instance and sets the instance_ pointer to nullptr this is a singleton class this function should be called when the WindowManager is no longer needed. More...

Private Member Functions
	WindowManager (Display *display, const std::shared_ptr< BaseX11Wrapper > &wrapper)
void	selectEventOnRoot () const
	set the event mask on the root window and register as the window manager for the X session More...
void	getTopLevelWindows ()
	look for existing top level windows and create clients for them More...
void	addGroupsFromConfig ()
	add groups configured in the ConfigDataGroups to the groups vector More...
void	createBars ()
	create the bars Bars are created from the config file and handled in a separate thread More...

Static Private Member Functions
static int	OnXError (Display *display, XErrorEvent *e)
	X11 Error handler. More...
static int	onWmDetected ([[maybe_unused]] Display *display, XErrorEvent *e)
	When selecting events on the root window, we may get a BadAccess error if another window manager is running this function is called when a BadAccess error is detected it sets the wmDetected flag to true and stops the window manager only one window manager can run at a time. More...

Private Attributes
Display *	display_
const Window	root_
std::vector< std::shared_ptr< Group > >	groups_
std::weak_ptr< Group >	active_group_ {}
const Atom	WM_PROTOCOLS
const Atom	WM_DELETE_WINDOW
unsigned int	geometryX {}
unsigned int	geometryY {}
bool	running
std::unordered_map< Window, std::shared_ptr< Client > >	clients_
std::shared_ptr< TSBarsData >	tsData
Window	activeWindow
std::shared_ptr< BaseX11Wrapper >	x11Wrapper

Static Private Attributes
static bool	wmDetected
static WindowManager *	instance_ = nullptr

Detailed Description

WindowManager class This class is responsible for managing the windows.in an X11 session. It is the main class of the project. It should be instantiated only via the static create function. You must use the init function to initialize the WindowManager. The Run function is the main loop of the WindowManager.

Constructor & Destructor Documentation

WindowManager() [1/2]

WindowManager::WindowManager ( const WindowManager &  )

delete

Referenced by create().

Here is the caller graph for this function:

~WindowManager()

WindowManager::~WindowManager

(

)

Destroy the WindowManager object i have yet to find a clean way to close the window manager.

                              {
    clients_.clear();
    groups_.clear();
    Logger::GetInstance()->Log("WindowManager destroyed", L_INFO);
}

References clients_, Logger::GetInstance(), groups_, L_INFO, and Logger::Log().

Here is the call graph for this function:

WindowManager() [2/2]

WindowManager::WindowManager ( Display *  display, const std::shared_ptr< BaseX11Wrapper > &  wrapper  )

private

        : display_(display),
          root_(DefaultRootWindow(display)),
          WM_PROTOCOLS( wrapper->internAtom(display_, "WM_PROTOCOLS", false)),
          WM_DELETE_WINDOW(wrapper->internAtom(display_, "WM_DELETE_WINDOW", false)),
          running(true),
          tsData(nullptr),
          geometryX(0),
          geometryY(0),
          activeWindow(0),
          x11Wrapper(wrapper){}

Member Function Documentation

addGroupsFromConfig()

void WindowManager::addGroupsFromConfig ( )

private

add groups configured in the ConfigDataGroups to the groups vector

                                        {
    auto configGroups = ConfigHandler::GetInstance().getConfigData<ConfigDataGroups>()->getGroups();
    std::string groupsNames = "";
    for (auto group: configGroups) {
        std::shared_ptr<Group> g = std::make_shared<Group>(group, x11Wrapper,display_,root_);
        groupsNames += g->getName() + ",";
        groups_.push_back(g);
    }
    if (groupsNames.back() == ',') {
        groupsNames.pop_back();
    }
    tsData->addData("Groups", groupsNames);
    groups_[0]->setActive(true);
    tsData->addData("ActiveGroup", groups_[0]->getName());
    active_group_ = groups_[0];
    Logger::GetInstance()->Log("Active Group is [" + getActiveGroup()->getName() + "]", L_INFO);
}

References active_group_, display_, getActiveGroup(), ConfigHandler::getConfigData(), getGroups(), ConfigHandler::GetInstance(), Logger::GetInstance(), groups_, L_INFO, Logger::Log(), root_, tsData, and x11Wrapper.

Referenced by getTopLevelWindows().

Here is the call graph for this function:

Here is the caller graph for this function:

create()

void WindowManager::create ( std::shared_ptr< BaseX11Wrapper >  wrapper, const std::string &  displayStr = std::string()  )

static

create a WindowManager object

Parameters

displayStr

Optional X Display string if not set, the DISPLAY environment variable will be used

                                                                                            {
    Logger::GetInstance()->Log("================ Yggdrasil Initialisation ================\n\n", L_INFO);
    if (WindowManager::instance_ != nullptr) {
        throw std::runtime_error("WindowManager instance already created");
    }
    const char *displayCStr =
            displayStr.empty() ? nullptr : displayStr.c_str();
    Display *display = XOpenDisplay(displayCStr);
    if (display == nullptr) {
        Logger::GetInstance()->Log("Failed to open X display " + std::string(XDisplayName(displayCStr)), L_ERROR);
        throw std::runtime_error("Failed to open X display");
    }
    Logger::GetInstance()->Log("Opened X Display:\t" + std::string(XDisplayName(displayCStr)), L_INFO);
    WindowManager::instance_ = new WindowManager(display,wrapper);
}

References Logger::GetInstance(), instance_, L_ERROR, L_INFO, Logger::Log(), and WindowManager().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

createBars()

void WindowManager::createBars ( )

private

create the bars Bars are created from the config file and handled in a separate thread

Note

communication between main thread and Bars thread is handled in Thread Safe way by the TSBarsData class

                               {
    Bars::createInstance();
    Bars::getInstance().init(ConfigHandler::GetInstance().getConfigData<ConfigDataBars>(), tsData, display_, root_);
    Bars::getInstance().start_thread();
    auto g = getActiveGroup();
    unsigned int sizeX = geometryX- Bars::getInstance().getSpaceE() - Bars::getInstance().getSpaceW() - g->getBorderSize() * 2;
    unsigned int sizeY = geometryY - Bars::getInstance().getSpaceN() - Bars::getInstance().getSpaceS() - g->getBorderSize() * 2;
    unsigned int posX = Bars::getInstance().getSpaceW();
    unsigned int posY = Bars::getInstance().getSpaceN();
    for (auto &g:groups_) {
        g->resize(sizeX,sizeY,posX,posY);
    }
}

References Bars::createInstance(), display_, geometryX, geometryY, getActiveGroup(), Bars::getInstance(), ConfigHandler::GetInstance(), Bars::getSpaceE(), Bars::getSpaceN(), Bars::getSpaceS(), Bars::getSpaceW(), groups_, Bars::init(), root_, Bars::start_thread(), and tsData.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

Destroy()

static void WindowManager::Destroy ( )

static

Destroy the WindowManager instance this function destroys the WindowManager instance and sets the instance_ pointer to nullptr this is a singleton class this function should be called when the WindowManager is no longer needed.

                            {
    if (WindowManager::instance_ != nullptr) {
        delete WindowManager::instance_;
        WindowManager::instance_ = nullptr;
    }
}

References instance_.

Referenced by main().

Here is the caller graph for this function:

getActiveGroup()

Group * WindowManager::getActiveGroup

(

)

const

get the current Active Group

Returns

                                                         {
    auto g = active_group_.lock();
    if (g)
        return g;
    else
        throw YggdrasilException("invalid active group");
}

References active_group_.

Referenced by addGroupsFromConfig(), createBars(), FocusGroup::execute(), Grow::execute(), getTopLevelWindows(), EventHandler::handleDestroyNotify(), and insertClient().

Here is the caller graph for this function:

getActiveWindow()

void WindowManager::getActiveWindow

(

)

const

Get the Active Window.

{ return activeWindow; }

References activeWindow.

getClient()

Client * WindowManager::getClient

(

Window

window

)

Get the Client by window ptr or frame ptr.

Parameters

window

Returns

nullptr if not found

                                                            {
    auto clientIter = clients_.find(window);
    if (clientIter != clients_.end()) {
        return clientIter->second;
    }
    for (const auto &client: clients_) {
        if (client.second->getFrame() == window) {
            return client.second;
        }
    }
    return nullptr;
}

References clients_.

Referenced by Grow::execute(), EventHandler::handleButtonPress(), EventHandler::handleFocusIn(), EventHandler::handleFocusOut(), EventHandler::handleMapNotify(), Group::moveClientToGroup(), and Group::removeClient().

Here is the caller graph for this function:

getClientCount()

unsigned long WindowManager::getClientCount

(

)

Get the number of clients.

{ return clients_.size(); }

References clients_.

getClientRef()

Client & WindowManager::getClientRef

(

Window

window

)

Get a ref to the Client by window ptr does not look for frames and throws if not found.

{ return clients_.at(window); }

References clients_.

Referenced by EventHandler::handleDestroyNotify(), EventHandler::handleMapRequest(), EventHandler::handleMotionNotify(), and EventHandler::handleUnmapNotify().

Here is the caller graph for this function:

getClients()

std::unordered_map< Window, Client * > & WindowManager::getClients

(

)

Get the Clients map.

{ return clients_; }

References clients_.

Referenced by EventHandler::handleDestroyNotify(), and EventHandler::handleUnmapNotify().

Here is the caller graph for this function:

getDisplay()

Display * WindowManager::getDisplay

(

)

const

Get the Display object.

{ return display_; }

References display_.

Referenced by EventHandler::handleClientMessage(), EventHandler::handleUnmapNotify(), and Bar::init().

Here is the caller graph for this function:

getGeometryX()

void WindowManager::getGeometryX

(

)

const

Get the Geometry X this function returns the width of the screen.

{ return geometryX; }

References geometryX.

Referenced by ewmh::updateDesktopGeometry().

Here is the caller graph for this function:

getGeometryY()

void WindowManager::getGeometryY

(

)

const

Get the Geometry Y.

{ return geometryY; }

References geometryY.

Referenced by ewmh::updateDesktopGeometry().

Here is the caller graph for this function:

getGroups()

const std::vector< Group * > & WindowManager::getGroups

(

)

const

Get the Groups vector this function returns the groups vector the groups vector contains all the groups the groups are the workspaces of the window manager the active group is the one that is currently displayed the groups are created from the config file the active group is set to the first group in the vector the active group can be changed by the user.

Returns

{ return groups_; }

References groups_.

Referenced by addGroupsFromConfig(), FocusGroup::execute(), and ewmh::updateNumberOfDesktops().

Here is the caller graph for this function:

getInstance()

WindowManager * WindowManager::getInstance ( )

static

Get the WindowManager instance this is a singleton class this function returns the instance of the WindowManager if it does not exist, it creates it.

Returns

WindowManager* instance

                                           {
    if (WindowManager::instance_ != nullptr) {
        return WindowManager::instance_;
    } else {
        throw std::runtime_error("WindowManager instance not created");
    }
}

References instance_.

Referenced by EventHandler::EventHandler(), FocusGroup::execute(), Grow::execute(), Quit::execute(), EventHandler::handleButtonPress(), EventHandler::handleClientMessage(), EventHandler::handleConfigureRequest(), EventHandler::handleDestroyNotify(), EventHandler::handleFocusIn(), EventHandler::handleFocusOut(), EventHandler::handleKeyPress(), EventHandler::handleMapNotify(), EventHandler::handleMapRequest(), EventHandler::handleMotionNotify(), handleSIGHUP(), EventHandler::handleUnmapNotify(), Bar::init(), main(), Group::moveClientToGroup(), OnXError(), Group::removeClient(), Bars::run(), Group::switchFrom(), Group::switchTo(), ewmh::updateDesktopGeometry(), and ewmh::updateNumberOfDesktops().

Here is the caller graph for this function:

getRoot()

Window WindowManager::getRoot

(

)

const

Get the Root Window pointer.

{ return root_; }

References root_.

Referenced by EventHandler::handleClientMessage(), EventHandler::handleDestroyNotify(), EventHandler::handleFocusIn(), EventHandler::handleFocusOut(), EventHandler::handleMapRequest(), and EventHandler::handleUnmapNotify().

Here is the caller graph for this function:

getRunning()

bool WindowManager::getRunning

(

)

const

Get the Running status.

{ return running; }

References running.

getTopLevelWindows()

void WindowManager::getTopLevelWindows ( )

private

look for existing top level windows and create clients for them

                                       {
    Window returnedRoot, returnedParent;
    Window *topLevelWindows;
    unsigned int numTopLevelWindows;
    x11Wrapper->queryTree(
            display_,
            root_,
            &returnedRoot,
            &returnedParent,
            &topLevelWindows,
            &numTopLevelWindows);
    if (returnedRoot != root_) {
        throw std::runtime_error("Root window is not the same as the one returned by XQueryTree");
    }
    addGroupsFromConfig();
    Logger::GetInstance()->Log("Found " + std::to_string(numTopLevelWindows) + " top level windows.\troot:" + std::to_string(root_), L_INFO);
    for (unsigned int i = 0; i < numTopLevelWindows; ++i) {
        std::shared_ptr<Client> newClient = nullptr;
        try {
            auto g = getActiveGroup();
            newClient = std::make_shared<Client>(display_, root_, topLevelWindows[i], g,
                                         g->getInactiveColor(), g->getBorderSize(), x11Wrapper);
            newClient->frame();
            g->addClient(newClient->getWindow(),newClient);
            setFocus(newClient.get());
        } catch (const YggdrasilException &e) {
            Logger::GetInstance()->Log(e.what(), L_ERROR);
            continue;
        }
        if (newClient != nullptr) {
            clients_[newClient->getWindow()] = newClient;
        }
    }
    x11Wrapper->freeX(topLevelWindows);
}

References addGroupsFromConfig(), clients_, display_, getActiveGroup(), Logger::GetInstance(), L_ERROR, L_INFO, Logger::Log(), root_, setFocus(), and x11Wrapper.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

getX11Wrapper()

std::shared_ptr< BaseX11Wrapper > WindowManager::getX11Wrapper

(

)

const

get the X11 Wrapper object

{ return x11Wrapper; }

References x11Wrapper.

Referenced by EventHandler::EventHandler(), and OnXError().

Here is the caller graph for this function:

init()

void WindowManager::init

(

)

Initialize the WindowManager set the event select mask on the root window creates clients for the existing top level windows and launch the bar window.

                         {
    selectEventOnRoot();
    ConfigHandler::GetInstance().getConfigData<ConfigDataBindings>()->initKeycodes(display_,x11Wrapper.get());
    if (wmDetected) {
        throw std::runtime_error("Another window manager is already running.");
    }
    ConfigHandler::GetInstance().getConfigData<ConfigDataBindings>()->grabKeys(display_, root_);
    geometryX = x11Wrapper->displayWidth(display_, x11Wrapper->defaultScreen(display_));
    geometryY = x11Wrapper->displayHeight(display_, x11Wrapper->defaultScreen(display_));
    x11Wrapper->grabServer(display_);
    ewmh::initEwmh(display_,root_);
    tsData = std::make_shared<TSBarsData>();
    getTopLevelWindows();
    createBars();
    x11Wrapper->ungrabServer(display_);
    ewmh::updateWmProperties(display_, root_);
    x11Wrapper->flush(display_);
    tsData->addData("EvCount", "0");
    signal(SIGINT, handleSIGHUP);
}

References createBars(), display_, geometryX, geometryY, ConfigHandler::getConfigData(), ConfigHandler::GetInstance(), getTopLevelWindows(), handleSIGHUP(), ewmh::initEwmh(), root_, selectEventOnRoot(), tsData, ewmh::updateWmProperties(), wmDetected, and x11Wrapper.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

insertClient()

void WindowManager::insertClient

(

Window

window

)

Insert a client in the clients map.

Parameters

window

                                              {
    try {
        int borderSize = getActiveGroup()->getBorderSize();
        unsigned long inactiveColor = getActiveGroup()->getInactiveColor();
        std::shared_ptr<Client> client = std::make_shared<Client>(display_, root_, window, getActiveGroup(), inactiveColor,
                                                                  borderSize, x11Wrapper);
        Logger::GetInstance()->Log(
                "Inserting client in map: " + client->getTitle() + "\t[" + std::to_string(window) + "]", L_INFO);
        clients_.insert({window, client});
    } catch (const YggdrasilException &e) {
        Logger::GetInstance()->Log(e.what(), L_ERROR);
    }
}

References clients_, display_, getActiveGroup(), Logger::GetInstance(), L_ERROR, L_INFO, Logger::Log(), root_, and x11Wrapper.

Referenced by EventHandler::handleMapRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

onWmDetected()

static int WindowManager::onWmDetected ( [[maybe_unused] ] Display *  display, XErrorEvent *  e  )

staticprivate

When selecting events on the root window, we may get a BadAccess error if another window manager is running this function is called when a BadAccess error is detected it sets the wmDetected flag to true and stops the window manager only one window manager can run at a time.

                                                                                 {
    if (static_cast<int>(e->error_code) == BadAccess)
        wmDetected = true;
    return 0;
}

References wmDetected.

Referenced by selectEventOnRoot().

Here is the caller graph for this function:

OnXError()

static int WindowManager::OnXError ( Display *  display, XErrorEvent *  e  )

staticprivate

X11 Error handler.

                                                            {
    const int MAX_ERROR_TEXT_LENGTH = 1024;
    char errorText[MAX_ERROR_TEXT_LENGTH];
    WindowManager::getInstance()->getX11Wrapper()->getErrorText(display, e->error_code, errorText, sizeof(errorText));
    std::stringstream errorStream;
    errorStream << "Received X error:\n"
                << "    Request: " << int(e->request_code)
                << "    Error code: " << int(e->error_code)
                << " - " << errorText << "\n"
                << "    Resource ID: " << e->resourceid;
    Logger::GetInstance()->Log(errorStream.str(), L_ERROR);
    // The return value is ignored.
    return 0;
}

References Logger::GetInstance(), getInstance(), getX11Wrapper(), L_ERROR, and Logger::Log().

Referenced by selectEventOnRoot().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

WindowManager& WindowManager::operator= ( const WindowManager &  )

delete

Run()

void WindowManager::Run

(

)

Run the window manager.

                        {
    Logger::GetInstance()->Log("================ Yggdrasil WM Running ================\n\n", L_INFO);
    EventHandler::create();
    XEvent e;
//  int evcount = 0;
    while (running && !x11Wrapper->nextEvent(display_, &e)) {
        EventHandler::getInstance()->dispatchEvent(e);
        x11Wrapper->sync(display_, false);
//      tsData->modifyData("EvCount", std::to_string(evcount++));
    }
    Logger::GetInstance()->Log("WindowManager stopped", L_INFO);
//  XCloseDisplay(display_);
}

References EventHandler::create(), EventHandler::dispatchEvent(), display_, EventHandler::getInstance(), Logger::GetInstance(), L_INFO, Logger::Log(), running, and x11Wrapper.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

selectEventOnRoot()

void WindowManager::selectEventOnRoot ( ) const

private

set the event mask on the root window and register as the window manager for the X session

                                            {
    x11Wrapper->setErrorHandler(&WindowManager::onWmDetected);
    x11Wrapper->selectInput(
            display_,
            root_,
            SubstructureRedirectMask | SubstructureNotifyMask | FocusChangeMask | ClientMessage);
    x11Wrapper->setErrorHandler(&WindowManager::OnXError);
    x11Wrapper->sync(display_, false);
}

References display_, onWmDetected(), OnXError(), root_, and x11Wrapper.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

setActiveGroup() [1/2]

void WindowManager::setActiveGroup

(

Group *

activeGroup

)

set the current active group

Parameters

activeGroup

                                                     {
    WindowManager::active_group_ = std::shared_ptr<Group>(activeGroup);
}

References active_group_.

setActiveGroup() [2/2]

void WindowManager::setActiveGroup

(

std::shared_ptr< Group >

activeGroup

)

                                                                   {
    tsData->modifyData("ActiveGroup", activeGroup->getName());
    active_group_ = std::weak_ptr<Group> (activeGroup);
}

References active_group_, and tsData.

Referenced by Group::switchTo().

Here is the caller graph for this function:

setActiveWindow()

void WindowManager::setActiveWindow

(

Window

activeWindow

)

set the Active Window

Parameters

activeWindow

{ WindowManager::activeWindow = aWindow; }

References activeWindow.

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

Here is the caller graph for this function:

setFocus()

void WindowManager::setFocus

(

Client *

client

)

Set the focus to a client.

                                           {
    if (client != nullptr) {
        x11Wrapper->setInputFocus(display_, client->getWindow(), RevertToParent, CurrentTime);
    }
}

References display_, Client::getWindow(), and x11Wrapper.

Referenced by getTopLevelWindows(), EventHandler::handleDestroyNotify(), and EventHandler::handleMapRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

Stop()

void WindowManager::Stop

(

)

Stop the window manager.

Todo:

: implement a clean way to stop the window manager

                         {
    this->running = false;
    XClientMessageEvent ev;
    memset(&ev, 0, sizeof(ev));
    ev.type = ClientMessage;
    ev.window = root_;
    ev.message_type = XInternAtom(display_, "WM_PROTOCOLS", False);
    ev.format = 32;
    ev.data.l[0] = static_cast<long>(XInternAtom(display_, "WM_DELETE_WINDOW", False));
    try {
        x11Wrapper->sendEvent(display_, root_, False, NoEventMask, (XEvent *) &ev);
        x11Wrapper->flush(display_); // Ensure the event is sent immediately
    } catch (const YggdrasilException &e) {
        std::cerr << e.what();
    }
    Bars::getInstance().stop_thread();
    Bars::destroy();
    std::cout << "Stopping WindowManager" << std::endl;
}

References Bars::destroy(), display_, Bars::getInstance(), root_, running, Bars::stop_thread(), and x11Wrapper.

Referenced by Quit::execute(), and handleSIGHUP().

Here is the call graph for this function:

Here is the caller graph for this function:

testRun()

void WindowManager::testRun

(

)

test function this function is used for testing purposes it is not used in the normal operation of the window manager

                            {
    try {
        EventHandler::getInstance();
    } catch (const std::exception &e) {
        EventHandler::create();
    }
    XSync(display_, false);
    XEvent ev;
    x11Wrapper->nextEvent(display_, &ev);
    EventHandler::getInstance()->dispatchEvent(ev);
    x11Wrapper->sync(display_, false);
}

References EventHandler::create(), EventHandler::dispatchEvent(), display_, EventHandler::getInstance(), and x11Wrapper.

Here is the call graph for this function:

Member Data Documentation

active_group_

std::weak_ptr<Group> WindowManager::active_group_ {}

private

Referenced by addGroupsFromConfig(), getActiveGroup(), and setActiveGroup().

activeWindow

Window WindowManager::activeWindow

private

Referenced by getActiveWindow(), and setActiveWindow().

clients_

std::unordered_map<Window, std::shared_ptr<Client> > WindowManager::clients_

private

Referenced by getClient(), getClientCount(), getClientRef(), getClients(), getTopLevelWindows(), insertClient(), and ~WindowManager().

display_

Display* WindowManager::display_

private

Referenced by addGroupsFromConfig(), createBars(), getDisplay(), getTopLevelWindows(), init(), insertClient(), Run(), selectEventOnRoot(), setFocus(), Stop(), and testRun().

geometryX

unsigned int WindowManager::geometryX {}

private

Referenced by createBars(), getGeometryX(), and init().

geometryY

unsigned int WindowManager::geometryY {}

private

Referenced by createBars(), getGeometryY(), and init().

groups_

std::vector<std::shared_ptr<Group> > WindowManager::groups_

private

Referenced by addGroupsFromConfig(), createBars(), getGroups(), and ~WindowManager().

instance_

WindowManager * WindowManager::instance_ = nullptr

staticprivate

Referenced by create(), Destroy(), and getInstance().

root_

const Window WindowManager::root_

private

Referenced by addGroupsFromConfig(), createBars(), getRoot(), getTopLevelWindows(), init(), insertClient(), selectEventOnRoot(), and Stop().

running

bool WindowManager::running

private

Referenced by getRunning(), Run(), and Stop().

tsData

std::shared_ptr<TSBarsData> WindowManager::tsData

private

Referenced by addGroupsFromConfig(), createBars(), init(), and setActiveGroup().

WM_DELETE_WINDOW

const Atom WindowManager::WM_DELETE_WINDOW

private

WM_PROTOCOLS

const Atom WindowManager::WM_PROTOCOLS

private

wmDetected

bool WindowManager::wmDetected

staticprivate

Referenced by init(), and onWmDetected().

x11Wrapper

std::shared_ptr<BaseX11Wrapper> WindowManager::x11Wrapper

private

Referenced by addGroupsFromConfig(), getTopLevelWindows(), getX11Wrapper(), init(), insertClient(), Run(), selectEventOnRoot(), setFocus(), Stop(), and testRun().

---

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

• inc/WindowManager.hpp
• src/WindowManager.cpp