[GRASS5] g51 v.digit

Hi,

I started update of v.digit. Currently almost nothing -
only one tool "new line" exists. But because I modified rasterlib
for this purpose, I would welcome if others, who know more about
xdriver, could look at it and comment or improve.

As I wanted to enable GUI to break running tools and change parameters
when tool is running, I added function R_set_update_function ()
which sets pointer to function which is regularly called by
running R_get_location_with_pointer/line(). Such function
can break running R_get_location_with* by calling R_set_cancel(1)

Tools in v.digit are started by loop in C part and GUI only sets
variable to the next tool it wants to start.

Driver is opened/closed for each tool. That enables to resize xdriver
and run other modules while v.digit is runnig but introduces new problems.
I don't know how to get information if xdriver was resized etc.

http://mpa.itc.it/radim/g51/v.digit1.png

Sorry Glynn, I must commit first, otherwise you would tell me, that it
is just hack, and I should wait for a new display architecture. But I cannot
wait 5-10 years :slight_smile:

Radim

Radim Blazek wrote:

I started update of v.digit. Currently almost nothing -
only one tool "new line" exists. But because I modified rasterlib
for this purpose, I would welcome if others, who know more about
xdriver, could look at it and comment or improve.

As I wanted to enable GUI to break running tools and change parameters
when tool is running, I added function R_set_update_function ()
which sets pointer to function which is regularly called by
running R_get_location_with_pointer/line(). Such function
can break running R_get_location_with* by calling R_set_cancel(1)

Tools in v.digit are started by loop in C part and GUI only sets
variable to the next tool it wants to start.

Driver is opened/closed for each tool. That enables to resize xdriver
and run other modules while v.digit is runnig but introduces new problems.
I don't know how to get information if xdriver was resized etc.

http://mpa.itc.it/radim/g51/v.digit1.png

Sorry Glynn, I must commit first, otherwise you would tell me, that it
is just hack, and I should wait for a new display architecture. But I cannot
wait 5-10 years :slight_smile:

It *is* just a hack. But you don't need to wait 5-10 years. Removing
the R_get_location_with* stuff altogether shouldn't take more than
5-10 minutes.

And removing it *is* the right solution for the monitor API. For
v.digit, the right solution is to use a real UI toolkit. Trying to
build something like v.digit on top of R_get_location_with* is a
mistake.

Of all of the possibilities which I've considered for a future display
architecture, none of them deal with input in any way; it's meant to
be a *display* architecture.

In short, modal input sucks. Big time. Every real-world UI toolkit
which I've ever seen uses a single main loop which reads events and
dispatches them to application-registered callbacks.

For trivial cases such as d.measure or "d.legend -m" you can just
about get away with it. For complex applications such as v.digit or
d.display, it just doesn't make sense.

--
Glynn Clements <glynn.clements@virgin.net>

On Wednesday 09 October 2002 08:04 pm, Glynn Clements wrote:

It *is* just a hack. But you don't need to wait 5-10 years. Removing
the R_get_location_with* stuff altogether shouldn't take more than
5-10 minutes.

And removing it *is* the right solution for the monitor API. For
v.digit, the right solution is to use a real UI toolkit. Trying to
build something like v.digit on top of R_get_location_with* is a
mistake.

Which portable UI toolkit is or should be used for GRASS?

Of all of the possibilities which I've considered for a future display
architecture, none of them deal with input in any way; it's meant to
be a *display* architecture.

Do you mean different systems for display and v.digit? So that if I have
displayed map and discover that I need to edit it, I have to start
some other application with new display? That is not good from user point
of view. It must be one system built on UI toolkit and that is what we have
to wait for 5 years.

Radim

Radim Blazek wrote:

> It *is* just a hack. But you don't need to wait 5-10 years. Removing
> the R_get_location_with* stuff altogether shouldn't take more than
> 5-10 minutes.
>
> And removing it *is* the right solution for the monitor API. For
> v.digit, the right solution is to use a real UI toolkit. Trying to
> build something like v.digit on top of R_get_location_with* is a
> mistake.

Which portable UI toolkit is or should be used for GRASS?

Will Tk not suffice?

I'm hesitant to suggest wxWindows due to its use of C++, although
having C++ calling C is usually less problematic than the reverse.

> Of all of the possibilities which I've considered for a future display
> architecture, none of them deal with input in any way; it's meant to
> be a *display* architecture.

Do you mean different systems for display and v.digit?

