OpenQNX :: The QNX Community Portal

A gray scale image is to be displayed with feature-related lines
overlaid later. The current approach to the initial display is as
follows:
* determine image size,
* call PhCreateImage(ph_image, ...) to obtain managed space (at
ph_image->image)
* copy the byte-per-pixel image into ph_image->image
* set the region id (which points to a PtLabel of "image"
type)
* call PgDrawPhImage()

This works fine: the window containing the PtLabel with the image can
return to the foreground with the image intact. The flags in ph_image
structure are set to release the image and masks. I don't know
exactly when this happens. But a redraw with a new,
differently-sized image results in a flawless appearance -- no code
needed to "paint over" what would have been artifacts of
the previous image.

The next part is not so good. The lines of interest (sets of end
points) are returned from a separate process then transformed into
screen coordinates. In the first trial, lines were copied into the
widget coordinates using PgDrawLine() and the end points. The lines
look good, but when the parent window is returned to the foreground,
the overlaid lines are not there. I sort of understand this. I used
a low-level draw function and the resultant pixels are not managed
like the image-bearing widget.

Trial number two attempted to build lines in ph_image->image by
using the end points and pixels interpolated between them. I assumed
that I could modify points in ph_image->image then invoke
PhDrawPhImage() and one of the "flush" functions to refresh
the image. But what I get is a dead Photon process! (Perhaps the
call to PhDrawPhImage results in the release of all the ph_image
pointers and storage.)

Boil all this down my main questions are these:
* How to display one PhImage then modify it later?
* How to use line drawing functions to do this?
* Where is documentation about draw contexts?
* Can one use other low-level draw functions with PhImag_t types.

My best guess: build an entirely new image using the same original
array but insert the lines then call
PhDrawPhImage().

Boil all this down my main questions are these:
* How to display one PhImage then modify it later?

* How to use line drawing functions to do this?

* Where is documentation about draw contexts?

* Can one use other low-level draw functions with PhImag_t types.

My best guess: build an entirely new image using the same original
array but insert the lines then call
PhDrawPhImage().

Rodney,

Thanks for your input. Earlier, I did look at the documentation for
PtRaw widget but, being simpled-minded and lazy, I was hoping for a
quick and easy solution. Now it looks like I will have to actually
think to implement the two-phase drawing.

My single draw function to PtRaw will have to supply both a 2D image
and a list of lines. When the image is previewed, only the image
argument will be non-null. A bit later, when the line data arrives,
the draw function will also have end point pairs (and colors, etc.)
for PgDrawLine to use. This, I hope, will produce a widget that,
when reappearing in the foreground, will retain both the image and
the overlaid lines.

Thanks again...