int do_draw(char *buff)
{
float xper, yper;
if (2 != sscanf(buff, "%*s %f %f", &xper, &yper)) {
G_warning(_("Problem parsing coordinates [%s]"), buff);
return (-1);
}
if (mapunits) {
/* skip check: clips segments if map coordinate is out of region.
if( xper < D_get_u_west() ||
yper < D_get_u_south() ||
xper > D_get_u_east() ||
yper > D_get_u_north() )
return(-1);
*/
R_cont_abs((int)(D_u_to_d_col(xper) + 0.5),
(int)(D_u_to_d_row(yper) + 0.5));
}
else {
if (xper < 0. || yper < 0. || xper > 100. || yper > 100.)
return (-1);
R_cont_abs(l + (int)(xper * xincr), b - (int)(yper * yincr));
}
return (0);
}
int do_poly(char *buff, FILE * infile)
{
int num;
char origcmd[64];
float xper, yper;
char *fgets();
int to_return;
sscanf(buff, "%s", origcmd);
num = 0;
for (;;) {
if ((to_return = G_getl2(buff, 128, infile)) != 1)
break;
if (2 != sscanf(buff, "%f %f", &xper, &yper)) {
if ('#' == buff[0]) {
G_debug(3, " skipping comment line [%s]", buff);
continue;
}
G_debug(3, "coordinate pair not found. ending polygon. [%s]",
buff);
break;
}
if (!mapunits) {
if (xper < 0. || yper < 0. || xper > 100. || yper > 100.)
break;
}
check_alloc(num + 1);
if (mapunits) {
xarray[num] = (int)(D_u_to_d_col(xper) + 0.5);
yarray[num] = (int)(D_u_to_d_row(yper) + 0.5);
}
else {
xarray[num] = l + (int)(xper * xincr);
yarray[num] = b - (int)(yper * yincr);
}
num++;
}
if (num) {
/* this check is here so you can use the "polyline" command
to make an unfilled polygon */
if (!strcmp(origcmd, "polygon"))
R_polygon_abs(xarray, yarray, num);
else
R_polyline_abs(xarray, yarray, num);
}
return (to_return);
}
int do_icon(char *buff)
{
double xper, yper;
char type;
int size;
int ix, iy;
if (4 != sscanf(buff, "%*s %c %d %lf %lf", &type, &size, &xper, &yper)) {
G_warning(_("Problem parsing command [%s]"), buff);
return (-1);
}
if (mapunits) {
ix = (int)(D_u_to_d_col(xper) + 0.5);
iy = (int)(D_u_to_d_row(yper) + 0.5);
/* size in map units too? currently in percentage.
use "size * D_get_u_to_d_yconv()" to convert? */
}
else {
if (xper < 0. || yper < 0. || xper > 100. || yper > 100.)
return (-1);
ix = l + (int)(xper * xincr);
iy = b - (int)(yper * yincr);
}
switch (type & 0177) {
case 'o':
R_move_abs(ix - size, iy - size);
R_cont_abs(ix - size, iy + size);
R_cont_abs(ix + size, iy + size);
R_cont_abs(ix + size, iy - size);
R_cont_abs(ix - size, iy - size);
break;
case 'x':
R_move_abs(ix - size, iy - size);
R_cont_abs(ix + size, iy + size);
R_move_abs(ix - size, iy + size);
R_cont_abs(ix + size, iy - size);
break;
case '+':
default:
R_move_abs(ix, iy - size);
R_cont_abs(ix, iy + size);
R_move_abs(ix - size, iy);
R_cont_abs(ix + size, iy);
break;
}
return (0);
}
int do_move(char *buff)
{
float xper, yper;
if (2 != sscanf(buff, "%*s %f %f", &xper, &yper)) {
G_warning(_("Problem parsing coordinates [%s]"), buff);
return (-1);
}
if (mapunits)
R_move_abs((int)(D_u_to_d_col(xper) + 0.5),
(int)(D_u_to_d_row(yper) + 0.5));
else {
if (xper < 0. || yper < 0. || xper > 100. || yper > 100.)
return (-1);
R_move_abs(l + (int)(xper * xincr), b - (int)(yper * yincr));
}
return (0);
}
static int
get_coordinates(double *x, double *y, double *east, double *north,
struct rectinfo win, char **at, char pixel,
char geocoor)
{
double e, n;
if (at) {
e = atof(at[0]);
n = atof(at[1]);
if (pixel) {
*x = e + win.l;
*y = n + win.t;
e = D_d_to_u_col(*x);
n = D_d_to_u_row(*y);
}
else if (geocoor) {
*x = D_u_to_d_col(e);
*y = D_u_to_d_row(n);
}
else {
*x = win.l + (win.r - win.l) * e / 100.0;
*y = win.t + (win.b - win.t) * (100.0 - n) / 100.0;
e = D_d_to_u_col(*x);
n = D_d_to_u_row(*y);
}
}
else
return 1;
if (east)
*east = e;
if (north)
*north = n;
return 0;
}
void edit_line_phase2(struct edit_line *el, double x, double y)
{
int node1, node2;
double nodex, nodey, nodez, dist;
el->phase = 2;
el->Points = Vect_new_line_struct();
el->Cats = Vect_new_cats_struct();
el->line_type = Vect_read_line(&Map, el->Points, el->Cats, el->line);
el->reversed = 0;
/* Find out the node nearest to the line */
Vect_get_line_nodes(&Map, el->line, &node1, &node2);
Vect_get_node_coor(&Map, node2, &nodex, &nodey, &nodez);
dist = (x - nodex) * (x - nodex) + (y - nodey) * (y - nodey);
Vect_get_node_coor(&Map, node1, &nodex, &nodey, &nodez);
if ((x - nodex) * (x - nodex) + (y - nodey) * (y - nodey) < dist) {
/* The first node is the nearest => reverse the line and remember
* doing so. */
Vect_line_reverse(el->Points);
el->reversed = 1;
}
display_node(node1, SYMB_BACKGROUND, 1);
display_node(node2, SYMB_BACKGROUND, 1);
i_prompt_buttons(_("New Point"), _("Undo Last Point"), _("Close line"));
set_location(D_u_to_d_col(el->Points->x[el->Points->n_points - 1]),
D_u_to_d_row(el->Points->y[el->Points->n_points - 1])
);
set_mode(MOUSE_LINE);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct
{
struct Option *text;
struct Option *size;
struct Option *fgcolor;
struct Option *bgcolor;
struct Option *line;
struct Option *at;
struct Option *rotation;
struct Option *align;
struct Option *linespacing;
struct Option *font;
struct Option *path;
struct Option *charset;
struct Option *input;
} opt;
struct
{
struct Flag *p;
struct Flag *g;
struct Flag *b;
struct Flag *r;
struct Flag *s;
} flag;
/* options and flags */
char *text;
double size;
double x, y;
int line;
double rotation;
char align[3];
double linespacing;
char bold;
/* window info */
struct rectinfo win;
/* command file */
FILE *cmd_fp;
char buf[512];
int first_text;
int linefeed;
int set_l;
double orig_x, orig_y;
double prev_x, prev_y;
double set_x, set_y;
double east, north;
int do_background, fg_color, bg_color;
/* initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description =
_("Draws text in the active display frame on the graphics monitor using the current font.");
opt.text = G_define_option();
opt.text->key = "text";
opt.text->type = TYPE_STRING;
opt.text->required = NO;
opt.text->description = _("Text to display");
opt.text->guisection = _("Input");
opt.input = G_define_standard_option(G_OPT_F_INPUT);
opt.input->required = NO;
opt.input->description = _("Input file");
opt.input->guisection = _("Input");
opt.fgcolor = G_define_option();
opt.fgcolor->key = "color";
opt.fgcolor->type = TYPE_STRING;
opt.fgcolor->answer = DEFAULT_COLOR;
opt.fgcolor->required = NO;
opt.fgcolor->description =
_("Text color, either a standard GRASS color or R:G:B triplet");
opt.fgcolor->gisprompt = "old_color,color,color";
opt.fgcolor->guisection = _("Text");
opt.bgcolor = G_define_option();
opt.bgcolor->key = "bgcolor";
opt.bgcolor->type = TYPE_STRING;
opt.bgcolor->required = NO;
opt.bgcolor->description =
_("Text background color, either a standard GRASS color or R:G:B triplet");
opt.bgcolor->gisprompt = "old_color,color,color";
opt.bgcolor->guisection = _("Text");
opt.rotation = G_define_option();
opt.rotation->key = "rotation";
opt.rotation->type = TYPE_DOUBLE;
opt.rotation->required = NO;
opt.rotation->answer = "0";
opt.rotation->description =
_("Rotation angle in degrees (counter-clockwise)");
opt.rotation->guisection = _("Text");
opt.linespacing = G_define_option();
opt.linespacing->key = "linespacing";
opt.linespacing->type = TYPE_DOUBLE;
opt.linespacing->required = NO;
opt.linespacing->answer = "1.25";
opt.linespacing->description = _("Line spacing");
opt.linespacing->guisection = _("Text");
opt.at = G_define_option();
opt.at->key = "at";
opt.at->key_desc = "x,y";
opt.at->type = TYPE_DOUBLE;
opt.at->required = NO;
opt.at->description =
_("Screen position at which text will begin to be drawn (percentage, [0,0] is lower left)");
opt.at->guisection = _("Position");
opt.line = G_define_option();
opt.line->key = "line";
opt.line->required = NO;
opt.line->type = TYPE_INTEGER;
opt.line->options = "1-1000";
opt.line->description =
_("The screen line number on which text will begin to be drawn");
opt.line->guisection = _("Position");
opt.align = G_define_option();
opt.align->key = "align";
opt.align->type = TYPE_STRING;
opt.align->required = NO;
opt.align->answer = "ll";
opt.align->options = "ll,lc,lr,cl,cc,cr,ul,uc,ur";
opt.align->description = _("Text alignment");
opt.align->guisection = _("Position");
opt.font = G_define_option();
opt.font->key = "font";
opt.font->type = TYPE_STRING;
opt.font->required = NO;
opt.font->description = _("Font name");
opt.font->guisection = _("Font settings");
opt.size = G_define_option();
opt.size->key = "size";
opt.size->type = TYPE_DOUBLE;
opt.size->required = NO;
opt.size->answer = "5";
opt.size->options = "0-100";
opt.size->description =
_("Height of letters in percentage of available frame height");
opt.size->guisection = _("Font settings");
opt.path = G_define_standard_option(G_OPT_F_INPUT);
opt.path->key = "path";
opt.path->required = NO;
opt.path->description = _("Path to font file");
opt.path->gisprompt = "old,font,file";
opt.path->guisection = _("Font settings");
opt.charset = G_define_option();
opt.charset->key = "charset";
opt.charset->type = TYPE_STRING;
opt.charset->required = NO;
opt.charset->description =
_("Text encoding (only applicable to TrueType fonts)");
opt.charset->guisection = _("Font settings");
flag.p = G_define_flag();
flag.p->key = 'p';
flag.p->description = _("Screen position in pixels ([0,0] is top left)");
flag.p->guisection = _("Position");
flag.g = G_define_flag();
flag.g->key = 'g';
flag.g->description = _("Screen position in geographic coordinates");
flag.g->guisection = _("Position");
flag.b = G_define_flag();
flag.b->key = 'b';
flag.b->description = _("Use bold text");
flag.b->guisection = _("Text");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description = _("Use radians instead of degrees for rotation");
flag.r->guisection = _("Text");
flag.s = G_define_flag();
flag.s->key = 's';
flag.s->description = _("Font size is height in pixels");
flag.s->guisection = _("Font settings");
/* check command line */
if (G_parser(argc, argv))
exit(1);
/* parse and check options and flags */
if ((opt.line->answer && opt.at->answer) ||
(flag.p->answer && flag.g->answer))
G_fatal_error(_("Please choose only one placement method"));
text = opt.text->answer;
line = (opt.line->answer ? atoi(opt.line->answer) : 1);
/* calculate rotation angle in radian */
rotation = atof(opt.rotation->answer);
if (!flag.r->answer)
rotation *= M_PI / 180.0;
rotation = fmod(rotation, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
strncpy(align, opt.align->answer, 2);
linespacing = atof(opt.linespacing->answer);
bold = flag.b->answer;
D_open_driver();
if (opt.font->answer)
D_font(opt.font->answer);
else if (opt.path->answer)
D_font(opt.path->answer);
if (opt.charset->answer)
D_encoding(opt.charset->answer);
D_setup_unity(0);
/* figure out where to put text */
D_get_src(&win.t, &win.b, &win.l, &win.r);
if (flag.s->answer)
size = atof(opt.size->answer);
else
#ifdef BACKWARD_COMPATIBILITY
size = atof(opt.size->answer) / 100.0 * (win.b - win.t) / linespacing;
#else
size = atof(opt.size->answer) / 100.0 * (win.b - win.t);
#endif
fg_color = D_parse_color(opt.fgcolor->answer, TRUE);
if (opt.bgcolor->answer) {
do_background = 1;
bg_color = D_parse_color(opt.bgcolor->answer, TRUE);
if (bg_color == 0) /* ie color="none" */
do_background = 0;
} else
do_background = 0;
set_color(opt.fgcolor->answer);
orig_x = orig_y = 0;
if (opt.at->answer) {
if (get_coordinates(&x, &y, &east, &north,
win, opt.at->answers,
flag.p->answer, flag.g->answer))
G_fatal_error(_("Invalid coordinates"));
orig_x = x;
orig_y = y;
}
else {
x = win.l + (size * linespacing + 0.5) - size; /* d.text: +5 */
y = win.t + line * (size * linespacing + 0.5);
}
prev_x = x;
prev_y = y;
D_text_size(size, size);
D_text_rotation(rotation * 180.0 / M_PI);
if (text) {
double x2, y2;
x2 = x;
y2 = y;
if (text[0])
draw_text(text, &x2, &y2, size, align, rotation, bold, do_background, fg_color, bg_color);
/* reset */
D_text_size(5, 5);
D_text_rotation(0.0);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
if (!opt.input->answer || strcmp(opt.input->answer, "-") == 0)
cmd_fp = stdin;
else {
cmd_fp = fopen(opt.input->answer, "r");
if (!cmd_fp)
G_fatal_error(_("Unable to open input file <%s>"), opt.input->answer);
}
if (isatty(fileno(cmd_fp)))
fprintf(stderr,
_("\nPlease enter text instructions. Enter EOF (ctrl-d) on last line to quit\n"));
set_x = set_y = set_l = 0;
first_text = 1;
linefeed = 1;
/* do the plotting */
while (fgets(buf, sizeof(buf), cmd_fp)) {
int buf_len;
char *buf_ptr, *ptr;
buf_len = strlen(buf) - 1;
for (; buf[buf_len] == '\r' || buf[buf_len] == '\n'; buf_len--) ;
buf[buf_len + 1] = 0;
if (buf[0] == '.' && buf[1] != '.') {
int i;
double d;
G_squeeze(buf); /* added 6/91 DBS @ CWU */
for (buf_ptr = buf + 2; *buf_ptr == ' '; buf_ptr++) ;
buf_len = strlen(buf_ptr);
switch (buf[1] & 0x7f) {
case 'F':
/* font */
if ((ptr = strchr(buf_ptr, ':')))
*ptr = 0;
D_font(buf_ptr);
if (ptr)
D_encoding(ptr + 1);
break;
case 'C':
/* color */
set_color(buf_ptr);
fg_color = D_parse_color(buf_ptr, 1);
break;
case 'G':
/* background color */
bg_color = D_parse_color(buf_ptr, 1);
do_background = 1;
break;
case 'S':
/* size */
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] != 'p')
#ifdef BACKWARD_COMPATIBILITY
d *= (win.b - win.t) / 100.0 / linespacing;
#else
d *= (win.b - win.t) / 100.0;
#endif
size = d + (i ? size : 0);
D_text_size(size, size);
break;
case 'B':
/* bold */
bold = (atoi(buf_ptr) ? 1 : 0);
break;
case 'A':
/* align */
strncpy(align, buf_ptr, 2);
break;
case 'R':
/* rotation */
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] != 'r')
d *= M_PI / 180.0;
d += (i ? rotation : 0.0);
rotation = fmod(d, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
D_text_rotation(rotation * 180.0 / M_PI);
break;
case 'I':
/* linespacing */
linespacing = atof(buf_ptr);
break;
case 'X':
/* x */
set_l = 0;
set_x = 1;
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
/* percentage */
d *= (win.r - win.l) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
/* column */
d = (d - 1) * size * linespacing + 0.5;
x = prev_x = d + (i ? x : orig_x);
break;
case 'Y':
/* y */
set_l = 0;
set_y = 1;
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
/* percentage */
d = win.b - d * (win.b - win.t) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
/* row */
d *= size * linespacing + 0.5;
y = prev_y = d + (i ? y : orig_y);
break;
case 'L':
/* linefeed */
set_l = 1;
linefeed = (atoi(buf_ptr) ? 1 : 0);
break;
case 'E':
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
d *= (win.r - win.l) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
d = D_u_to_d_col(d);
x = prev_x = orig_x = d + (i ? orig_x : win.l);
break;
case 'N':
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
d *= (win.b - win.t) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
d = D_u_to_d_row(d);
y = prev_y = orig_y = d + (i ? orig_y : win.t);
break;
}
}
else {
buf_ptr = buf;
if (buf[0] == '.' && buf[1] == '.')
buf_ptr++;
if (!first_text && (linefeed || set_l)) {
/* if x is not given, increment x */
if (!set_x)
x = prev_x +
(size * linespacing + 0.5) * sin(rotation);
/* if y is not given, increment y */
if (!set_y)
y = prev_y +
(size * linespacing + 0.5) * cos(rotation);
prev_x = x;
prev_y = y;
}
set_x = set_y = set_l = first_text = 0;
draw_text(buf_ptr, &x, &y, size, align, rotation, bold, do_background, fg_color, bg_color);
}
}
if (cmd_fp != stdin)
fclose(cmd_fp);
/* reset */
D_text_size(5, 5);
D_text_rotation(0.0);
D_close_driver();
exit(EXIT_SUCCESS);
}
/* *************************************************************** */
int plot1(struct Map_info *Map, int type, int area, struct cat_list *Clist,
const struct color_rgb *color, const struct color_rgb *fcolor,
int chcat, SYMBOL * Symb, int size, int id_flag,
int table_colors_flag, int cats_color_flag, char *rgb_column,
int default_width, char *width_column, double width_scale)
{
int i, ltype, nlines = 0, line, cat = -1;
double *x, *y;
struct line_pnts *Points, *PPoints;
struct line_cats *Cats;
double msize;
int x0, y0;
struct field_info *fi = NULL;
dbDriver *driver = NULL;
dbCatValArray cvarr_rgb, cvarr_width;
dbCatVal *cv_rgb = NULL, *cv_width = NULL;
int nrec_rgb = 0, nrec_width = 0;
int open_db;
int custom_rgb = FALSE;
char colorstring[12]; /* RRR:GGG:BBB */
int red, grn, blu;
RGBA_Color *line_color, *fill_color, *primary_color;
unsigned char which;
int width;
line_color = G_malloc(sizeof(RGBA_Color));
fill_color = G_malloc(sizeof(RGBA_Color));
primary_color = G_malloc(sizeof(RGBA_Color));
primary_color->a = RGBA_COLOR_OPAQUE;
/* change function prototype to pass RGBA_Color instead of color_rgb? */
if (color) {
line_color->r = color->r;
line_color->g = color->g;
line_color->b = color->b;
line_color->a = RGBA_COLOR_OPAQUE;
}
else
line_color->a = RGBA_COLOR_NONE;
if (fcolor) {
fill_color->r = fcolor->r;
fill_color->g = fcolor->g;
fill_color->b = fcolor->b;
fill_color->a = RGBA_COLOR_OPAQUE;
}
else
fill_color->a = RGBA_COLOR_NONE;
msize = size * (D_d_to_u_col(2.0) - D_d_to_u_col(1.0)); /* do it better */
Points = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
open_db = table_colors_flag || width_column;
if (open_db) {
fi = Vect_get_field(Map, (Clist->field > 0 ? Clist->field : 1));
if (fi == NULL) {
G_fatal_error(_("Database connection not defined for layer %d"),
(Clist->field > 0 ? Clist->field : 1));
}
driver = db_start_driver_open_database(fi->driver, fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
}
if (table_colors_flag) {
/* for reading RRR:GGG:BBB color strings from table */
if (rgb_column == NULL || *rgb_column == '\0')
G_fatal_error(_("Color definition column not specified"));
db_CatValArray_init(&cvarr_rgb);
nrec_rgb = db_select_CatValArray(driver, fi->table, fi->key,
rgb_column, NULL, &cvarr_rgb);
G_debug(3, "nrec_rgb (%s) = %d", rgb_column, nrec_rgb);
if (cvarr_rgb.ctype != DB_C_TYPE_STRING)
G_fatal_error(_("Color definition column (%s) not a string. "
"Column must be of form RRR:GGG:BBB where RGB values range 0-255."),
rgb_column);
if (nrec_rgb < 0)
G_fatal_error(_("Cannot select data (%s) from table"),
rgb_column);
G_debug(2, "\n%d records selected from table", nrec_rgb);
for (i = 0; i < cvarr_rgb.n_values; i++) {
G_debug(4, "cat = %d %s = %s", cvarr_rgb.value[i].cat,
rgb_column, db_get_string(cvarr_rgb.value[i].val.s));
}
}
if (width_column) {
if (*width_column == '\0')
G_fatal_error(_("Line width column not specified."));
db_CatValArray_init(&cvarr_width);
nrec_width = db_select_CatValArray(driver, fi->table, fi->key,
width_column, NULL, &cvarr_width);
G_debug(3, "nrec_width (%s) = %d", width_column, nrec_width);
if (cvarr_width.ctype != DB_C_TYPE_INT &&
cvarr_width.ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Line width column (%s) not a number."),
width_column);
if (nrec_width < 0)
G_fatal_error(_("Cannot select data (%s) from table"),
width_column);
G_debug(2, "\n%d records selected from table", nrec_width);
for (i = 0; i < cvarr_width.n_values; i++) {
G_debug(4, "cat = %d %s = %d", cvarr_width.value[i].cat,
width_column,
(cvarr_width.ctype ==
DB_C_TYPE_INT ? cvarr_width.value[i].val.
i : (int)cvarr_width.value[i].val.d));
}
}
if (open_db)
db_close_database_shutdown_driver(driver);
Vect_rewind(Map);
/* Is it necessary to reset line/label color in each loop ? */
if (color && !table_colors_flag && !cats_color_flag)
D_RGB_color(color->r, color->g, color->b);
if (Vect_level(Map) >= 2)
nlines = Vect_get_num_lines(Map);
line = 0;
while (1) {
if (Vect_level(Map) >= 2) {
line++;
if (line > nlines)
return 0;
if (!Vect_line_alive(Map, line))
continue;
ltype = Vect_read_line(Map, Points, Cats, line);
}
else {
ltype = Vect_read_next_line(Map, Points, Cats);
switch (ltype) {
case -1:
fprintf(stderr, _("\nERROR: vector map - can't read\n"));
return -1;
case -2: /* EOF */
return 0;
}
}
if (!(type & ltype))
continue;
if (chcat) {
int found = 0;
if (id_flag) { /* use line id */
if (!(Vect_cat_in_cat_list(line, Clist)))
continue;
}
else {
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = 1;
break;
}
}
if (!found)
continue;
}
}
else if (Clist->field > 0) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field) {
found = 1;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
if (table_colors_flag) {
/* only first category */
cat = Vect_get_line_cat(Map, line,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats >
0 ? Cats->field[0] : 1)));
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* Read RGB colors from db for current area # */
if (db_CatValArray_get_value(&cvarr_rgb, cat, &cv_rgb) !=
DB_OK) {
custom_rgb = FALSE;
}
else {
sprintf(colorstring, "%s", db_get_string(cv_rgb->val.s));
if (*colorstring != '\0') {
G_debug(3, "element %d: colorstring: %s", line,
colorstring);
if (G_str_to_color(colorstring, &red, &grn, &blu) ==
1) {
custom_rgb = TRUE;
G_debug(3, "element:%d cat %d r:%d g:%d b:%d",
line, cat, red, grn, blu);
}
else {
custom_rgb = FALSE;
G_warning(_("Error in color definition column (%s), element %d "
"with cat %d: colorstring [%s]"),
rgb_column, line, cat, colorstring);
}
}
else {
custom_rgb = FALSE;
G_warning(_("Error in color definition column (%s), element %d with cat %d"),
rgb_column, line, cat);
}
}
} /* end if cat */
else {
custom_rgb = FALSE;
}
} /* end if table_colors_flag */
/* random colors */
if (cats_color_flag) {
custom_rgb = FALSE;
if (Clist->field > 0) {
cat = Vect_get_line_cat(Map, line, Clist->field);
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* fetch color number from category */
which = (cat % palette_ncolors);
G_debug(3, "cat:%d which color:%d r:%d g:%d b:%d", cat,
which, palette[which].R, palette[which].G,
palette[which].B);
custom_rgb = TRUE;
red = palette[which].R;
grn = palette[which].G;
blu = palette[which].B;
}
}
else if (Cats->n_cats > 0) {
/* fetch color number from layer */
which = (Cats->field[0] % palette_ncolors);
G_debug(3, "layer:%d which color:%d r:%d g:%d b:%d",
Cats->field[0], which, palette[which].R,
palette[which].G, palette[which].B);
custom_rgb = TRUE;
red = palette[which].R;
grn = palette[which].G;
blu = palette[which].B;
}
}
if (nrec_width) {
/* only first category */
cat = Vect_get_line_cat(Map, line,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats >
0 ? Cats->field[0] : 1)));
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* Read line width from db for current area # */
if (db_CatValArray_get_value(&cvarr_width, cat, &cv_width) !=
DB_OK) {
width = default_width;
}
else {
width =
width_scale * (cvarr_width.ctype ==
DB_C_TYPE_INT ? cv_width->val.
i : (int)cv_width->val.d);
if (width < 0) {
G_warning(_("Error in line width column (%s), element %d "
"with cat %d: line width [%d]"),
width_column, line, cat, width);
width = default_width;
}
}
} /* end if cat */
else {
width = default_width;
}
D_line_width(width);
} /* end if nrec_width */
/* enough of the prep work, lets start plotting stuff */
x = Points->x;
y = Points->y;
if ((ltype & GV_POINTS) && Symb != NULL) {
if (!(color || fcolor || custom_rgb))
continue;
x0 = D_u_to_d_col(x[0]);
y0 = D_u_to_d_row(y[0]);
/* skip if the point is outside of the display window */
/* xy<0 tests make it go ever-so-slightly faster */
if (x0 < 0 || y0 < 0 ||
x0 > D_get_d_east() || x0 < D_get_d_west() ||
y0 > D_get_d_south() || y0 < D_get_d_north())
continue;
/* use random or RGB column color if given, otherwise reset */
/* centroids always use default color to stand out from underlying area */
if (custom_rgb && (ltype != GV_CENTROID)) {
primary_color->r = (unsigned char)red;
primary_color->g = (unsigned char)grn;
primary_color->b = (unsigned char)blu;
D_symbol2(Symb, x0, y0, primary_color, line_color);
}
else
D_symbol(Symb, x0, y0, line_color, fill_color);
}
else if (color || custom_rgb) {
if (!table_colors_flag && !cats_color_flag)
D_RGB_color(color->r, color->g, color->b);
else {
if (custom_rgb)
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
else
D_RGB_color(color->r, color->g, color->b);
}
/* Plot the lines */
if (Points->n_points == 1) /* line with one coor */
D_polydots_abs(x, y, Points->n_points);
else /*use different user defined render methods */
D_polyline_abs(x, y, Points->n_points);
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0; /* not reached */
}
int do_symbol(char *buff)
{
double xper, yper;
int size;
int ix, iy;
char *symb_name;
SYMBOL *Symb;
char *line_color_str, *fill_color_str;
RGBA_Color *line_color, *fill_color;
int R, G, B, ret;
line_color = G_malloc(sizeof(RGBA_Color));
fill_color = G_malloc(sizeof(RGBA_Color));
symb_name = G_malloc(sizeof(char) * strlen(buff) + 1); /* well, it won't be any bigger than this */
line_color_str = G_malloc(sizeof(char) * strlen(buff) + 1);
fill_color_str = G_malloc(sizeof(char) * strlen(buff) + 1);
G_debug(3, "do_symbol() [%s]", buff);
/* set default colors so colors are optional */
strcpy(line_color_str, DEFAULT_FG_COLOR);
strcpy(fill_color_str, "grey");
if (sscanf
(buff, "%*s %s %d %lf %lf %s %s", symb_name, &size, &xper, &yper,
line_color_str, fill_color_str) < 4) {
G_warning(_("Problem parsing command [%s]"), buff);
return (-1);
}
if (mapunits) {
ix = (int)(D_u_to_d_col(xper) + 0.5);
iy = (int)(D_u_to_d_row(yper) + 0.5);
/* consider size in map units too? maybe as percentage of display?
perhaps use "size * D_get_u_to_d_yconv()" to convert */
}
else {
if (xper < 0. || yper < 0. || xper > 100. || yper > 100.)
return (-1);
ix = l + (int)(xper * xincr);
iy = b - (int)(yper * yincr);
}
/* parse line color */
ret = G_str_to_color(line_color_str, &R, &G, &B);
line_color->r = (unsigned char)R;
line_color->g = (unsigned char)G;
line_color->b = (unsigned char)B;
if (ret == 1) {
/* here alpha is only used as an on/off switch, otherwise unused by the display drivers */
line_color->a = RGBA_COLOR_OPAQUE;
}
else if (ret == 2)
line_color->a = RGBA_COLOR_NONE;
else {
G_warning(_("[%s]: No such color"), line_color_str);
return (-1);
}
/* parse fill color */
ret = G_str_to_color(fill_color_str, &R, &G, &B);
fill_color->r = (unsigned char)R;
fill_color->g = (unsigned char)G;
fill_color->b = (unsigned char)B;
if (ret == 1)
fill_color->a = RGBA_COLOR_OPAQUE;
else if (ret == 2)
fill_color->a = RGBA_COLOR_NONE;
else {
G_warning(_("[%s]: No such color"), fill_color_str);
return (-1);
}
Symb = S_read(symb_name);
if (Symb == NULL) {
G_warning(_("Cannot read symbol, cannot display points"));
return (-1);
}
else
S_stroke(Symb, size, rotation, 0);
D_symbol(Symb, ix, iy, line_color, fill_color);
/* restore previous d.graph draw color */
if (last_color.a == RGBA_COLOR_OPAQUE)
R_RGB_color(last_color.r, last_color.g, last_color.b);
else if (last_color.a == RGBA_COLOR_NONE)
D_raster_use_color(D_parse_color(DEFAULT_BG_COLOR, 0));
else /* unset or bad */
R_RGB_color(line_color->r, line_color->g, line_color->b);
G_free(symb_name);
G_free(line_color_str);
G_free(fill_color_str);
G_free(line_color);
G_free(fill_color);
return (0);
}
int move_line_update(void *closure, int sxn, int syn, int button)
{
struct move_line *ml = closure;
double x = D_d_to_u_col(sxn);
double y = D_d_to_u_row(syn);
G_debug(3, "button = %d x = %d = %f y = %d = %f", button, sxn, x, syn, y);
if (ml->last_line > 0) {
display_line(ml->last_line, SYMB_DEFAULT, 1);
}
if (button == 3)
return 1;
if (button == 1) { /* Select / new location */
int type;
if (ml->last_line == 0) { /* Select line */
ml->line =
Vect_find_line(&Map, x, y, 0, GV_POINT | GV_CENTROID,
ml->thresh, 0, 0);
G_debug(2, "point found = %d", ml->line);
if (ml->line == 0)
ml->line =
Vect_find_line(&Map, x, y, 0, GV_LINE | GV_BOUNDARY,
ml->thresh, 0, 0);
G_debug(2, "line found = %d", ml->line);
/* Display new selected line if any */
if (ml->line > 0) {
display_line(ml->line, SYMB_HIGHLIGHT, 1);
/* Find the nearest point on the line */
type = Vect_read_line(&Map, ml->Points, NULL, ml->line);
Vect_line_distance(ml->Points, x, y, 0, 0, &ml->xo, &ml->yo,
NULL, NULL, NULL, NULL);
set_location(D_u_to_d_col(ml->xo), D_u_to_d_row(ml->yo));
i_prompt_buttons(_("New location"), _("Unselect"), _("Quit tool"));
}
ml->last_line = ml->line;
}
else { /* Line is already selected */
int node1, node2;
int i;
display_line(ml->last_line, SYMB_BACKGROUND, 1);
Vect_get_line_nodes(&Map, ml->last_line, &node1, &node2);
display_node(node1, SYMB_BACKGROUND, 1);
display_node(node2, SYMB_BACKGROUND, 1);
type = Vect_read_line(&Map, ml->Points, ml->Cats, ml->last_line);
for (i = 0; i < ml->Points->n_points; i++) {
ml->Points->x[i] = ml->Points->x[i] + x - ml->xo;
ml->Points->y[i] = ml->Points->y[i] + y - ml->yo;
}
Vect_rewrite_line(&Map, ml->last_line, type, ml->Points,
ml->Cats);
updated_lines_and_nodes_erase_refresh_display();
ml->last_line = 0;
}
}
if (button == 2) { /* Unselect */
if (ml->last_line > 0) {
ml->last_line = 0;
}
}
if (ml->last_line == 0) {
i_prompt_buttons(_("Select"), "", _("Quit tool"));
set_mode(MOUSE_POINT);
}
else
set_mode(MOUSE_LINE);
return 0;
}
int edit_line_update(void *closure, int sxn, int syn, int button)
{
struct edit_line *el = closure;
double x = D_d_to_u_col(sxn);
double y = D_d_to_u_row(syn);
G_debug(3, "button = %d x = %d = %f y = %d = %f", button, sxn, x, syn, y);
if (button == 3) /* Tool broken by GUI */
return 1;
switch (el->phase) {
case 1:
if (button != 1)
return 0;
/* Find nearest point or line */
el->line =
Vect_find_line(&Map, x, y, 0, GV_LINE | GV_BOUNDARY, el->thresh,
0, 0);
G_debug(2, "line found = %d", el->line);
/* Display new selected line if any */
if (el->line > 0) {
display_line(el->line, SYMB_HIGHLIGHT, 1);
edit_line_phase2(el, x, y);
}
break;
case 2:
if (button == 1) { /* New point */
snap(&x, &y);
Vect_append_point(el->Points, x, y, 0);
if (el->line_type == GV_LINE)
symb_set_driver_color(SYMB_LINE);
else
symb_set_driver_color(SYMB_BOUNDARY_0);
display_points(el->Points, 1);
set_location(sxn, syn);
i_prompt_buttons(_("New Point"), _("Undo Last Point"), _("Close line"));
}
else if (button == 2) { /* Undo last point */
if (el->Points->n_points > 1) {
symb_set_driver_color(SYMB_BACKGROUND);
display_points(el->Points, 1);
el->Points->n_points--;
if (el->line_type == GV_LINE)
symb_set_driver_color(SYMB_LINE);
else
symb_set_driver_color(SYMB_BOUNDARY_0);
display_points(el->Points, 1);
set_location(D_u_to_d_col
(el->Points->x[el->Points->n_points - 1]),
D_u_to_d_row(el->Points->
y[el->Points->n_points - 1])
);
if (el->Points->n_points == 1)
i_prompt_buttons(_("New Point"), "", _("Delete line and exit"));
}
}
break;
}
return 0;
}
int new_line_update(void *closure, int sxn, int syn, int button)
{
struct new_line *nl = closure;
double x = D_d_to_u_col(sxn);
double y = D_d_to_u_row(syn);
double dist;
G_debug(3, "button = %d x = %d = %f y = %d = %f", button, sxn, x, syn, y);
if (nl->first && button == 3) { /* Quit tool ( points & lines ), first is always for points */
Tool_next = TOOL_NOTHING;
return 1;
}
if (button > 3) /* Do nothing on mouse scroll */
return 0;
if (nl->type & GV_POINTS && (button == 1 || button == 2)) {
snap(&x, &y);
Vect_append_point(nl->Points, x, y, 0);
write_line(&Map, nl->type, nl->Points);
updated_lines_and_nodes_erase_refresh_display();
return 1;
}
else { /* GV_LINES */
/* Button may be 1,2,3 */
if (button == 1) { /* New point */
if (snap(&x, &y) == 0) {
/* If not snapping to other features, try to snap to lines start.
* Allows to create area of single boundary. */
if (nl->Points->n_points > 2) {
dist = Vect_points_distance(nl->Points->x[0], nl->Points->y[0], 0, x, y, 0, WITHOUT_Z);
if (dist < get_thresh()) {
x = nl->Points->x[0];
y = nl->Points->y[0];
}
}
}
if (Vect_append_point(nl->Points, x, y, 0) == -1) {
G_warning(_("Out of memory! Point not added."));
return 0;
}
if (nl->type == GV_LINE)
symb_set_driver_color(SYMB_LINE);
else
symb_set_driver_color(SYMB_BOUNDARY_0);
display_points(nl->Points, 1);
set_location(D_u_to_d_col(x), D_u_to_d_row(y));
nl->first = 0;
set_mode(MOUSE_LINE);
}
else if (button == 2) { /* Undo last point */
if (nl->Points->n_points >= 1) {
symb_set_driver_color(SYMB_BACKGROUND);
display_points(nl->Points, 1);
nl->Points->n_points--;
if (nl->type == GV_LINE)
symb_set_driver_color(SYMB_LINE);
else
symb_set_driver_color(SYMB_BOUNDARY_0);
display_points(nl->Points, 1);
set_location(D_u_to_d_col
(nl->Points->x[nl->Points->n_points - 1]),
D_u_to_d_row(nl->Points->
y[nl->Points->n_points - 1])
);
}
if (nl->Points->n_points == 0) {
i_prompt_buttons(_("New point"), "", _("Quit tool"));
nl->first = 1;
set_mode(MOUSE_POINT);
}
}
else if (button == 3) { /* write the line and quit */
if (nl->Points->n_points > 1) {
/* Before the line is written, we must check if connected to existing nodes, if yes,
* such nodes must be add to update list before! the line is written (areas/isles */
int node1 =
Vect_find_node(&Map, nl->Points->x[0], nl->Points->y[0],
nl->Points->z[0], 0, Vect_is_3d(&Map));
int i = nl->Points->n_points - 1;
int node2 =
Vect_find_node(&Map, nl->Points->x[i], nl->Points->y[i],
nl->Points->z[i], 0, Vect_is_3d(&Map));
G_debug(2, " old node1 = %d old node2 = %d", node1, node2);
write_line(&Map, nl->type, nl->Points);
updated_lines_and_nodes_erase_refresh_display();
}
else
G_warning(_("Less than 2 points for line -> nothing written"));
return 1;
}
G_debug(2, "n_points = %d", nl->Points->n_points);
}
i_prompt_buttons(_("New point"), _("Undo last point"), _("Close line"));
return 0;
}