No, I mean that the display system only handles display, not input.
Much the same way that e.g. OpenGL and Display PostScript only deal
with display, not input.

Programs which need user input would use the display mechanism for
display, and handle the input themselves.

So that if I have
displayed map and discover that I need to edit it, I have to start
some other application with new display? That is not good from user point
of view. It must be one system built on UI toolkit and that is what we have
to wait for 5 years.

This problem already exists. The only real solution is an overall user
interface solution (tcltkgrass doesn't really cut it), which is
inherently a hard problem.

--
Glynn Clements <glynn.clements@virgin.net>

Glynn Clements writes:
> This problem already exists. The only real solution is an overall user
> interface solution (tcltkgrass doesn't really cut it), which is
> inherently a hard problem.

What about stealing bunches of code? The gimp already displays
bitmaps, and has code to operate on bitmaps. Seems to me that it
already does most of what is expected, with one obvious exception:
coordinate systems. And the gimp already runs on Windows, so that
with ordinary care to preserve the existing portability, no
portability would be lost.

--
-russ nelson http://russnelson.com |
Crynwr sells support for free software | PGPok | businesses persuade
521 Pleasant Valley Rd. | +1 315 268 1925 voice | governments coerce
Potsdam, NY 13676-3213 | +1 315 268 9201 FAX |

Russell Nelson wrote:

> This problem already exists. The only real solution is an overall user
> interface solution (tcltkgrass doesn't really cut it), which is
> inherently a hard problem.

What about stealing bunches of code? The gimp already displays
bitmaps, and has code to operate on bitmaps. Seems to me that it
already does most of what is expected, with one obvious exception:
coordinate systems. And the gimp already runs on Windows, so that
with ordinary care to preserve the existing portability, no
portability would be lost.

Well, the GTK+ FAQ says:

  1.10. Is there a Windows version of GTK+?
  
  There is an on going port of GTK+ to the Windows platform which is
  making impressive progress.
  
  See http://www.iki.fi/tml/gimp/win32 for more information.

However, that link is broken.

Note that we only need the UI stuff. GRASS itself, including XDRIVER,
already runs on Windows (without an X server).

Or we could just decide that you need an X server on any platform
(this is already the case for NVIZ and tcltkgrass), in which case any
Unix/X11 toolkit would suffice.

--
Glynn Clements <glynn.clements@virgin.net>

Glynn Clements writes:
> 1.10. Is there a Windows version of GTK+?
>
> There is an on going port of GTK+ to the Windows platform which is
> making impressive progress.

Apparently it's made a lot of progress, because my son runs the gimp
on his Windows 98 machine.

> Note that we only need the UI stuff. GRASS itself, including XDRIVER,
> already runs on Windows (without an X server).

Right.

--
-russ nelson http://russnelson.com |
Crynwr sells support for free software | PGPok | businesses persuade
521 Pleasant Valley Rd. | +1 315 268 1925 voice | governments coerce
Potsdam, NY 13676-3213 | +1 315 268 9201 FAX |

Russell Nelson wrote:

> > This problem already exists. The only real solution is an overall user
> > interface solution (tcltkgrass doesn't really cut it), which is
> > inherently a hard problem.
>
> What about stealing bunches of code? The gimp already displays
> bitmaps, and has code to operate on bitmaps. Seems to me that it
> already does most of what is expected, with one obvious exception:
> coordinate systems. And the gimp already runs on Windows, so that
> with ordinary care to preserve the existing portability, no
> portability would be lost.

Well, the GTK+ FAQ says:

  1.10. Is there a Windows version of GTK+?
  
  There is an on going port of GTK+ to the Windows platform which is
  making impressive progress.
  
  See http://www.iki.fi/tml/gimp/win32 for more information.

However, that link is broken.

This link is obsolete as gtk+ (which also provides hooks for OpenGL/Mesa
DND and a lot of other fancy stuff) already supports win32 internal
The last changes regarding gtk+ && win32 were made 2002-10-07 on the
gtk+/gimp/gnome cvs

Or we could just decide that you need an X server on any platform
(this is already the case for NVIZ and tcltkgrass), in which case any
Unix/X11 toolkit would suffice.

In that case why not really drop tcltk and NVIZ Display routines altogether
and have a generic output API so everyone could choose the GUI he prefers
(I really like gtk+ as I was (small) part of it's evolution connected with
"The Gimp" some time back and use it more or less once every week for tooling)

(I really like tcltk for most not computing intensive apps but GRASS becomes
more and more intensive with regards to on screen display capabilities)

I really would like to join a task force for the implementation of
a) a Generic Display API (GAPI)
b) the gtk+ Display System (GDS)
  e.g. it may be possible to revamp some NVIZ togl code for
  GDS

What I personally don't want to see is some kind of monster application
that needs 5 minutes to start just to change location
so we should keep the console based variants as well (grass scripting
is really fun and beats most of the commercial click-ware interfaces
both in routine (production) and experimental work)

It should be more like the tcltkgrass toolbar with plugins/modules
for each grass command

like d.rast,v,rast,d.dm,nviz,d.* etc -> main display routine
with helper plugins/modules for typical console work

(just to keep the single system feeling)

This approach would also allow for gradual implementation
(perhaps 1 module/per week without the major display routine
that covers the d.* commands that would take about 1-2 month of development)

I better stop now or I might just code the following night away;-)

Anyone else willing to join that task force?

kind regards,
Christoph

--
Glynn Clements <glynn.clements@virgin.net>

Christoph Hoegl wrote:

I really would like to join a task force for the implementation of
a) a Generic Display API (GAPI)
b) the gtk+ Display System (GDS)
  e.g. it may be possible to revamp some NVIZ togl code for
  GDS

