static void draw_bg(RoadMapGuiRect *rect){
static RoadMapPen day_pen = NULL;
static RoadMapPen night_pen = NULL;
if (roadmap_skin_state()){
if (night_pen == NULL){
night_pen = roadmap_canvas_create_pen("container_bg_pen_night");
roadmap_canvas_set_foreground ("#74859b");
roadmap_canvas_set_thickness (1);
}
else{
roadmap_canvas_select_pen(night_pen);
}
}
else{
if (day_pen == NULL){
day_pen = roadmap_canvas_create_pen("container_bg_pen_day");
roadmap_canvas_set_foreground ("#70bfea");
roadmap_canvas_set_thickness (1);
}
else{
roadmap_canvas_select_pen(day_pen);
}
}
roadmap_canvas_erase_area(rect);
}
void RealtimeTrafficInfoPluginInit () {
roadmap_config_declare
("schema", &RouteInfoConfigRouteColorGood, "#fdf66b", NULL); //Yellow
roadmap_config_declare
("schema", &RouteInfoConfigRouteColorMild, "#f57a24", NULL); //Orange
roadmap_config_declare
("schema", &RouteInfoConfigRouteColorBad, "#FF0000", NULL); //Red
roadmap_config_declare_enumeration
("preferences", &RouteInfoConfigDisplayTraffic, NULL, "yes", "no", NULL);
pens[TRAFFIC_OK] = roadmap_canvas_create_pen ("RealtimeTrafficInfoPenGood");
roadmap_canvas_set_foreground
(roadmap_config_get (&RouteInfoConfigRouteColorGood));
roadmap_canvas_set_thickness (TRAFFIC_PEN_WIDTH);
pens[TRAFFIC_MILD] = roadmap_canvas_create_pen ("RealtimeTrafficInfoPenMild");
roadmap_canvas_set_foreground
(roadmap_config_get (&RouteInfoConfigRouteColorMild));
roadmap_canvas_set_thickness (TRAFFIC_PEN_WIDTH);
pens[TRAFFIC_BAD] = roadmap_canvas_create_pen ("RealtimeTrafficInfoPenBad");
roadmap_canvas_set_foreground
(roadmap_config_get (&RouteInfoConfigRouteColorBad));
roadmap_canvas_set_thickness (TRAFFIC_PEN_WIDTH);
speed_text_pen = roadmap_canvas_create_pen("SpeedText");
roadmap_canvas_set_foreground("#000000");
if (roadmap_config_match(&RouteInfoConfigDisplayTraffic, "yes")){
RealtimeTrafficInfoRegister();
Realtime_SendTrafficInfo(1);
}
}
RoadMapPen roadmap_canvas_create_pen (const char *name)
{
struct roadmap_canvas_pen *pen;
for (pen = RoadMapPenList; pen != NULL; pen = pen->next) {
if (strcmp(pen->name, name) == 0) break;
}
if (pen == NULL) {
pen = new roadmap_canvas_pen();
roadmap_check_allocated(pen);
pen->name = strdup (name);
pen->color = agg::rgba8(0, 0, 0);
pen->thickness = 1;
pen->next = RoadMapPenList;
RoadMapPenList = pen;
}
roadmap_canvas_select_pen (pen);
roadmap_canvas_set_thickness (pen->thickness);
return pen;
}
static void init_containers (void) {
bg = roadmap_canvas_create_pen ("container_bg");
roadmap_canvas_set_foreground (default_bg);
border = roadmap_canvas_create_pen ("container_border");
roadmap_canvas_set_foreground ("#e1e1e1");
roadmap_canvas_set_thickness (1);
initialized = 1;
}
static void roadmap_sprite_decode_plane
(RoadMapSprite sprite,
const char *arg, int length, const char *thickness) {
int t;
char pen[256];
char color[256];
if (length >= (int)sizeof(color)-1) {
roadmap_log (ROADMAP_FATAL,
"color name too long: %*s", length, arg);
}
if (sprite->last == NULL) {
sprite->last = &(sprite->first);
sprite->first.next = NULL;
} else {
sprite->last->next = calloc (1, sizeof(sprite->first));
roadmap_check_allocated(sprite->last->next);
sprite->last = sprite->last->next;
}
t = atoi(thickness);
strncpy (color, arg, length);
color[length] = 0;
sprintf (pen, "%s.%d.%s", sprite->name, t, color);
sprite->last->pen = roadmap_canvas_create_pen (pen);
roadmap_canvas_set_foreground (color);
roadmap_canvas_set_thickness (t);
}
void roadmap_layer_adjust (void) {
int i;
int j;
int k;
int future_thickness;
int thickness;
struct roadmap_canvas_category *category;
if (last_zoom == roadmap_math_get_zoom()) return;
if (!RoadMapCategoryCount) return;
last_zoom = roadmap_math_get_zoom();
for (i = RoadMapCategoryCount; i > 0; --i) {
category = RoadMapCategory + i;
for (k=0; k<LAYER_PROJ_AREAS; k++) {
if (roadmap_layer_is_visible(i, k)) {
thickness =
roadmap_math_thickness (category->thickness,
category->declutter,
k+1,
category->pen_count > 1);
if (thickness <= 0) thickness = 1;
#ifdef VIEW_MODE_3D_OGL
if (roadmap_screen_get_view_mode() == VIEW_MODE_3D)
thickness *= 2;
#endif
if (thickness > 40) thickness = 40;
#if !defined (OPENGL) && !defined (J2ME)
if (roadmap_screen_fast_refresh()) {
if (thickness && (thickness <= 4))
thickness = 1;
#elif defined(J2ME)
if (thickness && (thickness <= 4)) {
thickness = 1;
} else
#endif
{
/* As a matter of taste, I do dislike roads with a filler
* of 1 pixel. Lets force at least a filler of 2.
*/
future_thickness = thickness;
for (j = 1; j < category->pen_count; ++j) {
if (category->delta_thickness[j] > 0) break;
future_thickness = category->thickness + category->delta_thickness[j];
if (future_thickness == 1) {
thickness += 1;
}
}
}
#if !defined (OPENGL) && !defined (J2ME)
}
#endif
if (k == 0) {
roadmap_plugin_adjust_layer (i, thickness, category->pen_count);
}
if (thickness > 0) {
roadmap_canvas_select_pen (category->pen[k][0]);
roadmap_canvas_set_thickness (thickness);
}
category->in_use[k][0] = 1;
for (j = 1; j < category->pen_count; ++j) {
/* The previous thickness was already the minimum:
* the pens that follow should not be used.
*/
if (thickness <= 1) {
category->in_use[k][j] = 0;
continue;
}
if (category->delta_thickness[j] < 0) {
thickness += category->delta_thickness[j];
#ifdef VIEW_MODE_3D_OGL
if (roadmap_screen_get_view_mode() == VIEW_MODE_3D/* &&
!roadmap_screen_fast_refresh()*/)
thickness += category->delta_thickness[j]*2; //increase the delta
#endif
} else {
/* Don't end with a road mostly drawn with the latter
* pen.
*/
if ((category->delta_thickness[j] >= thickness / 2) && (j != 2)) {
category->in_use[k][j] = 0;
thickness = 1;
continue;
}
thickness = category->delta_thickness[j];
}
/* If this pen is not visible, there is no reason
* to draw it.
*/
if (thickness < 1) {
category->in_use[k][j] = 0;
continue;
}
roadmap_canvas_select_pen (category->pen[k][j]);
roadmap_canvas_set_thickness (thickness);
category->in_use[k][j] = 1;
}
}
}
}
}
static void roadmap_layer_reload_internal (void) {
int i;
int j;
int k;
RoadMapConfigDescriptor descriptor = ROADMAP_CONFIG_ITEM_EMPTY;
static BOOL initialized = FALSE;
const char *global_label_color, *global_label_bg_color;
global_label_color = roadmap_config_get (&RoadMapConfigLabelsColor);
global_label_bg_color = roadmap_config_get (&RoadMapConfigLabelsBgColor);
use_new_pens = FALSE;
for (i = 1; i <= RoadMapCategoryCount; ++i) {
int max_pens;
struct roadmap_canvas_category *category = RoadMapCategory + i;
const char *name = RoadMapDefaultCategoryTable[i-1];
const char *class_name;
const char *color[ROADMAP_LAYER_PENS];
const char *label_color;
int bg_color;
int thickness;
int other_pens_length = strlen(name) + 64;
char *other_pens = malloc(other_pens_length);
RoadMapClass *p;
descriptor.category = name;
descriptor.age = 0;
/* Retrieve the class of the category. */
if (!initialized) {
category->name = name;
category->visible = 1;
category->label_visible = 1;
category->label_pen = NULL;
descriptor.name = "Class";
descriptor.reference = NULL;
roadmap_config_declare ("schema", &descriptor, "", NULL);
class_name = roadmap_config_get (&descriptor);
for (p = RoadMapClasses; p->name != NULL; ++p) {
if (strcasecmp (class_name, p->name) == 0) {
p->category[p->count++] = i;
category->class_index = (int) (p - RoadMapClasses);
break;
}
}
}
/* Retrieve the category thickness & declutter. */
descriptor.name = "Thickness";
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "1", NULL);
thickness = category->thickness = roadmap_config_get_integer (&descriptor);
#if !defined (ANDROID) && !defined(J2ME)
if ( roadmap_screen_is_hd_screen() )
{
category->thickness = (int)(category->thickness * roadmap_screen_get_screen_scale() /100);
thickness = (int)(thickness * roadmap_screen_get_screen_scale() /100);
}
#endif
if (!initialized) {
descriptor.name = "Declutter";
descriptor.reference = NULL;
roadmap_config_declare
("schema", &descriptor, "2024800000", NULL);
category->declutter = roadmap_config_get_integer (&descriptor);
descriptor.name = "LabelDeclutter";
descriptor.reference = NULL;
roadmap_config_declare
("schema", &descriptor, "-1", NULL);
category->label_declutter = roadmap_config_get_integer (&descriptor);
if (category->label_declutter == -1)
category->label_declutter = category->declutter;
}
/* Retrieve the first pen's color (mandatory). */
descriptor.name = "Color";
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "black", NULL);
color[0] = roadmap_config_get (&descriptor);
/* Retrieve label color (optional) */
descriptor.name = "LabelColor";
descriptor.reference = NULL;
roadmap_config_declare ("schema", &descriptor, "", NULL);
label_color = roadmap_config_get (&descriptor);
/* Retrieve the category's other colors (optional). */
if (!editor_screen_gray_scale())
max_pens = 2;
else
max_pens = ROADMAP_LAYER_PENS;
for (j = 1; j < max_pens; ++j) {
int is_new = 0;
snprintf (other_pens, other_pens_length, "Delta%d", j);
descriptor.name = strdup(other_pens);
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "0", &is_new);
category->delta_thickness[j] =
roadmap_config_get_integer (&descriptor);
#if !defined (ANDROID) && !defined(J2ME)
if ( roadmap_screen_is_hd_screen() )
{
category->delta_thickness[j] = (int)(category->delta_thickness[j] * roadmap_screen_get_screen_scale() /100);
}
#endif
if ((j == 2) && !editor_screen_gray_scale()) break;
if (!is_new) free ((void *)descriptor.name);
if (category->delta_thickness[j] == 0) break;
snprintf (other_pens, other_pens_length, "Color%d", j);
descriptor.name = strdup(other_pens);
descriptor.reference = NULL;
if (!initialized)
roadmap_config_declare ("schema", &descriptor, "", &is_new);
color[j] = roadmap_config_get (&descriptor);
if (!is_new) free ((void *)descriptor.name);
if (*color[j] == 0) break;
}
category->pen_count = j;
if (j > RoadMapMaxUsedPen) RoadMapMaxUsedPen = j;
/* Create all necessary pens. */
for (j=0; j<LAYER_PROJ_AREAS; j++) {
snprintf (other_pens, other_pens_length, "%d%s", j, name);
category->pen[j][0] = roadmap_canvas_create_pen(other_pens,use_new_pens);
roadmap_canvas_set_thickness (category->thickness);
if (color[0] != NULL && *(color[0]) > ' ') {
roadmap_canvas_set_foreground (color[0]);
}
}
for (k=0; k<LAYER_PROJ_AREAS; k++)
for (j = 1; j < category->pen_count; ++j) {
snprintf (other_pens, other_pens_length, "%d%s%d", k, name, j);
category->pen[k][j] = roadmap_canvas_create_pen (other_pens, use_new_pens);
if (category->delta_thickness[j] < 0) {
thickness = category->thickness + category->delta_thickness[j];
} else {
thickness = category->delta_thickness[j];
}
roadmap_canvas_set_foreground (color[j]);
if (thickness > 0) {
roadmap_canvas_set_thickness (thickness);
}
}
snprintf (other_pens, other_pens_length, "%s_label_pen", name);
category->label_pen = roadmap_canvas_create_pen (other_pens,use_new_pens);
if (strlen(label_color) != 0) {
roadmap_canvas_set_foreground (label_color);
} else {
roadmap_canvas_set_foreground (global_label_color);
}
#ifdef OPENGL
bg_color = (category->pen_count > 2 ? 1 : 0);
if (color[bg_color] != NULL && *(color[bg_color]) > ' ') {
roadmap_canvas_set_background (global_label_bg_color);
}
#endif //OPENGL
free (other_pens);
}
initialized = TRUE;
}
static void RealtimeTrafficInfoScreenRepaint (int max_pen) {
int i;
int iNumLines;
int width = TRAFFIC_PEN_WIDTH;
int previous_with = -1;
int previous_type = -1;
if (!isDisplayingTrafficInfoOn())
return;
if (RTTrafficInfo_IsEmpty()) return;
iNumLines = RTTrafficInfo_GetNumLines();
for (i=0; i<iNumLines; i++) {
RTTrafficInfoLines *pTrafficLine = RTTrafficInfo_GetLine(i);
RoadMapGuiPoint seg_middle;
RoadMapPen previous_pen;
RoadMapPen layer_pen;
roadmap_square_set_current(pTrafficLine->pluginLine.square);
if (!roadmap_layer_is_visible (pTrafficLine->pluginLine.cfcc, 0))
continue;
if (!roadmap_math_line_is_visible (&pTrafficLine->positionFrom, &pTrafficLine->positionTo))
continue;
layer_pen = roadmap_layer_get_pen (pTrafficLine->pluginLine.cfcc, 0, 0);
if (layer_pen)
width = roadmap_canvas_get_thickness (layer_pen)+1;
else
width = TRAFFIC_PEN_WIDTH;
if (width < TRAFFIC_PEN_WIDTH) {
width = TRAFFIC_PEN_WIDTH;
}
previous_pen = roadmap_canvas_select_pen (pens[pTrafficLine->iType]);
roadmap_canvas_set_thickness (width);
if (previous_pen) {
roadmap_canvas_select_pen (previous_pen);
}
if ((width != previous_with) || (previous_type != pTrafficLine->iType))
roadmap_screen_draw_flush();
previous_with = width;
previous_type = pTrafficLine->iType;
roadmap_screen_draw_one_line (&pTrafficLine->positionFrom,
&pTrafficLine->positionTo,
0,
&pTrafficLine->positionFrom,
pTrafficLine->iFirstShape,
pTrafficLine->iLastShape,
roadmap_shape_get_position,
&pens[pTrafficLine->iType],
1,
-1,
NULL,
&seg_middle,
NULL);
if (width >= 4){
static const char *direction_colors[3] = {"#fd9f0b", "#FFF380", "#FFFFFF"};
roadmap_screen_draw_line_direction (&pTrafficLine->positionFrom,
&pTrafficLine->positionTo,
&pTrafficLine->positionFrom,
pTrafficLine->iFirstShape,
pTrafficLine->iLastShape,
roadmap_shape_get_position,
width,
pTrafficLine->iDirection,
direction_colors[pTrafficLine->iType]);
}
}
}
