mayhem-firmware/firmware/common/ui_widget.cpp
furrtek 4465cfb905 Added tone keys for some wireless mic brands
Renamed CTCSS stuff to Tone key
Changed PTT key in mic TX (was left, now right) to allow easier exit
Mic samplerate bumped to 48kHz
Updated binary
2017-11-09 20:02:34 +00:00

1662 lines
34 KiB
C++

/*
* Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
* Copyright (C) 2016 Furrtek
*
* This file is part of PortaPack.
*
* 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 2, 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; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#include "ui_widget.hpp"
#include "ui_painter.hpp"
#include "portapack.hpp"
#include <cstdint>
#include <cstddef>
#include <algorithm>
#include "string_format.hpp"
using namespace portapack;
namespace ui {
static bool ui_dirty = true;
void dirty_set() {
ui_dirty = true;
}
void dirty_clear() {
ui_dirty = false;
}
bool is_dirty() {
return ui_dirty;
}
/* Widget ****************************************************************/
const std::vector<Widget*> Widget::no_children { };
Point Widget::screen_pos() {
return screen_rect().location();
}
Size Widget::size() const {
return _parent_rect.size();
}
Rect Widget::screen_rect() const {
return parent() ? (parent_rect() + parent()->screen_pos()) : parent_rect();
}
Rect Widget::parent_rect() const {
return _parent_rect;
}
void Widget::set_parent_rect(const Rect new_parent_rect) {
_parent_rect = new_parent_rect;
set_dirty();
}
Widget* Widget::parent() const {
return parent_;
}
void Widget::set_parent(Widget* const widget) {
if( widget == parent_ ) {
return;
}
if( parent_ && !widget ) {
// We have a parent, but are losing it. Update visible status.
dirty_overlapping_children_in_rect(screen_rect());
visible(false);
}
parent_ = widget;
set_dirty();
}
void Widget::set_dirty() {
flags.dirty = true;
dirty_set();
}
bool Widget::dirty() const {
return flags.dirty;
}
void Widget::set_clean() {
flags.dirty = false;
}
void Widget::hidden(bool hide) {
if( hide != flags.hidden ) {
flags.hidden = hide;
// If parent is hidden, either of these is a no-op.
if( hide ) {
// TODO: Instead of dirtying parent entirely, dirty only children
// that overlap with this widget.
//parent()->dirty_overlapping_children_in_rect(parent_rect());
/* TODO: Notify self and all non-hidden children that they're
* now effectively hidden?
*/
} else {
set_dirty();
/* TODO: Notify self and all non-hidden children that they're
* now effectively shown?
*/
}
}
}
void Widget::focus() {
context().focus_manager().set_focus_widget(this);
}
void Widget::on_focus() {
//set_dirty();
}
void Widget::blur() {
context().focus_manager().set_focus_widget(nullptr);
}
void Widget::on_blur() {
//set_dirty();
}
bool Widget::focusable() const {
return flags.focusable;
}
void Widget::set_focusable(const bool value) {
flags.focusable = value;
}
bool Widget::has_focus() {
return (context().focus_manager().focus_widget() == this);
}
bool Widget::on_key(const KeyEvent event) {
(void)event;
return false;
}
bool Widget::on_encoder(const EncoderEvent event) {
(void)event;
return false;
}
bool Widget::on_touch(const TouchEvent event) {
(void)event;
return false;
}
const std::vector<Widget*>& Widget::children() const {
return no_children;
}
Context& Widget::context() const {
return parent()->context();
}
void Widget::set_style(const Style* new_style) {
if( new_style != style_ ) {
style_ = new_style;
set_dirty();
}
}
const Style& Widget::style() const {
return style_ ? *style_ : parent()->style();
}
void Widget::visible(bool v) {
if( v != flags.visible ) {
flags.visible = v;
/* TODO: This on_show/on_hide implementation seems inelegant.
* But I need *some* way to take/configure resources when
* a widget becomes visible, and reverse the process when the
* widget becomes invisible, whether the widget (or parent) is
* hidden, or the widget (or parent) is removed from the tree.
*/
if( v ) {
on_show();
} else {
on_hide();
// Set all children invisible too.
for(const auto child : children()) {
child->visible(false);
}
}
}
}
bool Widget::highlighted() const {
return flags.highlighted;
}
void Widget::set_highlighted(const bool value) {
flags.highlighted = value;
}
void Widget::dirty_overlapping_children_in_rect(const Rect& child_rect) {
for(auto child : children()) {
if( !child_rect.intersect(child->parent_rect()).is_empty() ) {
child->set_dirty();
}
}
}
/* View ******************************************************************/
void View::paint(Painter& painter) {
painter.fill_rectangle(
screen_rect(),
style().background
);
}
void View::add_child(Widget* const widget) {
if( widget ) {
if( widget->parent() == nullptr ) {
widget->set_parent(this);
children_.push_back(widget);
}
}
}
void View::add_children(const std::initializer_list<Widget*> children) {
children_.insert(std::end(children_), children);
for(auto child : children) {
child->set_parent(this);
}
}
void View::remove_child(Widget* const widget) {
if( widget ) {
children_.erase(std::remove(children_.begin(), children_.end(), widget), children_.end());
widget->set_parent(nullptr);
}
}
void View::remove_children(const std::vector<Widget*>& children) {
for(auto child : children) {
remove_child(child);
}
}
const std::vector<Widget*>& View::children() const {
return children_;
}
std::string View::title() const {
return "";
};
/* OptionTabView *********************************************************/
OptionTabView::OptionTabView(Rect parent_rect) {
set_parent_rect(parent_rect);
add_child(&check_enable);
hidden(true);
check_enable.on_select = [this](Checkbox&, bool value) {
enabled = value;
};
}
void OptionTabView::set_enabled(bool value) {
check_enable.set_value(value);
}
bool OptionTabView::is_enabled() {
return check_enable.value();
}
void OptionTabView::set_type(std::string type) {
check_enable.set_text("Transmit " + type);
}
void OptionTabView::focus() {
check_enable.focus();
}
/* Rectangle *************************************************************/
Rectangle::Rectangle(
Color c
) : Widget { },
color { c }
{
}
Rectangle::Rectangle(
Rect parent_rect,
Color c
) : Widget { parent_rect },
color { c }
{
}
void Rectangle::set_color(const Color c) {
color = c;
set_dirty();
}
void Rectangle::set_outline(const bool outline) {
_outline = outline;
set_dirty();
}
void Rectangle::paint(Painter& painter) {
if (!_outline) {
painter.fill_rectangle(
screen_rect(),
color
);
} else {
painter.draw_rectangle(
screen_rect(),
color
);
}
}
/* Text ******************************************************************/
Text::Text(
Rect parent_rect,
std::string text
) : Widget { parent_rect },
text { text }
{
}
Text::Text(
Rect parent_rect
) : Text { parent_rect, { } }
{
}
void Text::set(const std::string value) {
text = value;
set_dirty();
}
void Text::paint(Painter& painter) {
const auto rect = screen_rect();
const auto s = style();
painter.fill_rectangle(rect, s.background);
painter.draw_string(
rect.location(),
s,
text
);
}
/* Labels ****************************************************************/
Labels::Labels(
std::initializer_list<Label> labels
) : labels_ { labels }
{
}
void Labels::set_labels(std::initializer_list<Label> labels) {
labels_ = labels;
set_dirty();
}
void Labels::paint(Painter& painter) {
for (auto &label : labels_) {
painter.draw_string(
label.pos + screen_pos(),
style().font,
label.color,
style().background,
label.text
);
}
}
/* LiveDateTime **********************************************************/
void LiveDateTime::on_tick_second() {
rtcGetTime(&RTCD1, &datetime);
text = to_string_dec_uint(datetime.month(), 2, '0') + "/" + to_string_dec_uint(datetime.day(), 2, '0') + " " +
to_string_dec_uint(datetime.hour(), 2, '0') + ":" + to_string_dec_uint(datetime.minute(), 2, '0');
set_dirty();
}
LiveDateTime::LiveDateTime(
Rect parent_rect
) : Widget { parent_rect }
{
signal_token_tick_second = rtc_time::signal_tick_second += [this]() {
this->on_tick_second();
};
}
LiveDateTime::~LiveDateTime() {
rtc_time::signal_tick_second -= signal_token_tick_second;
}
void LiveDateTime::paint(Painter& painter) {
const auto rect = screen_rect();
const auto s = style();
on_tick_second();
painter.fill_rectangle(rect, s.background);
painter.draw_string(
rect.location(),
s,
text
);
}
/* BigFrequency **********************************************************/
BigFrequency::BigFrequency(
Rect parent_rect,
rf::Frequency frequency
) : Widget { parent_rect },
_frequency { frequency }
{
}
void BigFrequency::set(const rf::Frequency frequency) {
_frequency = frequency;
set_dirty();
}
void BigFrequency::paint(Painter& painter) {
uint32_t i, digit_def;
std::array<char, 7> digits;
char digit;
Point digit_pos;
ui::Color segment_color;
const auto rect = screen_rect();
// Erase
painter.fill_rectangle({ { 0, rect.location().y() }, { 240, 52 } }, ui::Color::black());
// Prepare digits
if (!_frequency) {
digits.fill(10); // ----.---
digit_pos = { 0, rect.location().y() };
} else {
_frequency /= 1000; // GMMM.KKK(uuu)
for (i = 0; i < 7; i++) {
digits[6 - i] = _frequency % 10;
_frequency /= 10;
}
// Remove leading zeros
for (i = 0; i < 3; i++) {
if (!digits[i])
digits[i] = 16; // "Don't draw" code
else
break;
}
digit_pos = { (Coord)(240 - ((7 * digit_width) + 8) - (i * digit_width)) / 2, rect.location().y() };
}
segment_color = style().foreground;
// Draw
for (i = 0; i < 7; i++) {
digit = digits[i];
if (digit < 16) {
digit_def = segment_font[(uint8_t)digit];
for (size_t s = 0; s < 7; s++) {
if (digit_def & 1)
painter.fill_rectangle({ digit_pos + segments[s].location(), segments[s].size() }, segment_color);
digit_def >>= 1;
}
}
if (i == 3) {
// Dot
painter.fill_rectangle({ digit_pos + Point(34, 48), { 4, 4 } }, segment_color);
digit_pos += { (digit_width + 8), 0 };
} else {
digit_pos += { digit_width, 0 };
}
}
}
/* ProgressBar ***********************************************************/
ProgressBar::ProgressBar(
Rect parent_rect
) : Widget { parent_rect }
{
}
void ProgressBar::set_max(const uint32_t max) {
if (max == _max) return;
_value = 0;
_max = max;
set_dirty();
}
void ProgressBar::set_value(const uint32_t value) {
if (value == _value) return;
if (value > _max)
_value = _max;
else
_value = value;
set_dirty();
}
void ProgressBar::paint(Painter& painter) {
int v_scaled;
const auto sr = screen_rect();
const auto s = style();
v_scaled = (sr.size().width() * _value) / _max;
painter.fill_rectangle({sr.location(), {v_scaled, sr.size().height()}}, style().foreground);
painter.fill_rectangle({{sr.location().x() + v_scaled, sr.location().y()}, {sr.size().width() - v_scaled, sr.size().height()}}, s.background);
painter.draw_rectangle(sr, s.foreground);
}
/* Console ***************************************************************/
Console::Console(
Rect parent_rect
) : Widget { parent_rect }
{
}
void Console::clear() {
display.fill_rectangle(
screen_rect(),
Color::black()
);
pos = { 0, 0 };
}
void Console::write(std::string message) {
bool escape = false;
if (!hidden() && visible()) {
const Style& s = style();
const Font& font = s.font;
const auto rect = screen_rect();
ui::Color pen_color = s.foreground;
for (const auto c : message) {
if (escape) {
if (c <= 15)
pen_color = term_colors[c & 15];
else
pen_color = s.foreground;
escape = false;
} else {
if (c == '\n') {
crlf();
} else if (c == '\x1B') {
escape = true;
} else {
const auto glyph = font.glyph(c);
const auto advance = glyph.advance();
if( (pos.x() + advance.x()) > rect.width() ) {
crlf();
}
const Point pos_glyph {
rect.left() + pos.x(),
display.scroll_area_y(pos.y())
};
display.draw_glyph(pos_glyph, glyph, pen_color, s.background);
pos += { advance.x(), 0 };
}
}
}
buffer = message;
} else {
if (buffer.size() < 256) buffer += message;
}
}
void Console::writeln(std::string message) {
write(message);
crlf();
}
void Console::paint(Painter&) {
write(buffer);
}
void Console::on_show() {
const auto screen_r = screen_rect();
display.scroll_set_area(screen_r.top(), screen_r.bottom());
display.scroll_set_position(0);
clear();
//visible = true;
}
void Console::on_hide() {
/* TODO: Clear region to eliminate brief flash of content at un-shifted
* position?
*/
display.scroll_disable();
//visible = false;
}
void Console::crlf() {
if (hidden() || !visible()) return;
const Style& s = style();
const auto sr = screen_rect();
const auto line_height = s.font.line_height();
pos = { 0, pos.y() + line_height };
const int32_t y_excess = pos.y() + line_height - sr.height();
if( y_excess > 0 ) {
display.scroll(-y_excess);
pos = { pos.x(), pos.y() - y_excess };
const Rect dirty { sr.left(), display.scroll_area_y(pos.y()), sr.width(), line_height };
display.fill_rectangle(dirty, s.background);
}
}
/* Checkbox **************************************************************/
Checkbox::Checkbox(
Point parent_pos,
size_t length,
std::string text,
bool small
) : Widget { },
text_ { text },
small_ { small }
{
if (!small_)
set_parent_rect({ parent_pos, { static_cast<ui::Dim>((8 * length) + 24), 24 } });
else
set_parent_rect({ parent_pos, { static_cast<ui::Dim>((8 * length) + 16), 16 } });
set_focusable(true);
}
void Checkbox::set_text(const std::string value) {
text_ = value;
set_dirty();
}
bool Checkbox::set_value(const bool value) {
value_ = value;
set_dirty();
if( on_select ) {
on_select(*this, value_);
return true;
}
return false;
}
bool Checkbox::value() const {
return value_;
}
void Checkbox::paint(Painter& painter) {
const auto r = screen_rect();
const auto paint_style = (has_focus() || highlighted()) ? style().invert() : style();
const auto x = r.location().x();
const auto y = r.location().y();
const auto label_r = paint_style.font.size_of(text_);
if (!small_) {
painter.draw_rectangle({ { r.location() }, { 24, 24 } }, style().foreground);
painter.fill_rectangle({ x + 1, y + 1, 24 - 2, 24 - 2 }, style().background);
// Highlight
painter.draw_rectangle({ x + 2, y + 2, 24 - 4, 24 - 4 }, paint_style.background);
if (value_ == true) {
// Check
portapack::display.draw_line( {x + 2, y + 14}, {x + 6, y + 18}, ui::Color::green());
portapack::display.draw_line( {x + 6, y + 18}, {x + 20, y + 4}, ui::Color::green());
} else {
// Cross
portapack::display.draw_line( {x + 1, y + 1}, {x + 24 - 2, y + 24 - 2}, ui::Color::red());
portapack::display.draw_line( {x + 24 - 2, y + 1}, {x + 1, y + 24 - 2}, ui::Color::red());
}
painter.draw_string(
{
static_cast<Coord>(x + 24 + 4),
static_cast<Coord>(y + (24 - label_r.height()) / 2)
},
paint_style,
text_
);
} else {
painter.draw_rectangle({ { r.location() }, { 16, 16 } }, style().foreground);
painter.fill_rectangle({ x + 1, y + 1, 16 - 2, 16 - 2 }, style().background);
// Highlight
painter.draw_rectangle({ x + 1, y + 1, 16 - 2, 16 - 2 }, paint_style.background);
if (value_ == true) {
// Check
portapack::display.draw_line( {x + 2, y + 8}, {x + 6, y + 12}, ui::Color::green());
portapack::display.draw_line( {x + 6, y + 12}, {x + 13, y + 5}, ui::Color::green());
} else {
// Cross
portapack::display.draw_line( {x + 1, y + 1}, {x + 16 - 2, y + 16 - 2}, ui::Color::red());
portapack::display.draw_line( {x + 16 - 2, y + 1}, {x + 1, y + 16 - 2}, ui::Color::red());
}
painter.draw_string(
{
static_cast<Coord>(x + 16 + 2),
static_cast<Coord>(y + (16 - label_r.height()) / 2)
},
paint_style,
text_
);
}
}
bool Checkbox::on_key(const KeyEvent key) {
if( key == KeyEvent::Select )
return set_value(not value_);
return false;
}
bool Checkbox::on_touch(const TouchEvent event) {
switch(event.type) {
case TouchEvent::Type::Start:
set_highlighted(true);
set_dirty();
return true;
case TouchEvent::Type::End:
set_highlighted(false);
value_ = not value_;
set_dirty();
if( on_select ) {
on_select(*this, value_);
}
return true;
default:
return false;
}
}
/* Button ****************************************************************/
Button::Button(
Rect parent_rect,
std::string text
) : Widget { parent_rect },
text_ { text }
{
set_focusable(true);
}
void Button::set_text(const std::string value) {
text_ = value;
set_dirty();
}
std::string Button::text() const {
return text_;
}
void Button::paint(Painter& painter) {
Color bg, fg;
const auto r = screen_rect();
if (has_focus() || highlighted()) {
bg = style().foreground;
fg = Color::black();
} else {
bg = Color::grey();
fg = style().foreground;
}
const Style paint_style = { style().font, bg, fg };
painter.draw_rectangle({r.location(), {r.size().width(), 1}}, Color::light_grey());
painter.draw_rectangle({r.location().x(), r.location().y() + r.size().height() - 1, r.size().width(), 1}, Color::dark_grey());
painter.draw_rectangle({r.location().x() + r.size().width() - 1, r.location().y(), 1, r.size().height()}, Color::dark_grey());
painter.fill_rectangle(
{ r.location().x(), r.location().y() + 1, r.size().width() - 1, r.size().height() - 2 },
paint_style.background
);
const auto label_r = paint_style.font.size_of(text_);
painter.draw_string(
{ r.location().x() + (r.size().width() - label_r.width()) / 2, r.location().y() + (r.size().height() - label_r.height()) / 2 },
paint_style,
text_
);
}
void Button::on_focus() {
if( on_highlight )
on_highlight(*this);
}
bool Button::on_key(const KeyEvent key) {
if( key == KeyEvent::Select ) {
if( on_select ) {
on_select(*this);
return true;
}
} else {
if( on_dir ) {
return on_dir(*this, key);
}
}
return false;
}
bool Button::on_touch(const TouchEvent event) {
switch(event.type) {
case TouchEvent::Type::Start:
set_highlighted(true);
set_dirty();
return true;
case TouchEvent::Type::End:
set_highlighted(false);
set_dirty();
if( on_select ) {
on_select(*this);
}
return true;
default:
return false;
}
#if 0
switch(event.type) {
case TouchEvent::Type::Start:
flags.highlighted = true;
set_dirty();
return true;
case TouchEvent::Type::Move:
{
const bool new_highlighted = screen_rect().contains(event.point);
if( flags.highlighted != new_highlighted ) {
flags.highlighted = new_highlighted;
set_dirty();
}
}
return true;
case TouchEvent::Type::End:
if( flags.highlighted ) {
flags.highlighted = false;
set_dirty();
if( on_select ) {
on_select(*this);
}
}
return true;
default:
return false;
}
#endif
}
/* Image *****************************************************************/
Image::Image(
) : Image { { }, nullptr, Color::white(), Color::black() }
{
}
Image::Image(
const Rect parent_rect,
const Bitmap* bitmap,
const Color foreground,
const Color background
) : Widget { parent_rect },
bitmap_ { bitmap },
foreground_ { foreground },
background_ { background }
{
}
void Image::set_bitmap(const Bitmap* bitmap) {
bitmap_ = bitmap;
set_dirty();
}
void Image::set_foreground(const Color color) {
foreground_ = color;
set_dirty();
}
void Image::set_background(const Color color) {
background_ = color;
set_dirty();
}
void Image::invert_colors() {
Color temp;
temp = background_;
background_ = foreground_;
foreground_ = temp;
set_dirty();
}
void Image::paint(Painter& painter) {
if( bitmap_ ) {
// Code also handles ImageButton behavior.
const bool selected = (has_focus() || highlighted());
painter.draw_bitmap(
screen_pos(),
*bitmap_,
selected ? background_ : foreground_,
selected ? foreground_ : background_
);
}
}
/* ImageButton ***********************************************************/
// TODO: Virtually all this code is duplicated from Button. Base class?
ImageButton::ImageButton(
const Rect parent_rect,
const Bitmap* bitmap,
const Color foreground,
const Color background
) : Image { parent_rect, bitmap, foreground, background }
{
set_focusable(true);
}
bool ImageButton::on_key(const KeyEvent key) {
if( key == KeyEvent::Select ) {
if( on_select ) {
on_select(*this);
return true;
}
}
return false;
}
bool ImageButton::on_touch(const TouchEvent event) {
switch(event.type) {
case TouchEvent::Type::Start:
set_highlighted(true);
set_dirty();
return true;
case TouchEvent::Type::End:
set_highlighted(false);
set_dirty();
if( on_select ) {
on_select(*this);
}
return true;
default:
return false;
}
}
/* ImageOptionsField *****************************************************/
ImageOptionsField::ImageOptionsField(
const Rect parent_rect,
const Color foreground,
const Color background,
const options_t options
) : Widget { parent_rect },
options { options },
foreground_ { foreground },
background_ { background }
{
set_focusable(true);
}
size_t ImageOptionsField::selected_index() const {
return selected_index_;
}
size_t ImageOptionsField::selected_index_value() const {
return options[selected_index_].second;
}
void ImageOptionsField::set_selected_index(const size_t new_index) {
if ( new_index < options.size() ) {
if ( new_index != selected_index() ) {
selected_index_ = new_index;
if ( on_change ) {
on_change(selected_index(), options[selected_index()].second);
}
set_dirty();
}
}
}
void ImageOptionsField::set_by_value(value_t v) {
size_t new_index { 0 };
for(const auto& option : options) {
if( option.second == v ) {
set_selected_index(new_index);
break;
}
new_index++;
}
}
void ImageOptionsField::set_options(options_t new_options) {
options = new_options;
set_by_value(0);
set_dirty();
}
void ImageOptionsField::paint(Painter& painter) {
const bool selected = (has_focus() || highlighted());
const auto paint_style = selected ? style().invert() : style();
painter.draw_rectangle(
{ screen_rect().location(), { screen_rect().size().width() + 4, screen_rect().size().height() + 4 } },
paint_style.background
);
painter.draw_bitmap(
{screen_pos().x() + 2, screen_pos().y() + 2},
*options[selected_index_].first,
foreground_,
background_
);
}
void ImageOptionsField::on_focus() {
if( on_show_options ) {
on_show_options();
}
}
bool ImageOptionsField::on_encoder(const EncoderEvent delta) {
set_selected_index(selected_index() + delta);
return true;
}
bool ImageOptionsField::on_touch(const TouchEvent event) {
if( event.type == TouchEvent::Type::Start ) {
focus();
}
return true;
}
/* OptionsField **********************************************************/
OptionsField::OptionsField(
Point parent_pos,
int length,
options_t options
) : Widget { { parent_pos, { 8 * length, 16 } } },
length_ { length },
options { options }
{
set_focusable(true);
}
size_t OptionsField::selected_index() const {
return selected_index_;
}
size_t OptionsField::selected_index_value() const {
return options[selected_index_].second;
}
void OptionsField::set_selected_index(const size_t new_index) {
if( new_index < options.size() ) {
if( new_index != selected_index() ) {
selected_index_ = new_index;
if( on_change ) {
on_change(selected_index(), options[selected_index()].second);
}
set_dirty();
}
}
}
void OptionsField::set_by_value(value_t v) {
size_t new_index { 0 };
for(const auto& option : options) {
if( option.second == v ) {
set_selected_index(new_index);
break;
}
new_index++;
}
}
void OptionsField::set_options(options_t new_options) {
options = new_options;
set_by_value(0);
set_dirty();
}
void OptionsField::paint(Painter& painter) {
const auto paint_style = has_focus() ? style().invert() : style();
painter.fill_rectangle({screen_rect().location(), {(int)length_ * 8, 16}}, ui::Color::black());
if( selected_index() < options.size() ) {
const auto text = options[selected_index()].first;
painter.draw_string(
screen_pos(),
paint_style,
text
);
}
}
void OptionsField::on_focus() {
if( on_show_options ) {
on_show_options();
}
}
bool OptionsField::on_encoder(const EncoderEvent delta) {
set_selected_index(selected_index() + delta);
return true;
}
bool OptionsField::on_touch(const TouchEvent event) {
if( event.type == TouchEvent::Type::Start ) {
focus();
}
return true;
}
/* NumberField ***********************************************************/
NumberField::NumberField(
Point parent_pos,
int length,
range_t range,
int32_t step,
char fill_char,
bool can_loop
) : Widget { { parent_pos, { 8 * length, 16 } } },
range { range },
step { step },
length_ { length },
fill_char { fill_char },
can_loop { can_loop }
{
set_focusable(true);
}
int32_t NumberField::value() const {
return value_;
}
void NumberField::set_value(int32_t new_value, bool trigger_change) {
if (can_loop) {
if (new_value >= 0)
new_value = new_value % (range.second + 1);
else
new_value = range.second + new_value + 1;
}
new_value = clip_value(new_value);
if( new_value != value() ) {
value_ = new_value;
if( on_change && trigger_change ) {
on_change(value_);
}
set_dirty();
}
}
void NumberField::set_range(const int32_t min, const int32_t max) {
range.first = min;
range.second = max;
set_value(value(), false);
}
void NumberField::set_step(const int32_t new_step) {
step = new_step;
}
void NumberField::paint(Painter& painter) {
const auto text = to_string_dec_int(value_, length_, fill_char);
const auto paint_style = has_focus() ? style().invert() : style();
painter.draw_string(
screen_pos(),
paint_style,
text
);
}
bool NumberField::on_key(const KeyEvent key) {
if( key == KeyEvent::Select ) {
if( on_select ) {
on_select(*this);
return true;
}
}
return false;
}
bool NumberField::on_encoder(const EncoderEvent delta) {
set_value(value() + (delta * step));
return true;
}
bool NumberField::on_touch(const TouchEvent event) {
if( event.type == TouchEvent::Type::Start ) {
focus();
}
return true;
}
int32_t NumberField::clip_value(int32_t value) {
if( value > range.second ) {
value = range.second;
}
if( value < range.first ) {
value = range.first;
}
return value;
}
/* SymField **************************************************************/
SymField::SymField(
Point parent_pos,
size_t length,
symfield_type type
) : Widget { { parent_pos, { static_cast<ui::Dim>(8 * length), 16 } } },
length_ { length },
type_ { type }
{
uint32_t c;
// Auto-init
if (type == SYMFIELD_OCT) {
for (c = 0; c < length; c++)
set_symbol_list(c, "01234567");
} else if (type == SYMFIELD_DEC) {
for (c = 0; c < length; c++)
set_symbol_list(c, "0123456789");
} else if (type == SYMFIELD_HEX) {
for (c = 0; c < length; c++)
set_symbol_list(c, "0123456789ABCDEF");
}
set_focusable(true);
}
uint32_t SymField::value_dec_u32() {
uint32_t c, mul = 1;
uint32_t v = 0;
if (type_ == SYMFIELD_DEC) {
for (c = 0; c < length_; c++) {
v += values_[(length_ - 1 - c)] * mul;
mul *= 10;
}
return v;
} else
return 0;
}
uint64_t SymField::value_hex_u64() {
uint32_t c;
uint64_t v = 0;
if (type_ != SYMFIELD_DEF) {
for (c = 0; c < length_; c++)
v += (uint64_t)(values_[c]) << (4 * (length_ - 1 - c));
return v;
} else
return 0;
}
uint32_t SymField::get_sym(const uint32_t index) {
if (index >= length_) return 0;
return values_[index];
}
void SymField::set_sym(const uint32_t index, const uint32_t new_value) {
if (index >= length_) return;
uint32_t clipped_value = clip_value(index, new_value);
if (clipped_value != values_[index]) {
values_[index] = clipped_value;
if( on_change ) {
on_change();
}
set_dirty();
}
}
void SymField::set_length(const uint32_t new_length) {
if ((new_length <= 32) && (new_length != length_)) {
prev_length_ = length_;
length_ = new_length;
// Clip eventual garbage from previous shorter word
for (size_t n = 0; n < length_; n++)
set_sym(n, values_[n]);
erase_prev_ = true;
set_dirty();
}
}
void SymField::set_symbol_list(const uint32_t index, const std::string symbol_list) {
if (index >= length_) return;
symbol_list_[index] = symbol_list;
// Re-clip symbol's value
set_sym(index, values_[index]);
}
void SymField::paint(Painter& painter) {
Point pt_draw = screen_pos();
if (erase_prev_) {
painter.fill_rectangle( { pt_draw, { (int)prev_length_ * 8, 16 } }, Color::black() );
erase_prev_ = false;
}
for (size_t n = 0; n < length_; n++) {
const auto text = symbol_list_[n].substr(values_[n], 1);
const auto paint_style = (has_focus() && (n == selected_)) ? style().invert() : style();
painter.draw_string(
pt_draw,
paint_style,
text
);
pt_draw += { 8, 0 };
}
}
bool SymField::on_key(const KeyEvent key) {
switch (key) {
case KeyEvent::Select:
if( on_select ) {
on_select(*this);
return true;
}
break;
case KeyEvent::Left:
if (selected_ > 0) {
selected_--;
set_dirty();
return true;
}
break;
case KeyEvent::Right:
if (selected_ < (length_ - 1)) {
selected_++;
set_dirty();
return true;
}
break;
default:
break;
}
return false;
}
bool SymField::on_encoder(const EncoderEvent delta) {
int32_t new_value = (int)values_[selected_] + delta;
if (new_value >= 0)
set_sym(selected_, values_[selected_] + delta);
return true;
}
bool SymField::on_touch(const TouchEvent event) {
if (event.type == TouchEvent::Type::Start) {
focus();
}
return true;
}
int32_t SymField::clip_value(const uint32_t index, const uint32_t value) {
size_t symbol_count = symbol_list_[index].length() - 1;
if (value > symbol_count)
return symbol_count;
else
return value;
}
/* Waveform **************************************************************/
Waveform::Waveform(
Rect parent_rect,
int16_t * data,
uint32_t length,
uint32_t offset,
bool digital,
Color color
) : Widget { parent_rect },
data_ { data },
length_ { length },
offset_ { offset },
digital_ { digital },
color_ { color }
{
//set_focusable(false);
}
void Waveform::set_cursor(const uint32_t i, const int16_t position) {
if (i < 2) {
if (position != cursors[i]) {
cursors[i] = position;
set_dirty();
}
show_cursors = true;
}
}
void Waveform::set_offset(const uint32_t new_offset) {
if (new_offset != offset_) {
offset_ = new_offset;
set_dirty();
}
}
void Waveform::set_length(const uint32_t new_length) {
if (new_length != length_) {
length_ = new_length;
set_dirty();
}
}
void Waveform::paint(Painter& painter) {
size_t n;
Coord y, y_offset = screen_rect().location().y();
Coord prev_x = screen_rect().location().x(), prev_y;
float x, x_inc;
Dim h = screen_rect().size().height();
const float y_scale = (float)(h - 1) / 65536.0;
int16_t * data_start = data_ + offset_;
// Clear
painter.fill_rectangle(screen_rect(), Color::black());
if (!length_) return;
x_inc = (float)screen_rect().size().width() / length_;
if (digital_) {
// Digital waveform: each value is an horizontal line
x = 0;
h--;
for (n = 0; n < length_; n++) {
y = *(data_start++) ? h : 0;
if (n) {
if (y != prev_y)
painter.draw_vline( {(Coord)x, y_offset}, h, color_);
}
painter.draw_hline( {(Coord)x, y_offset + y}, ceil(x_inc), color_);
prev_y = y;
x += x_inc;
}
} else {
// Analog waveform: each value is a point's Y coordinate
x = prev_x + x_inc;
h /= 2;
prev_y = y_offset + h - (*(data_start++) * y_scale);
for (n = 1; n < length_; n++) {
y = y_offset + h - (*(data_start++) * y_scale);
display.draw_line( {prev_x, prev_y}, {(Coord)x, y}, color_);
prev_x = x;
prev_y = y;
x += x_inc;
}
}
// Cursors
if (show_cursors) {
for (n = 0; n < 2; n++) {
painter.draw_vline(
Point(std::min(screen_rect().size().width(), (int)cursors[n]), y_offset),
screen_rect().size().height(),
cursor_colors[n]
);
}
}
}
/* VuMeter **************************************************************/
VuMeter::VuMeter(
Rect parent_rect,
uint32_t LEDs,
bool show_max
) : Widget { parent_rect },
LEDs_ { LEDs },
show_max_ { show_max }
{
//set_focusable(false);
LED_height = std::max(1UL, parent_rect.size().height() / LEDs);
split = 256 / LEDs;
}
void VuMeter::set_value(const uint32_t new_value) {
if ((new_value != value_) && (new_value < 256)) {
value_ = new_value;
set_dirty();
}
}
void VuMeter::set_mark(const uint32_t new_mark) {
if ((new_mark != mark) && (new_mark < 256)) {
mark = new_mark;
set_dirty();
}
}
void VuMeter::paint(Painter& painter) {
uint32_t bar;
Color color;
bool lit = false;
uint32_t bar_level;
Point pos = screen_rect().location();
Dim width = screen_rect().size().width() - 4;
Dim height = screen_rect().size().height();
Dim bottom = pos.y() + height;
Coord marks_x = pos.x() + width;
if (value_ != prev_value) {
bar_level = LEDs_ - ((value_ + 1) / split);
// Draw LEDs
for (bar = 0; bar < LEDs_; bar++) {
if (bar >= bar_level)
lit = true;
if (bar == 0)
color = lit ? Color::red() : Color::dark_red();
else if (bar == 1)
color = lit ? Color::orange() : Color::dark_orange();
else if ((bar == 2) || (bar == 3))
color = lit ? Color::yellow() : Color::dark_yellow();
else
color = lit ? Color::green() : Color::dark_green();
painter.fill_rectangle({ pos.x(), pos.y() + (Coord)(bar * (LED_height + 1)), width, (Coord)LED_height }, color);
}
prev_value = value_;
}
// Update max level
if (show_max_) {
if (value_ > max) {
max = value_;
hold_timer = 30; // 0.5s @ 60Hz
} else {
if (hold_timer) {
hold_timer--;
} else {
if (max) max--; // Let it drop
}
}
// Draw max level
if (max != prev_max) {
painter.draw_hline({ marks_x, bottom - (height * prev_max) / 256 }, 8, Color::black());
painter.draw_hline({ marks_x, bottom - (height * max) / 256 }, 8, Color::white());
if (prev_max == mark)
prev_mark = 0; // Force mark refresh
prev_max = max;
}
}
// Draw mark (forced refresh)
if (mark) {
painter.draw_hline({ marks_x, bottom - (height * prev_mark) / 256 }, 8, Color::black());
painter.draw_hline({ marks_x, bottom - (height * mark) / 256 }, 8, Color::grey());
prev_mark = mark;
}
}
} /* namespace ui */