What I personally don't want to see is some kind of monster application
that needs 5 minutes to start just to change location
so we should keep the console based variants as well (grass scripting
is really fun and beats most of the commercial click-ware interfaces
both in routine (production) and experimental work)

It should be more like the tcltkgrass toolbar with plugins/modules
for each grass command

like d.rast,v,rast,d.dm,nviz,d.* etc -> main display routine
with helper plugins/modules for typical console work

(just to keep the single system feeling)

Output-only programs (i.e. most of the d.*) commands aren't really a
problem; they will fit into any architecture.

The complicated bit is handling user-interaction, e.g. v.digit,
d.measure, d.what.* etc (to me, d.display has already been dealt with
by the introduction of d.dm).

The current tools are based around modal input, which is basically
dead as a UI concept, and with good reason. While this may be easy to
modularise, the end result sucks from a usability perspective.

A monolithic application would be much more usable, but also more
limited (and potentially much more fragile). So, we're basically
looking for a UI with plug-ins. However, that's easier said than done;
designing a decent interface for interactive modules is *much* harder
than for "fire-and-forget" commands.

This approach would also allow for gradual implementation
(perhaps 1 module/per week without the major display routine
that covers the d.* commands that would take about 1-2 month of development)

I better stop now or I might just code the following night away;-)

The last thing that anyone should be doing in that area is coding.
That's how we got into this mess in the first place; too much of
GRASS' code was written without any consideration as to how it fits
into the whole.

Anyone else willing to join that task force?

A large part of the problem is that this isn't just a matter of
getting enough manpower. The problem is that the result needs to be
suitable for the purposes to which it will be put, and that requires
input from the people who are likely to make use of it.

And that takes time; the design will likely need to go through many
iterations of putting ideas on the table, getting feedback and
refining the ideas.

In the meantime, we are likely to be stuck with a situation where
highly interactive tasks (e.g. digitising) require dedicated
applications. Given that, I'm asking that people (in this instance,
Radim) choose a better UI framework than R_get_location_with_*().

--
Glynn Clements <glynn.clements@virgin.net>

On Thursday 10 October 2002 11:32 pm, Glynn Clements wrote:

A monolithic application would be much more usable, but also more
limited (and potentially much more fragile). So, we're basically
looking for a UI with plug-ins. However, that's easier said than done;
designing a decent interface for interactive modules is *much* harder
than for "fire-and-forget" commands.

The last thing that anyone should be doing in that area is coding.
That's how we got into this mess in the first place; too much of
GRASS' code was written without any consideration as to how it fits
into the whole.

But without coding we will never move forward. For years, reading
grass mailing list, I can see from time to time long discussions
about GUI for grass. Problem is that nobody started coding.

A large part of the problem is that this isn't just a matter of
getting enough manpower. The problem is that the result needs to be
suitable for the purposes to which it will be put, and that requires
input from the people who are likely to make use of it.

And that takes time; the design will likely need to go through many
iterations of putting ideas on the table, getting feedback and
refining the ideas.

Do you believe we can go through this without coding? Are user here GRASS
users or programmers of UI plugins?

In the meantime, we are likely to be stuck with a situation where
highly interactive tasks (e.g. digitising) require dedicated
applications. Given that, I'm asking that people (in this instance,
Radim) choose a better UI framework than R_get_location_with_*().

