You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
676 lines
19 KiB
676 lines
19 KiB
/**
|
|
* ScreenUi
|
|
* A toolkit for building character based user interfaces on small displays.
|
|
* Copyright (c) 2012 Jason von Nieda <jason@vonnieda.org>
|
|
*
|
|
* This file is part of ScreenUi.
|
|
*
|
|
* ScreenUi 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.
|
|
*
|
|
* ScreenUi 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 ScreenUi. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <ScreenUi.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#ifdef SCREENUI_DEBUG
|
|
#include <WProgram.h>
|
|
#endif
|
|
|
|
void* operator new(size_t size) { return malloc(size); }
|
|
void operator delete(void* ptr) { free(ptr); }
|
|
|
|
// TODO: Change to PROGMEM
|
|
uint8_t charCheckmark[] = {0, // B00000
|
|
0, // B00000
|
|
1, // B00001
|
|
2, // B00010
|
|
20, // B10100
|
|
8, // B01000
|
|
0, // B00000
|
|
0}; // B00000
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Screen
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
Screen::Screen(uint8_t width, uint8_t height) {
|
|
setSize(width, height);
|
|
cleared_ = false;
|
|
focusHolder_ = NULL;
|
|
focusHolderSelected_ = false;
|
|
createCustomChar(7, charCheckmark);
|
|
annoyingBugWorkedAround_ = false;
|
|
}
|
|
|
|
void Screen::update() {
|
|
if (!cleared_) {
|
|
clear();
|
|
cleared_ = true;
|
|
}
|
|
Container::update(this);
|
|
int x, y;
|
|
bool selected, cancelled;
|
|
getInputDeltas(&x, &y, &selected, &cancelled);
|
|
Component *oldFocusHolder = focusHolder_;
|
|
if (x || y || selected || cancelled) {
|
|
if (focusHolderSelected_) {
|
|
focusHolderSelected_ = focusHolder_->handleInputEvent(x, y, selected, cancelled);
|
|
}
|
|
else {
|
|
if (selected) {
|
|
focusHolderSelected_ = focusHolder_->handleInputEvent(x, y, selected, cancelled);
|
|
}
|
|
else if (x || y) {
|
|
// TODO: Make axis x or y configurable.
|
|
// TODO: consider making the last widget in the screen the end of focus,
|
|
// so that you don't cycle back to the top but instead lock at the end
|
|
// and vice-verse. Maybe make this configurable.
|
|
if (y > 0) {
|
|
focusHolder_ = nextFocusHolder(focusHolder_, false);
|
|
if (!focusHolder_) {
|
|
focusHolder_ = nextFocusHolder(focusHolder_, false);
|
|
}
|
|
}
|
|
else if (y < 0) {
|
|
focusHolder_ = nextFocusHolder(focusHolder_, true);
|
|
if (!focusHolder_) {
|
|
focusHolder_ = nextFocusHolder(focusHolder_, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (focusHolder_ == NULL) {
|
|
focusHolder_ = nextFocusHolder(focusHolder_, false);
|
|
}
|
|
if (oldFocusHolder != focusHolder_) {
|
|
if (oldFocusHolder) {
|
|
oldFocusHolder->repaint();
|
|
}
|
|
focusHolder_->repaint();
|
|
}
|
|
paint(this);
|
|
moveCursor(cursorX_, cursorY_);
|
|
|
|
// TODO: Bug I can't figure out. If we use the dirtyness system, the first paint
|
|
// fails to draw anything to the screen and then subsequent ones don't get called
|
|
// because they aren't dirty. The second paint works fine.
|
|
// Adding repaint() here allows us to paint during the second loop which gets
|
|
// everything into a state where it works great, but I can't figure out why.
|
|
// It doesn't seem to have to do with timing or the clear().
|
|
if (!annoyingBugWorkedAround_) {
|
|
repaint();
|
|
annoyingBugWorkedAround_ = true;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Container
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
Container::Container() {
|
|
components_ = NULL;
|
|
componentsLength_ = 0;
|
|
componentCount_ = 0;
|
|
}
|
|
|
|
Container::~Container() {
|
|
if (components_) {
|
|
free(components_);
|
|
}
|
|
}
|
|
|
|
void Container::update(Screen *screen) {
|
|
if (!firstUpdateCompleted_) {
|
|
offsetChildren(0, y_);
|
|
firstUpdateCompleted_ = true;
|
|
}
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
components_[i]->update(screen);
|
|
}
|
|
}
|
|
|
|
void Container::paint(Screen *screen) {
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
if (components_[i]->dirty()) {
|
|
components_[i]->paint(screen);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Container::repaint() {
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
components_[i]->repaint();
|
|
}
|
|
}
|
|
|
|
void Container::add(Component *component, int8_t x, int8_t y) {
|
|
if (!components_ || componentsLength_ <= componentCount_) {
|
|
componentsLength_ = (componentsLength_ * 2) + 1;
|
|
components_ = (Component**) realloc(components_, componentsLength_ * sizeof(Component*));
|
|
}
|
|
components_[componentCount_++] = component;
|
|
if (firstUpdateCompleted_) {
|
|
// TODO: if the first update has already completed we need to update
|
|
// incoming components locations as they are added
|
|
}
|
|
component->setLocation(x, y);
|
|
component->repaint();
|
|
}
|
|
|
|
void Container::offsetChildren(int x, int y) {
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
Component *c = components_[i];
|
|
/*
|
|
Serial.print("Moving ");
|
|
Serial.print(c->description());
|
|
Serial.print(" from ");
|
|
Serial.print(c->x(), DEC);
|
|
Serial.print(", ");
|
|
Serial.print(c->y(), DEC);
|
|
Serial.print(" to ");
|
|
Serial.print(c->x() + x, DEC);
|
|
Serial.print(", ");
|
|
Serial.println(c->y() + y, DEC);
|
|
*/
|
|
c->setLocation(c->x() + x, c->y() + y);
|
|
}
|
|
}
|
|
|
|
Component *Container::nextFocusHolder(Component *focusHolder, bool reverse) {
|
|
bool focusHolderFound = false;
|
|
return nextFocusHolder(focusHolder, reverse, &focusHolderFound);
|
|
}
|
|
|
|
Component *Container::nextFocusHolder(Component *focusHolder, bool reverse, bool *focusHolderFound) {
|
|
for (int i = (reverse ? componentCount_ - 1 : 0); (reverse ? (i > 0) : (i < componentCount_)); (reverse ? i-- : i++)) {
|
|
Component *c = components_[i];
|
|
if (c->isContainer()) {
|
|
Component *next = ((Container*) c)->nextFocusHolder(focusHolder, reverse, focusHolderFound);
|
|
if (next) {
|
|
return next;
|
|
}
|
|
}
|
|
else {
|
|
if (c->acceptsFocus()) {
|
|
if (!focusHolder || *focusHolderFound) {
|
|
return c;
|
|
}
|
|
else if (c == focusHolder) {
|
|
*focusHolderFound = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool Container::dirty() {
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
if (components_[i]->dirty()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Container::contains(Component *component) {
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
Component *c = components_[i];
|
|
if (c == component) {
|
|
return true;
|
|
}
|
|
else if (c->isContainer()) {
|
|
if (((Container*) c)->contains(component)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Component
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Component::paint(Screen *screen) {
|
|
dirty_ = false;
|
|
}
|
|
|
|
bool Component::dirty() {
|
|
return dirty_;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Label
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
Label::Label(const char *text) {
|
|
setSize(0, 1);
|
|
setText(text);
|
|
captured_ = false;
|
|
dirtyWidth_ = 0;
|
|
}
|
|
|
|
void Label::paint(Screen *screen) {
|
|
Component::paint(screen);
|
|
|
|
// Label does not accept focus, but Button, Checkbox and List are all
|
|
// subclasses that want to share the same text drawing system, so we
|
|
// just account for it here.
|
|
if (acceptsFocus()) {
|
|
if (screen->focusHolder() == this) {
|
|
if (captured_) {
|
|
screen->draw(x_, y_, ">");
|
|
screen->draw(x_ + width_ + 1, y_, "<");
|
|
}
|
|
else {
|
|
screen->draw(x_, y_, "<");
|
|
screen->draw(x_ + width_ + 1, y_, ">");
|
|
}
|
|
}
|
|
else {
|
|
screen->draw(x_, y_, "[");
|
|
screen->draw(x_ + width_ + 1, y_, "]");
|
|
}
|
|
}
|
|
|
|
screen->draw(x_ + (acceptsFocus() ? 1 : 0), y_, text_);
|
|
if (dirtyWidth_) {
|
|
for (int i = 0; i < dirtyWidth_ - width_; i++) {
|
|
screen->draw(x_ + width_ + i + (acceptsFocus() ? 2 : 0), y_, " ");
|
|
}
|
|
dirtyWidth_ = 0;
|
|
}
|
|
}
|
|
|
|
void Label::setText(const char *text) {
|
|
text_ = (char*) text;
|
|
uint8_t newWidth = strlen(text);
|
|
if (newWidth < width_) {
|
|
dirtyWidth_ = width_;
|
|
}
|
|
width_ = newWidth;
|
|
repaint();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Button
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
Button::Button(const char *text) : Label(text) {
|
|
setText(text);
|
|
pressed_ = false;
|
|
}
|
|
|
|
void Button::update(Screen *screen) {
|
|
pressed_ = false;
|
|
}
|
|
|
|
bool Button::handleInputEvent(int x, int y, bool selected, bool cancelled) {
|
|
pressed_ = selected;
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Checkbox
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Checkbox::Checkbox() : Label(" ") {
|
|
checked_ = false;
|
|
}
|
|
|
|
bool Checkbox::handleInputEvent(int x, int y, bool selected, bool cancelled) {
|
|
if (selected) {
|
|
checked_ = !checked_;
|
|
// Not James Bond. The 8th custom character location. By using a non-zero
|
|
// location we can still send it via a string, which means we can still
|
|
// be a Label instead of having a custom paint routine.
|
|
setText(checked_ ? "\007" : " ");
|
|
repaint();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// List
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
List::List(uint8_t maxItems) : Label(NULL) {
|
|
items_ = (char **) malloc(maxItems * (sizeof(char*)));
|
|
itemCount_ = 0;
|
|
selectedIndex_ = 0;
|
|
captured_ = false;
|
|
}
|
|
|
|
List::~List() {
|
|
free(items_);
|
|
}
|
|
|
|
void List::addItem(const char *item) {
|
|
items_[itemCount_++] = (char*) item;
|
|
if (text_ == NULL) {
|
|
setText(selectedItem());
|
|
}
|
|
}
|
|
|
|
void List::setSelectedIndex(uint8_t selectedIndex) {
|
|
selectedIndex_ = selectedIndex;
|
|
setText(selectedItem());
|
|
repaint();
|
|
}
|
|
|
|
bool List::handleInputEvent(int x, int y, bool selected, bool cancelled) {
|
|
if (captured_ && y) {
|
|
if (y < 0) {
|
|
setSelectedIndex(max(selectedIndex_ + y, 0));
|
|
}
|
|
else {
|
|
setSelectedIndex(min(selectedIndex_ + y, itemCount_ - 1));
|
|
}
|
|
}
|
|
if (selected) {
|
|
captured_ = !captured_;
|
|
repaint();
|
|
}
|
|
return captured_;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Spinner
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Spinner::Spinner(int value, int low, int high, int increment, bool rollover) : Label(NULL) {
|
|
value_ = value;
|
|
low_ = low;
|
|
high_ = high;
|
|
increment_ = increment;
|
|
rollover_ = rollover;
|
|
sprintf(buffer_, "%d", value_);
|
|
setText(buffer_);
|
|
}
|
|
|
|
int Spinner::intValue() {
|
|
return value_;
|
|
}
|
|
|
|
bool Spinner::handleInputEvent(int x, int y, bool selected, bool cancelled) {
|
|
if (captured_ && y) {
|
|
value_ += (y * increment_);
|
|
if (value_ < low_) {
|
|
value_ = rollover_ ? high_ : low_;
|
|
}
|
|
else if (value_ > high_) {
|
|
value_ = rollover_ ? low_ : high_;
|
|
}
|
|
sprintf(buffer_, "%d", value_);
|
|
setText(buffer_);
|
|
repaint();
|
|
}
|
|
if (selected) {
|
|
captured_ = !captured_;
|
|
repaint();
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Input
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// TODO: trim incoming text and after each return, right justify the text
|
|
Input::Input(char *text) : Label((const char*) text) {
|
|
position_ = 0;
|
|
selecting_ = false;
|
|
charSet_ = &defaultCharSet;
|
|
}
|
|
|
|
void Input::setText(char *text) {
|
|
Label::setText((const char *) text);
|
|
position_ = 0;
|
|
selecting_ = false;
|
|
repaint();
|
|
}
|
|
|
|
void Input::paint(Screen *screen) {
|
|
Label::paint(screen);
|
|
screen->setCursorVisible(captured_ && selecting_);
|
|
screen->setBlink(captured_ && !selecting_);
|
|
screen->setCursorLocation(x_ + position_ + 1, y_);
|
|
}
|
|
|
|
bool Input::handleInputEvent(int x, int y, bool selected, bool cancelled) {
|
|
// If the input is captured and there has been a scroll event we're going to
|
|
// either change the position or change the selection.
|
|
if (captured_ && y) {
|
|
// If we're changing the selection, scroll through the character set.
|
|
if (selecting_) {
|
|
// TODO: replace this with a selectable character set that makes more
|
|
// sense
|
|
if (y < 0) {
|
|
text_[position_] = charSet_->charAt(max(charSet_->indexOf(text_[position_]) + y, 0));
|
|
}
|
|
else {
|
|
text_[position_] = charSet_->charAt(min(charSet_->indexOf(text_[position_]) + y, charSet_->size() - 1));
|
|
}
|
|
}
|
|
// Otherwise we are changing the position. If the position is moving before
|
|
// or after the field we release the input.
|
|
else {
|
|
position_ += y;
|
|
if (position_ < 0 || position_ >= width_) {
|
|
captured_ = false;
|
|
}
|
|
}
|
|
repaint();
|
|
}
|
|
// If there has been a click we will either capture the input,
|
|
// start selection or end selection.
|
|
if (selected) {
|
|
// If input is captured we will start or end selection
|
|
// input.
|
|
if (captured_) {
|
|
selecting_ = !selecting_;
|
|
}
|
|
// Capture the input
|
|
else {
|
|
captured_ = true;
|
|
position_ = 0;
|
|
selecting_ = false;
|
|
}
|
|
repaint();
|
|
}
|
|
return captured_;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// IntegerInput
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
IntegerInput::IntegerInput(long value, unsigned char width, unsigned char base) : Input(NULL) {
|
|
signed_ = true;
|
|
base_ = base;
|
|
if (!width) {
|
|
// count the digits
|
|
}
|
|
}
|
|
|
|
IntegerInput::IntegerInput(unsigned long value, unsigned char width, unsigned char base) : Input(NULL) {
|
|
signed_ = false;
|
|
base_ = base;
|
|
if (!width) {
|
|
// count the digits
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ScrollContainer
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
ScrollContainer::ScrollContainer(Screen *screen, uint8_t width, uint8_t height) {
|
|
setSize(width, height);
|
|
screen_ = screen;
|
|
clearLine = (char*) malloc(width + 1);
|
|
memset(clearLine, ' ', width);
|
|
clearLine[width] = NULL;
|
|
firstUpdateCompleted_ = false;
|
|
}
|
|
|
|
ScrollContainer::~ScrollContainer() {
|
|
free(clearLine);
|
|
}
|
|
|
|
bool ScrollContainer::dirty() {
|
|
if (Container::dirty()) {
|
|
return true;
|
|
}
|
|
return scrollNeeded();
|
|
}
|
|
|
|
bool ScrollContainer::scrollNeeded() {
|
|
// see if the focus holder has changed since the last check
|
|
Component *focusHolder = screen_->focusHolder();
|
|
if (lastFocusHolder_ != focusHolder) {
|
|
// it has, so see if the new focus holder is one of ours
|
|
if (contains(focusHolder)) {
|
|
// it is, so we need to be sure it's visible, which means it's
|
|
// y position plus height has to be within our window of visibility
|
|
// our window of visbility is our y_ + row_ to y_ + row_ + height_
|
|
uint8_t yStart = y_;
|
|
uint8_t yEnd = y_ + height_ - 1;
|
|
if (focusHolder->y() < yStart || focusHolder->y() > yEnd) {
|
|
// it is not currently visible, so we are dirty
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ScrollContainer::paint(Screen *screen) {
|
|
Component::paint(screen);
|
|
if (scrollNeeded()) {
|
|
// we need to scroll the window
|
|
Component *focusHolder = screen_->focusHolder();
|
|
// clear the window
|
|
for (int i = 0; i < height_; i++) {
|
|
screen->draw(x_, y_ + i, clearLine);
|
|
}
|
|
// set the new row_. if the new focus holder is below our currently
|
|
// visible area we want to increment the row the minimum amount to make it
|
|
// visible, and likewise if it is above, we want to decrement.
|
|
// TODO: These are calculated in scrollNeeded(), see if it would be better
|
|
// to reuse them somehow
|
|
uint8_t yStart = y_;
|
|
uint8_t yEnd = y_ + height_ - 1;
|
|
if (focusHolder->y() > yEnd) {
|
|
// if the component is below our visible window, increment the row count
|
|
// by the difference between the bottom visible row and the y position
|
|
// of the component
|
|
offsetChildren(0, yEnd - focusHolder->y());
|
|
}
|
|
else {
|
|
offsetChildren(0, yStart - focusHolder->y());
|
|
}
|
|
|
|
lastFocusHolder_ = screen->focusHolder();
|
|
|
|
// tell all the children they need to be repainted. we will only paint
|
|
// the ones that are now visible
|
|
repaint();
|
|
}
|
|
for (int i = 0; i < componentCount_; i++) {
|
|
Component *component = components_[i];
|
|
if (component->dirty() && (component->y() >= y_) && (component->y() < y_ + height_)) {
|
|
component->paint(screen);
|
|
}
|
|
else {
|
|
component->clearDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// CharSet
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int CharSet::indexOf(unsigned char ch) {
|
|
for (int i = 0; i < size(); i++) {
|
|
if (charAt(i) == ch) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// RangeCharSet
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
RangeCharSet::RangeCharSet(int rangeCount, ...) {
|
|
rangeCount_ = (unsigned char) rangeCount;
|
|
ranges_ = (unsigned char *) malloc(sizeof(unsigned char) * rangeCount * 2);
|
|
va_list argp;
|
|
va_start(argp, rangeCount);
|
|
for (int i = 0; i < rangeCount; i++) {
|
|
ranges_[i * 2] = (unsigned char) va_arg(argp, int);
|
|
ranges_[i * 2 + 1] = (unsigned char) va_arg(argp, int);
|
|
}
|
|
va_end(argp);
|
|
}
|
|
|
|
RangeCharSet::~RangeCharSet() {
|
|
free(ranges_);
|
|
}
|
|
|
|
int RangeCharSet::charAt(int index) {
|
|
// determine which range the index falls within by iterating the ranges
|
|
// and then use that plus the index to determine the character
|
|
int currentIndex = 0;
|
|
for (int i = 0; i < rangeCount_; i++) {
|
|
if (index >= currentIndex && index <= currentIndex + (ranges_[i * 2 + 1] - ranges_[i * 2])) {
|
|
unsigned char ch = (unsigned char) (ranges_[i * 2] + (index - currentIndex));
|
|
return (int) ch;
|
|
}
|
|
else {
|
|
currentIndex += (ranges_[i * 2 + 1] - ranges_[i * 2]) + 1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
unsigned char RangeCharSet::size() {
|
|
unsigned char size = 0;
|
|
for (int i = 0; i < rangeCount_; i++) {
|
|
size += (ranges_[i * 2 + 1] - ranges_[i * 2]) + 1;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
RangeCharSet defaultCharSet(8,
|
|
32, 32, // space
|
|
65, 90, // capital letters
|
|
97, 122, // lowercase letters
|
|
48, 57, // digits
|
|
33, 47, // special chars
|
|
58, 64, // special chars
|
|
91, 96, // special chars
|
|
123, 126 // special chars
|
|
);
|
|
|
|
RangeCharSet floatingPointCharSet(4,
|
|
32, 32, // space
|
|
48, 57, // digits
|
|
46, 46, // period
|
|
45, 45 // negative
|
|
);
|
|
|
|
|