/* * text.cc * * Copyright (C) 2011 Tim Marston and Dan Marston. * * This file is part of propeller-clock (hereafter referred to as "this * program"). See http://ed.am/dev/software/arduino/propeller-clock for more * information. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3 of the License, 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see . */ #include "text.h" #include "text_renderer.h" #include "config.h" #include "Arduino.h" #include // the buffer for the message char Text::_messages[ NUM_MESSAGE_BUFFERS ][ MESSAGE_BUFFER_LEN ]; // message buffer lengths static int _message_lens[ NUM_MESSAGE_BUFFERS ]; // the mode that each message represents static char _message_modes[ NUM_MESSAGE_BUFFERS ]; // mode-specific message parameters static signed long _message_pos[ NUM_MESSAGE_BUFFERS ]; // text scaling factors static char _message_scale[ NUM_MESSAGE_BUFFERS ]; // time last frame static unsigned long _last_millis; // duration last frame (in case we can't calculate it this frame!) static unsigned long _duration; // recalculate message params, based on _duration static bool _do_draw_reset; #define MASK_MODE_SIZE 0x07 #define MASK_MODE_POS 0x40 void reset_message_pos( int message_num ) { if( _message_modes[ message_num ] & Text::MODE_HSCROLL ) { switch( _message_modes[ message_num ] & MASK_MODE_SIZE ) { case Text::MODE_ONEQUARTER: _message_pos[ message_num ] = -NUM_SEGMENTS / 4; break; case Text::MODE_ONETHIRD: _message_pos[ message_num ] = -NUM_SEGMENTS / 3; break; case Text::MODE_HALF: _message_pos[ message_num ] = -NUM_SEGMENTS / 2; break; case Text::MODE_TWOTHIRDS: _message_pos[ message_num ] = -NUM_SEGMENTS * 2 / 3; break; case Text::MODE_THREEQUARTERS: _message_pos[ message_num ] = -NUM_SEGMENTS * 3 / 4; break; case Text::MODE_ALL: _message_pos[ message_num ] = -NUM_SEGMENTS; break; } } else { switch( _message_modes[ message_num ] & MASK_MODE_SIZE ) { case Text::MODE_ONEQUARTER: _message_pos[ message_num ] = NUM_SEGMENTS / 4; break; case Text::MODE_ONETHIRD: _message_pos[ message_num ] = NUM_SEGMENTS / 3; break; case Text::MODE_HALF: _message_pos[ message_num ] = NUM_SEGMENTS / 2; break; case Text::MODE_TWOTHIRDS: _message_pos[ message_num ] = NUM_SEGMENTS * 2 / 3; break; case Text::MODE_THREEQUARTERS: _message_pos[ message_num ] = NUM_SEGMENTS * 3 / 4; break; case Text::MODE_ALL: _message_pos[ message_num ] = NUM_SEGMENTS; break; } _message_pos[ message_num ] = -( _message_pos[ message_num ] - TextRenderer::get_width( _message_lens[ message_num ], _message_scale[ message_num ] ) ) / 2; } } void Text::reset() { // reset renderer _duration = 0; _last_millis = ::millis(); // clear all message modes (disable messages) for( int a = 0; a < NUM_MESSAGE_BUFFERS; a++ ) _message_modes[ a ] = 0; // reset the text renderer's output buffer TextRenderer::reset_buffer(); } void Text::set_up_message( int message_num, char mode, char scale ) { _message_modes[ message_num ] = mode; _message_scale[ message_num ] = scale; // horizontal scrolling messages need their position reset at start of mode if( _message_modes[ message_num ] & MODE_HSCROLL ) reset_message_pos( message_num ); } void Text::set_message_text( int message_num, PString &pstring ) { // update message _message_lens[ message_num ] = pstring.length(); // non-horizontal scrolling modes need their position reset whenever the // text changes if( !( _message_modes[ message_num ] & MODE_HSCROLL ) ) reset_message_pos( message_num ); } void Text::draw_reset() { // how many milliseconds have elapsed since last frame? unsigned long millis = ::millis(); if( millis > _last_millis ) _duration = millis - _last_millis; _last_millis = millis; // we'll need to recalculate params for the frame, but we want to do it when // we're not in the middle of a text display (to avoid tearing). _do_draw_reset = true; } static void draw_message( int message_num, int segment ) { TextRenderer::buffer_in_use(); // calculate the width int width; switch( _message_modes[ message_num ] & MASK_MODE_SIZE ) { case Text::MODE_ONEQUARTER: width = NUM_SEGMENTS / 4; break; case Text::MODE_ONETHIRD: width = NUM_SEGMENTS / 3; break; case Text::MODE_HALF: width = NUM_SEGMENTS / 2; break; case Text::MODE_TWOTHIRDS: width = NUM_SEGMENTS * 2 / 3; break; case Text::MODE_THREEQUARTERS: width = NUM_SEGMENTS * 3 / 4; break; case Text::MODE_ALL: width = NUM_SEGMENTS; break; } // convert segment to display-space switch( _message_modes[ message_num ] & MASK_MODE_POS ) { case Text::MODE_TOP: if( segment < width / 2 ) segment += width / 2; else if( segment >= NUM_SEGMENTS - width / 2 ) segment -= ( NUM_SEGMENTS - width / 2 ); else return; break; case Text::MODE_BOTTOM: if( segment > ( NUM_SEGMENTS - width ) / 2 && segment < ( NUM_SEGMENTS - width ) / 2 + width ) { segment = width - ( segment - ( NUM_SEGMENTS - width ) / 2 ); } else return; break; } // render TextRenderer::render( Text::_messages[ message_num ], _message_lens[ message_num ], (long)segment + _message_pos[ message_num ], ( _message_modes[ message_num ] & MASK_MODE_POS ) == Text::MODE_BOTTOM, 0, _message_scale[ message_num ] ); } void Text::draw( int segment ) { // perform a mid-frame reset, as necessary if( _do_draw_reset && segment == NUM_SEGMENTS / 2 ) { _do_draw_reset = false; // go through the messages looking for an active one for( int a = 0; a < NUM_MESSAGE_BUFFERS; a++ ) if( _message_modes[ a ] & MASK_MODE_SIZE ) { // add to horizontal scroll position if( _message_modes[ a ] & Text::MODE_HSCROLL ) { _message_pos[ a ] += _duration * TEXT_SCROLL_SPEED / 1000; long excess = _message_pos[ a ] - TextRenderer::get_width( _message_lens[ a ], _message_scale[ a ] ); if( excess >= 0 ) { reset_message_pos( a ); _message_pos[ a ] += excess; } } } } // draw any active messages for( int a = 0; a < NUM_MESSAGE_BUFFERS; a++ ) if( _message_modes[ a ] & MASK_MODE_SIZE ) draw_message( a, segment ); }