OK, what is that better framework? And, I cannot call some theoretical
framework functions. Currently nothing better than R_get_location_with_*
exists in GRASS, until somebody can give me something I have to use it.

But BTW, I don't think that most of code in v.digit will be related to UI.
If I want to break a line for example, I need to get one point from UI, but
then I have to rewrite lines, update topology status (not topology) of lines
and appropriately display. That is much more code and that is what I am
working on. I added GUI just because old text based interface is terribly
uneffective even for debugging.

BTW2, I need v.digit because it will be the best way to test/debug
level2 update in vector library. New GUI for GRASS (or v.digit) is not my
primal aim. That I left for others.

Radim

Christoph Hoegl wrote:

> I really would like to join a task force for the implementation of
> a) a Generic Display API (GAPI)
> b) the gtk+ Display System (GDS)
> e.g. it may be possible to revamp some NVIZ togl code for
> GDS
>
> What I personally don't want to see is some kind of monster application
> that needs 5 minutes to start just to change location
> so we should keep the console based variants as well (grass scripting
> is really fun and beats most of the commercial click-ware interfaces
> both in routine (production) and experimental work)
>
> It should be more like the tcltkgrass toolbar with plugins/modules
> for each grass command
>
> like d.rast,v,rast,d.dm,nviz,d.* etc -> main display routine
> with helper plugins/modules for typical console work
>
> (just to keep the single system feeling)

Output-only programs (i.e. most of the d.*) commands aren't really a
problem; they will fit into any architecture.

What about the case of the CELL and PNG drivers where you want to generate an image
I currently use a version of the PNG driver to do this and I wish to add features for
the display of vectors in other than single solid line (size, style etc).

John Preston
jpreston@uwimona.edu.jm

_______________________________________________
grass5 mailing list
grass5@grass.itc.it
http://grass.itc.it/mailman/listinfo/grass5

Radim Blazek wrote:

> A monolithic application would be much more usable, but also more
> limited (and potentially much more fragile). So, we're basically
> looking for a UI with plug-ins. However, that's easier said than done;
> designing a decent interface for interactive modules is *much* harder
> than for "fire-and-forget" commands.

> The last thing that anyone should be doing in that area is coding.
> That's how we got into this mess in the first place; too much of
> GRASS' code was written without any consideration as to how it fits
> into the whole.

But without coding we will never move forward. For years, reading
grass mailing list, I can see from time to time long discussions
about GUI for grass. Problem is that nobody started coding.

> A large part of the problem is that this isn't just a matter of
> getting enough manpower. The problem is that the result needs to be
> suitable for the purposes to which it will be put, and that requires
> input from the people who are likely to make use of it.

> And that takes time; the design will likely need to go through many
> iterations of putting ideas on the table, getting feedback and
> refining the ideas.

Do you believe we can go through this without coding? Are user here GRASS
users or programmers of UI plugins?

Regarding both of the above: coding only moves us forward if the end
result is actually usable. There isn't much difference between writing
code then discarding it and not writing it in the first place.

Coding is a necessary condition, but not a sufficient one. We need
code that is useful, not just any code.

> In the meantime, we are likely to be stuck with a situation where
> highly interactive tasks (e.g. digitising) require dedicated
> applications. Given that, I'm asking that people (in this instance,
> Radim) choose a better UI framework than R_get_location_with_*().

OK, what is that better framework? And, I cannot call some theoretical
framework functions. Currently nothing better than R_get_location_with_*
exists in GRASS, until somebody can give me something I have to use it.

GRASS doesn't include a database engine, but that hasn't prevented the
database modules from being written. Solution: use additional
components (in the database case, PostgreSQL or ODBC).

We already have some UI code: tcltkgrass, NVIZ and d.dm use Tcl/Tk;
xganim uses Motif. If the Windows port of GTK+ is sufficiently
advanced to run the GIMP, it's likely to suffice for anything that
GRASS might be needing to do; e.g. v.digit.

But BTW, I don't think that most of code in v.digit will be related to UI.
If I want to break a line for example, I need to get one point from UI, but
then I have to rewrite lines, update topology status (not topology) of lines
and appropriately display. That is much more code and that is what I am
working on. I added GUI just because old text based interface is terribly
uneffective even for debugging.

BTW2, I need v.digit because it will be the best way to test/debug
level2 update in vector library. New GUI for GRASS (or v.digit) is not my
primal aim. That I left for others.

