mirror/polybar
3
0
Fork 0
mirror of https://github.com/polybar/polybar.git synced 2026-03-16 21:27:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(clang-tidy): Apply fixes

Browse Source
This commit is contained in:
Michael Carlberg
2016-11-25 13:55:15 +01:00
parent 0128014d44
commit ff9be848c7
119 changed files with 1752 additions and 1046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
src/modules/volume.cpp
View File

@ -25,26 +25,34 @@ namespace modules {
GET_CONFIG_VALUE(name(), headphone_mixer_name, "headphone-mixer");
GET_CONFIG_VALUE(name(), m_mapped, "mapped");
if (!headphone_mixer_name.empty())
if (!headphone_mixer_name.empty()) {
REQ_CONFIG_VALUE(name(), m_headphoneid, "headphone-id");
}
if (string_util::compare(speaker_mixer_name, "master"))
if (string_util::compare(speaker_mixer_name, "master")) {
throw module_error("Master mixer is already defined");
if (string_util::compare(headphone_mixer_name, "master"))
}
if (string_util::compare(headphone_mixer_name, "master")) {
throw module_error("Master mixer is already defined");
}
// Setup mixers
try {
if (!master_mixer_name.empty())
m_mixers[mixer::MASTER].reset(new mixer_t::element_type{master_mixer_name});
if (!speaker_mixer_name.empty())
m_mixers[mixer::SPEAKER].reset(new mixer_t::element_type{speaker_mixer_name});
if (!headphone_mixer_name.empty())
m_mixers[mixer::HEADPHONE].reset(new mixer_t::element_type{headphone_mixer_name});
if (m_mixers[mixer::HEADPHONE])
m_controls[control::HEADPHONE].reset(new control_t::element_type{m_headphoneid});
if (m_mixers.empty())
if (!master_mixer_name.empty()) {
m_mixer[mixer::MASTER].reset(new mixer_t::element_type{master_mixer_name});
}
if (!speaker_mixer_name.empty()) {
m_mixer[mixer::SPEAKER].reset(new mixer_t::element_type{speaker_mixer_name});
}
if (!headphone_mixer_name.empty()) {
m_mixer[mixer::HEADPHONE].reset(new mixer_t::element_type{headphone_mixer_name});
}
if (m_mixer[mixer::HEADPHONE]) {
m_ctrl[control::HEADPHONE].reset(new control_t::element_type{m_headphoneid});
}
if (m_mixer.empty()) {
throw module_error("No configured mixers");
}
} catch (const alsa_mixer_error& err) {
throw module_error(err.what());
} catch (const alsa_ctl_interface_error& err) {
@ -55,12 +63,15 @@ namespace modules {
m_formatter->add(FORMAT_VOLUME, TAG_LABEL_VOLUME, {TAG_RAMP_VOLUME, TAG_LABEL_VOLUME, TAG_BAR_VOLUME});
m_formatter->add(FORMAT_MUTED, TAG_LABEL_MUTED, {TAG_RAMP_VOLUME, TAG_LABEL_MUTED, TAG_BAR_VOLUME});
if (m_formatter->has(TAG_BAR_VOLUME))
if (m_formatter->has(TAG_BAR_VOLUME)) {
m_bar_volume = load_progressbar(m_bar, m_conf, name(), TAG_BAR_VOLUME);
if (m_formatter->has(TAG_LABEL_VOLUME, FORMAT_VOLUME))
}
if (m_formatter->has(TAG_LABEL_VOLUME, FORMAT_VOLUME)) {
m_label_volume = load_optional_label(m_conf, name(), TAG_LABEL_VOLUME, "%percentage%");
if (m_formatter->has(TAG_LABEL_MUTED, FORMAT_MUTED))
}
if (m_formatter->has(TAG_LABEL_MUTED, FORMAT_MUTED)) {
m_label_muted = load_optional_label(m_conf, name(), TAG_LABEL_MUTED, "%percentage%");
}
if (m_formatter->has(TAG_RAMP_VOLUME)) {
m_ramp_volume = load_ramp(m_conf, name(), TAG_RAMP_VOLUME);
m_ramp_headphones = load_ramp(m_conf, name(), TAG_RAMP_HEADPHONES, false);
@ -68,20 +79,24 @@ namespace modules {
}
void volume_module::teardown() {
m_mixers.clear();
m_mixer.clear();
}
bool volume_module::has_event() {
// Poll for mixer and control events
try {
if (m_mixers[mixer::MASTER] && m_mixers[mixer::MASTER]->wait(25))
if (m_mixer[mixer::MASTER] && m_mixer[mixer::MASTER]->wait(25)) {
return true;
if (m_mixers[mixer::SPEAKER] && m_mixers[mixer::SPEAKER]->wait(25))
}
if (m_mixer[mixer::SPEAKER] && m_mixer[mixer::SPEAKER]->wait(25)) {
return true;
if (m_mixers[mixer::HEADPHONE] && m_mixers[mixer::HEADPHONE]->wait(25))
}
if (m_mixer[mixer::HEADPHONE] && m_mixer[mixer::HEADPHONE]->wait(25)) {
return true;
if (m_controls[control::HEADPHONE] && m_controls[control::HEADPHONE]->wait(25))
}
if (m_ctrl[control::HEADPHONE] && m_ctrl[control::HEADPHONE]->wait(25)) {
return true;
}
} catch (const alsa_exception& e) {
m_log.err("%s: %s", name(), e.what());
}
@ -91,35 +106,53 @@ namespace modules {
bool volume_module::update() {
// Consume pending events
if (m_mixers[mixer::MASTER])
m_mixers[mixer::MASTER]->process_events();
if (m_mixers[mixer::SPEAKER])
m_mixers[mixer::SPEAKER]->process_events();
if (m_mixers[mixer::HEADPHONE])
m_mixers[mixer::HEADPHONE]->process_events();
if (m_controls[control::HEADPHONE])
m_controls[control::HEADPHONE]->process_events();
if (m_mixer[mixer::MASTER]) {
m_mixer[mixer::MASTER]->process_events();
}
if (m_mixer[mixer::SPEAKER]) {
m_mixer[mixer::SPEAKER]->process_events();
}
if (m_mixer[mixer::HEADPHONE]) {
m_mixer[mixer::HEADPHONE]->process_events();
}
if (m_ctrl[control::HEADPHONE]) {
m_ctrl[control::HEADPHONE]->process_events();
}
// Get volume, mute and headphone state
m_volume = 100;
m_muted = false;
m_headphones = false;
if (m_mixers[mixer::MASTER]) {
m_volume = m_volume * (m_mapped ? m_mixers[mixer::MASTER]->get_normalized_volume() / 100.0f
: m_mixers[mixer::MASTER]->get_volume() / 100.0f);
m_muted = m_muted || m_mixers[mixer::MASTER]->is_muted();
try {
if (m_mixer[mixer::MASTER]) {
m_volume = m_volume * (m_mapped ? m_mixer[mixer::MASTER]->get_normalized_volume() / 100.0f
: m_mixer[mixer::MASTER]->get_volume() / 100.0f);
m_muted = m_muted || m_mixer[mixer::MASTER]->is_muted();
}
} catch (const alsa_exception& err) {
m_log.err("%s: Failed to query master mixer (%s)", name(), err.what());
}
if (m_controls[control::HEADPHONE] && m_controls[control::HEADPHONE]->test_device_plugged()) {
m_headphones = true;
m_volume = m_volume * (m_mapped ? m_mixers[mixer::HEADPHONE]->get_normalized_volume() / 100.0f
: m_mixers[mixer::HEADPHONE]->get_volume() / 100.0f);
m_muted = m_muted || m_mixers[mixer::HEADPHONE]->is_muted();
} else if (m_mixers[mixer::SPEAKER]) {
m_volume = m_volume * (m_mapped ? m_mixers[mixer::SPEAKER]->get_normalized_volume() / 100.0f
: m_mixers[mixer::SPEAKER]->get_volume() / 100.0f);
m_muted = m_muted || m_mixers[mixer::SPEAKER]->is_muted();
try {
if (m_ctrl[control::HEADPHONE] && m_ctrl[control::HEADPHONE]->test_device_plugged()) {
m_headphones = true;
m_volume = m_volume * (m_mapped ? m_mixer[mixer::HEADPHONE]->get_normalized_volume() / 100.0f
: m_mixer[mixer::HEADPHONE]->get_volume() / 100.0f);
m_muted = m_muted || m_mixer[mixer::HEADPHONE]->is_muted();
}
} catch (const alsa_exception& err) {
m_log.err("%s: Failed to query headphone mixer (%s)", name(), err.what());
}
try {
if (!m_headphones && m_mixer[mixer::SPEAKER]) {
m_volume = m_volume * (m_mapped ? m_mixer[mixer::SPEAKER]->get_normalized_volume() / 100.0f
: m_mixer[mixer::SPEAKER]->get_volume() / 100.0f);
m_muted = m_muted || m_mixer[mixer::SPEAKER]->is_muted();
}
} catch (const alsa_exception& err) {
m_log.err("%s: Failed to query speaker mixer (%s)", name(), err.what());
}
// Replace label tokens
@ -143,48 +176,58 @@ namespace modules {
string volume_module::get_output() {
m_builder->cmd(mousebtn::LEFT, EVENT_TOGGLE_MUTE);
if (!m_muted && m_volume < 100)
if (!m_muted && m_volume < 100) {
m_builder->cmd(mousebtn::SCROLL_UP, EVENT_VOLUME_UP);
if (!m_muted && m_volume > 0)
}
if (!m_muted && m_volume > 0) {
m_builder->cmd(mousebtn::SCROLL_DOWN, EVENT_VOLUME_DOWN);
}
m_builder->append(module::get_output());
return m_builder->flush();
}
bool volume_module::build(builder* builder, string tag) const {
if (tag == TAG_BAR_VOLUME)
bool volume_module::build(builder* builder, const string& tag) const {
if (tag == TAG_BAR_VOLUME) {
builder->node(m_bar_volume->output(m_volume));
else if (tag == TAG_RAMP_VOLUME && (!m_headphones || !*m_ramp_headphones))
} else if (tag == TAG_RAMP_VOLUME && (!m_headphones || !*m_ramp_headphones)) {
builder->node(m_ramp_volume->get_by_percentage(m_volume));
else if (tag == TAG_RAMP_VOLUME && m_headphones && *m_ramp_headphones)
} else if (tag == TAG_RAMP_VOLUME && m_headphones && *m_ramp_headphones) {
builder->node(m_ramp_headphones->get_by_percentage(m_volume));
else if (tag == TAG_LABEL_VOLUME)
} else if (tag == TAG_LABEL_VOLUME) {
builder->node(m_label_volume);
else if (tag == TAG_LABEL_MUTED)
} else if (tag == TAG_LABEL_MUTED) {
builder->node(m_label_muted);
else
} else {
return false;
}
return true;
}
bool volume_module::handle_event(string cmd) {
if (cmd.compare(0, 3, EVENT_PREFIX) != 0)
if (cmd.compare(0, 3, EVENT_PREFIX) != 0) {
return false;
if (!m_mixers[mixer::MASTER])
}
if (!m_mixer[mixer::MASTER]) {
return false;
vector<mixer_t> mixers;
if (m_mixers[mixer::MASTER])
mixers.emplace_back(new mixer_t::element_type(m_mixers[mixer::MASTER]->get_name()));
if (m_mixers[mixer::HEADPHONE] && m_headphones)
mixers.emplace_back(new mixer_t::element_type(m_mixers[mixer::HEADPHONE]->get_name()));
if (m_mixers[mixer::SPEAKER] && !m_headphones)
mixers.emplace_back(new mixer_t::element_type(m_mixers[mixer::SPEAKER]->get_name()));
}
try {
vector<mixer_t> mixers;
bool headphones{m_headphones};
if (m_mixer[mixer::MASTER] && !m_mixer[mixer::MASTER]->get_name().empty()) {
mixers.emplace_back(new mixer_t::element_type(m_mixer[mixer::MASTER]->get_name()));
}
if (m_mixer[mixer::HEADPHONE] && !m_mixer[mixer::HEADPHONE]->get_name().empty() && headphones) {
mixers.emplace_back(new mixer_t::element_type(m_mixer[mixer::HEADPHONE]->get_name()));
}
if (m_mixer[mixer::SPEAKER] && !m_mixer[mixer::SPEAKER]->get_name().empty() && !headphones) {
mixers.emplace_back(new mixer_t::element_type(m_mixer[mixer::SPEAKER]->get_name()));
}
if (cmd.compare(0, strlen(EVENT_TOGGLE_MUTE), EVENT_TOGGLE_MUTE) == 0) {
for (auto&& mixer : mixers) {
mixer->set_mute(m_muted || mixers[0]->is_muted());
@ -202,7 +245,13 @@ namespace modules {
} else {
return false;
}
} catch (const std::exception& err) {
for (auto&& mixer : mixers) {
if (mixer->wait(0)) {
mixer->process_events();
}
}
} catch (const exception& err) {
m_log.err("%s: Failed to handle command (%s)", name(), err.what());
}