Bars Class Reference

Class to manage the bars This class is a singleton and is responsible for managing the bars instanciate with createInstance and initialize with init should be destroyed with destroy when the program ends Bars::run runs in a separate thread, so all data must be passed through the TSBarsData class that handle synchronization. More...

#include <Bars.hpp>

Collaboration diagram for Bars:

Public Member Functions
	Bars (const Bars &)=delete
Bars &	operator= (const Bars &)=delete
	~Bars ()
void	init (std::shared_ptr< ConfigDataBars > configData, std::shared_ptr< TSBarsData > tsData, Display *display, Window root)
	Initialize the Bars class. More...
void	run ()
	Run the Bars class in a separate thread. More...
void	start_thread ()
unsigned int	getSpaceN () const
	Get the spaceN value used to calculate the space left for the Layout Manager. More...
unsigned int	getSpaceS () const
	Get the spaceS value used to calculate the space left for the Layout Manager. More...
unsigned int	getSpaceE () const
	Get the spaceE value used to calculate the space left for the Layout Manager. More...
unsigned int	getSpaceW () const
	Get the spaceW value used to calculate the space left for the Layout Manager. More...
const std::unordered_map< std::string, std::string > &	getData () const
bool	isBarWindow (Window window)
	Check if the window is a bar window used to filter events in EventHandler. More...
void	stop_thread ()
	Stop the thread (join) More...
void	redraw ()
	Redraw the bars by calling the draw method of each bar. More...
void	addPluginLocation (const std::string &location)
const std::set< std::string > &	getPluginsLocations () const
void *	getWidgetTypeHandle (const std::string &widgetType)
void	setWidgetTypeHandle (const std::string &widgetType, void *handle)
void	subscribeWidget (Widget *w)

Static Public Member Functions
static void	createInstance ()
	Create the singleton instance if the instance is already created, it will do nothing. More...
static Bars &	getInstance ()
	Get the singleton instance if the instance is not created, it will create it. More...
static void	destroy ()
	Destroy the singleton instance if the instance is not created, it will do nothing. More...

Private Member Functions
	Bars ()

Private Attributes
std::vector< std::unique_ptr< Bar > >	bars
std::vector< Window >	windows
std::shared_ptr< ConfigDataBars >	configData
std::shared_ptr< TSBarsData >	tsData
std::unordered_map< std::string, std::string >	data
Display *	display
Window	root
unsigned int	spaceN
unsigned int	spaceS
unsigned int	spaceE
unsigned int	spaceW
std::thread	barThread
std::set< std::string >	pluginsLocations
std::unordered_map< std::string, void * >	widgetTypeHandle
std::unordered_map< std::string, std::vector< Widget * > >	subscriptions

Static Private Attributes
static Bars *	instance = nullptr

Detailed Description

Class to manage the bars This class is a singleton and is responsible for managing the bars instanciate with createInstance and initialize with init should be destroyed with destroy when the program ends Bars::run runs in a separate thread, so all data must be passed through the TSBarsData class that handle synchronization.

Note

This class is a singleton

See also

TSBarsData

Constructor & Destructor Documentation

Bars() [1/2]

Bars::Bars ( const Bars &  )

delete

~Bars()

Bars::~Bars

(

)

            {
    for (auto &bar : bars) {
        for (auto &w : bar->getWidgets()) {
            typedef void (destroy_t)(Widget *);
            destroy_t* destroy = (destroy_t*) dlsym(w.second , "destroyPlugin");
            const char* dlsym_error = dlerror();
            if (dlsym_error) {
                Logger::GetInstance()->Log("Cannot load symbol destroy: " + std::string(dlerror()),L_ERROR);
                continue;
            }
            destroy(w.second);
        }
    }
    for (auto handle : widgetTypeHandle) {
        dlclose(handle.second);
    }
}

References bars, destroy(), Logger::GetInstance(), L_ERROR, Logger::Log(), and widgetTypeHandle.

Here is the call graph for this function:

Bars() [2/2]

