EventHandler Class Reference

EventHandler class. This class is responsible for handling the XEvents. It is a part of the WindowManager class The event handlers functions are private and are called by the dispatchEvent function. More...

#include <EventHandler.hpp>

Collaboration diagram for EventHandler:

Public Member Functions
	EventHandler (const EventHandler &)=delete
EventHandler &	operator= (const EventHandler &)=delete
	~EventHandler ()
	Destroy the Event handler:: Event handler object. More...
void	dispatchEvent (const XEvent &event)
	Dispatches the event to the appropriate handler function. the eventHandlerArray is an array of pointers to member functions of the EventHandler class. The array is initialized with the handleUnknown function. The array is then populated with the appropriate handler functions. More...

Static Public Member Functions
static void	create ()
	create the Event handler:: Event handler object More...
static EventHandler *	getInstance ()
	Get the Event handler:: Event handler object. More...
static void	destroy ()

Private Types
using	handler = void(EventHandler::*)(const XEvent &)

Private Member Functions
	EventHandler ()
void	handleMapNotify (const XEvent &event)
	Handles the MapNotify event. The MapNotify event is sent to a client when it is mapped. The event handler retrieves the client from the WindowManager object and sets its mapped attribute to true. The event handler then logs the event. the client is restacked. More...
void	handleUnmapNotify (const XEvent &event)
	Handles the UnmapNotify event. The UnmapNotify event is sent to a client when it is unmapped. The event handler retrieves the client from the WindowManager object and sets its mapped attribute to false. The event handler then logs the event. More...
void	handleConfigureRequest (const XEvent &event)
	Handles the ConfigureRequest event. The ConfigureRequest event is sent to a client when it requests a change in its size, position, or stacking order. More...
void	handleConfigureNotify (const XEvent &event)
	Handles the ConfigureNotify event. More...
void	handleButtonPress (const XEvent &event)
	Handles the ButtonPress event. The ButtonPress event is sent to a client when a mouse button is pressed. More...
void	handleButtonRelease (const XEvent &event)
	Handles the ButtonRelease event. More...
void	handleKeyPress (const XEvent &event)
	Handles the KeyPress event. the handling of KeyPress event is delegated to the ConfigDataBindings object to avoid dependencies to the Binding class and the Command class. More...
void	handleKeyRelease (const XEvent &event)
	Handles the KeyRelease event. More...
void	handleEnterNotify (const XEvent &event)
	Handles the EnterNotify event. More...
void	handleLeaveNotify (const XEvent &event)
	Handles the LeaveNotify event. More...
void	handleExpose (const XEvent &event)
	This where the bar is drawn, other windows are ignored. More...
void	handleFocusIn (const XEvent &event)
	Handles the FocusIn event. Changes the border color of the client. More...
void	handleFocusOut (const XEvent &event)
	Handles the FocusOut event. Changes the border color of the client. More...
void	handlePropertyNotify (const XEvent &event)
	Handles the PropertyNotify event. More...
void	handleClientMessage (const XEvent &event)
	Handles the ClientMessage event. More...
void	handleDestroyNotify (const XEvent &event)
	Handles the DestroyNotify event. More...
void	handleReparentNotify (const XEvent &event)
	Handles the ReparentNotify event. More...
void	handleMapRequest (const XEvent &event)
	Handles the MapRequest event. The MapRequest event is sent to a client when it is mapped. The event handler retrieves the client from the WindowManager object and sets its mapped attribute to true. The event handler then logs the event. More...
void	handleMotionNotify (const XEvent &event)
	Handles the MotionNotify event. this was previously used for dragging windows.r. More...
void	handleUnknown (const XEvent &event)
	Handles the Unknown event. More...
void	handleCreateNotify (const XEvent &event)
	Handles the CreateNotify event. More...

Private Attributes
handler	eventHandlerArray [LASTEvent] {}
std::shared_ptr< BaseX11Wrapper >	wrapper

Static Private Attributes
static EventHandler *	instance_ = nullptr

Detailed Description

EventHandler class. This class is responsible for handling the XEvents. It is a part of the WindowManager class The event handlers functions are private and are called by the dispatchEvent function.

Todo:

see the pertinence of implementing observer pattern here

See also

WindowManager

Client

Logger

Member Typedef Documentation

handler

using EventHandler::handler = void (EventHandler::*)(const XEvent&)

private

Constructor & Destructor Documentation

EventHandler() [1/2]

EventHandler::EventHandler ( const EventHandler &  )

delete

~EventHandler()

