Binding Class Reference

Binding store a binding to a command object. More...

#include <Binding.hpp>

Collaboration diagram for Binding:

Public Member Functions
	Binding ()
	~Binding ()
void	init (std::string Mod, std::string Key, std::string Command, std::string Args)
	Initialize a binding all the parameters are read from the Json::Value from the configuration file Mod is parsed to store the proper modMask Command is parsed to link the proper command object. More...
void	init_keycode (Display *display, BaseX11Wrapper *x11Wrapper)
	Initialize the keycode of the binding had to be initialized after the display is opened. More...
void	execute (const XKeyEvent *)
	Execute the command linked to the binding The arguments passed to the command are the one stored in the binding. More...
const std::string &	getMod () const
const std::string &	getKey () const
const std::string &	getCommandName () const
const std::string &	getArgs () const
unsigned int	getModMask () const
int	getKeyCode () const

Private Attributes
std::string	mod_
unsigned int	modMask_
std::string	key_
int	keyCode_
std::string	commandName_
std::string	args_
CommandBase *	command_

Detailed Description

Binding store a binding to a command object.

Constructor & Destructor Documentation

Binding()

Binding::Binding

(

)

                 :
    mod_(""),
    modMask_(0),
    key_(""),
    keyCode_(0),
    commandName_(""),
    args_(""),
    command_(nullptr) {}

~Binding()

Binding::~Binding

(

)

                  {
    delete command_;
}

References command_.

Member Function Documentation

execute()

void Binding::execute

(

const XKeyEvent *

event = nullptr

)

Execute the command linked to the binding The arguments passed to the command are the one stored in the binding.

                                                      {
    if (command_ != nullptr) {
        if (event == nullptr) {
            command_->execute(args_);
        } else {
            std::stringstream ss;
            ss << args_ << "," <<event->subwindow << "," << event->window << "," << event->state << "," << event->keycode;
            command_->execute(ss.str());
        }
    }
    else
        throw std::runtime_error("Command not initialized.");
}

References args_, command_, and CommandBase::execute().

Here is the call graph for this function:

getArgs()

const std::string & Binding::getArgs

(

)

const

{ return args_; }

References args_.

getCommandName()

const std::string & Binding::getCommandName

(

)

const

{ return commandName_; }

References commandName_.

getKey()

const std::string & Binding::getKey

(

)

const

{ return key_; }

References key_.

getKeyCode()

int Binding::getKeyCode

(

)

const

{ return keyCode_; }

References keyCode_.

getMod()

const std::string & Binding::getMod

(

)

const

{ return mod_; }

References mod_.

getModMask()

unsigned int Binding::getModMask

(

)

const

{ return modMask_; }

References modMask_.

init()

void Binding::init	(	std::string	Mod,
		std::string	Key,
		std::string	Command,
		std::string	Args
	)

Initialize a binding all the parameters are read from the Json::Value from the configuration file Mod is parsed to store the proper modMask Command is parsed to link the proper command object.

Note

you need to call init_keycode after the display is opened

                                                                                  {
    mod_ = Mod;
    key_ = Key;
    commandName_ = Command;
    args_ = Args;
    if (commandName_ == "FocusGroup") {
        command_ = new FocusGroup();
    } else if (commandName_ == "Spawn") {
        command_ = new Spawn();
    } else if (commandName_== "Quit") {
        command_ = new Quit();
    } else if (commandName_ == "Grow") {
         command_ = new Grow();
    } else {
        throw std::runtime_error("Unknown command: " + commandName_);
    }
    if (mod_ == "Mod4") {
        modMask_ = Mod4Mask;
    } else if (mod_ == "Mod1") {
        modMask_ = Mod1Mask;
    } else {
        throw std::runtime_error("Unknown mod : " + mod_);
    }
}

References args_, command_, commandName_, key_, mod_, and modMask_.

init_keycode()

void Binding::init_keycode	(	Display *	display,
		BaseX11Wrapper *	x11Wrapper
	)

Initialize the keycode of the binding had to be initialized after the display is opened.

Parameters

display

                                                                       {
    keyCode_ = x11Wrapper->keysymToKeycode(display, (int)x11Wrapper->stringToKeysym(key_.c_str()));
    Logger::GetInstance()->Log("Binding registered : ["
                                + mod_
                                + " + "
                                +key_
                                +"] Command: "
                                + commandName_
                                + " Args: "
                                + args_
                                + " keycode: ["
                                + std::to_string(keyCode_)
                                +"]", L_INFO);
}

References args_, commandName_, Logger::GetInstance(), key_, keyCode_, BaseX11Wrapper::keysymToKeycode(), L_INFO, Logger::Log(), mod_, and BaseX11Wrapper::stringToKeysym().

Here is the call graph for this function:

Member Data Documentation

args_

std::string Binding::args_

private

Referenced by execute(), getArgs(), init(), and init_keycode().

command_

CommandBase* Binding::command_

private

Referenced by execute(), init(), and ~Binding().

commandName_

std::string Binding::commandName_

private

Referenced by getCommandName(), init(), and init_keycode().

key_

std::string Binding::key_

private

Referenced by getKey(), init(), and init_keycode().

keyCode_

int Binding::keyCode_

private

Referenced by getKeyCode(), and init_keycode().

mod_

std::string Binding::mod_

private

Referenced by getMod(), init(), and init_keycode().

modMask_

unsigned int Binding::modMask_

private

Referenced by getModMask(), and init().

---

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

• inc/Config/Binding.hpp
• src/Config/Binding.cpp