Bars::Bars ( )

private

           : spaceN(0),
               spaceS(0),
               spaceE(0),
               spaceW(0),
               configData(nullptr),
               tsData(nullptr),
               data(),
               display(nullptr),
               root(0)
                {}

Referenced by createInstance().

Here is the caller graph for this function:

Member Function Documentation

addPluginLocation()

void Bars::addPluginLocation

(

const std::string &

location

)

                                                      {
    pluginsLocations.emplace(location);
}

References pluginsLocations.

Referenced by init().

Here is the caller graph for this function:

createInstance()

static void Bars::createInstance ( )

static

Create the singleton instance if the instance is already created, it will do nothing.

                          {
    if (Bars::instance == nullptr)
        Bars::instance = new Bars();
}

References Bars(), and instance.

Referenced by WindowManager::createBars(), and getInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy()

static void Bars::destroy ( )

static

Destroy the singleton instance if the instance is not created, it will do nothing.

                   {
    if (Bars::instance != nullptr)
        delete Bars::instance;
}

References instance.

Referenced by WindowManager::Stop(), and ~Bars().

Here is the caller graph for this function:

getData()

const std::unordered_map< std::string, std::string > & Bars::getData

(

)

const

{ return data; }

References data.

getInstance()

static Bars & Bars::getInstance ( )

static

Get the singleton instance if the instance is not created, it will create it.

Returns

reference to the singleton instance

                        {
    if (Bars::instance == nullptr)
        Bars::createInstance();
    return *Bars::instance;
}

References createInstance(), and instance.

Referenced by WindowManager::createBars(), EventHandler::handleButtonPress(), EventHandler::handleDestroyNotify(), EventHandler::handleEnterNotify(), EventHandler::handleExpose(), EventHandler::handleMotionNotify(), EventHandler::handleUnmapNotify(), and WindowManager::Stop().

Here is the call graph for this function:

Here is the caller graph for this function:

getPluginsLocations()

const std::set< std::string > & Bars::getPluginsLocations

(

)

const

                                                         {
    return pluginsLocations;
}

References pluginsLocations.

getSpaceE()

unsigned int Bars::getSpaceE

(

)

const

Get the spaceE value used to calculate the space left for the Layout Manager.

{ return this->spaceE; }

References spaceE.

Referenced by WindowManager::createBars().

Here is the caller graph for this function:

getSpaceN()

unsigned int Bars::getSpaceN

(

)

const

Get the spaceN value used to calculate the space left for the Layout Manager.

{ return this->spaceN; }

References spaceN.

Referenced by WindowManager::createBars().

Here is the caller graph for this function:

getSpaceS()

unsigned int Bars::getSpaceS

(

)

const

Get the spaceS value used to calculate the space left for the Layout Manager.

{ return this->spaceS; }

References spaceS.

Referenced by WindowManager::createBars().

Here is the caller graph for this function:

getSpaceW()

unsigned int Bars::getSpaceW

(

)

const

Get the spaceW value used to calculate the space left for the Layout Manager.

{ return this->spaceW; }

References spaceW.

Referenced by WindowManager::createBars().

Here is the caller graph for this function:

getWidgetTypeHandle()

void * Bars::getWidgetTypeHandle

(

const std::string &

widgetType

)

                                                           {
    try {
        void * handle = widgetTypeHandle[widgetType];
        return handle;
    } catch (std::out_of_range &e) {
        Logger::GetInstance()->Log("Widget Type " + widgetType + " not found",L_ERROR);
        return nullptr;
    }
}

References Logger::GetInstance(), L_ERROR, Logger::Log(), and widgetTypeHandle.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Bars::init	(	std::shared_ptr< ConfigDataBars >	configData,
		std::shared_ptr< TSBarsData >	tsData,
		Display *	display,
		Window	root
	)

Initialize the Bars class.

Parameters

configData	global bars configuration will pass the right config data to each bar
tsData	thread safe data to pass data between threads
display	to limit calls to WindowManager::getDisplay
root	to limit calls to WindowManager::getRoot