The problem is that yet-another-hack was added to the monitor API.
R_get_location_with_* aren't suitable for anything beyond the most
trivial of uses, and are out of place in what's basically an output
API. IMHO, they should be removed, not expanded.

Adding a motion callback sounds suspiciously like a move in the
direction of the event/callback model which is the norm for all modern
UI toolkits. In which case, why not use such a toolkit instead of
turning XDRIVER into an X server and libraster into Xlib? Because
that's basically what lies at the end of the slippery slope on which
these changes are a start.

--
Glynn Clements <glynn.clements@virgin.net>

John A. Preston wrote:

> > I really would like to join a task force for the implementation of
> > a) a Generic Display API (GAPI)
> > b) the gtk+ Display System (GDS)
> > e.g. it may be possible to revamp some NVIZ togl code for
> > GDS
> >
> > What I personally don't want to see is some kind of monster application
> > that needs 5 minutes to start just to change location
> > so we should keep the console based variants as well (grass scripting
> > is really fun and beats most of the commercial click-ware interfaces
> > both in routine (production) and experimental work)
> >
> > It should be more like the tcltkgrass toolbar with plugins/modules
> > for each grass command
> >
> > like d.rast,v,rast,d.dm,nviz,d.* etc -> main display routine
> > with helper plugins/modules for typical console work
> >
> > (just to keep the single system feeling)
>
> Output-only programs (i.e. most of the d.*) commands aren't really a
> problem; they will fit into any architecture.

What about the case of the CELL and PNG drivers where you want to
generate an image?

What about it? I don't really understand the question.

I currently use a version of the PNG driver to do
this and I wish to add features for the display of vectors in other
than single solid line (size, style etc).

The PNG driver relies upon the GD library, which doesn't support
"thick" lines. More generally, allowing thick lines introduces a lot
of issues which don't apply to thin lines, e.g. corner and end styles
(round, butt, mitred) and whether/how those styles apply to dashed
lines etc.

That's part of the reason for my initial preference for PostScript. It
has a high level of functionality and can be used for display,
hardcopy and image output. The down side is that there is some
functionality which is available in display/image drawing APIs which
can't be implemented in PostScript due to the write-only framebuffer.

Most graphics APIs follow a similar pattern; a set of drawing
primitives, plus a set of parameters which modify the effect of
drawing primitives. The overall nature of the APIs doesn't differ
much.

Provided that the underlying graphics API provided the necessary
functionality, it wouldn't be particularly difficult to add more
functions to the raster library (e.g. R_set_line_width()).

--
Glynn Clements <glynn.clements@virgin.net>

Hi,
Actually the GD library does support thick lines with various styles which
I have modified d.vect to use. However the issue of the
style of the joints is not handled and GRASS itself
does not seem to optimise the output of vector display points to the
driver.

Currently I see where to draw a line from point A to point B
GRASS sends all the coordinates of the points that make up the line.
However all these points are in a lot of cases 1 pixel apart and thus to
implement a line style scheme I would have to drop various
consecutive points while displaying the others. I don't find
this particularly scalable, and was wondering whether
the move to change the drawing API would address this case.

Also as most of my work with GRASS involves creating images
for remote display or hardcopy I wanted to find out whether the
new API for the drawing functions would work well for these cases.

--
John Preston <jpreston@uwimona.edu.jm>

John A. Preston wrote:

Actually the GD library does support thick lines with various styles which
I have modified d.vect to use.

OK. I was looking for something that mentioned "line", "width" or
"thickness"; gdImageSetBrush() didn't register. That won't play nicely
with dashed lines, though (i.e. the result will be significantly
different to how other graphics APIs handle thick, dashed lines).

However the issue of the
style of the joints is not handled and GRASS itself
does not seem to optimise the output of vector display points to the
driver.

Currently I see where to draw a line from point A to point B
GRASS sends all the coordinates of the points that make up the line.

This doesn't appear to be a driver issue. Each call to
R_cont_{abs,rel} should result in a single call to gdImageLine()
within the PNG driver.

However, I don't think that e.g. d.vect will attempt to "optimise"
paths, i.e. merge adjacent colinear segments into a single line. So,
if the actual vector map is comprised of many small segments, that's
the way that it will get drawn.

However all these points are in a lot of cases 1 pixel apart and thus to
implement a line style scheme I would have to drop various
consecutive points while displaying the others. I don't find
this particularly scalable, and was wondering whether
the move to change the drawing API would address this case.