EventHandler::~EventHandler ( )

default

Destroy the Event handler:: Event handler object.

EventHandler() [2/2]

EventHandler::EventHandler ( )

private

                           {
    for (auto & i : eventHandlerArray) {
        i = &EventHandler::handleUnknown;
    }
    eventHandlerArray[MapNotify] = &EventHandler::handleMapNotify;
    eventHandlerArray[UnmapNotify] = &EventHandler::handleUnmapNotify;
    eventHandlerArray[ConfigureNotify] = &EventHandler::handleConfigureNotify;
    eventHandlerArray[ConfigureRequest] = &EventHandler::handleConfigureRequest;
    eventHandlerArray[ButtonPress] = &EventHandler::handleButtonPress;
    eventHandlerArray[ButtonRelease] = &EventHandler::handleButtonRelease;
    eventHandlerArray[KeyPress] = &EventHandler::handleKeyPress;
    eventHandlerArray[KeyRelease] = &EventHandler::handleKeyRelease;
    eventHandlerArray[EnterNotify] = &EventHandler::handleEnterNotify;
    eventHandlerArray[LeaveNotify] = &EventHandler::handleLeaveNotify;
    eventHandlerArray[Expose] = &EventHandler::handleExpose;
    eventHandlerArray[FocusIn] = &EventHandler::handleFocusIn;
    eventHandlerArray[FocusOut] = &EventHandler::handleFocusOut;
    eventHandlerArray[PropertyNotify] = &EventHandler::handlePropertyNotify;
    eventHandlerArray[ClientMessage] = &EventHandler::handleClientMessage;
    eventHandlerArray[DestroyNotify] = &EventHandler::handleDestroyNotify;
    eventHandlerArray[ReparentNotify] = &EventHandler::handleReparentNotify;
    eventHandlerArray[MapRequest] = &EventHandler::handleMapRequest;
    eventHandlerArray[MotionNotify] = &EventHandler::handleMotionNotify;
    wrapper = WindowManager::getInstance()->getX11Wrapper();
}

References eventHandlerArray, WindowManager::getInstance(), WindowManager::getX11Wrapper(), handleButtonPress(), handleButtonRelease(), handleClientMessage(), handleConfigureNotify(), handleConfigureRequest(), handleDestroyNotify(), handleEnterNotify(), handleExpose(), handleFocusIn(), handleFocusOut(), handleKeyPress(), handleKeyRelease(), handleLeaveNotify(), handleMapNotify(), handleMapRequest(), handleMotionNotify(), handlePropertyNotify(), handleReparentNotify(), handleUnknown(), handleUnmapNotify(), and wrapper.

Referenced by create().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

create()

static void EventHandler::create ( )

static

create the Event handler:: Event handler object

                          {
    if (instance_ != nullptr) {
        throw std::runtime_error("EventHandler instance already created");
    }
    instance_ = new EventHandler();
}

References EventHandler(), and instance_.

Referenced by WindowManager::Run(), and WindowManager::testRun().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy()

void EventHandler::destroy ( )

static

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

References instance_.

Referenced by main().

Here is the caller graph for this function:

dispatchEvent()

void EventHandler::dispatchEvent

(

const XEvent &

event

)

Dispatches the event to the appropriate handler function. the eventHandlerArray is an array of pointers to member functions of the EventHandler class. The array is initialized with the handleUnknown function. The array is then populated with the appropriate handler functions.

Parameters

event

The XEvent to be dispatched.

                                                    {
    std::string name = GetEventTypeName(event.xany.type);
    if (event.type > 0 && event.type < LASTEvent && eventHandlerArray[event.type] != nullptr)
        (this->*eventHandlerArray[event.type])(event);
    else
        Logger::GetInstance()->Log("Unknown event type: ["  + std::to_string(event.type) + "]\t" + name, L_WARNING);
}

References eventHandlerArray, GetEventTypeName(), Logger::GetInstance(), L_WARNING, and Logger::Log().

Referenced by WindowManager::Run(), and WindowManager::testRun().

Here is the call graph for this function:

Here is the caller graph for this function:

getInstance()

EventHandler * EventHandler::getInstance ( )

static

Get the Event handler:: Event handler object.

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

References instance_.

Referenced by WindowManager::Run(), and WindowManager::testRun().

Here is the caller graph for this function:

handleButtonPress()

void EventHandler::handleButtonPress ( const XEvent &  event )

private

Handles the ButtonPress event. The ButtonPress event is sent to a client when a mouse button is pressed.