Todo:

use of x11wrapper

                             {
    this->configData = configData;
    this->tsData =tsData;
    this->display = display;
    this->root = root;
    for (auto &bar : this->configData->getBars()) {
        std::unique_ptr<Bar> newBar = std::make_unique<Bar>();
        newBar->init(bar, this->tsData);
        if (bar->getBarPosition() == "top") {
            this->spaceN += bar->getBarSize();
        } else if (bar->getBarPosition() == "bottom") {
            this->spaceS += bar->getBarSize();
        } else if (bar->getBarPosition() == "left") {
            this->spaceW += bar->getBarSize();
        } else if (bar->getBarPosition() == "right") {
            this->spaceE += bar->getBarSize();
        }
        for (auto &w : bar->getWidgets()) {
            if (pluginsLocations.find(w->getPluginLocation()) == pluginsLocations.end()) {
                addPluginLocation(w->getPluginLocation());
                void *handle = dlopen(w->getPluginLocation().c_str(), RTLD_LAZY);
                if (!handle) {
                    Logger::GetInstance()->Log("Cannot open library: " + std::string(dlerror()),L_ERROR);
                    continue;
                }
                setWidgetTypeHandle(w->getType(), handle);
                Logger::GetInstance()->Log("Library " + w->getPluginLocation() + " opened",L_INFO);
            }
            newBar->addWidget(getWidgetTypeHandle(w->getType()), w);
        }
        Logger::GetInstance()->Log("Bar ["
                                    + std::to_string(this->bars.size())
                                    + "] on window ["
                                    + std::to_string(newBar->getWindow())
                                    + "] initialized\t"
                                    + bar->getBarPosition()
                                    + " "
                                    + std::to_string(newBar->getSizeX())
                                    + " x "
                                    + std::to_string(newBar->getSizeY()),L_INFO);
        for (auto w:newBar->getWidgets()) {
            subscribeWidget(w.second);
        }
        this->windows.push_back(newBar->getWindow());
        this->bars.push_back(std::move(newBar));
    }
}

References addPluginLocation(), bars, configData, display, Logger::GetInstance(), getWidgetTypeHandle(), L_ERROR, L_INFO, Logger::Log(), pluginsLocations, root, setWidgetTypeHandle(), spaceE, spaceN, spaceS, spaceW, subscribeWidget(), tsData, and windows.

Referenced by WindowManager::createBars().

Here is the call graph for this function:

Here is the caller graph for this function:

isBarWindow()

bool Bars::isBarWindow

(

Window

window

)

Check if the window is a bar window used to filter events in EventHandler.

Parameters

window

Returns

true if the window is a bar window

                                    {
    auto it = std::find(windows.begin(), windows.end(), window);
    return it != windows.end();
}

References windows.

operator=()

Bars& Bars::operator= ( const Bars &  )

delete

redraw()

void Bars::redraw

(

)

Redraw the bars by calling the draw method of each bar.

Parameters

msg	message to pass to the draw method (temporary arg for debug purpose)

                  {
    for (auto &bar : this->bars) {
        bar->draw();
    }
}

References bars.

Referenced by EventHandler::handleEnterNotify(), EventHandler::handleExpose(), and run().

Here is the caller graph for this function:

run()

void Bars::run

(

)

Run the Bars class in a separate thread.

Note

all data must be passed through the TSBarsData class

               {
    while (WindowManager::getInstance()->getRunning()){
        try {
            if (tsData->wait()) {
                // Updated Data redraw
                std::unordered_map<std::string,std::string>updated = tsData->getData();
                for (const auto &pair: updated) {
                    this->data[pair.first] = pair.second;
                    if (subscriptions.find(pair.first) != subscriptions.end()) {
                        for (Widget* widget : subscriptions[pair.first]) {
                            widget->updateData(pair.first, pair.second);
                            widget->draw();
                        }
                    }
                    XFlush(display);
                }
                this->redraw();
            } else {
                // Periodic redraw
                this->redraw();
            }
        } catch (const std::exception &e) {
            Logger::GetInstance()->Log("Bars thread exception: " + std::string(e.what()),L_ERROR);
        }
    }
}

