void ft_burning_hub(mlx_t *mlx)
{
mlx->win_burning = mlx_new_window(mlx->mlx_ptr, WIDTH, HEIGHT, "burning");
mlx_key_hook(mlx->win_burning, key_burning, mlx);
mlx_mouse_hook(mlx->win_burning, mouse_burning, mlx);
mlx_expose_hook(mlx->win_burning, expose_burning, mlx);
}
int main ()
{
int x;
int y;
void *mlx;
void *win;// va receuillir l'identifiant de la fenetre ! on peux ouvrir plusieur fenetre grace a sa et travailler sur la fenetre desire
y = 0;
x = 0;
mlx = mlx_init();
win = mlx_new_window(mlx, 400, 400, "MLX 42");
while (y < 150)
{
x = 50;
while (x < 150)
{
mlx_pixel_put(mlx, win, x,y, 0x00FFFFFF);
x++;
}
y++;
}
// mlx_pixel_put(mlx, win, 200, 200, 0x00FFFFFF);
mlx_key_hook(win, my_key_funct, 0);
mlx_loop(mlx); // sans mlx loop aps de fgestion d'evenement
return(0);
}
int key_pressed(int kc, t_env *e)
{
key_pressed_split(kc, e);
key_pressed_splitted_split(kc, e);
if (e->zomfgtwins == 1)
mlx_key_hook(e->win2, &key_pressed2, e);
if (kc == KEY_P || kc == KEY_O)
e->puissance += kc == KEY_P ? 1 : -1;
if (kc == KEY_PLUS || kc == KEY_MOINS)
e->nb_it += kc == KEY_PLUS ? 5 : -5;
if (kc == LEFT || kc == RIGHT)
{
e->re_min += kc == LEFT ? e->pixel_size * 50 : e->pixel_size * (-50);
e->re_max += kc == LEFT ? e->pixel_size * 50 : e->pixel_size * (-50);
}
if (kc == UP || kc == DOWN)
{
e->im_min -= kc == DOWN ? e->pixel_size * 50 : e->pixel_size * (-50);
e->im_max -= kc == DOWN ? e->pixel_size * 50 : e->pixel_size * (-50);
}
if (e->ens == 0)
return (1);
clear_image(&e->img_address);
mlx_clear_window(e->mlx, e->win);
e->draw_fract(e);
return (1);
}
void ft_julia(void)
{
t_env *e;
int bpp;
int ls;
int endian;
e = (t_env *)malloc(sizeof(t_env));
e->mlx = mlx_init();
e->win = mlx_new_window(e->mlx, SIZE_W, SIZE_W, "fractal de Julia");
bpp = 4;
ls = 4 * SIZE_W;
endian = 0;
e->xmin = -2;
e->xmax = 2;
e->ymin = -2;
e->ymax = 2;
e->data = NULL;
e->img = mlx_new_image(e->mlx, SIZE_W, SIZE_W);
e->data = mlx_get_data_addr(e->img, &bpp, &ls, &endian);
mlx_expose_hook(e->win, expose_hook, e);
mlx_mouse_move_hook(e->win, mouse_move_hook, e);
mlx_mouse_hook(e->win, mouse_hook, e);
mlx_key_hook(e->win, key_hook, e);
mlx_loop(e->mlx);
}
int main(int ac, char **av)
{
t_env env;
List *list;
t_coord *ptr;
list = NULL;
if (av[1])
{
if (!(env.fd = open(av[1], O_RDONLY)))
return (-1);
while (get_next_line(env.fd, &env.data))
{
env.val = ft_strsplit(env.data, ' ');
list = ft_get_params_to_lst(env.val, list);
free (env.val);
}
ft_init(&env);
ft_add_param_to_struct(&env, &ptr, list);
env.ptr2 = ptr;
mlx_key_hook(env.win, ft_key_hook, &env);
mlx_expose_hook(env.win, ft_expose_hook, &env);
mlx_loop_hook(env.win, ft_key_hook, &env);
mlx_loop(env.mlx);
}
return (0);
}
int main(int ac, char **av)
{
t_fdf_ctx ctx;
if (ac != 2)
{
fdf_usage(av[0]);
return (-42);
}
ft_bzero(&ctx, sizeof(t_fdf_ctx));
ctx.win_h = FDF_WIN_H;
ctx.win_w = FDF_WIN_W;
fdf_parse_file(&ctx, av[1]);
fdf_check_errors(&ctx);
if ((ctx.map_len = ctx.map_w * ctx.map_h) == 0)
return (-1);
fdf_map_lst_to_array(&ctx);
fdf_init_mlx(&ctx, av[1]);
fdf_get_center(&ctx);
fdf_adapt_map(&ctx);
mlx_expose_hook(ctx.win, fdf_hook_expose, &ctx);
mlx_key_hook(ctx.win, fdf_hook_keys, &ctx);
fdf_commands();
mlx_loop(ctx.mlx);
return (0);
}
void ft_mlx(t_env *e)
{
e->mlx = mlx_init();
e->win = mlx_new_window(e->mlx, SIZE, SIZE, "42");
mlx_expose_hook(e->win, expose_hook, e);
mlx_key_hook(e->win, key_hook, e);
mlx_loop(e->mlx);
}
void ft_first_creation(t_id s)
{
s.mlx = mlx_init();
s.win = mlx_new_window(s.mlx, W_X, W_Y, WIN_NAME);
ft_initialization(&s);
mlx_key_hook(s.win, key_reaction, &s);
mlx_loop(s.mlx);
}
void run_application(t_interface *env)
{
mlx_key_hook(env->gui.win, onkey_handler, env);
mlx_expose_hook(env->gui.win, expose_handler, env);
mlx_loop(env->gui.mlx);
mlx_destroy_image(env->gui.mlx, env->gui.image);
kill_stack(&env->objects);
dispose_garbage();
}
static void event(t_var *var)
{
if (var != NULL)
{
mlx_expose_hook(var->win, gere_expose, var);
mlx_key_hook(var->win, gere_key, var);
mlx_loop(var->mlx);
}
}
int main(int argc, char **argv)
{
t_env env;
if (argc != 2)
print_usage();
if (WINX <= 0 || WINY <= 0)
exit(0);
init_env(&env);
init_fract(argv, &env);
mlx_mouse_hook(env.win, my_mouse_hook, &env);
mlx_key_hook(env.win, my_key_hook, &env);
mlx_key_hook(env.winop, i_quit, &env);
mlx_loop_hook(env.mlx, my_loop_hook, &env);
mlx_hook(env.win, 6, (1L << 6), my_hook_events, &env);
mlx_loop(env.mlx);
return (0);
}
void draw_again(t_map *map)
{
map->image->image = mlx_new_image(map->mlx, map->x_win, map->y_win);
put_map(map);
mlx_put_image_to_window(map->mlx, map->win, map->image->image, 0, 0);
mlx_destroy_image(map->mlx, map->image->image);
mlx_key_hook(map->win, &ft_keyhook, map);
mlx_loop(map->mlx);
}
int main_loop(t_map *m)
{
set_param(m);
calculus(m);
mlx_key_hook(m->win, &get_loop_key, m);
mlx_mouse_hook(m->win, &get_loop_scroll, m);
mlx_hook(m->win, 6, (1l << 6), &get_loop_mouse, m);
mlx_loop(m->mlx);
return (0);
}
void handle_second_win(void)
{
static int i = 0;
mlx_hook(g()->p2.win, 6, 64, &mouse_hook, &g()->p2);
mlx_key_hook(g()->p2.win, key_hook, &g()->p2);
mlx_mouse_hook(g()->p2.win, mouse2_hook, &g()->p2);
mlx_expose_hook(g()->p2.win, expose_hook, &g()->p2);
if (i == 0)
first_display_secwin(&i);
}
void aff(t_env *win)
{
win->mlx = mlx_init();
win->win = mlx_new_window(win->mlx, 1280, 1024, "fdf");
win->base_x = 100;
win->base_y = 100;
win->size = 10;
mlx_expose_hook(win->win, draw, &*win);
mlx_key_hook(win->win, keyboard, &*win);
mlx_loop(win->mlx);
}
/*
init_conf() va lire le ficher conf.cf et stocker les different obj dans t_rtv1;
start_rt() lance le calcule des couleur par pixel.
*/
void start_rt(t_rtv1 *rt)
{
if ((rt->img->mlx_ptr = mlx_init()) == NULL)
exit(1);
rt->img->img_ptr = mlx_new_image(rt->img->mlx_ptr,
rt->img->imgx, rt->img->imgy);
rt->img->win_ptr = mlx_new_window(rt->img->mlx_ptr,
rt->win->winx, rt->win->winy, "RT-V1");
mlx_key_hook(rt->img->win_ptr, gere_key, rt);
mlx_loop(rt->img->mlx_ptr);
}
int main(int ac, char **av)
{
t_env env;
init(&env, av, ac);
mlx_key_hook(env.win, key_hook, &env);
mlx_hook(env.win, ButtonPress, ButtonPressMask, mouse_press, &env);
mlx_hook(env.win, MotionNotify, PointerMotionMask, mouse_motion, &env);
mlx_loop_hook(env.ptr, loop_hook, &env);
mlx_loop(env.ptr);
return (0);
}
void init_libx(t_param *param, char *file)
{
param->mlx_ptr = mlx_init();
if (param->mlx_ptr == 0)
my_puterror("Can not init LibX.\n");
param->win_ptr = mlx_new_window(param->mlx_ptr, WIN_X, WIN_Y, "Raytracer");
param->img = mlx_new_image(param->mlx_ptr, WIN_X, WIN_Y);
treat_image(param, file);
mlx_key_hook(param->win_ptr, &key, ¶m);
mlx_expose_hook(param->win_ptr, &expose, param);
mlx_loop(param->mlx_ptr);
}
int main(int argc, char **argv)
{
t_env e;
e.mlx = mlx_init();
e.win = mlx_new_window(e.mlx, 420, 420, "fenetre de fouuuuuuuuu !!!!!!");
mlx_key_hook(e.win, key_hook, &e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_mouse_hook(e.win, mouse_hook, &e);
mlx_loop(e.mlx);
return (0);
}
int core_start(t_all *data)
{
if (ini_connection(data->ip, atoi(data->port), data) == -1 ||
init_struct_data(data) == 1 ||
init_raytracer_win_img(data) == 1 ||
my_call_thread(data) == 1)
return (1);
mlx_key_hook(data->win->win_ptr, &key_control, &data);
mlx_expose_hook(data->win->win_ptr, &my_control_expose, data);
mlx_loop(data->win->mlx_ptr);
return (0);
}
void ft_mlx(t_env *e)
{
e->f = malloc(sizeof(t_img));
e->mlx = mlx_init();
e->win = mlx_new_window(e->mlx, WIDTH + (2 * OFF), HEIGHT + (2 * OFF), "triangle_try_angle");
e->f->img = mlx_new_image(e->mlx, WIDTH + (2 * OFF), HEIGHT + (2 * OFF));
e->f->d = mlx_get_data_addr(e->f->img, &e->f->bpp, &e->f->line_size, &e->f->endian);
mlx_key_hook(e->win, key_hook, e);
mlx_mouse_hook(e->win, mouse_hook, e);
mlx_expose_hook(e->win, expose_hook, e);
mlx_loop(e->mlx);
}
int main (int argc, char **argv)
{
t_mlx *mlx;
mlx = ft_mlx_init();
ft_fdf(mlx, argv);
printf("F**k tha police");
argc = 0;
printf("F**k tha police");
mlx_key_hook(mlx->win, mlx_key_press, mlx);
mlx_loop(mlx->mlx);
return (0);
}
int main(void)
{
t_env e;
init(&e);
panoramiquator(&e);
mlx_key_hook(e.win, key_hook, &e);
mlx_hook(e.win, 2, 1, key_hook, &e);
// pthread_create(&t, NULL, niark, &e);
mlx_loop_hook(e.mlx, loop_hook, &e);
mlx_loop(e.mlx);
return (0);
}
void ft_draw_grid(int **tab, int nb_line, int nb_col)
{
t_fdf e;
e.mlx_ptr = mlx_init();
e.win = mlx_new_window(e.mlx_ptr, 1500, 1500, "image_42");
e.tab = tab;
e.nb_line = nb_line;
e.nb_col = nb_col;
mlx_key_hook(e.win, key_hook, &e);
mlx_expose_hook(e.win, expose_hook, &e);
mlx_loop(e.mlx_ptr);
}
int main(void)
{
t_env e;
e.mlx = mlx_init();
e.win = mlx_new_window(e.mlx, WIDTH, HEIGHT, TITLE);
ft_init_env(&e);
mlx_key_hook(e.win, ft_key_hook, &e);
mlx_mouse_hook(e.win, ft_mouse_hook, &e);
mlx_expose_hook(e.win, ft_expose_hook, &e);
mlx_loop(e.mlx);
return (0);
}
void ft_launch(t_param *p, char *file)
{
if ((p->e.mlx = mlx_init()) == NULL)
exit(ft_error("[Mlx init]: Initialisation impossible"));
p->e.win = mlx_new_window(p->e.mlx, WIN_X, WIN_Y, p->file);
p->e.img = mlx_new_image(p->e.mlx, WIN_X, WIN_Y);
p->data = mlx_get_data_addr(p->e.img, &(p->bpp), &(p->sl), &(p->endian));
ft_work(p, 0);
mlx_mouse_hook(p->e.win, &ft_mouse_hook, p);
mlx_expose_hook(p->e.win, &ft_expose_hook, p);
mlx_key_hook(p->e.win, &ft_key_hook, p);
mlx_loop(p->e.mlx);
}
void draw(t_content *axx, int nb_list)
{
t_clist *param;
param = init_param();
CONTENT(0) = nb_list;
PARAM(0) = mlx_init();
PARAM(1) = mlx_new_window(PARAM(0), LARGEUR, HAUTEUR, "fdf");
PARAM(2) = axx;
mlx_key_hook(PARAM(1), key_hook, param);
mlx_expose_hook(PARAM(1), expose_hook, param);
mlx_loop(PARAM(0));
}
int main(int ac, char **av)
{
t_env e;
parser(&e, ac, av);
env_setup(&e);
algorithm(&e);
mlx_key_hook(e.win, key, &e);
mlx_mouse_hook(e.win, mouse, &e);
mlx_expose_hook(e.win, expose, &e);
mlx_hook(e.win, MOTION_NOTIFY, POINTER_MOTION_MASK, motion_mouse, &e);
mlx_loop(e.mlx);
return (0);
}
int init_mlx(t_win *win)
{
win->mlx = mlx_init();
win->win = mlx_new_window(win->mlx, WIDTH, HEIGHT, NAME);
win->img = mlx_new_image(win->mlx, WIDTH, HEIGHT);
win->endian = 1;
win->bpp = 4;
win->s_line = WIDTH;
win->data = mlx_get_data_addr(win->img, &(win->bpp), &(win->s_line), &(win->endian));
mlx_key_hook(win->win, key_hook, win);
// mlx_expose_hook(win->win, expose_hook, win);
mlx_loop(win->mlx);
return (0);
}
int main(int argc, char *argv[])
{
t_all *all;
all = ft_malloc(sizeof(t_all));
frac_init(all, argc, argv);
mlx_hook(all->env.win, 6, (1L << 6), mouse_move, all);
mlx_key_hook(all->env.win, key_hook, all);
mlx_mouse_hook(all->env.win, mouse_hook, all);
mlx_loop_hook(all->env.mlx, loop_hook, all);
mlx_expose_hook(all->env.win, expose_hook, all);
mlx_loop(all->env.mlx);
return (0);
}
