void
reset_cursor(void)
{
if (active_cursor != cur_cursor) {
active_cursor = cur_cursor;
XDefineCursor(tool_d, main_canvas, cur_cursor);
app_flush();
}
}
void
set_temp_cursor(Cursor cursor)
{
if (active_cursor != cursor) {
active_cursor = cursor;
XDefineCursor(tool_d, main_canvas, cursor);
app_flush();
}
}
void
do_print_batch(Widget w)
{
FILE *infp,*outfp;
char tmp_exp_file[PATH_MAX];
char str[255];
char backgrnd[10], grid[80];
int fd;
if (writing_batch || emptyfigure_msg(print_msg))
return;
/* set lock so we don't come here while still writing a file */
/* this could happen if the user presses the button too fast */
writing_batch = True;
/* make a temporary name to write this figure to */
snprintf(tmp_exp_file, sizeof(tmp_exp_file), "%s/xfig-exp.XXXXXX",
TMPDIR);
if (batch_exists != True) {
/* make a temporary name to write the batch stuff to */
sprintf(batch_file, "%s/xfig-batch.XXXXXX", TMPDIR);
if ((fd = mkstemp(batch_file)) == -1) {
file_msg("Error creating temporary file");
return;
}
close(fd);
batch_exists = True;
}
if (!print_popup)
create_print_panel(w);
/* get magnification into appres.magnification */
get_magnif();
/* update the figure size (magnification * bounding_box) */
print_update_figure_size();
/* make a #rrggbb string from the background color */
make_rgb_string(export_background_color, backgrnd);
if ((fd = mkstemp(tmp_exp_file)) == -1) {
file_msg("Error creating temporary file");
return;
}
close(fd);
/* get grid params and assemble into fig2dev parm */
get_grid_spec(grid, print_grid_minor_text, print_grid_major_text);
print_to_file(tmp_exp_file, "ps", appres.magnification, 0, 0, backgrnd,
NULL, False, print_all_layers, bound_active_layers, 0, False, grid, appres.overlap);
put_msg("Appending to batch file \"%s\" (%s mode) ... done",
batch_file, appres.landscape ? "LANDSCAPE" : "PORTRAIT");
app_flush(); /* make sure message gets displayed */
/* now append that to the batch file */
if ((infp = fopen(tmp_exp_file, "rb")) == NULL) {
file_msg("Error during PRINT - can't open temporary file to read");
return;
}
if ((outfp = fopen(batch_file, "ab")) == NULL) {
file_msg("Error during PRINT - can't open print file to append");
return;
}
while (fgets(str,255,infp) != NULL)
(void) fputs(str,outfp);
fclose(infp);
fclose(outfp);
unlink(tmp_exp_file);
/* count this batch figure */
num_batch_figures++ ;
/* and update the label widget */
update_batch_count();
/* we're done */
writing_batch = False;
}
Boolean
captureImage(Widget window, char *filename) /* returns True on success */
{
unsigned char Red[MAX_COLORMAP_SIZE],
Green[MAX_COLORMAP_SIZE],
Blue[MAX_COLORMAP_SIZE];
int numcols;
int captured;
int width, height;
Boolean status;
FILE *pngfile;
int type;
if (!ok_to_write(filename, "EXPORT") )
return(False);
/* unmap the xfig windows, capture a png then remap our windows */
XtUnmapWidget(tool);
XtUnmapWidget(window);
app_flush();
/* capture the screen area */
status = getImageData(&width, &height, &type, &numcols, Red, Green, Blue);
/* make sure server is ungrabbed if we're debugging */
app_flush();
/* map our windows again */
XtMapWidget(tool);
XtMapWidget(window);
if ( status == False ) {
put_msg("Nothing Captured.");
app_flush();
captured = False;
} else {
/* encode the image and write to the file */
put_msg("Writing screenshot to PNG file...");
app_flush();
if ((pngfile = fopen(filename,"wb"))==0) {
file_msg("Cannot open PNG file %s for writing",filename);
put_msg("Cannot open PNG file %s for writing",filename);
captured = False;
} else {
/* write the png file */
if (!write_png(pngfile, data, type, Red, Green, Blue, numcols, width, height))
file_msg("Problem writing PNG file from screen capture");
fclose(pngfile);
captured = True;
}
free(data);
}
return ( captured );
}
void remap_imagecolors(void)
{
int i;
/* if monochrome, return */
if (tool_cells <= 2 || appres.monochrome)
return;
npixels = 0;
/* first see if there are enough colorcells for all image colors */
usenet = False;
/* see if the total number of colors will fit without using the neural net */
ncolors = count_colors();
if (ncolors == 0)
return;
put_msg(REMAP_MSG);
set_temp_cursor(wait_cursor);
app_flush();
if (ncolors > appres.max_image_colors) {
if (appres.DEBUG)
fprintf(stderr,"More colors (%d) than allowed (%d), using neural net\n",
ncolors,appres.max_image_colors);
ncolors = appres.max_image_colors;
usenet = True;
}
/* if this is the first image, allocate the number of colorcells we need */
if (num_oldcolors != ncolors) {
if (num_oldcolors != -1) {
unsigned long pixels[MAX_USR_COLS];
for (i=0; i<num_oldcolors; i++)
pixels[i] = image_cells[i].pixel;
if (tool_vclass == PseudoColor)
XFreeColors(tool_d, tool_cm, pixels, num_oldcolors, 0);
}
alloc_imagecolors(ncolors);
/* hmm, we couldn't get that number of colors anyway; use the net, Luke */
if (ncolors > avail_image_cols) {
usenet = True;
if (appres.DEBUG)
fprintf(stderr,"More colors (%d) than available (%d), using neural net\n",
ncolors,avail_image_cols);
}
num_oldcolors = avail_image_cols;
if (avail_image_cols < 2 && ncolors >= 2) {
file_msg("Cannot allocate even 2 colors for pictures");
reset_cursor();
num_oldcolors = -1;
reset_cursor();
put_msg(REMAP_MSG2);
app_flush();
return;
}
}
reset_cursor();
if (usenet) {
int stat;
int mult = 1;
/* check if user pressed cancel button (in file preview) */
if (check_cancel())
return;
/* count total number of pixels in all the pictures */
npixels = count_pixels();
/* check if user pressed cancel button */
if (check_cancel())
return;
/* initialize the neural network */
/* -1 means can't alloc memory, -2 or more means must have that many times
as many pixels */
set_temp_cursor(wait_cursor);
if ((stat=neu_init(npixels)) <= -2) {
mult = -stat;
npixels *= mult;
/* try again with more pixels */
stat = neu_init2(npixels);
}
if (stat == -1) {
/* couldn't alloc memory for network */
fprintf(stderr,"Can't alloc memory for neural network\n");
reset_cursor();
put_msg(REMAP_MSG2);
app_flush();
return;
}
/* now add all pixels to the samples */
for (i=0; i<mult; i++)
add_all_pixels();
/* make a new colortable with the optimal colors */
avail_image_cols = neu_clrtab(avail_image_cols);
/* now change the color cells with the new colors */
/* clrtab[][] is the colormap produced by neu_clrtab */
for (i=0; i<avail_image_cols; i++) {
image_cells[i].red = (unsigned short) clrtab[i][N_RED] << 8;
image_cells[i].green = (unsigned short) clrtab[i][N_GRN] << 8;
image_cells[i].blue = (unsigned short) clrtab[i][N_BLU] << 8;
}
YStoreColors(tool_cm, image_cells, avail_image_cols);
reset_cursor();
/* check if user pressed cancel button */
if (check_cancel())
return;
/* get the new, mapped indices for the image colormap */
remap_image_colormap();
} else {
/*
* Extract the RGB values from the image's colormap and allocate
* the appropriate X colormap entries.
*/
scol = 0; /* global color counter */
set_temp_cursor(wait_cursor);
extract_cmap();
for (i=0; i<scol; i++) {
image_cells[i].flags = DoRed|DoGreen|DoBlue;
}
YStoreColors(tool_cm, image_cells, scol);
scol = 0; /* global color counter */
readjust_cmap();
if (appres.DEBUG)
fprintf(stderr,"Able to use %d colors without neural net\n",scol);
reset_cursor();
}
put_msg(REMAP_MSG2);
app_flush();
}
Boolean
MakeFileList(char *dir_name, char *mask, char ***dir_list, char ***file_list)
{
DIR *dirp;
DIRSTRUCT *dp;
char **cur_file, **cur_directory;
char **last_file, **last_dir;
int nmasks,i;
char *wild[MAX_MASKS],*cmask;
Boolean match;
set_temp_cursor(wait_cursor);
cur_file = filelist;
cur_directory = dirlist;
last_file = filelist + file_entry_cnt - 1;
last_dir = dirlist + dir_entry_cnt - 1;
dirp = opendir(dir_name);
if (dirp == NULL) {
reset_cursor();
*file_list = filelist;
*file_list[0]="";
*dir_list = dirlist;
*dir_list[0]="..";
return False;
}
/* process any events to ensure cursor is set to wait_cursor */
/*
* don't do this inside the following loop because this procedure could
* be re-entered if the user presses (e.g.) rescan
*/
app_flush();
/* make copy of mask */
cmask = my_strdup(mask);
if ((cmask == NULL) || (*cmask == '\0'))
strcpy(cmask,"*");
wild[0] = strtok(cmask," \t");
nmasks = 1;
while ((wild[nmasks]=strtok((char*) NULL, " \t")) && nmasks < MAX_MASKS)
nmasks++;
for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
/* skip over '.' (current dir) */
if (!strcmp(dp->d_name, "."))
continue;
/* if don't want to see the hidden files (beginning with ".") skip them */
if (!show_hidden && dp->d_name[0]=='.' && strcmp(dp->d_name,".."))
continue;
if (IsDirectory(dir_name, dp->d_name)) {
*cur_directory++ = my_strdup(dp->d_name);
if (cur_directory == last_dir) { /* out of space, make more */
dirlist = (char **) realloc(dirlist,
2 * dir_entry_cnt * sizeof(char *));
cur_directory = dirlist + dir_entry_cnt - 1;
dir_entry_cnt = 2 * dir_entry_cnt;
last_dir = dirlist + dir_entry_cnt - 1;
}
} else {
/* check if matches regular expression */
match=False;
for (i=0; i<nmasks; i++) {
if (wild_match(dp->d_name, wild[i])) {
int wild_match (char *string, char *pattern);
match = True;
break;
}
}
if (!match)
continue; /* no, do next */
if (wild[i][0] == '*' && dp->d_name[0] == '.')
continue; /* skip files with leading . */
*cur_file++ = my_strdup(dp->d_name);
if (cur_file == last_file) { /* out of space, make more */
filelist = (char **) realloc(filelist,
2 * file_entry_cnt * sizeof(char *));
cur_file = filelist + file_entry_cnt - 1;
file_entry_cnt = 2 * file_entry_cnt;
last_file = filelist + file_entry_cnt - 1;
}
}
}
*cur_file = NULL;
*cur_directory = NULL;
if (cur_file != filelist)
qsort(filelist, cur_file - filelist, sizeof(char *), (int(*)())SPComp);
if (cur_directory != dirlist)
qsort(dirlist, cur_directory - dirlist, sizeof(char *), (int(*)())SPComp);
*file_list = filelist;
*dir_list = dirlist;
reset_cursor();
closedir(dirp);
free(cmask); /* free copy of mask */
return True;
}