References data, display, Logger::GetInstance(), WindowManager::getInstance(), L_ERROR, Logger::Log(), redraw(), subscriptions, and tsData.

Referenced by start_thread().

Here is the call graph for this function:

Here is the caller graph for this function:

setWidgetTypeHandle()

void Bars::setWidgetTypeHandle	(	const std::string &	widgetType,
		void *	handle
	)

                                                                        {
    widgetTypeHandle[widgetType] = handle;
}

References widgetTypeHandle.

Referenced by init().

Here is the caller graph for this function:

start_thread()

void Bars::start_thread

(

)

                        {
    barThread = std::thread(&Bars::run, this);
}

References barThread, and run().

Referenced by WindowManager::createBars().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_thread()

void Bars::stop_thread

(

)

Stop the thread (join)

                       {
    barThread.join();
}

References barThread.

Referenced by WindowManager::Stop().

Here is the caller graph for this function:

subscribeWidget()

void Bars::subscribeWidget

(

Widget *

w

)

                                    {
    std::vector<std::string> keys = w->registerDataKey();
    for (const auto &key: keys) {
        if (key.empty())
            continue;
        subscriptions[key].push_back(w);
    }
}

References Widget::registerDataKey(), and subscriptions.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bars

std::vector<std::unique_ptr<Bar> > Bars::bars

private

Referenced by init(), redraw(), and ~Bars().

barThread

std::thread Bars::barThread

private

Referenced by start_thread(), and stop_thread().

configData

std::shared_ptr<ConfigDataBars> Bars::configData

private

Referenced by init().

data

std::unordered_map<std::string, std::string> Bars::data

private

Referenced by getData(), and run().

display

Display* Bars::display

private

Referenced by init(), and run().

instance

Bars * Bars::instance = nullptr

staticprivate

Yb dP 8 w 8 Yb dP 8b d8 YbdP .d88 .d88 .d88 8d8b .d88 d88b w 8 Yb db dP 8YbmdP8 YP 8 8 8 8 8 8 8P 8 8 Yb. 8 8 YbdPYbdP 8 " 8 88Y88 Y88Y88 8 `Y88 Y88P 8 8 YP YP 8 8 wwdP wwdP Yggdrasil Window Manager https://github.com/corecaps/YggdrasilWM Copyright (C) 2024 jgarcia jgarc.nosp@m.ia@s.nosp@m.tuden.nosp@m.t.42.nosp@m..fr corec.nosp@m.aps@.nosp@m.gmail.nosp@m..com

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Referenced by createInstance(), destroy(), and getInstance().

pluginsLocations

std::set<std::string> Bars::pluginsLocations

private

Referenced by addPluginLocation(), getPluginsLocations(), and init().

root

Window Bars::root

private

Referenced by init().

spaceE

unsigned int Bars::spaceE

private

Referenced by getSpaceE(), and init().

spaceN

unsigned int Bars::spaceN

private

Referenced by getSpaceN(), and init().

spaceS

unsigned int Bars::spaceS

private

Referenced by getSpaceS(), and init().

spaceW

unsigned int Bars::spaceW

private

Referenced by getSpaceW(), and init().

subscriptions

std::unordered_map<std::string,std::vector<Widget *> > Bars::subscriptions

private

Referenced by run(), and subscribeWidget().

tsData

std::shared_ptr<TSBarsData> Bars::tsData

private

Referenced by init(), and run().

widgetTypeHandle

std::unordered_map<std::string, void *> Bars::widgetTypeHandle

private

Referenced by getWidgetTypeHandle(), setWidgetTypeHandle(), and ~Bars().

windows

std::vector<Window> Bars::windows

private

Referenced by init(), and isBarWindow().

---

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

• inc/Bars/Bars.hpp
• src/Bars/Bars.cpp