TCHAR *
FormatGeoPoint(const GeoPoint &location, TCHAR *buffer, size_t size,
TCHAR separator)
{
return FormatGeoPoint(location, buffer, size, user_coordinate_format,
separator);
}
static int
l_GeoPoint_tostring(lua_State *L)
{
auto gp = Lua::ToGeoPoint(L, 1);
Lua::Push(L, WideToUTF8Converter(FormatGeoPoint(gp, CoordinateFormat::DDMMSS)));
return 1;
}
bool
CAI302::DownloadNavpoint(Port &port, const GeoPoint &location,
int altitude, unsigned id,
bool turnpoint, bool airfield, bool markpoint,
bool landing_point, bool start_point,
bool finish_point, bool home_point,
bool thermal_point, bool waypoint, bool airspace,
const char *name, const char *remark,
OperationEnvironment &env)
{
assert(name != nullptr);
char location_string[32];
FormatGeoPoint(location_string, location);
unsigned attr = turnpoint | (airfield << 1) | (markpoint << 2) |
(landing_point << 3) | (start_point << 4) | (finish_point << 5) |
(home_point << 6) | (thermal_point << 7) | (waypoint << 8) |
(airfield << 9);
if (remark == nullptr)
remark = "";
char buffer[256];
snprintf(buffer, sizeof(buffer), "C,0,%s,%d,%u,%u,%-12s,%-12s\r",
location_string, altitude, id, attr, name, remark);
return DownloadCommand(port, buffer, env);
}
void
MapItemListRenderer::Draw(Canvas &canvas, const PixelRect rc,
const SelfMapItem &item,
const DialogLook &dialog_look,
const AircraftLook &look,
const MapSettings &settings)
{
const PixelScalar line_height = rc.bottom - rc.top;
RasterPoint pt = { (PixelScalar)(rc.left + line_height / 2),
(PixelScalar)(rc.top + line_height / 2) };
AircraftRenderer::Draw(canvas, settings, look, item.bearing, pt);
const Font &name_font = *dialog_look.list.font;
const Font &small_font = *dialog_look.small_font;
canvas.SetTextColor(COLOR_BLACK);
PixelScalar left = rc.left + line_height + Layout::FastScale(2);
canvas.Select(name_font);
canvas.text_clipped(left, rc.top + Layout::FastScale(2), rc,
_("Your Position"));
TCHAR buffer[128];
FormatGeoPoint(item.location, buffer, 128);
canvas.Select(small_font);
canvas.text_clipped(left,
rc.top + name_font.GetHeight() + Layout::FastScale(4),
rc, buffer);
}
void
FlightStatusPanel::Refresh()
{
const NMEAInfo &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
if (basic.location_available)
SetText(Location, FormatGeoPoint(basic.location));
else
ClearText(Location);
if (basic.gps_altitude_available)
SetText(Altitude, FormatUserAltitude(basic.gps_altitude));
else
ClearText(Altitude);
SetText(MaxHeightGain, FormatUserAltitude(calculated.max_height_gain));
if (nearest_waypoint) {
GeoVector vec(basic.location,
nearest_waypoint->location);
SetText(Near, nearest_waypoint->name.c_str());
SetText(Bearing, FormatBearing(vec.bearing).c_str());
SetText(Distance, FormatUserDistanceSmart(vec.distance));
} else {
SetText(Near, _T("-"));
SetText(Bearing, _T("-"));
SetText(Distance, _T("-"));
}
}
static void
DisplayParsedMETAR(const NOAAStore::Item &station)
{
if (!station.parsed_metar_available) {
printf("METAR parsing failed!\n");;
return;
}
const ParsedMETAR &parsed = station.parsed_metar;
printf("Parsed Data:\n");
if (parsed.name_available)
_tprintf(_T("Name: %s\n"), parsed.name.c_str());
if (parsed.location_available) {
TCHAR buffer[256];
FormatGeoPoint(parsed.location, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS);
_tprintf(_T("Location: %s\n"), buffer);
}
if (parsed.qnh_available) {
TCHAR buffer[256];
FormatUserPressure(parsed.qnh, buffer, ARRAY_SIZE(buffer));
_tprintf(_T("QNH: %s\n"), buffer);
}
if (parsed.wind_available) {
TCHAR buffer[256];
FormatUserWindSpeed(parsed.wind.norm, buffer, ARRAY_SIZE(buffer));
_tprintf(_T("Wind: %.0f" DEG " %s\n"),
(double)parsed.wind.bearing.Degrees(), buffer);
}
if (parsed.temperatures_available) {
TCHAR buffer[256];
FormatUserTemperature(parsed.temperature, buffer, ARRAY_SIZE(buffer));
_tprintf(_T("Temperature: %s\n"), buffer);
FormatUserTemperature(parsed.dew_point, buffer, ARRAY_SIZE(buffer));
_tprintf(_T("Dew point: %s\n"), buffer);
}
if (parsed.visibility_available) {
TCHAR buffer[256];
if (parsed.visibility >= 9999)
_tcscpy(buffer, _T("unlimited"));
else {
fixed visibility(parsed.visibility);
FormatUserDistanceSmart(visibility, buffer, ARRAY_SIZE(buffer));
}
_tprintf(_T("Visibility: %s\n"), buffer);
}
printf("\n");
}
void
GlueMapWindow::DrawPanInfo(Canvas &canvas) const
{
GeoPoint location = render_projection.GetGeoLocation();
TextInBoxMode mode;
mode.mode = RenderMode::RM_OUTLINED_INVERTED;
mode.bold = true;
mode.align = A_RIGHT;
UPixelScalar padding = Layout::FastScale(4);
UPixelScalar height = Fonts::map_bold.GetHeight();
PixelScalar y = 0 + padding;
PixelScalar x = render_projection.GetScreenWidth() - padding;
if (terrain) {
short elevation = terrain->GetTerrainHeight(location);
if (!RasterBuffer::IsSpecial(elevation)) {
StaticString<64> elevation_short, elevation_long;
FormatUserAltitude(fixed(elevation),
elevation_short.buffer(), elevation_short.MAX_SIZE);
elevation_long = _("Elevation: ");
elevation_long += elevation_short;
TextInBox(canvas, elevation_long, x, y, mode,
render_projection.GetScreenWidth(),
render_projection.GetScreenHeight());
y += height;
}
}
TCHAR buffer[256];
FormatGeoPoint(location, buffer, ARRAY_SIZE(buffer), _T('\n'));
TCHAR *start = buffer;
while (true) {
TCHAR *newline = _tcschr(start, _T('\n'));
if (newline != NULL)
*newline = _T('\0');
TextInBox(canvas, start, x, y, mode,
render_projection.GetScreenWidth(),
render_projection.GetScreenHeight());
y += height;
if (newline == NULL)
break;
start = newline + 1;
}
}
gcc_pure
static inline StringBuffer<TCHAR, 32>
FormatGeoPoint(const GeoPoint &location, CoordinateFormat format,
TCHAR separator = _T(' '))
{
StringBuffer<TCHAR, 32> buffer;
auto result = FormatGeoPoint(location, buffer.data(), buffer.capacity(),
format, separator);
if (result == nullptr)
buffer.clear();
return buffer;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
WaveSettings settings;
settings.SetDefaults();
settings.enabled = true;
WaveComputer wave;
wave.Reset();
WaveResult result;
result.Clear();
while (replay->Next()) {
const MoreData &basic = replay->Basic();
const DerivedInfo &calculated = replay->Calculated();
wave.Compute(basic, calculated.flight, result, settings);
}
delete replay;
for (const auto &w : result.waves) {
TCHAR time_buffer[32];
if (w.time >= 0)
FormatTime(time_buffer, w.time);
else
_tcscpy(time_buffer, _T("?"));
_tprintf(_T("wave: t=%s location=%f,%f a=%f,%f b=%f,%f location=%s normal=%f\n"),
time_buffer,
(double)w.location.longitude.Degrees(),
(double)w.location.latitude.Degrees(),
(double)w.a.longitude.Degrees(),
(double)w.a.latitude.Degrees(),
(double)w.b.longitude.Degrees(),
(double)w.b.latitude.Degrees(),
FormatGeoPoint(w.location, CoordinateFormat::DDMMSS).c_str(),
(double)w.normal.Degrees());
}
return EXIT_SUCCESS;
}
static void
Main()
{
GeoPoint value = GeoPoint(Angle::Degrees(7.7061111111111114),
Angle::Degrees(51.051944444444445));
if (!GeoPointEntryDialog(_T("The caption"), value, format, true))
return;
if (value.IsValid())
_tprintf(_T("%s\n"),
FormatGeoPoint(value, CoordinateFormat::DDMMSS).c_str());
else
printf("invalid\n");
}
bool
CAI302::DeclareTP(Port &port, unsigned i, const GeoPoint &location,
int altitude, const char *name, OperationEnvironment &env)
{
char location_string[32];
FormatGeoPoint(location_string, location);
char buffer[256];
snprintf(buffer, sizeof(buffer),
"D,%d,%s,%s,%d\r",
128 + i, location_string,
name,
altitude);
return DownloadCommand(port, buffer, env);
}
static void
Main()
{
GeoPoint value = GeoPoint(Angle::Degrees(7.7061111111111114),
Angle::Degrees(51.051944444444445));
if (!GeoPointEntryDialog(_T("The caption"), value, true))
return;
if (value.IsValid()) {
TCHAR buffer[64];
_tprintf(_T("%s\n"), FormatGeoPoint(value, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS));
} else
printf("invalid\n");
}
static void
Draw(Canvas &canvas, PixelRect rc,
const SelfMapItem &item,
const TwoTextRowsRenderer &row_renderer,
const AircraftLook &look,
const MapSettings &settings)
{
const unsigned line_height = rc.GetHeight();
const unsigned text_padding = Layout::GetTextPadding();
const PixelPoint pt(rc.left + line_height / 2, rc.top + line_height / 2);
AircraftRenderer::Draw(canvas, settings, look, item.bearing, pt);
rc.left += line_height + text_padding;
row_renderer.DrawFirstRow(canvas, rc, _("Your Position"));
row_renderer.DrawSecondRow(canvas, rc, FormatGeoPoint(item.location));
}
void
FlightStatusPanel::Refresh()
{
const NMEAInfo &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
StaticString<32> buffer;
if (basic.location_available) {
FormatGeoPoint(basic.location, buffer.buffer(), buffer.MAX_SIZE);
SetText(Location, buffer);
} else
SetText(Location, _T(""));
if (basic.gps_altitude_available) {
FormatUserAltitude(basic.gps_altitude,
buffer.buffer(), buffer.MAX_SIZE);
SetText(Altitude, buffer);
} else
SetText(Altitude, _T(""));
FormatUserAltitude(calculated.max_height_gain,
buffer.buffer(), buffer.MAX_SIZE);
SetText(MaxHeightGain, buffer);
if (nearest_waypoint) {
GeoVector vec(basic.location,
nearest_waypoint->location);
SetText(Near, nearest_waypoint->name.c_str());
FormatBearing(buffer.buffer(), buffer.MAX_SIZE, vec.bearing, _T(""));
SetText(Bearing, buffer);
FormatUserDistanceSmart(vec.distance, buffer.buffer(), buffer.MAX_SIZE);
SetText(Distance, buffer);
} else {
SetText(Near, _T("-"));
SetText(Bearing, _T("-"));
SetText(Distance, _T("-"));
}
}
void
ATCReferencePanel::UpdateValues()
{
const GeoPoint &location =
CommonInterface::GetComputerSettings().poi.atc_reference;
const Waypoint *waypoint = location.IsValid()
? way_points.GetNearest(location, fixed(100))
: nullptr;
SetText(WAYPOINT, waypoint != nullptr ? waypoint->name.c_str() : _T("---"));
const TCHAR *location_string;
TCHAR buffer[64];
if (location.IsValid()) {
FormatGeoPoint(location, buffer, ARRAY_SIZE(buffer),
CommonInterface::GetUISettings().coordinate_format);
location_string = buffer;
} else
location_string = _T("---");
SetText(LOCATION, location_string);
}
void
WaypointInfoWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const MoreData &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
const ComputerSettings &settings = CommonInterface::GetComputerSettings();
StaticString<64> buffer;
if (!waypoint.comment.empty())
AddMultiLine(waypoint.comment.c_str());
if (waypoint.radio_frequency.IsDefined() &&
waypoint.radio_frequency.Format(buffer.buffer(),
buffer.MAX_SIZE) != nullptr) {
buffer += _T(" MHz");
AddReadOnly(_("Radio frequency"), nullptr, buffer);
}
if (waypoint.runway.IsDirectionDefined())
buffer.UnsafeFormat(_T("%02u"), waypoint.runway.GetDirectionName());
else
buffer.clear();
if (waypoint.runway.IsLengthDefined()) {
if (!buffer.empty())
buffer += _T("; ");
TCHAR length_buffer[16];
FormatSmallUserDistance(length_buffer,
fixed(waypoint.runway.GetLength()));
buffer += length_buffer;
}
if (!buffer.empty())
AddReadOnly(_("Runway"), nullptr, buffer);
if (FormatGeoPoint(waypoint.location,
buffer.buffer(), buffer.MAX_SIZE) != nullptr)
AddReadOnly(_("Location"), nullptr, buffer);
FormatUserAltitude(waypoint.elevation,
buffer.buffer(), buffer.MAX_SIZE);
AddReadOnly(_("Elevation"), nullptr, buffer);
if (basic.time_available && basic.date_time_utc.IsDatePlausible()) {
const SunEphemeris::Result sun =
SunEphemeris::CalcSunTimes(waypoint.location, basic.date_time_utc,
settings.utc_offset);
const BrokenTime sunrise = BreakHourOfDay(sun.time_of_sunrise);
const BrokenTime sunset = BreakHourOfDay(sun.time_of_sunset);
buffer.UnsafeFormat(_T("%02u:%02u - %02u:%02u"),
sunrise.hour, sunrise.minute,
sunset.hour, sunset.minute);
AddReadOnly(_("Daylight time"), nullptr, buffer);
}
if (basic.location_available) {
const GeoVector vector = basic.location.DistanceBearing(waypoint.location);
TCHAR distance_buffer[32];
FormatUserDistanceSmart(vector.distance, distance_buffer,
ARRAY_SIZE(distance_buffer));
FormatBearing(buffer.buffer(), buffer.MAX_SIZE,
vector.bearing, distance_buffer);
AddReadOnly(_("Bearing and Distance"), nullptr, buffer);
}
if (basic.location_available && basic.NavAltitudeAvailable() &&
settings.polar.glide_polar_task.IsValid()) {
const GlideState glide_state(basic.location.DistanceBearing(waypoint.location),
waypoint.elevation + settings.task.safety_height_arrival,
basic.nav_altitude,
calculated.GetWindOrZero());
GlidePolar gp0 = settings.polar.glide_polar_task;
gp0.SetMC(fixed(0));
AddGlideResult(_("Alt. diff. MC 0"),
MacCready::Solve(settings.task.glide,
gp0, glide_state));
AddGlideResult(_("Alt. diff. MC safety"),
MacCready::Solve(settings.task.glide,
calculated.glide_polar_safety,
glide_state));
AddGlideResult(_("Alt. diff. MC current"),
MacCready::Solve(settings.task.glide,
settings.polar.glide_polar_task,
glide_state));
}
if (basic.location_available && basic.NavAltitudeAvailable()) {
const TaskBehaviour &task_behaviour =
CommonInterface::GetComputerSettings().task;
const fixed safety_height = task_behaviour.safety_height_arrival;
const fixed target_altitude = waypoint.elevation + safety_height;
const fixed delta_h = basic.nav_altitude - target_altitude;
if (positive(delta_h)) {
const fixed distance = basic.location.Distance(waypoint.location);
const fixed gr = distance / delta_h;
if (GradientValid(gr)) {
buffer.UnsafeFormat(_T("%.1f"), (double)gr);
AddReadOnly(_("Required glide ratio"), nullptr, buffer);
}
}
}
}
int
main(int argc, char **argv)
{
plan_tests(14);
TCHAR buffer[256];
GeoPoint location1(Angle::Degrees(8.466322),
Angle::Degrees(49.487153));
GeoPoint location2(Angle::Degrees(-70.011667),
Angle::Degrees(-32.653333));
// Test DD.ddddd
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DD_DDDDD);
ok1(StringIsEqual(buffer, _T("49.48715° N 008.46632° E")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DD_DDDDD);
ok1(StringIsEqual(buffer, _T("32.65333° S 070.01167° W")));
// Test DDMM.mmm
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMM_MMM);
ok1(StringIsEqual(buffer, _T("49°29.229' N 008°27.979' E")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMM_MMM);
ok1(StringIsEqual(buffer, _T("32°39.200' S 070°00.700' W")));
// Test DDMMSS
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS);
ok1(StringIsEqual(buffer, _T("49°29'14\" N 008°27'59\" E")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS);
ok1(StringIsEqual(buffer, _T("32°39'12\" S 070°00'42\" W")));
// Test DDMMSS.s
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS_S);
ok1(StringIsEqual(buffer, _T("49°29'13.8\" N 008°27'58.8\" E")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS_S);
ok1(StringIsEqual(buffer, _T("32°39'12.0\" S 070°00'42.0\" W")));
// Test UTM
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::UTM);
ok1(StringIsEqualWildcard(buffer, _T("32U 4613** 5481***")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::UTM);
ok1(StringIsEqualWildcard(buffer, _T("19H 4051** 6386***")));
// Test seperator
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS, _T('\n'));
ok1(StringIsEqual(buffer, _T("49°29'14\" N\n008°27'59\" E")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::DDMMSS, _T('\n'));
ok1(StringIsEqual(buffer, _T("32°39'12\" S\n070°00'42\" W")));
FormatGeoPoint(location1, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::UTM, _T('\n'));
ok1(StringIsEqualWildcard(buffer, _T("32U\n4613**\n5481***")));
FormatGeoPoint(location2, buffer, ARRAY_SIZE(buffer),
CoordinateFormat::UTM, _T('\n'));
ok1(StringIsEqualWildcard(buffer, _T("19H\n4051**\n6386***")));
return exit_status();
}
void
WaypointInfoWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const MoreData &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
const ComputerSettings &settings = CommonInterface::GetComputerSettings();
StaticString<64> buffer;
if (!waypoint.comment.empty())
AddMultiLine(waypoint.comment.c_str());
if (waypoint.radio_frequency.IsDefined() &&
waypoint.radio_frequency.Format(buffer.buffer(),
buffer.MAX_SIZE) != NULL) {
buffer += _T(" MHz");
AddReadOnly(_("Radio frequency"), NULL, buffer);
}
if (waypoint.runway.IsDirectionDefined())
buffer.UnsafeFormat(_T("%02u"), waypoint.runway.GetDirectionName());
else
buffer.clear();
if (waypoint.runway.IsLengthDefined()) {
if (!buffer.empty())
buffer += _T("; ");
TCHAR length_buffer[16];
FormatSmallUserDistance(length_buffer,
fixed(waypoint.runway.GetLength()));
buffer += length_buffer;
}
if (!buffer.empty())
AddReadOnly(_("Runway"), NULL, buffer);
if (FormatGeoPoint(waypoint.location,
buffer.buffer(), buffer.MAX_SIZE) != NULL)
AddReadOnly(_("Location"), NULL, buffer);
FormatUserAltitude(waypoint.elevation,
buffer.buffer(), buffer.MAX_SIZE);
AddReadOnly(_("Elevation"), NULL, buffer);
if (basic.time_available) {
const SunEphemeris::Result sun =
SunEphemeris::CalcSunTimes(waypoint.location, basic.date_time_utc,
fixed(GetUTCOffset()) / 3600);
const unsigned sunrisehours = (int)sun.time_of_sunrise;
const unsigned sunrisemins = (int)((sun.time_of_sunrise - fixed(sunrisehours)) * 60);
const unsigned sunset_hour = (int)sun.time_of_sunset;
const unsigned sunset_minute = (int)((sun.time_of_sunset - fixed(sunset_hour)) * 60);
buffer.UnsafeFormat(_T("%02u:%02u - %02u:%02u"), sunrisehours, sunrisemins, sunset_hour, sunset_minute);
AddReadOnly(_("Daylight time"), NULL, buffer);
}
if (basic.location_available) {
const GeoVector vector = basic.location.DistanceBearing(waypoint.location);
TCHAR distance_buffer[32];
FormatUserDistanceSmart(vector.distance, distance_buffer,
ARRAY_SIZE(distance_buffer));
FormatBearing(buffer.buffer(), buffer.MAX_SIZE,
vector.bearing, distance_buffer);
AddReadOnly(_("Bearing and Distance"), NULL, buffer);
}
if (basic.location_available && basic.NavAltitudeAvailable() &&
settings.polar.glide_polar_task.IsValid()) {
const GlideState glide_state(basic.location.DistanceBearing(waypoint.location),
waypoint.elevation + settings.task.safety_height_arrival,
basic.nav_altitude,
calculated.GetWindOrZero());
GlidePolar gp0 = settings.polar.glide_polar_task;
gp0.SetMC(fixed(0));
AddGlideResult(_("Alt. diff. MC 0"),
MacCready::Solve(settings.task.glide,
gp0, glide_state));
AddGlideResult(_("Alt. diff. MC safety"),
MacCready::Solve(settings.task.glide,
calculated.glide_polar_safety,
glide_state));
AddGlideResult(_("Alt. diff. MC current"),
MacCready::Solve(settings.task.glide,
settings.polar.glide_polar_task,
glide_state));
}
}
void
GlueMapWindow::DrawPanInfo(Canvas &canvas) const
{
if (!render_projection.IsValid())
return;
GeoPoint location = render_projection.GetGeoLocation();
TextInBoxMode mode;
mode.shape = LabelShape::OUTLINED;
mode.align = TextInBoxMode::Alignment::RIGHT;
const Font &font = *look.overlay_font;
canvas.Select(font);
UPixelScalar padding = Layout::FastScale(4);
UPixelScalar height = font.GetHeight();
PixelScalar y = 0 + padding;
PixelScalar x = render_projection.GetScreenWidth() - padding;
if (compass_visible)
/* don't obscure the north arrow */
/* TODO: obtain offset from CompassRenderer */
y += Layout::Scale(19) + Layout::FastScale(13);
if (terrain) {
short elevation = terrain->GetTerrainHeight(location);
if (!RasterBuffer::IsSpecial(elevation)) {
StaticString<64> elevation_short, elevation_long;
FormatUserAltitude(fixed(elevation),
elevation_short.buffer(), elevation_short.MAX_SIZE);
elevation_long = _("Elevation: ");
elevation_long += elevation_short;
TextInBox(canvas, elevation_long, x, y, mode,
render_projection.GetScreenWidth(),
render_projection.GetScreenHeight());
y += height;
}
}
TCHAR buffer[256];
FormatGeoPoint(location, buffer, ARRAY_SIZE(buffer), _T('\n'));
TCHAR *start = buffer;
while (true) {
TCHAR *newline = _tcschr(start, _T('\n'));
if (newline != nullptr)
*newline = _T('\0');
TextInBox(canvas, start, x, y, mode,
render_projection.GetScreenWidth(),
render_projection.GetScreenHeight());
y += height;
if (newline == nullptr)
break;
start = newline + 1;
}
}