Parameters

event

The ButtonPress event to be handled.

                                                        {
    auto e = event.xbutton;
    if (Bars::getInstance().isBarWindow(e.window)) {
        Logger::GetInstance()->Log("Ignoring unmap for bar window", L_INFO);
        return;
    }
    const Window frame = WindowManager::getInstance()->getClient(event.xbutton.window)->getFrame();
    // give focus to the window
    wrapper->setInputFocus(WindowManager::getInstance()->getDisplay(), frame, RevertToParent, CurrentTime);
    // 1. Save initial cursor position.
//  drag_start_pos_ = Position<int>(e.x_root, e.y_root);
//  // 2. Save initial window info.
//  Window returned_root;
//  int x, y;
//  unsigned width, height, border_width, depth;
//  XGetGeometry(
//          wm_.getDisplay(),
//          frame,
//          &returned_root,
//          &x, &y,
//          &width, &height,
//          &border_width,
//          &depth);
//  drag_start_frame_pos_ = Position<int>(x, y);
//  drag_start_frame_size_ = Size<int>(width, height);
    // 3. Raise clicked window to top.
    wrapper->raiseWindow(WindowManager::getInstance()->getDisplay(),frame);
}

References WindowManager::getClient(), Bars::getInstance(), Logger::GetInstance(), WindowManager::getInstance(), L_INFO, Logger::Log(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleButtonRelease()

void EventHandler::handleButtonRelease ( const XEvent &  event )

private

Handles the ButtonRelease event.

Parameters

event

{}

Referenced by EventHandler().

Here is the caller graph for this function:

handleClientMessage()

void EventHandler::handleClientMessage ( const XEvent &  event )

private

Handles the ClientMessage event.

Parameters

event

                                                          {
    XClientMessageEvent e = event.xclient;
    Display * display = WindowManager::getInstance()->getDisplay();
    Window root = WindowManager::getInstance()->getRoot();
    ewmh::handleMessage(&e, display, root);
}

References WindowManager::getDisplay(), WindowManager::getInstance(), WindowManager::getRoot(), and ewmh::handleMessage().

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleConfigureNotify()

void EventHandler::handleConfigureNotify ( const XEvent &  event )

private

Handles the ConfigureNotify event.

Parameters

event

                                                            {
}

Referenced by EventHandler().

Here is the caller graph for this function:

handleConfigureRequest()

void EventHandler::handleConfigureRequest ( const XEvent &  event )

private

Handles the ConfigureRequest event. The ConfigureRequest event is sent to a client when it requests a change in its size, position, or stacking order.

Parameters

event

                                                             {
    auto e = event.xconfigurerequest;
    XWindowChanges changes;
    changes.x = e.x;
    changes.y = e.y;
    changes.width = e.width;
    changes.height = e.height;
    changes.border_width = e.border_width;
    changes.sibling = e.above;
    changes.stack_mode = e.detail;
    wrapper->configureWindow(WindowManager::getInstance()->getDisplay(),e.window,e.value_mask,&changes);
}

References WindowManager::getInstance(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleCreateNotify()

void EventHandler::handleCreateNotify ( const XEvent &  event )

private

Handles the CreateNotify event.

Parameters

event

{}

handleDestroyNotify()

void EventHandler::handleDestroyNotify ( const XEvent &  event )

private

Handles the DestroyNotify event.

Parameters

event

                                                          {
    auto e = event.xdestroywindow;
    if (e.window == WindowManager::getInstance()->getRoot()) {
        Logger::GetInstance()->Log("Ignoring destroy for root window", L_INFO);
        return;
    }
    if (Bars::getInstance().isBarWindow(e.window)) {
        Logger::GetInstance()->Log("Ignoring unmap for bar window", L_INFO);
        return;
    }
    try {
        auto client = WindowManager::getInstance()->getClientRef(e.window);
        Logger::GetInstance()->Log("Destroying window: " + client->getTitle(), L_INFO);
        client->unframe();
        WindowManager::getInstance()->getClients().erase(e.window);
        client->getGroup()->removeClient(client.get());
        auto clients = WindowManager::getInstance()->getActiveGroup()->getClients();
        if (!clients.empty()) {
            Client *dclient = clients.begin()->second.get();
            if (dclient != nullptr) {
                WindowManager::getInstance()->setFocus(dclient);
                return;
            }
        }
        wrapper->setInputFocus(WindowManager::getInstance()->getDisplay(),
                       WindowManager::getInstance()->getRoot(),
                       RevertToParent, CurrentTime);
    } catch (std::out_of_range &err) {
        Logger::GetInstance()->Log("Destroying unknown window: " + std::to_string(e.window), L_WARNING);
    }
}

References WindowManager::getActiveGroup(), WindowManager::getClientRef(), WindowManager::getClients(), Bars::getInstance(), Logger::GetInstance(), WindowManager::getInstance(), WindowManager::getRoot(), L_INFO, L_WARNING, Logger::Log(), WindowManager::setFocus(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleEnterNotify()

void EventHandler::handleEnterNotify ( const XEvent &  event )

private

Handles the EnterNotify event.

Parameters

event

                                                        {
    auto e = event.xcrossing;
    if (Bars::getInstance().isBarWindow(e.window)) {
        Bars::getInstance().redraw();
        return;
    }
}

References Bars::getInstance(), and Bars::redraw().

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleExpose()

void EventHandler::handleExpose ( const XEvent &  event )

private

This where the bar is drawn, other windows are ignored.

                                                   {
    auto e = event.xexpose;
    if (Bars::getInstance().isBarWindow(e.window)) {
        Bars::getInstance().redraw();
        return;
    }
}

References Bars::getInstance(), and Bars::redraw().

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleFocusIn()

void EventHandler::handleFocusIn ( const XEvent &  event )

private

Handles the FocusIn event. Changes the border color of the client.

Parameters

event

                                                    {
    auto e = event.xfocus;
    WindowManager::getInstance()->setActiveWindow(e.window);
    ewmh::updateActiveWindow(WindowManager::getInstance()->getDisplay(), WindowManager::getInstance()->getRoot(), e.window);
    if (e.window == WindowManager::getInstance()->getRoot()) {
        return;
    }
    Client * client = WindowManager::getInstance()->getClient(e.window).get();
    if (client == nullptr) {
        return;
    }
    else {
        unsigned long ActiveColor = client->getGroup()->getActiveColor();
        Logger::GetInstance()->Log("Window focused: " + client->getTitle() , L_INFO);
        wrapper->setWindowBorder(WindowManager::getInstance()->getDisplay(), client->getFrame(), ActiveColor);
        wrapper->flush(WindowManager::getInstance()->getDisplay());
    }
}

References WindowManager::getClient(), Client::getFrame(), Client::getGroup(), Logger::GetInstance(), WindowManager::getInstance(), WindowManager::getRoot(), Client::getTitle(), L_INFO, Logger::Log(), WindowManager::setActiveWindow(), ewmh::updateActiveWindow(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleFocusOut()

void EventHandler::handleFocusOut ( const XEvent &  event )

private

Handles the FocusOut event. Changes the border color of the client.

Parameters

event

                                                     {
    auto e = event.xfocus;
    if (WindowManager::getInstance()->getActiveWindow() == e.window) {
        WindowManager::getInstance()->setActiveWindow(0);
        ewmh::updateActiveWindow(WindowManager::getInstance()->getDisplay(), WindowManager::getInstance()->getRoot(), None);
    }
    if (e.window == WindowManager::getInstance()->getRoot()) {
        return;
    }
    Client * client = WindowManager::getInstance()->getClient(e.window).get();
    if (client == nullptr) {
        return;
    }
    else {
        unsigned long InActiveColor = client->getGroup()->getInactiveColor();
        Logger::GetInstance()->Log("Window unfocused: " + client->getTitle() , L_INFO);
        wrapper->setWindowBorder(WindowManager::getInstance()->getDisplay(), client->getFrame(), InActiveColor);
        wrapper->flush(WindowManager::getInstance()->getDisplay());
    }
}

References WindowManager::getClient(), Client::getFrame(), Client::getGroup(), Logger::GetInstance(), WindowManager::getInstance(), WindowManager::getRoot(), Client::getTitle(), L_INFO, Logger::Log(), WindowManager::setActiveWindow(), ewmh::updateActiveWindow(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleKeyPress()

void EventHandler::handleKeyPress ( const XEvent &  event )

private

Handles the KeyPress event. the handling of KeyPress event is delegated to the ConfigDataBindings object to avoid dependencies to the Binding class and the Command class.

Parameters

event

                                                     {
    auto e = &event.xkey;
    ConfigHandler::GetInstance().getConfigData<ConfigDataBindings>()->handleKeypressEvent(e);
    wrapper->sync(WindowManager::getInstance()->getDisplay(),false);
}

References ConfigHandler::getConfigData(), ConfigHandler::GetInstance(), WindowManager::getInstance(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleKeyRelease()

void EventHandler::handleKeyRelease ( const XEvent &  event )

private

Handles the KeyRelease event.

Parameters

event

{}

Referenced by EventHandler().

Here is the caller graph for this function:

handleLeaveNotify()

void EventHandler::handleLeaveNotify ( const XEvent &  event )

private

Handles the LeaveNotify event.

Parameters

event

{}

Referenced by EventHandler().

Here is the caller graph for this function:

handleMapNotify()

void EventHandler::handleMapNotify ( const XEvent &  event )

private

Handles the MapNotify event. The MapNotify event is sent to a client when it is mapped. The event handler retrieves the client from the WindowManager object and sets its mapped attribute to true. The event handler then logs the event. the client is restacked.

Parameters

event

The MapNotify event to be handled.

                                                      {
    auto e = event.xmap;
    Client * client = WindowManager::getInstance()->getClient(e.window).get();
    if (client == nullptr) {
        Logger::GetInstance()->Log("Ignoring map for unknown window: " + std::to_string(e.window), L_INFO);
        return;
    }
    else {
        Logger::GetInstance()->Log("Window Mapped: " + client->getTitle() , L_INFO);
        if (client->getFrame() != e.window) {
            client->restack();
            client->setMapped(true);
        }
    }
}

References WindowManager::getClient(), Client::getFrame(), Logger::GetInstance(), WindowManager::getInstance(), Client::getTitle(), L_INFO, Logger::Log(), Client::restack(), and Client::setMapped().

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleMapRequest()

void EventHandler::handleMapRequest ( const XEvent &  event )

private

Handles the MapRequest event. The MapRequest event is sent to a client when it is mapped. The event handler retrieves the client from the WindowManager object and sets its mapped attribute to true. The event handler then logs the event.

Parameters

event

The MapRequest event to be handled.

                                                       {
    XMapRequestEvent e = event.xmaprequest;
    if (e.parent != WindowManager::getInstance()->getRoot()) {
        Logger::GetInstance()->Log("Ignoring map request for window: " + std::to_string(e.window), L_INFO);
        return;
    }
    try {
        if (WindowManager::getInstance()->getClientRef(e.window)->isMapped()) {
            Logger::GetInstance()->Log("Window already mapped: " + std::to_string(e.window), L_INFO);
            return;
        }
        auto client = WindowManager::getInstance()->getClientRef(e.window);
        if (client->isFramed()) {
            Logger::GetInstance()->Log("Window already framed: " + std::to_string(e.window), L_INFO);
            return;
        }
        else {
            Logger::GetInstance()->Log("Framing window: " + client->getTitle(), L_INFO);
            try {
                client->frame();
                client->getGroup()->addClient(client->getWindow(),client);
                WindowManager::getInstance()->setFocus(client.get());
            } catch (const std::exception &ex) {
                Logger::GetInstance()->Log(ex.what(), L_ERROR);
            }
        }
        Logger::GetInstance()->Log("Window already mapped: " + std::to_string(e.window), L_INFO);
        return;
    }
    catch (std::out_of_range &err) {
        Logger::GetInstance()->Log("Creating new client for window: " + std::to_string(e.window), L_INFO);
        WindowManager::getInstance()->insertClient(e.window);
        try {
            auto c = WindowManager::getInstance()->getClientRef(e.window);
            c->frame();
            c->getGroup()->addClient(e.window,c);
        } catch (const std::exception &ex) {
            Logger::GetInstance()->Log(ex.what(), L_ERROR);
        }
    }
    wrapper->mapWindow(WindowManager::getInstance()->getDisplay(), e.window);
}

References WindowManager::getClientRef(), Logger::GetInstance(), WindowManager::getInstance(), WindowManager::getRoot(), WindowManager::insertClient(), L_ERROR, L_INFO, Logger::Log(), WindowManager::setFocus(), and wrapper.

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleMotionNotify()

void EventHandler::handleMotionNotify ( const XEvent &  event )

private

Handles the MotionNotify event. this was previously used for dragging windows.r.

Todo:

: rework this function to handle dragging windows.

Parameters

event

                                                         {
    auto e = event.xmotion;
    if (Bars::getInstance().isBarWindow(e.window)) {
        return;
    }
    const Window frame = WindowManager::getInstance()->getClientRef(event.xmotion.window)->getFrame();
//  const Position<int> drag_pos(e.x_root, e.y_root);
//  const Vector2D<int> delta = drag_pos - drag_start_pos_;
//
//  if (e.state & Button1Mask) {
//      // alt + left button: Move window.
//      const Position<int> dest_frame_pos = drag_start_frame_pos_ + delta;
//      XMoveWindow(
//              wm_.getDisplay(),
//              frame,
//              dest_frame_pos.x, dest_frame_pos.y);
//  } else if (e.state & Button3Mask) {
//      // alt + right button: Resize window.
//      // Window dimensions cannot be negative.
//      const Vector2D<int> size_delta(
//              std::max(delta.x, -drag_start_frame_size_.width),
//              std::max(delta.y, -drag_start_frame_size_.height));
//      const Size<int> dest_frame_size = drag_start_frame_size_ + size_delta;
//      // 1. Resize frame.
//      XResizeWindow(
//              wm_.getDisplay(),
//              frame,
//              dest_frame_size.width, dest_frame_size.height);
//      // 2. Resize client window.
//      XResizeWindow(
//              wm_.getDisplay(),
//              e.window,
//              dest_frame_size.width, dest_frame_size.height);
//  }
}

References WindowManager::getClientRef(), Bars::getInstance(), and WindowManager::getInstance().

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handlePropertyNotify()

void EventHandler::handlePropertyNotify ( const XEvent &  event )

private

Handles the PropertyNotify event.

Parameters

event

                                                           {
    XPropertyEvent e = event.xproperty;
    Logger::GetInstance()->Log("PropertyNotify: " + std::to_string(e.atom), L_INFO);
}

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

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

handleReparentNotify()

void EventHandler::handleReparentNotify ( const XEvent &  event )

private

Handles the ReparentNotify event.

Parameters

event

{}

Referenced by EventHandler().

Here is the caller graph for this function:

handleUnknown()

void EventHandler::handleUnknown ( const XEvent &  event )

private

Handles the Unknown event.

Parameters

event

{}

Referenced by EventHandler().

Here is the caller graph for this function:

handleUnmapNotify()

void EventHandler::handleUnmapNotify ( const XEvent &  event )

private

Handles the UnmapNotify event. The UnmapNotify event is sent to a client when it is unmapped. The event handler retrieves the client from the WindowManager object and sets its mapped attribute to false. The event handler then logs the event.

Parameters

event

The UnmapNotify event to be handled.

                                                        {
    auto e = event.xunmap;
    if (Bars::getInstance().isBarWindow(e.window)) {
        Logger::GetInstance()->Log("Ignoring unmap for bar window", L_INFO);
        return;
    }
    if (e.window == WindowManager::getInstance()->getRoot()) {
        ConfigHandler::GetInstance().getConfigData<ConfigDataBindings>()->grabKeys(WindowManager::getInstance()->getDisplay(),WindowManager::getInstance()->getRoot());
        Logger::GetInstance()->Log("Ignoring unmap for root window", L_INFO);
        return;
    }
    try {
        auto client = WindowManager::getInstance()->getClientRef(e.window);
        Logger::GetInstance()->Log("Unmapping window: " + client->getTitle(), L_INFO);
        if (client->getFrame() != e.window) {
            client->setMapped(false);
        }
        else {
            client->unframe();
            client->getGroup()->removeClient(client.get());
            WindowManager::getInstance()->getClients().erase(e.window);
        }
    }
    catch (std::out_of_range &err) {
        Logger::GetInstance()->Log("Unmapping unknown window: " + std::to_string(e.window), L_WARNING);
    }
}

References WindowManager::getClientRef(), WindowManager::getClients(), ConfigHandler::getConfigData(), WindowManager::getDisplay(), Bars::getInstance(), ConfigHandler::GetInstance(), Logger::GetInstance(), WindowManager::getInstance(), WindowManager::getRoot(), L_INFO, L_WARNING, and Logger::Log().

Referenced by EventHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

EventHandler& EventHandler::operator= ( const EventHandler &  )

delete

Member Data Documentation

eventHandlerArray

handler EventHandler::eventHandlerArray[LASTEvent] {}

private

Referenced by dispatchEvent(), and EventHandler().

instance_

EventHandler * EventHandler::instance_ = nullptr

staticprivate

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

wrapper

std::shared_ptr<BaseX11Wrapper> EventHandler::wrapper

private

Referenced by EventHandler(), handleButtonPress(), handleConfigureRequest(), handleDestroyNotify(), handleFocusIn(), handleFocusOut(), handleKeyPress(), and handleMapRequest().

---

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

• inc/EventHandler.hpp
• src/EventHandler.cpp