int main(int argc, char **argv)
{
FILE *ifp;
pixel **pixels;
int rows, row, cols, col,
pal_len, i;
pixval maxval;
struct cmdlineInfo
cmdline;
unsigned char rgb[NUM_COLORS][3];
char ansi_code[NUM_COLORS][MAX_ANSI_STR_LEN];
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifp = pm_openr(cmdline.inputFilespec);
pixels = ppm_readppm(ifp, &cols, &rows, &maxval);
pm_close(ifp);
pal_len=generate_palette(rgb, ansi_code);
for (row = 0; row < rows; ++row) {
for (col = 0; col < cols; col++) {
pixval const r=(int)PPM_GETR(pixels[row][col])*255/maxval;
pixval const g=(int)PPM_GETG(pixels[row][col])*255/maxval;
pixval const b=(int)PPM_GETB(pixels[row][col])*255/maxval;
int val, dist;
/*
The following loop calculates the index that
corresponds to the minimum color distance
between the given RGB values and the values
available in the palette.
*/
for(i=0, dist=sqr(255)*3, val=0; i<pal_len; i++) {
pixval const pr=rgb[i][0];
pixval const pg=rgb[i][1];
pixval const pb=rgb[i][2];
unsigned int j;
if( (j=sqr(r-pr)+sqr(b-pb)+sqr(g-pg))<dist ) {
dist=j;
val=i;
}
}
printf("%s%c", ansi_code[val],0xB1);
}
printf(ESC"\x30m\n");
}
printf(ESC"\x30m");
ppm_freearray(pixels, rows);
exit(0);
}
int main(int argc, char *argv[])
{
#ifdef USEBMP
GSTEXTURE backtex;
#endif
GSTEXTURE fb;
GSGLOBAL *gsGlobal;
/* initialize dmaKit */
dmaKit_init(D_CTRL_RELE_OFF,D_CTRL_MFD_OFF, D_CTRL_STS_UNSPEC, D_CTRL_STD_OFF, D_CTRL_RCYC_8, 1 << DMA_CHANNEL_GIF);
dmaKit_chan_init(DMA_CHANNEL_GIF);
/* allocate GSGLOBAL structure */
gsGlobal = gsKit_init_global();
/* initialize screen */
gsGlobal->PSM = GS_PSM_CT24;
gsGlobal->ZBuffering = GS_SETTING_OFF; /* spare some vram */
// If we disable double buffering, we can't fill the frame fast enough.
// When this happens, we get a line through the top texture about 20% up
// from the bottom of the screen.
// gsGlobal->DoubleBuffering = GS_SETTING_OFF; /* only one screen */
gsKit_init_screen(gsGlobal);
gsKit_mode_switch(gsGlobal, GS_PERSISTENT);
fb.Width = 320;
fb.Height = 200;
fb.PSM = GS_PSM_T8;
fb.ClutPSM = GS_PSM_CT32;
fb.Mem = memalign(128, gsKit_texture_size_ee(fb.Width, fb.Height, fb.PSM));
fb.Clut = memalign(128, gsKit_texture_size_ee(16, 16, fb.ClutPSM));
fb.VramClut = gsKit_vram_alloc(gsGlobal, gsKit_texture_size(16, 16, fb.ClutPSM), GSKIT_ALLOC_USERBUFFER);
fb.Vram = gsKit_vram_alloc(gsGlobal, gsKit_texture_size(fb.Width, fb.Height, fb.PSM), GSKIT_ALLOC_USERBUFFER);
fb.Filter = GS_FILTER_LINEAR; /* enable bilinear filtering */
generate_palette(&fb);
#ifdef USEBMP
gsKit_texture_bmp(gsGlobal, &backtex, "host:bsdgirl.bmp");
#endif
/* print out useless debug information */
printf("CLUT Texture:\n");
printf("\tHost start: 0x%08x, end: 0x%08x\n", (unsigned)fb.Mem, (unsigned)(gsKit_texture_size_ee(fb.Width, fb.Height, fb.PSM) + fb.Mem));
printf("\tLocal start: 0x%08x, end: 0x%08x\n", (unsigned)fb.Vram, (unsigned)(gsKit_texture_size(fb.Width, fb.Height, fb.PSM) + fb.Vram));
printf("\tWidth - %d : Height - %d : TBW - %d : Page - %d : Block %d\n", fb.Width, fb.Height, fb.TBW, (fb.Vram / 8192), (fb.Vram / 256));
printf("CLUT Pallete:\n");
printf("\tHost start: 0x%08x, end: 0x%08x\n", (unsigned)fb.Clut, (unsigned)(gsKit_texture_size_ee(16, 16, GS_PSM_CT32) + fb.Clut));
printf("\tLocal start: 0x%08x, end: 0x%08x\n", (unsigned)fb.VramClut, (unsigned)(gsKit_texture_size(16, 16, GS_PSM_CT32) + fb.VramClut));
printf("\tWidth - %d : Height - %d : TBW - %d : Page - %d : Block %d\n", 16, 16, 1, (fb.VramClut / 8192), (fb.VramClut / 256));
#ifdef USEBMP
printf("BMP Texture:\n");
printf("\tHost start: 0x%08x, end: 0x%08x\n", (unsigned)backtex.Mem, (unsigned)(gsKit_texture_size_ee(backtex.Width, backtex.Height, backtex.PSM) + backtex.Mem));
printf("\tLocal start: 0x%08x, end: 0x%08x\n", (unsigned)backtex.Vram, (unsigned)(gsKit_texture_size(backtex.Width, backtex.Height, backtex.PSM) + backtex.Vram));
printf("\tWidth - %d : Height - %d : TBW - %d : Page - %d : Block %d\n", backtex.Width, backtex.Height, backtex.TBW, (backtex.Vram / 8192), (backtex.Vram / 256));
#endif
printf("VRAM Alignment Check - Value of \"0\" is OKAY! Anything else is BAD!\n");
printf("VRAM - CLUT Pallete - Start Address Aligned: %d\n", fb.VramClut % GS_VRAM_BLOCKSIZE_256);
printf("VRAM - CLUT Texture - Start Address Aligned: %d\n", fb.Vram % GS_VRAM_BLOCKSIZE_256);
#ifdef USEBMP
printf("VRAM - BMP Texture - Start Address Aligned: %d\n", backtex.Vram % GS_VRAM_BLOCKSIZE_256);
#endif
/* clear buffer */
gsKit_clear(gsGlobal, GS_SETREG_RGBAQ(0x00,0x00,0x00,0x00,0x00));
/* render frame buffer */
gsKit_prim_sprite_texture( gsGlobal, &fb,
0.0f, /* X1 */
0.0f, /* Y1 */
0.0f, /* U1 */
0.0f, /* V1 */
gsGlobal->Width, /* X2 */
gsGlobal->Height, /* Y2 */
fb.Width, /* U2 */
fb.Height, /* V2*/
1, /* Z */
GS_SETREG_RGBAQ(0x80,0x80,0x80,0x80,0x00) /* RGBAQ */
);
#ifdef USEBMP
gsKit_prim_sprite_texture(gsGlobal, &backtex,
(gsGlobal->Width /2) - (backtex.Width / 2), /* X1 */
0.0f, /* Y1 */
0.0f, /* U1 */
0.0f, /* V1 */
backtex.Width + ((gsGlobal->Width /2) - (backtex.Width / 2)), /* X2 */
backtex.Height, /* Y2 */
backtex.Width, /* U2 */
backtex.Height, /* V2*/
2, /* Z */
GS_SETREG_RGBAQ(0x80,0x80,0x80,0x80,0x00) /* RGBAQ */
);
#endif
while (1)
{
/* generate next frame */
generate_frame(&fb);
/* upload new frame buffer */
gsKit_texture_upload(gsGlobal, &fb);
/* vsync and flip buffer */
gsKit_sync_flip(gsGlobal);
/* execute render queue */
gsKit_queue_exec(gsGlobal);
}
/* keep compilers happy (tm) */
return 0;
}
static void button_click(gpointer data)
{
if(strcmp("button.open", (char *)data) == 0)
{
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Open file",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".dat", file) == 0)
{
add_buffer();
image_load_map(file);
}
else if(srecmpend(".bmp", file) == 0 || srecmpend(".png", file) == 0 || srecmpend(".jpg", file) == 0 || srecmpend(".jpeg", file) == 0 || srecmpend(".gif", file) == 0)
{
GError * err = NULL;
add_buffer();
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(FSD_checkbox)))
generate_image_dithered(mdata[current_buffer], file, colors, &err);
else
generate_image(mdata[current_buffer], file, colors, &err);
if(err != NULL)
{
information("Error while loading image file!");
printf("%s\n", err->message);
g_error_free(err);
}
set_image();
}
else if(srecmpend(".imtm", file) == 0)
{
add_buffer();
load_raw_map(file, mdata[current_buffer]);
set_image();
}
else
information("File format not supported!");
}
gtk_widget_destroy(dialog);
}
else if(strcmp("button.save", (char *)data) == 0)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map_0.dat");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
if(srecmpend(".dat", file) == 0)
save_map(file);
}
gtk_widget_destroy(dialog);
printf("bracket cleared\n");
}
else if(strcmp("button.exp_img", (char *)data) == 0)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Export Image of Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.png");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
unsigned char * data = malloc(128 * 128 * 3);
int i;
for(i = 0; i < 128 * 128; i++)
{
if(mdata[current_buffer][i] > 3)
{
data[i * 3] = colors[mdata[current_buffer][i]].r;
data[i * 3 + 1] = colors[mdata[current_buffer][i]].g;
data[i * 3 + 2] = colors[mdata[current_buffer][i]].b;
}
else
{
int x = i % 128, y = i / 128;
x /= 4;
y /= 4;
data[i * 3] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
data[i * 3 + 1] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
data[i * 3 + 2] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
}
}
GdkPixbuf * spixbuf = image_from_data(data, 0);
free(data);
GError * err = NULL;
gdk_pixbuf_save(spixbuf, file, "png", &err, "compression", "9", NULL);
if (err != NULL)
{
/* Report error to user, and free error */
printf("Error while saving: %s\n", err->message);
g_error_free(err);
}
g_object_unref(spixbuf);
}
gtk_widget_destroy(dialog);
}
else if(strcmp("button.save_rm", (char *)data) == 0)
{
if(mdata == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.imtm");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
save_raw_map(file, mdata[current_buffer]);
}
gtk_widget_destroy(dialog);
}
else if(strcmp("button.palette", (char *)data) == 0)
{
add_buffer();
generate_palette(mdata[current_buffer]);
set_image();
}
else if(strcmp("button.random_noise", (char *)data) == 0)
{
add_buffer();
generate_random_noise(mdata[current_buffer]);
set_image();
}
else if(strcmp("button.mandelbrot", (char *)data) == 0)
{
add_buffer();
generate_mandelbrot(mdata[current_buffer]);
set_image();
}
else if(strcmp("button.julia", (char *)data) == 0)
{
add_buffer();
generate_julia(mdata[current_buffer], 0.5, 0.5);
set_image();
}
else if(strcmp("button.from_clipboard", (char *)data) == 0)
{
GtkClipboard * clipboard;
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_image(clipboard, clipboard_callback, NULL);
}
else
printf("Unhandeled button press: %s\n", (char *)data);
}
int
main( int argc, char *argv[] )
{
int quit = 0;
DFBResult err;
DFBSurfaceDescription sdsc;
DFBCHECK(DirectFBInit( &argc, &argv ));
/* create the super interface */
DFBCHECK(DirectFBCreate( &dfb ));
/* create an event buffer for all devices */
DFBCHECK(dfb->CreateInputEventBuffer( dfb, DICAPS_ALL,
DFB_FALSE, &events ));
/* set our cooperative level to DFSCL_FULLSCREEN
for exclusive access to the primary layer */
dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );
/* get the primary surface, i.e. the surface of the
primary layer we have exclusive access to */
sdsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT;
sdsc.caps = DSCAPS_PRIMARY;
sdsc.pixelformat = DSPF_LUT8;
DFBCHECK(dfb->CreateSurface( dfb, &sdsc, &primary ));
primary->Clear( primary, 0, 0, 0, 0 );
primary->GetSize( primary, &screen_width, &screen_height );
/* get access to the palette */
DFBCHECK(primary->GetPalette( primary, &palette ));
generate_palette();
fill_surface( primary );
while (!quit) {
DFBInputEvent evt;
while (events->GetEvent( events, DFB_EVENT(&evt) ) == DFB_OK) {
switch (evt.type) {
case DIET_KEYPRESS:
switch (evt.key_symbol) {
case DIKS_ESCAPE:
quit = 1;
break;
default:
;
}
default:
;
}
}
rotate_palette();
}
/* release our interfaces to shutdown DirectFB */
palette->Release( palette );
primary->Release( primary );
events->Release( events );
dfb->Release( dfb );
return 0;
}
static unsigned char *fb_init_driver(unsigned char *param, unsigned char *ignore)
{
unsigned char *e;
struct stat st;
int rs;
unsigned long ul;
TTY = 0;
EINTRLOOP(rs, ioctl(TTY,VT_GETMODE, &vt_omode));
if (rs == -1) {
TTY = 1;
EINTRLOOP(rs, ioctl(TTY,VT_GETMODE, &vt_omode));
if (rs == -1) {
TTY = 0;
}
}
kbd_set_raw = 1;
fb_old_vd = NULL;
fb_driver_param=NULL;
if(param != NULL)
fb_driver_param=stracpy(param);
border_left = border_right = border_top = border_bottom = 0;
if (!param) param=cast_uchar "";
if (*param) {
if (*param < '0' || *param > '9') {
bad_p:
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
return stracpy(cast_uchar "-mode syntax is left_border[,top_border[,right_border[,bottom_border]]]\n");
}
ul = strtoul(cast_const_char param, (char **)(void *)¶m, 10);
if (ul > MAXINT / 10) goto bad_p;
border_left = (int)ul;
if (*param == ',') param++;
} else {
border_left = 0;
}
if (*param) {
if (*param < '0' || *param > '9') goto bad_p;
ul = strtoul(cast_const_char param, (char **)(void *)¶m, 10);
if (ul > MAXINT / 10) goto bad_p;
border_top = (int)ul;
if (*param == ',') param++;
} else {
border_top = border_left;
}
if (*param) {
if (*param < '0' || *param > '9') goto bad_p;
ul = strtoul(cast_const_char param, (char **)(void *)¶m, 10);
if (ul > MAXINT / 10) goto bad_p;
border_right = (int)ul;
if (*param == ',') param++;
} else {
border_right = border_left;
}
if (*param) {
if (*param < '0' || *param > '9') goto bad_p;
ul = strtoul(cast_const_char param, (char **)(void *)¶m, 10);
if (ul > MAXINT / 10) goto bad_p;
border_bottom = (int)ul;
if (*param == ',') param++;
} else {
border_bottom = border_top;
}
if (*param) goto bad_p;
EINTRLOOP(rs, fstat(TTY, &st));
if (rs) {
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
return stracpy(cast_uchar "Cannon stat stdin.\n");
}
fb_console = (int)(st.st_rdev & 0xff);
fb_hide_cursor();
if ((e = fb_switch_init())) {
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return e;
}
EINTRLOOP(fb_handle, open("/dev/fb0", O_RDWR));
if (fb_handle==-1) {
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Cannot open /dev/fb0.\n");
}
EINTRLOOP(rs, ioctl(fb_handle, FBIOGET_VSCREENINFO, &vi));
if (rs==-1)
{
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Cannot get FB VSCREENINFO.\n");
}
/*oldmode=vi;*/
EINTRLOOP(rs, ioctl(fb_handle, FBIOGET_FSCREENINFO, &fi));
if (rs==-1)
{
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Cannot get FB FSCREENINFO.\n");
}
fb_xsize=vi.xres;
fb_ysize=vi.yres;
fb_bits_pp=vi.bits_per_pixel;
if (fb_bits_pp == 16 && vi.green.length == 5) fb_bits_pp = 15;
if (fb_xsize <= border_left + border_right) border_left = border_right = 0;
fb_xsize -= border_left + border_right;
if (fb_ysize <= border_top + border_bottom) border_top = border_bottom = 0;
fb_ysize -= border_top + border_bottom;
fb_driver.x=fb_xsize;
fb_driver.y=fb_ysize;
switch(fb_bits_pp)
{
case 4:
fb_pixelsize=1;
fb_palette_colors=16;
break;
case 8:
fb_pixelsize=1;
fb_palette_colors=256;
break;
case 15:
case 16:
fb_pixelsize=2;
fb_palette_colors=64;
break;
case 24:
fb_palette_colors=256;
fb_pixelsize=3;
break;
case 32:
fb_palette_colors=256;
fb_pixelsize=4;
fb_bits_pp=24;
break;
default:
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Unknown bit depth");
}
fb_colors=1<<fb_bits_pp;
/* we must pan before setting palette */
fb_pan_display();
have_cmap = 0;
if (fi.visual==FB_VISUAL_PSEUDOCOLOR && fb_colors <= 0x1000000) /* set palette */
{
have_cmap=1;
fb_palette_colors=fb_colors;
alloc_palette(&old_palette);
get_palette(&old_palette);
alloc_palette(&global_pal);
generate_palette(&global_pal);
set_palette(&global_pal);
}
if (fi.visual==FB_VISUAL_DIRECTCOLOR) /* set pseudo palette */
{
have_cmap=2;
alloc_palette(&old_palette);
get_palette(&old_palette);
alloc_palette(&global_pal);
generate_palette(&global_pal);
set_palette(&global_pal);
}
fb_linesize=fi.line_length;
fb_mem_size=fi.smem_len;
if (init_virtual_devices(&fb_driver, NUMBER_OF_DEVICES)){
fb_shutdown_palette();
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Allocation of virtual devices failed.\n");
}
fb_kbd = handle_svgalib_keyboard(fb_key_in);
/* Mikulas: nechodi to na sparcu */
if (fb_mem_size < (unsigned)((border_top + fb_ysize + border_bottom) * fb_linesize))
{
fb_shutdown_palette();
svgalib_free_trm(fb_kbd);
shutdown_virtual_devices();
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Nonlinear mapping of graphics memory not supported.\n");
}
if (vi.nonstd) {
fb_shutdown_palette();
svgalib_free_trm(fb_kbd);
shutdown_virtual_devices();
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Non-standard pixel format.\n");
}
fb_driver.flags |= GD_DONT_USE_SCROLL;
#ifdef USE_FB_ACCEL
need_accel_sync = 0;
EINTRLOOP(rs, ioctl(fb_handle, FBIO_ACCEL_SUPPORT));
if (rs < 0) {
accel_flags = 0;
/*debug("accel not supported");*/
} else {
accel_flags = rs;
/*debug("accel supported, flags %x", accel_flags);*/
}
if (fb_bits_pp != 8)
accel_flags &= ~(FB_ACCEL_FILLRECT_SUPPORTED | FB_ACCEL_FILLRECT_ACCELERATED);
if (accel_flags & FB_ACCEL_COPYAREA_ACCELERATED)
fb_driver.flags &= ~GD_DONT_USE_SCROLL;
#endif
/*
* Some framebuffer implementations (for example Mach64) on Sparc64 hate
* partial framebuffer mappings.
*
* For others, we can save virtual memory space by doing a partial mmap.
*/
fb_mapped_size = (border_top + fb_ysize + border_bottom) * fb_linesize;
retry1:
if ((fb_mem=mmap(0,fb_mapped_size,PROT_READ|PROT_WRITE,MAP_SHARED,fb_handle,0))==MAP_FAILED) {
if (errno == EINTR) goto retry1;
fb_mapped_size = fb_mem_size;
retry2:
if ((fb_mem=mmap(0,fb_mapped_size,PROT_READ|PROT_WRITE,MAP_SHARED,fb_handle,0))==MAP_FAILED) {
if (errno == EINTR) goto retry2;
fb_shutdown_palette();
svgalib_free_trm(fb_kbd);
shutdown_virtual_devices();
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Cannot mmap graphics memory.\n");
}
}
fb_vmem = fb_mem + border_left * fb_pixelsize + border_top * fb_linesize;
fb_driver.depth=fb_pixelsize&7;
fb_driver.depth|=(fb_bits_pp&31)<<3;
if (htonl(0x12345678) == 0x12345678) {
/* Big endian */
if (fb_driver.depth == 130 || fb_driver.depth == 122) fb_driver.depth |= 1 << 8;
else if (fb_driver.depth == 196) fb_driver.depth |= 1 << 9;
}
fb_driver.get_color=get_color_fn(fb_driver.depth);
if (!fb_driver.get_color) {
fb_shutdown_palette();
svgalib_free_trm(fb_kbd);
shutdown_virtual_devices();
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Unknown bit format.\n");
}
install_signal_handler(SIGINT, (void (*)(void *))fb_ctrl_c, fb_kbd, 0);
/* mouse */
mouse_buffer=mem_alloc(fb_pixelsize*arrow_area);
background_buffer=mem_alloc(fb_pixelsize*arrow_area);
new_background_buffer=mem_alloc(fb_pixelsize*arrow_area);
background_x=mouse_x=fb_xsize>>1;
background_y=mouse_y=fb_ysize>>1;
mouse_black=fb_driver.get_color(0);
mouse_white=fb_driver.get_color(0xffffff);
mouse_graphics_device=fb_driver.init_device();
virtual_devices[0] = NULL;
global_mouse_hidden=1;
last_mouse_buttons = B_MOVE;
if (handle_fb_mouse()) {
fb_driver.shutdown_device(mouse_graphics_device);
mem_free(mouse_buffer);
mem_free(background_buffer);
mem_free(new_background_buffer);
fb_shutdown_palette();
svgalib_free_trm(fb_kbd);
shutdown_virtual_devices();
EINTRLOOP(rs, close(fb_handle));
fb_switch_shutdown();
if(fb_driver_param) { mem_free(fb_driver_param); fb_driver_param=NULL; }
fb_show_cursor();
return stracpy(cast_uchar "Cannot open GPM mouse.\n");
}
/* hide cursor */
if (border_left | border_top | border_right | border_bottom) fb_clear_videoram();
show_mouse();
END_GR
return NULL;
}
static void button_click(gpointer data)
{
if((size_t)data == ITEM_SIGNAL_OPEN)
{
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Open file",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".dat", file) == 0)
{
add_buffer();
image_load_map(file);
}
else if(srecmpend(".bmp", file) == 0 || srecmpend(".png", file) == 0 || srecmpend(".jpg", file) == 0 || srecmpend(".jpeg", file) == 0 || srecmpend(".gif", file) == 0)
{
GError * err = NULL;
add_buffer();
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(FSD_checkbox)))
generate_image_dithered(mdata[current_buffer], 128, 128,gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
else
generate_image(mdata[current_buffer], 128, 128, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
if(err != NULL)
{
information("Error while loading image file!");
printf("%s\n", err->message);
g_error_free(err);
}
set_image();
}
else if(srecmpend(".imtm", file) == 0)
{
add_buffer();
load_raw_map(file, mdata[current_buffer]);
set_image();
}
else
information("File format not supported!");
}
gtk_widget_destroy(dialog);
}
if((size_t)data == ITEM_SIGNAL_OPEN_GRID_IMAGE)
{
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Open file",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".bmp", file) == 0 || srecmpend(".png", file) == 0 || srecmpend(".jpg", file) == 0 || srecmpend(".jpeg", file) == 0 || srecmpend(".gif", file) == 0)
{
GError * err = NULL;
int width = 1, height = 1;
int i, j;
int pi, pj;
{
GtkWidget * dialog = gtk_dialog_new_with_buttons("Split Image",
GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_OK"),
GTK_RESPONSE_ACCEPT, NULL);
GtkWidget * content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget * hbox;
GtkWidget * label;
#ifdef GTK2
hbox = gtk_hbox_new(FALSE, 0);
#else
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
label = gtk_label_new("width");
GtkWidget * width_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(width_entry), "1");
gtk_container_add(GTK_CONTAINER(hbox), width_entry);
gtk_container_add(GTK_CONTAINER(hbox), label);
gtk_container_add(GTK_CONTAINER(content_area), hbox);
#ifdef GTK2
hbox = gtk_hbox_new(FALSE, 0);
#else
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
label = gtk_label_new("height");
GtkWidget * height_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(height_entry), "1");
gtk_container_add(GTK_CONTAINER(hbox), height_entry);
gtk_container_add(GTK_CONTAINER(hbox), label);
gtk_container_add(GTK_CONTAINER(content_area), hbox);
gtk_widget_show_all(dialog);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
width = atoi((char *)gtk_entry_get_text(GTK_ENTRY(width_entry)));
height = atoi((char *)gtk_entry_get_text(GTK_ENTRY(height_entry)));
}
gtk_widget_destroy(dialog);
}
unsigned char tmp_buffer[width * height * 128 * 128];
if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(FSD_checkbox)))
generate_image_dithered(tmp_buffer, width * 128, height * 128, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
else
generate_image(tmp_buffer, width * 128, height * 128, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(YUV_checkbox)), file, colors, &err);
if(err != NULL)
{
information("Error while loading image file!");
printf("%s\n", err->message);
g_error_free(err);
}
for(i = 0; i < width; i++)
for(j = 0; j < height; j++)
{
add_buffer();
for(pi = 0; pi < 128; pi++)
for(pj = 0; pj < 128; pj++)
{
int buffer_i, buffer_j;
buffer_i = i * 128 + pi;
buffer_j = j * 128 + pj;
mdata[current_buffer][pi + pj * 128] =
tmp_buffer[buffer_i + (width * 128) * buffer_j];
}
}
set_image();
}
else
information("File format not supported!");
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_SAVE)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map_0.dat");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
if(srecmpend(".dat", file) == 0)
{
save_map(file);
sprintf(last_file, "%s", file);
}
}
gtk_widget_destroy(dialog);
printf("bracket cleared\n");
}
else if((size_t)data == ITEM_SIGNAL_SAVE_INCREMENT)
{
int i = 0;
char * tmp = last_file;
char * basename_s, * dirname_s;
if(mdata[current_buffer] == NULL)
return;
basename_s = custom_basename(tmp);
dirname_s = last_file;
if(basename_s != NULL)
{
tmp = basename_s;
if(strncmp("map_", tmp, 4) == 0)
{
tmp += 4;
i = strtol(tmp, &tmp, 10) + 1;
if(strcmp(".dat", tmp) == 0)
{
#ifdef OS_LINUX
sprintf(last_file, "%s/map_%i.dat", dirname_s, i);
#else
sprintf(last_file, "%s\\map_%i.dat", dirname_s, i);
#endif
save_map(last_file);
/* save_map(last_file); */
}
}
}
}
else if((size_t)data == ITEM_SIGNAL_SAVE_ALL)
{
int old_current_buffer = current_buffer;
GtkWidget * dialog;
int i = 0;
char * tmp;
char * basename_s, * dirname_s;
/* Gets first file name */
dialog = gtk_file_chooser_dialog_new ("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map_0.dat");
if(gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dialog);
return;
}
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if(srecmpend(".dat", file) != 0) {
gtk_widget_destroy(dialog);
return;
}
sprintf(last_file, "%s", file);
gtk_widget_destroy(dialog);
/* Gets the directory and the file name */
basename_s = custom_basename(last_file);
dirname_s = malloc(strlen(last_file)+8); /* 8 is a magic number! Naa jk, it is just to make sure we don't overflow */
if (dirname_s == NULL)
return;
strcpy(dirname_s, last_file);
memset(dirname_s+(strlen(dirname_s)-strlen(basename_s)), strlen(basename_s), '\0');
if(basename_s == NULL)
return;
tmp = basename_s;
/* Gets the number in the file name, 10 for 'map_10.dat' */
if(strncmp("map_", tmp, 4) != 0)
return;
tmp += 4;
i = strtol(tmp, &tmp, 10);
/* Saves all the buffers */
for (current_buffer = 0; current_buffer < BUFFER_COUNT; current_buffer++) {
if(mdata[current_buffer] == NULL)
break;
#ifdef OS_LINUX
sprintf(last_file, "%s/map_%i.dat", dirname_s, i);
#else
sprintf(last_file, "%s\\map_%i.dat", dirname_s, i);
#endif
save_map(last_file);
i++;
}
/* Restores the selection to the right buffer and frees the allocated memory */
current_buffer = old_current_buffer;
free(dirname_s);
}
else if((size_t)data == ITEM_SIGNAL_EXPORT_IMAGE)
{
if(mdata[current_buffer] == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new ("Export Image of Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.png");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
unsigned char * data = malloc(128 * 128 * 3);
int i;
for(i = 0; i < 128 * 128; i++)
{
if(mdata[current_buffer][i] > 3)
{
data[i * 3] = colors[mdata[current_buffer][i]].r;
data[i * 3 + 1] = colors[mdata[current_buffer][i]].g;
data[i * 3 + 2] = colors[mdata[current_buffer][i]].b;
}
else
{
int x = i % 128, y = i / 128;
x /= 4;
y /= 4;
data[i * 3] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
data[i * 3 + 1] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
data[i * 3 + 2] = ((x + (y % 2)) % 2) ? 0xFF : 0xAA;
}
}
GdkPixbuf * spixbuf = image_from_data(data, 0);
free(data);
GError * err = NULL;
gdk_pixbuf_save(spixbuf, file, "png", &err, "compression", "9", NULL);
if (err != NULL)
{
/* Report error to user, and free error */
printf("Error while saving: %s\n", err->message);
g_error_free(err);
}
g_object_unref(spixbuf);
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_SAVE_RM)
{
if(mdata == NULL)
return;
GtkWidget * dialog;
dialog = gtk_file_chooser_dialog_new("Save Map",
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), "map.imtm");
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char * file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("%s\n", file);
save_raw_map(file, mdata[current_buffer]);
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_PALETTE)
{
add_buffer();
generate_palette(mdata[current_buffer]);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_RANDOM_NOISE)
{
add_buffer();
generate_random_noise(mdata[current_buffer]);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_MANDELBROT)
{
add_buffer();
generate_mandelbrot(mdata[current_buffer]);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_JULIA)
{
add_buffer();
generate_julia(mdata[current_buffer], 0.5, 0.5);
set_image();
}
else if((size_t)data == ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD)
{
GtkClipboard * clipboard;
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_image(clipboard, clipboard_callback, NULL);
}
else if((size_t)data == ITEM_SIGNAL_WORLD_RENDER_ITEM)
{
GtkWidget * dialog = gtk_dialog_new_with_buttons("Render World Map",
GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_OK"),
GTK_RESPONSE_ACCEPT,
_("_Cancel"),
GTK_RESPONSE_REJECT, NULL);
GtkWidget * content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget * scale_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(scale_entry), "3");
gtk_container_add(GTK_CONTAINER(content_area), scale_entry);
GtkWidget * xpos_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(xpos_entry), "0");
gtk_container_add(GTK_CONTAINER(content_area), xpos_entry);
GtkWidget * zpos_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(zpos_entry), "0");
gtk_container_add(GTK_CONTAINER(content_area), zpos_entry);
GtkWidget * directory_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(directory_entry), MINECRAFT_PATH);
gtk_container_add(GTK_CONTAINER(content_area), directory_entry);
gtk_widget_show_all(dialog);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
int scale = atoi((char *)gtk_entry_get_text(GTK_ENTRY(scale_entry)));
char * path = (char *)gtk_entry_get_text(GTK_ENTRY(directory_entry));
int x = atoi((char *)gtk_entry_get_text(GTK_ENTRY(xpos_entry)));
int z = atoi((char *)gtk_entry_get_text(GTK_ENTRY(zpos_entry)));
int rs = pow(2, scale) * 128;
block_info_t * blocks = read_region_files(path, x - (rs / 2), z - (rs / 2),
rs, rs);
add_buffer();
render_map(blocks, mdata[current_buffer], scale);
free(blocks);
mdata_info[current_buffer].scale = scale;
mdata_info[current_buffer].xpos = x;
mdata_info[current_buffer].zpos = z;
mdata_info[current_buffer].dimension = 0;
set_image();
}
gtk_widget_destroy(dialog);
}
else if((size_t)data == ITEM_SIGNAL_CLEAN)
{
while(mdata[1] != NULL)
{
remove_buffer(0);
}
/* set_image(); */
}
else if((size_t)data == ITEM_SIGNAL_QUIT)
{
kill_window(NULL, NULL, NULL);
}
else
printf("Unhandeled button press: %i\n", (int)(size_t)data);
}