Also as most of my work with GRASS involves creating images
for remote display or hardcopy I wanted to find out whether the
new API for the drawing functions would work well for these cases.

The new API is currently at the drawing board stage.

My preference would be a framework, within which individual modules
would be free to generate arbitrary PostScript objects (in the sense
of %%BeginObject/%%EndObject). Others may have different views, and
I'm open to suggestions.

However, I am keen to ensure that hardcopy is well supported (which
basically boils down to ruling out anything which involves explicit
rasterisation, "pixel" coordinates, or "thin" lines).

--
Glynn Clements <glynn.clements@virgin.net>

This doesn't appear to be a driver issue. Each call to
R_cont_{abs,rel} should result in a single call to gdImageLine()
within the PNG driver.

However, I don't think that e.g. d.vect will attempt to "optimise"
paths, i.e. merge adjacent colinear segments into a single line. So,
if the actual vector map is comprised of many small segments, that's
the way that it will get drawn.

But I think that some component of the display architecture should have
this to be able to provide good quality output .

The new API is currently at the drawing board stage.

My preference would be a framework, within which individual modules
would be free to generate arbitrary PostScript objects (in the sense
of %%BeginObject/%%EndObject). Others may have different views, and
I'm open to suggestions.

I like that. Would it be possible to include the capabiity of merging adajacent segments
somewhere here?

However, I am keen to ensure that hardcopy is well supported (which
basically boils down to ruling out anything which involves explicit
rasterisation, "pixel" coordinates, or "thin" lines).

I agree.

--
John Preston <jpreston@uwimona.edu.jm>

John A. Preston wrote:

> This doesn't appear to be a driver issue. Each call to
> R_cont_{abs,rel} should result in a single call to gdImageLine()
> within the PNG driver.
>
> However, I don't think that e.g. d.vect will attempt to "optimise"
> paths, i.e. merge adjacent colinear segments into a single line. So,
> if the actual vector map is comprised of many small segments, that's
> the way that it will get drawn.

But I think that some component of the display architecture should have
this to be able to provide good quality output .

For most graphics APIs, it wouldn't make any difference to the
quality, although it might make a difference to the performance.

AFAICT, the problem which you are reporting is specific to the way
that GD handles line drawing. Most "real" graphics APIs support
drawing "polylines" in such a way that properties such as the dash
phase carry over between line segments, so it wouldn't make any
difference.

> The new API is currently at the drawing board stage.
>
> My preference would be a framework, within which individual modules
> would be free to generate arbitrary PostScript objects (in the sense
> of %%BeginObject/%%EndObject). Others may have different views, and
> I'm open to suggestions.

I like that. Would it be possible to include the capabiity of merging adajacent segments
somewhere here?

Well, you could add such an option to d.vect easily enough; that
wouldn't depend upon any particular graphics API.

The main problem is that such a feature would have to be under user
control, particularly if you start supporting vector formats such as
PostScript. Two line segments may appear colinear on a 75 DPI screen
but have a distinct corner on a 600 DPI hardcopy.

--
Glynn Clements <glynn.clements@virgin.net>

On Friday 11 October 2002 07:45 pm, Glynn Clements wrote:

Regarding both of the above: coding only moves us forward if the end
result is actually usable. There isn't much difference between writing
code then discarding it and not writing it in the first place.

Coding is a necessary condition, but not a sufficient one. We need
code that is useful, not just any code.

Do you believe, that we can design it first without mistakes? I expect that
some code will be written and thrown away later. To learn what we should not
do is almost of the same value as to know what we should do.

GRASS doesn't include a database engine, but that hasn't prevented the
database modules from being written. Solution: use additional
components (in the database case, PostgreSQL or ODBC).

*.pg and db.* modules are quite different. db.* modules are based on DBMI
library which is in fact such DB engine. What I don't want to do is
to write v.digit in style of *.pg. I am waiting for GUI equivalent
of DBMI.

The problem is that yet-another-hack was added to the monitor API.
R_get_location_with_* aren't suitable for anything beyond the most
trivial of uses, and are out of place in what's basically an output
API. IMHO, they should be removed, not expanded.

OK, we can consider it to be a hack which is planned to be replaced
by new GUI.

Radim

On Monday 14 October 2002 09:22 pm, Glynn Clements wrote:

My preference would be a framework, within which individual modules
would be free to generate arbitrary PostScript objects (in the sense
of %%BeginObject/%%EndObject). Others may have different views, and
I'm open to suggestions.

PostScript is and always will be slow. We cannot use it for interactive
display.

Radim