/* f b _ Z o o m _ W i n d o w ( ) */
void
fb_Zoom_Window(void)
{
int xpos, ypos;
zoom = fb_getwidth( fbiop ) / grid_sz;
xpos = ypos = grid_sz / 2;
if ( tty )
prnt_Event( "Zooming..." );
if ( fb_zoom( fbiop, zoom, zoom ) == -1 )
bu_log( "Can not set zoom <%d,%d>.\n", zoom, zoom );
if ( x_fb_origin >= grid_sz )
xpos += x_fb_origin;
if ( y_fb_origin >= grid_sz )
ypos += y_fb_origin;
if ( tty )
prnt_Event( "Windowing..." );
if ( fb_viewport( fbiop, 0, 0, grid_sz, grid_sz ) == -1 )
bu_log( "Can not set viewport {<%d,%d>,<%d,%d>}.\n",
0, 0, grid_sz, grid_sz
);
if ( fb_window( fbiop, xpos, ypos ) == -1 )
bu_log( "Can not set window <%d,%d>.\n", xpos, ypos );
if ( tty )
prnt_Event( (char *) NULL );
return;
}
/*
Must be called after gridInit() so that gridsz is setup.
*/
int
openFbDevice(char *fbdev)
{
int ret = 1;
notify("Opening frame buffer", NOTIFY_APPEND);
if (zoom < 1) {
prntScr("Device is too small to display image.");
ret = 0;
goto safe_exit;
}
if (((fbiop != FBIO_NULL && fb_getwidth(fbiop) != devwid)
|| pixgrid == NULL)
&& (pixgrid = (unsigned char *) calloc(devwid*3, sizeof(unsigned char)))
== (unsigned char *) NULL) {
prntScr("Memory allocation of %d bytes failed.",
sizeof(unsigned char)*devwid);
ret = 0;
goto safe_exit;
}
(void) memset((char *) pixgrid, NUL, sizeof(unsigned char)*devwid*3);
if (fbiop != FBIO_NULL) {
if (! closFbDevice()) {
ret = 0;
goto safe_exit;
}
}
fbiop = fb_open(fbdev, devwid, devhgt);
if (fbiop == NULL) {
ret = 0;
goto safe_exit;
} else if (fb_clear(fbiop, pixblack) == -1
|| (notify("Zooming", NOTIFY_APPEND),
fb_zoom(fbiop, 1, 1) == -1)
|| (notify("Windowing", NOTIFY_DELETE),
fb_window(fbiop, devwid/2, devhgt/2) == -1)
) {
ret = 0;
goto safe_exit;
}
safe_exit : notify(NULL, NOTIFY_DELETE);
return ret;
}
static bool_t
display_Cells(long int ncells)
{
Cell *gp, *ep = &grid[ncells];
static int zoom;
unsigned char *buf;
static RGBpixel pixel;
double lasty = -INFINITY;
double dx, dy;
int y_0 = 0, y_1;
if (compute_fb_height) {
dy = ((ymax - ymin) / cell_size + 1.0) * (hgt + grid_flag);
if (compute_fb_height == SNUG_FIT)
fb_height = dy + (key_flag * 2 * hgt) + yorigin;
else if (dy > LORES) /* LOOSE_FIT */
fb_height = HIRES;
else
fb_height = LORES;
}
if (compute_fb_width) {
dx = ((xmax - xmin) / cell_size + 1.0) * (wid + grid_flag);
if (compute_fb_width == SNUG_FIT)
fb_width = dx + xorigin;
else if (dx > LORES) /* LOOSE_FIT */
fb_width = HIRES;
else
fb_width = LORES;
}
zoom = 1;
fbiop = fb_open((fbfile[0] != '\0') ? fbfile : NULL, fb_width, fb_height);
if (fbiop == FB_NULL)
return 0;
if (compute_fb_height || compute_fb_width) {
bu_log("fb_size requested: %d %d\n", fb_width, fb_height);
fb_width = fb_getwidth(fbiop);
fb_height = fb_getheight(fbiop);
bu_log("fb_size obtained: %d %d\n", fb_width, fb_height);
}
if (fb_wmap(fbiop, COLORMAP_NULL) == -1)
bu_log("Cannot initialize color map\n");
if (fb_zoom(fbiop, zoom, zoom) == -1)
bu_log("Cannot set zoom <%d, %d>\n", zoom, zoom);
if (erase_flag && fb_clear(fbiop, BACKGROUND) == -1)
bu_log("Cannot clear frame buffer\n");
buf = (unsigned char *) bu_malloc(sizeof(RGBpixel) * fb_width,
"line of frame buffer");
if (debug_flag & CFB_DBG_MEM)
bu_log("buf = %p... %d pixels @ %lu bytes/pixel\n",
(void *)buf, fb_width, sizeof(RGBpixel));
for (gp = grid; gp < ep; gp++) {
int x0, x1;
/* Whenever Y changes, write out row of cells. */
if (!ZERO(lasty - gp->c_y)) {
/* If first time, nothing to write out. */
if (!ZERO(lasty - INFINITY)) {
if (debug_flag & CFB_DBG_GRID)
bu_log("%g = V2SCRY(%g)\n", V2SCRY(lasty), lasty);
y_0 = V2SCRY(lasty);
if (y_0 >= 0 && y_0 < fb_height) {
for (y_1 = y_0 + hgt; y_0 < y_1; y_0++)
if (fb_write(fbiop, 0, y_0, buf, fb_width) == -1) {
bu_log("Couldn't write to <%d, %d>\n", 0, y_0);
(void) fb_close(fbiop);
return 0;
}
}
}
/* Clear buffer. */
for (x0 = 0; x0 < fb_width; x0++) {
COPYRGB(&buf[3*x0], BACKGROUND);
}
/* Draw grid line between rows of cells. */
if (grid_flag && !ZERO(lasty - INFINITY)) {
if (fb_write(fbiop, 0, y_0, buf, fb_width) == -1) {
bu_log("Couldn't write to <%d, %d>\n", 0, y_0);
(void) fb_close(fbiop);
return 0;
}
if (debug_flag & CFB_DBG_GRID)
bu_log("Writing grid row at %d\n", y_0);
}
lasty = gp->c_y;
}
val_To_RGB(gp->c_val, pixel);
/* Be careful only to write color within bounds of the screen */
x0 = H2SCRX(gp->c_x);
if (x0 >= 0 && x0 <= fb_width - wid) {
for (x1 = x0 + wid; x0 < x1; x0++) {
COPYRGB(&buf[3*x0], pixel);
}
}
}
/* Write out last row of cells. */
if (debug_flag & CFB_DBG_GRID)
bu_log("%g = V2SCRY(%g)\n", V2SCRY(lasty), lasty);
for (y_0 = V2SCRY(lasty), y_1 = y_0 + hgt; y_0 < y_1; y_0++)
if (fb_write(fbiop, 0, y_0, buf, fb_width) == -1) {
bu_log("Couldn't write to <%d, %d>\n", 0, y_0);
(void) fb_close(fbiop);
return 0;
}
/* Draw color key. */
if (key_flag && (fb_width < (10 + 1) * wid))
bu_log("Width of key (%d) would exceed frame-buffer width (%d)\n",
(10 + 1) * wid, fb_width);
else if (key_flag) {
int i, j;
double base;
int scr_min, scr_max;
int scr_center; /* screen coord of center of view */
int center_cell; /* cell # of center of view */
/* Clear buffer. */
for (i = 0; i < fb_width; i++) {
COPYRGB(&buf[3*i], BACKGROUND);
}
/* Center the color key from side-to-side in the viewport.
* Find screen coords of min and max vals, clip to (0, fb_width).
* If there are fewer than 11 cells, the run the key
* from the left edge to beyond the right edge.
*/
scr_min = H2SCRX(xmin);
scr_max = H2SCRX(xmax);
CLAMP(scr_min, 0, fb_width);
CLAMP(scr_max, 0, fb_width);
scr_center = (scr_max + scr_min)/2;
if ((center_cell = VPX2CX(SCRX2VPX(scr_center))) < 5)
center_cell = 5;
/* Draw 10 cells for the color key */
dom_cvt = 10.0;
for (i = 0; i <= 10; i++) {
cell_val cv;
/*
* Determine where to start the key,
* being careful not to back up beyond the beginning of buf.
*/
base = VPX2SCRX(CX2VPX(center_cell - 10/2 + i));
cv.v_scalar = i / 10.0;
val_To_RGB(cv, pixel);
for (j = 0; j < wid; j++) {
int idx = base + j;
COPYRGB(&buf[3*idx], pixel);
}
}
dom_cvt = 10.0 / (dom_max - dom_min);
for (i = yorigin; i < yorigin+hgt; i++)
if (fb_write(fbiop, 0, i, buf, fb_width) == -1) {
bu_log("Couldn't write to <%d, %d>\n", 0, i);
(void) fb_close(fbiop);
return 0;
}
}
(void) fb_close(fbiop);
bu_free((char *) buf, "line of frame buffer");
if (debug_flag & CFB_DBG_MEM)
bu_log("freed buf, which is now %p\n", (void *)buf);
return 1;
}
