int key_funct(int keycode, void *param)
{
t_env *env;
env = (t_env *)param;
events(keycode, env);
fractals(*env);
return (1);
}
int mouse_funct(int x, int y, t_env *env)
{
env->pos_x = (double)x;
env->pos_y = (double)y;
if (env->param == 1)
{
fractals(*env);
}
return (1);
}
int clic_funct(int button, int x, int y, t_env *env)
{
if ((button == 1) || (button == 4))
{
env->x_decal += (x - (SIZE_X / 2)) / env->zoom;
env->y_decal += (y - (SIZE_Y / 2)) / env->zoom;
events(69, env);
}
if ((button == 2) || (button == 5))
{
env->x_decal -= (x - (SIZE_X / 2)) / env->zoom;
env->y_decal -= (y - (SIZE_Y / 2)) / env->zoom;
events(78, env);
}
fractals(*env);
return (0);
}
// ----------------------------------------------------------------------------
// imported functions:
// get_reply(): get a pointer on the 'reply' dynamic buffer from the server
// getus(): get current time in microseconds (1 millisecond = 1,000 us)
// get_env(): get connection's 'environment' variables from the server
// xbuf_cat(): like strcat(), but it works in the specified dynamic buffer
// gif_build(): build an in-memory GIF image from a bitmap and palette
// ----------------------------------------------------------------------------
int main(int argc, char *argv[])
{
// -------------------------------------------------------------------------
// get a pointer on the server reply
// -------------------------------------------------------------------------
xbuf_t *reply = get_reply(argv);
// -------------------------------------------------------------------------
// allocate memory for a raw bitmap
// -------------------------------------------------------------------------
int w = 800, h = 800, nbcolors = 256, wXh = w * h;
u8 *bmp = (u8*)malloc(wXh);
if(!bmp) return 503; // service unavailable
// -------------------------------------------------------------------------
// render the Mandelbrot set in our bitmap
// -------------------------------------------------------------------------
fractals(bmp, w, h, nbcolors);
// -------------------------------------------------------------------------
// display the palette (useful when playing with 'tabcol[]' values)
// -------------------------------------------------------------------------
{
#define ROUND(a) ((a) > 0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
u8 *p = bmp;
int i = h, wd20 = w / 20;
float color = 0, col = (float)nbcolors / (float)h;
while(i--)
{
color += col;
memset(p, ROUND(color) & 255, wd20);
p += w;
}
}
// -------------------------------------------------------------------------
// build a smooth multi-gradient color palette from the fixed values below
// -------------------------------------------------------------------------
static
rgb_t tabcol[]={ { 0, 0, 128}, // Med. Blue
{ 0, 100, 200}, // Light Blue
{100, 160, 160}, // Cyan
{ 0, 220, 100}, // Green
{255, 255, 0}, // Yellow
{255, 128, 0}, // Orange
{128, 0, 0}, // Med. Red
{ 64, 0, 0}, // Dark Red
{128, 0, 0}, // Med. Red
{255, 128, 0}, // Orange
{255, 255, 0}, // Yellow
{ 0, 220, 100}, // Green
{100, 160, 160}, // Cyan
{ 0, 100, 200}, // Light Blue
{ 0, 0, 128}, // Med. Blue
{ 64, 0, 0}, // Dark Red
{128, 0, 0}, // Med. Red
{255, 128, 0}, // Orange
{255, 255, 0}, // Yellow
{ 0, 220, 100}, // Green
{100, 160, 160}, // Cyan
{ 0, 100, 200}, // Light Blue
{ 0, 0, 128}, // Med. Blue
{ 0, 0, 64}, // Dark Blue
}, *tab = tabcol;
// -------------------------------------------------------------------------
// just for fun, select different colors for each call
// -------------------------------------------------------------------------
static u32 call = 0;
u32 ncols = sizeof(tabcol) / sizeof(rgb_t);
switch(call)
{
case 0: tab = tabcol; ncols = 10; break; // blue
case 1: tab = &tabcol[ 4]; ncols = 10; break; // yellow
case 2: tab = &tabcol[ 7]; ncols = 7; break; // dark red
case 3: tab = &tabcol[ 1]; ncols = 16; break; // rainbow -
}
call = (call + 1) & 3;
// generate the palette with our defined gradient steps
u8 pal[768]; dr_gradient(pal, nbcolors, tab, ncols);
// nice palete but we want a black body to delimit the mandelbrot set
memset(pal + ((nbcolors - (nbcolors / 16)) * 3), 0, (nbcolors / 16) * 3);
// -------------------------------------------------------------------------
// create custom HTTP response headers to send a GIF file
// -------------------------------------------------------------------------
// (G-WAN automatically generates headers if none are provided but it can't
// guess all MIME types so this automatic feature is for 'text/html' only
// ...unless you explicitly specify the reply buffer MIME type)
#ifdef BUILD_CUSTOM_HEADERS // old way of doing things
// get the current HTTP date (like "Wed, 02 Jun 2010 06:49:37 GMT")
u8 *date = (u8*)get_env(argv, SERVER_DATE);
xbuf_xcat(reply,
"HTTP/1.1 200 OK\r\n"
"Date: %s\r\n"
"Last-Modified: %s\r\n"
"Content-type: image/gif\r\n"
"Content-Length: \r\n" // make room for the for GIF length
"Connection: close\r\n\r\n",
date, date);
// -------------------------------------------------------------------------
// make sure that we have enough space in the 'reply' buffer
// (we are going to fill it directly from gif_build(), not via xbuf_xxx)
// -------------------------------------------------------------------------
// (if we have not enough memory, we will get a 'graceful' crash)
if(reply->allocated < (wXh / 10)) // very gross approximation
{
if(!xbuf_growto(reply, wXh / 10)) // resize reply
{
xbuf_init(reply);
xbuf_ncat(reply, " ", 1);
reply->len = 0; // discart pointless data, keep allocated memory
return 503; // error: we could not allocate enough memory
}
}
// -------------------------------------------------------------------------
// save the place where to patch the void 'Content-Length' HTTP Header
// -------------------------------------------------------------------------
char *p = reply->ptr + reply->len
- (sizeof("\r\nConnection: close\r\n\r\n") - 1);
// -------------------------------------------------------------------------
// append a GIF image (-1:no transparency, 0: no comment) to 'reply'
// -------------------------------------------------------------------------
int len = gif_build((u8*)(reply->ptr + reply->len), bmp, w, h,
pal, nbcolors,
-1, 0);
if(len < 0) len = 0; // (len == -1) if gif_build() failed
reply->len += len; // add the GIF size to the 'reply' buffer length
free(bmp);
// -------------------------------------------------------------------------
// store the GIF size in the empty space of the 'Content-Length' header
// -------------------------------------------------------------------------
u32toa(p, len);
#else // #ifdef BUILD_CUSTOM_HEADERS // works with any supported MIME type
// -------------------------------------------------------------------------
// specify a MIME type so we don't have to build custom HTTP headers
// -------------------------------------------------------------------------
char *mime = (char*)get_env(argv, REPLY_MIME_TYPE);
// note that we setup the FILE EXTENTION, not the MIME type:
mime[0] = '.'; mime[1] = 'g'; mime[2] = 'i'; mime[3] = 'f'; mime[4] = 0;
// -------------------------------------------------------------------------
// make sure that we have enough space in the 'reply' buffer
// (we are going to fill it directly from gif_build(), not via xbuf_xxx)
// -------------------------------------------------------------------------
// (if we have not enough memory, we will get a 'graceful' crash)
if(reply->allocated < (wXh / 10)) // very gross approximation
{
if(!xbuf_growto(reply, wXh / 10)) // resize reply
{
xbuf_init(reply);
xbuf_ncat(reply, " ", 1);
reply->len = 0; // discart pointless data, keep allocated memory
return 503; // error: we could not allocate enough memory
}
}
// -------------------------------------------------------------------------
// append a GIF image (-1:no transparency, 0: no comment) to 'reply'
// -------------------------------------------------------------------------
int len = gif_build((u8*)(reply->ptr + reply->len), bmp, w, h,
pal, nbcolors,
-1, 0);
if(len < 0) len = 0; // (len == -1) if gif_build() failed
reply->len += len; // add the GIF size to the 'reply' buffer length
free(bmp);
#endif // #else #ifdef BUILD_CUSTOM_HEADERS
return 200; // return an HTTP code (200:'OK')
}
