2006-07-04 15:32:55 +00:00
|
|
|
// HUD_label.cxx -- HUD Label
|
|
|
|
//
|
|
|
|
// Written by Michele America, started September 1997.
|
|
|
|
//
|
|
|
|
// Copyright (C) 1997 Michele F. America [micheleamerica#geocities:com]
|
|
|
|
// Copyright (C) 2006 Melchior FRANZ [mfranz#aon:at]
|
|
|
|
//
|
|
|
|
// 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 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
|
|
|
|
// General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with this program; if not, write to the Free Software
|
|
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
|
2006-07-05 06:22:05 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2006-07-04 15:32:55 +00:00
|
|
|
#include <simgear/props/condition.hxx>
|
|
|
|
#include "HUD.hxx"
|
|
|
|
|
|
|
|
|
|
|
|
HUD::Label::Label(HUD *hud, const SGPropertyNode *n, float x, float y) :
|
|
|
|
Item(hud, n, x, y),
|
|
|
|
_input(n->getNode("input", false)),
|
|
|
|
_box(n->getBoolValue("box", false)),
|
2006-07-25 07:07:34 +00:00
|
|
|
_pointer_width(n->getFloatValue("pointer-width", 7.0)),
|
|
|
|
_pointer_length(n->getFloatValue("pointer-length", 5.0)),
|
2006-07-04 15:32:55 +00:00
|
|
|
_blink_condition(0),
|
|
|
|
_blink_interval(n->getFloatValue("blinking/interval", -1.0f)),
|
|
|
|
_blink_target(0.0),
|
|
|
|
_blink_state(true)
|
|
|
|
{
|
|
|
|
const SGPropertyNode *node = n->getNode("blinking/condition");
|
|
|
|
if (node)
|
|
|
|
_blink_condition = sgReadCondition(globals->get_props(), node);
|
|
|
|
|
|
|
|
const char *halign = n->getStringValue("halign", "center");
|
|
|
|
if (!strcmp(halign, "left"))
|
2006-08-01 15:31:15 +00:00
|
|
|
_halign = LEFT;
|
2006-07-04 15:32:55 +00:00
|
|
|
else if (!strcmp(halign, "right"))
|
2006-08-01 15:31:15 +00:00
|
|
|
_halign = RIGHT;
|
2006-07-04 15:32:55 +00:00
|
|
|
else
|
2006-08-01 15:31:15 +00:00
|
|
|
_halign = HCENTER;
|
2006-07-31 13:10:26 +00:00
|
|
|
|
2006-08-01 15:31:15 +00:00
|
|
|
_halign |= VCENTER;
|
2006-07-04 15:32:55 +00:00
|
|
|
|
|
|
|
const char *pre = n->getStringValue("prefix", 0);
|
|
|
|
const char *post = n->getStringValue("postfix", 0);
|
|
|
|
const char *fmt = n->getStringValue("format", 0);
|
|
|
|
|
|
|
|
if (pre)
|
|
|
|
_format = pre;
|
2006-07-24 16:00:18 +00:00
|
|
|
|
2006-07-04 15:32:55 +00:00
|
|
|
if (fmt)
|
|
|
|
_format += fmt;
|
|
|
|
else
|
|
|
|
_format += "%s";
|
2006-07-24 16:00:18 +00:00
|
|
|
|
2006-07-04 15:32:55 +00:00
|
|
|
if (post)
|
|
|
|
_format += post;
|
|
|
|
|
|
|
|
_mode = check_format(_format.c_str());
|
|
|
|
if (_mode == INVALID) {
|
|
|
|
SG_LOG(SG_INPUT, SG_ALERT, "HUD: invalid format '" << _format.c_str() << '\'');
|
|
|
|
_format = "INVALID";
|
|
|
|
_mode = NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
blink();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HUD::Label::draw(void)
|
|
|
|
{
|
|
|
|
if (!(_mode == NONE || _input.isValid() && blink()))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (_box) {
|
2006-07-24 17:09:03 +00:00
|
|
|
float l, r, p;
|
2006-07-25 07:07:34 +00:00
|
|
|
float pw = _pointer_width / 2.0;
|
2006-07-24 17:09:03 +00:00
|
|
|
|
2006-07-25 07:07:34 +00:00
|
|
|
l = _center_x - pw;
|
|
|
|
r = _center_x + pw;
|
|
|
|
bool draw_parallel = fabsf(_pointer_width - _w) > 2.0; // draw lines left and right of arrow?
|
2006-07-24 17:09:03 +00:00
|
|
|
|
|
|
|
if (option_bottom()) {
|
2006-07-25 07:07:34 +00:00
|
|
|
if (draw_parallel) {
|
|
|
|
draw_line(_x, _y, l, _y);
|
|
|
|
draw_line(r, _y, _x + _w, _y);
|
|
|
|
}
|
|
|
|
p = _y - _pointer_length;
|
2006-07-24 17:09:03 +00:00
|
|
|
draw_line(l, _y, _center_x, p);
|
|
|
|
draw_line(_center_x, p, r, _y);
|
|
|
|
} else
|
|
|
|
draw_line(_x, _y, _x + _w, _y);
|
|
|
|
|
|
|
|
if (option_top()) {
|
2006-07-25 07:07:34 +00:00
|
|
|
if (draw_parallel) {
|
|
|
|
draw_line(_x, _y + _h, l, _y + _h);
|
|
|
|
draw_line(r, _y + _h, _x + _w, _y + _h);
|
|
|
|
}
|
|
|
|
p = _y + _h + _pointer_length;
|
2006-07-24 17:09:03 +00:00
|
|
|
draw_line(l, _y + _h, _center_x, p);
|
|
|
|
draw_line(_center_x, p, r, _y + _h);
|
|
|
|
} else
|
|
|
|
draw_line(_x + _w, _y + _h, _x, _y + _h);
|
|
|
|
|
2006-07-25 07:07:34 +00:00
|
|
|
l = _center_y - pw;
|
|
|
|
r = _center_y + pw;
|
|
|
|
draw_parallel = fabsf(_pointer_width - _h) > 2.0;
|
2006-07-24 17:09:03 +00:00
|
|
|
|
|
|
|
if (option_left()) {
|
2006-07-25 07:07:34 +00:00
|
|
|
if (draw_parallel) {
|
|
|
|
draw_line(_x, _y, _x, l);
|
|
|
|
draw_line(_x, r, _x, _y + _h);
|
|
|
|
}
|
|
|
|
p = _x - _pointer_length;
|
2006-07-24 17:09:03 +00:00
|
|
|
draw_line(_x, l, p, _center_y);
|
|
|
|
draw_line(p, _center_y, _x, r);
|
|
|
|
} else
|
|
|
|
draw_line(_x, _y + _h, _x, _y);
|
|
|
|
|
|
|
|
if (option_right()) {
|
2006-07-25 07:07:34 +00:00
|
|
|
if (draw_parallel) {
|
|
|
|
draw_line(_x + _w, _y, _x + _w, l);
|
|
|
|
draw_line(_x + _w, r, _x + _w, _y + _h);
|
|
|
|
}
|
|
|
|
p = _x + _w + _pointer_length;
|
2006-07-24 17:09:03 +00:00
|
|
|
draw_line(_x + _w, l, p, _center_y);
|
|
|
|
draw_line(p, _center_y, _x + _w, r);
|
|
|
|
} else
|
|
|
|
draw_line(_x + _w, _y, _x + _w, _y + _h);
|
2006-07-04 15:32:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const int BUFSIZE = 256;
|
|
|
|
char buf[BUFSIZE];
|
|
|
|
if (_mode == NONE)
|
|
|
|
snprintf(buf, BUFSIZE, _format.c_str());
|
|
|
|
else if (_mode == STRING)
|
|
|
|
snprintf(buf, BUFSIZE, _format.c_str(), _input.getStringValue());
|
|
|
|
else if (_mode == INT)
|
|
|
|
snprintf(buf, BUFSIZE, _format.c_str(), int(_input.getFloatValue()));
|
|
|
|
else if (_mode == LONG)
|
|
|
|
snprintf(buf, BUFSIZE, _format.c_str(), long(_input.getFloatValue()));
|
|
|
|
else if (_mode == FLOAT)
|
|
|
|
snprintf(buf, BUFSIZE, _format.c_str(), float(_input.getFloatValue()));
|
|
|
|
else if (_mode == DOUBLE) // not really supported yet
|
|
|
|
snprintf(buf, BUFSIZE, _format.c_str(), double(_input.getFloatValue()));
|
|
|
|
|
2006-08-01 15:31:15 +00:00
|
|
|
if (_halign & HCENTER)
|
2006-07-31 13:10:26 +00:00
|
|
|
draw_text(_center_x, _center_y, buf, _halign, get_digits());
|
2006-08-01 15:31:15 +00:00
|
|
|
else if (_halign & LEFT)
|
2006-07-31 13:10:26 +00:00
|
|
|
draw_text(_x, _center_y, buf, _halign, get_digits());
|
2006-08-01 15:31:15 +00:00
|
|
|
else // if (_halign & RIGHT)
|
2006-07-31 13:10:26 +00:00
|
|
|
draw_text(_x + _w, _center_y, buf, _halign, get_digits());
|
2006-07-04 15:32:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// make sure the format matches '[ -+#]?\d*(\.\d*)?(l?[df]|s)'
|
|
|
|
//
|
|
|
|
HUD::Label::Format HUD::Label::check_format(const char *f) const
|
|
|
|
{
|
|
|
|
bool l = false;
|
|
|
|
Format fmt = STRING;
|
|
|
|
|
|
|
|
for (; *f; f++) {
|
|
|
|
if (*f == '%') {
|
|
|
|
if (f[1] == '%')
|
|
|
|
f++;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*f++ != '%')
|
|
|
|
return NONE;
|
|
|
|
if (*f == ' ' || *f == '+' || *f == '-' || *f == '#')
|
|
|
|
f++;
|
|
|
|
while (*f && isdigit(*f))
|
|
|
|
f++;
|
|
|
|
if (*f == '.') {
|
|
|
|
f++;
|
|
|
|
while (*f && isdigit(*f))
|
|
|
|
f++;
|
|
|
|
}
|
|
|
|
if (*f == 'l')
|
|
|
|
l = true, f++;
|
|
|
|
|
|
|
|
if (*f == 'd')
|
|
|
|
fmt = l ? LONG : INT;
|
2006-07-12 20:54:27 +00:00
|
|
|
else if (*f == 'f')
|
2006-07-04 15:32:55 +00:00
|
|
|
fmt = l ? DOUBLE : FLOAT;
|
|
|
|
else if (*f == 's') {
|
|
|
|
if (l)
|
|
|
|
return INVALID;
|
|
|
|
fmt = STRING;
|
|
|
|
} else
|
|
|
|
return INVALID;
|
|
|
|
|
|
|
|
for (++f; *f; f++) {
|
|
|
|
if (*f == '%') {
|
|
|
|
if (f[1] == '%')
|
|
|
|
f++;
|
|
|
|
else
|
|
|
|
return INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return fmt;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool HUD::Label::blink()
|
|
|
|
{
|
|
|
|
if (_blink_interval < 0.0f)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (_blink_condition && !_blink_condition->test())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (_hud->timer() < _blink_target)
|
|
|
|
return _blink_state;
|
|
|
|
|
|
|
|
_blink_target = _hud->timer() + _blink_interval;
|
|
|
|
return _blink_state = !_blink_state;
|
|
|
|
}
|
|
|
|
|
|
|
|
|