m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add visible_image and backups to the T_Document structure

Browse Source
This commit is contained in:
Thomas Bernard 2018-01-22 16:16:39 +01:00
parent 8ae651c75f
commit a53d6da6ea
23 changed files with 579 additions and 574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/brush.c
View File

@ -120,7 +120,7 @@ void Display_paintbrush(short x,short y,byte color)
if (Mouse_K) // pas de curseur si on est en preview et if (Mouse_K) // pas de curseur si on est en preview et
return; // en train de cliquer return; // en train de cliquer
if (Main_backups->Pages->Image_mode == IMAGE_MODE_MODE5 && Main.current_layer < 4) if (Main.backups->Pages->Image_mode == IMAGE_MODE_MODE5 && Main.current_layer < 4)
{ {
goto single_pixel; goto single_pixel;
} }
@ -284,7 +284,7 @@ void Draw_paintbrush(short x,short y,byte color)
int position; int position;
byte old_color; byte old_color;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_MODE5 && Main.current_layer < 4) if (Main.backups->Pages->Image_mode == IMAGE_MODE_MODE5 && Main.current_layer < 4)
{ {
// Flood-fill the enclosing area // Flood-fill the enclosing area
if (x<Main.image_width && y<Main.image_height && x>= 0 && y >= 0 if (x<Main.image_width && y<Main.image_height && x>= 0 && y >= 0

160
src/buttons.c
View File

@ -169,8 +169,8 @@ void Button_Message_initial(void)
//Print_in_window( 120-4*13,128,"(placeholder)",MC_Dark,MC_Light); //Print_in_window( 120-4*13,128,"(placeholder)",MC_Dark,MC_Light);
Print_in_window(130-4*16,136,"http://grafx2.tk",MC_Dark,MC_Light); Print_in_window(130-4*16,136,"http://grafx2.tk",MC_Dark,MC_Light);
Window_set_normal_button(56, 151, 71, 14, "Anim", 0, (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION), KEY_NONE); Window_set_normal_button(56, 151, 71, 14, "Anim", 0, (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION), KEY_NONE);
Window_set_normal_button(133, 151, 71, 14, "Layers", 0, (Main_backups->Pages->Image_mode != IMAGE_MODE_LAYERED), KEY_NONE); Window_set_normal_button(133, 151, 71, 14, "Layers", 0, (Main.backups->Pages->Image_mode != IMAGE_MODE_LAYERED), KEY_NONE);
Update_window_area(0,0,Window_width, Window_height); Update_window_area(0,0,Window_width, Window_height);
@ -187,7 +187,7 @@ void Button_Message_initial(void)
if (clicked_button > 0) if (clicked_button > 0)
{ {
if (Main_backups->Pages->Image_mode == IMAGE_MODE_LAYERED) if (Main.backups->Pages->Image_mode == IMAGE_MODE_LAYERED)
{ {
Switch_layer_mode(IMAGE_MODE_ANIMATION); Switch_layer_mode(IMAGE_MODE_ANIMATION);
Config.Default_mode_layers = 0; Config.Default_mode_layers = 0;
@ -203,7 +203,7 @@ void Button_Message_initial(void)
Display_all_screen(); Display_all_screen();
} }
// Modify the mode for the spare too // Modify the mode for the spare too
Spare_backups->Pages->Image_mode = Main_backups->Pages->Image_mode; Spare.backups->Pages->Image_mode = Main.backups->Pages->Image_mode;
Update_spare_buffers(Spare.image_width,Spare.image_height); Update_spare_buffers(Spare.image_width,Spare.image_height);
Redraw_spare_image(); Redraw_spare_image();
} }
@ -506,12 +506,12 @@ void Button_Toggle_toolbar(void)
Window_dropdown_add_item(&dropdown, 0, menu_name_tools); Window_dropdown_add_item(&dropdown, 0, menu_name_tools);
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION || if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION ||
Main_backups->Pages->Nb_layers==1) Main.backups->Pages->Nb_layers==1)
Window_dropdown_add_item(&dropdown, 1, menu_name_layers); Window_dropdown_add_item(&dropdown, 1, menu_name_layers);
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION || if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION ||
(Main_backups->Pages->Image_mode == IMAGE_MODE_LAYERED && Main_backups->Pages->Nb_layers==1)) (Main.backups->Pages->Image_mode == IMAGE_MODE_LAYERED && Main.backups->Pages->Nb_layers==1))
Window_dropdown_add_item(&dropdown, 2, menu_name_anim); Window_dropdown_add_item(&dropdown, 2, menu_name_anim);
item=Dropdown_activate(&dropdown,0,Menu_Y+Menu_bars[MENUBAR_STATUS].Top*Menu_factor_Y); item=Dropdown_activate(&dropdown,0,Menu_Y+Menu_bars[MENUBAR_STATUS].Top*Menu_factor_Y);
@ -531,7 +531,7 @@ void Button_Toggle_toolbar(void)
} }
Set_bar_visibility(MENUBAR_LAYERS, !Menu_bars[MENUBAR_LAYERS].Visible, 0); Set_bar_visibility(MENUBAR_LAYERS, !Menu_bars[MENUBAR_LAYERS].Visible, 0);
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
Switch_layer_mode(IMAGE_MODE_LAYERED); Switch_layer_mode(IMAGE_MODE_LAYERED);
break; break;
@ -543,7 +543,7 @@ void Button_Toggle_toolbar(void)
} }
Set_bar_visibility(MENUBAR_ANIMATION, !Menu_bars[MENUBAR_ANIMATION].Visible, 0); Set_bar_visibility(MENUBAR_ANIMATION, !Menu_bars[MENUBAR_ANIMATION].Visible, 0);
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
Switch_layer_mode(IMAGE_MODE_ANIMATION); Switch_layer_mode(IMAGE_MODE_ANIMATION);
break; break;
@ -631,7 +631,7 @@ byte Button_Quit_local_function(void)
{ {
case 1 : return 0; // Rester case 1 : return 0; // Rester
case 2 : // Sauver et enregistrer case 2 : // Sauver et enregistrer
Get_full_filename(filename, Main_backups->Pages->Filename, Main_backups->Pages->File_directory); Get_full_filename(filename, Main.backups->Pages->Filename, Main.backups->Pages->File_directory);
if ( (!File_exists(filename)) || Confirmation_box("Erase old file ?") ) if ( (!File_exists(filename)) || Confirmation_box("Erase old file ?") )
{ {
T_IO_Context save_context; T_IO_Context save_context;
@ -641,7 +641,7 @@ byte Button_Quit_local_function(void)
Cursor_shape=CURSOR_SHAPE_HOURGLASS; Cursor_shape=CURSOR_SHAPE_HOURGLASS;
Display_cursor(); Display_cursor();
Init_context_layered_image(&save_context, Main_backups->Pages->Filename, Main_backups->Pages->File_directory); Init_context_layered_image(&save_context, Main.backups->Pages->Filename, Main.backups->Pages->File_directory);
Save_image(&save_context); Save_image(&save_context);
Destroy_context(&save_context); Destroy_context(&save_context);
@ -698,9 +698,9 @@ void Button_Clear(void)
Hide_cursor(); Hide_cursor();
Backup(); Backup();
if (Stencil_mode && Config.Clear_with_stencil) if (Stencil_mode && Config.Clear_with_stencil)
Clear_current_image_with_stencil(Main_backups->Pages->Transparent_color,Stencil); Clear_current_image_with_stencil(Main.backups->Pages->Transparent_color,Stencil);
else else
Clear_current_image(Main_backups->Pages->Transparent_color); Clear_current_image(Main.backups->Pages->Transparent_color);
Redraw_layered_image(); Redraw_layered_image();
End_of_modification(); End_of_modification();
Display_all_screen(); Display_all_screen();
@ -1565,9 +1565,9 @@ void Button_Page(void)
// On fait le reste du travail "à la main": // On fait le reste du travail "à la main":
// TODO // TODO
SWAP_PBYTES(Main_visible_image.Image,Spare_visible_image.Image)// ! SWAP_PBYTES(Main.visible_image.Image,Spare.visible_image.Image)
SWAP_WORDS (Main_visible_image.Width,Spare_visible_image.Width)// ! SWAP_WORDS (Main.visible_image.Width,Spare.visible_image.Width)
SWAP_WORDS (Main_visible_image.Height,Spare_visible_image.Height)// ! SWAP_WORDS (Main.visible_image.Height,Spare.visible_image.Height)
SWAP_SHORTS(Main.offset_X,Spare.offset_X) SWAP_SHORTS(Main.offset_X,Spare.offset_X)
SWAP_SHORTS(Main.offset_Y,Spare.offset_Y) SWAP_SHORTS(Main.offset_Y,Spare.offset_Y)
SWAP_SHORTS(Main.separator_position,Spare.separator_position) SWAP_SHORTS(Main.separator_position,Spare.separator_position)
@ -1652,20 +1652,20 @@ void Copy_image_only(void)
{ {
byte i; byte i;
for (i=0; i<Spare_backups->Pages->Nb_layers; i++) for (i=0; i<Spare.backups->Pages->Nb_layers; i++)
{ {
if (i == Spare.current_layer) if (i == Spare.current_layer)
{ {
// Copy the current layer // Copy the current layer
memcpy(Spare_backups->Pages->Image[i].Pixels,Main_backups->Pages->Image[Main.current_layer].Pixels,Main.image_width*Main.image_height); memcpy(Spare.backups->Pages->Image[i].Pixels,Main.backups->Pages->Image[Main.current_layer].Pixels,Main.image_width*Main.image_height);
} }
else else
{ {
// Resize the original layer // Resize the original layer
Copy_part_of_image_to_another( Copy_part_of_image_to_another(
Spare_backups->Pages->Next->Image[i].Pixels,0,0,Min(old_width,Spare.image_width), Spare.backups->Pages->Next->Image[i].Pixels,0,0,Min(old_width,Spare.image_width),
Min(old_height,Spare.image_height),old_width, Min(old_height,Spare.image_height),old_width,
Spare_backups->Pages->Image[i].Pixels,0,0,Spare.image_width); Spare.backups->Pages->Image[i].Pixels,0,0,Spare.image_width);
} }
} }
@ -1812,10 +1812,10 @@ void Button_Copy_page(void)
// -- Suppression d'une page ------------------------------------------------- // -- Suppression d'une page -------------------------------------------------
void Button_Kill(void) void Button_Kill(void)
{ {
if ( (Main_backups->List_size==1) if ( (Main.backups->List_size==1)
|| (!Confirmation_box("Delete the current page?")) ) || (!Confirmation_box("Delete the current page?")) )
{ {
if (Main_backups->List_size==1) if (Main.backups->List_size==1)
Warning_message("You can't delete the last page."); Warning_message("You can't delete the last page.");
Hide_cursor(); Hide_cursor();
Unselect_button(BUTTON_KILL); Unselect_button(BUTTON_KILL);
@ -2467,19 +2467,19 @@ void Draw_button_gradient_style(short x_pos,short y_pos,int technique)
void Load_gradient_data(int index) void Load_gradient_data(int index)
{ {
if (Main_backups->Pages->Gradients->Range[index].Start>Main_backups->Pages->Gradients->Range[index].End) if (Main.backups->Pages->Gradients->Range[index].Start>Main.backups->Pages->Gradients->Range[index].End)
Error(0); Error(0);
Gradient_lower_bound =Main_backups->Pages->Gradients->Range[index].Start; Gradient_lower_bound =Main.backups->Pages->Gradients->Range[index].Start;
Gradient_upper_bound =Main_backups->Pages->Gradients->Range[index].End; Gradient_upper_bound =Main.backups->Pages->Gradients->Range[index].End;
Gradient_is_inverted =Main_backups->Pages->Gradients->Range[index].Inverse; Gradient_is_inverted =Main.backups->Pages->Gradients->Range[index].Inverse;
Gradient_random_factor=Main_backups->Pages->Gradients->Range[index].Mix+1; Gradient_random_factor=Main.backups->Pages->Gradients->Range[index].Mix+1;
Gradient_bounds_range=(Gradient_lower_bound<Gradient_upper_bound)? Gradient_bounds_range=(Gradient_lower_bound<Gradient_upper_bound)?
Gradient_upper_bound-Gradient_lower_bound: Gradient_upper_bound-Gradient_lower_bound:
Gradient_lower_bound-Gradient_upper_bound; Gradient_lower_bound-Gradient_upper_bound;
Gradient_bounds_range++; Gradient_bounds_range++;
switch(Main_backups->Pages->Gradients->Range[index].Technique) switch(Main.backups->Pages->Gradients->Range[index].Technique)
{ {
case 0 : // Degradé de base case 0 : // Degradé de base
Gradient_function=Gradient_basic; Gradient_function=Gradient_basic;
@ -2541,7 +2541,7 @@ void Button_Gradients(void)
Gradient_pixel=Pixel; Gradient_pixel=Pixel;
old_current_gradient=Current_gradient; old_current_gradient=Current_gradient;
changed_gradient_index=0; changed_gradient_index=0;
memcpy(&backup_gradients,Main_backups->Pages->Gradients,sizeof(T_Gradient_array)); memcpy(&backup_gradients,Main.backups->Pages->Gradients,sizeof(T_Gradient_array));
Open_window(235,146,"Gradation menu"); Open_window(235,146,"Gradation menu");
@ -2550,19 +2550,19 @@ void Button_Gradients(void)
gradient_scroller=Window_set_scroller_button(218,20,75,16,1,Current_gradient); // 2 gradient_scroller=Window_set_scroller_button(218,20,75,16,1,Current_gradient); // 2
// Slider for mix // Slider for mix
mix_scroller = Window_set_scroller_button(31,20,84,256,1, mix_scroller = Window_set_scroller_button(31,20,84,256,1,
Main_backups->Pages->Gradients->Range[Current_gradient].Mix); // 3 Main.backups->Pages->Gradients->Range[Current_gradient].Mix); // 3
// Direction // Direction
Window_set_normal_button(8,20,15,14, Window_set_normal_button(8,20,15,14,
(Main_backups->Pages->Gradients->Range[Current_gradient].Inverse)?"\033":"\032",0,1,SDLK_TAB); // 4 (Main.backups->Pages->Gradients->Range[Current_gradient].Inverse)?"\033":"\032",0,1,SDLK_TAB); // 4
// Technique // Technique
Window_set_normal_button(8,90,15,14,"",0,1,SDLK_TAB|MOD_SHIFT); // 5 Window_set_normal_button(8,90,15,14,"",0,1,SDLK_TAB|MOD_SHIFT); // 5
Draw_button_gradient_style(8,90,Main_backups->Pages->Gradients->Range[Current_gradient].Technique); Draw_button_gradient_style(8,90,Main.backups->Pages->Gradients->Range[Current_gradient].Technique);
Window_set_normal_button(178,128,51,14,"OK",0,1,SDLK_RETURN); // 6 Window_set_normal_button(178,128,51,14,"OK",0,1,SDLK_RETURN); // 6
Window_set_normal_button(123,128,51,14,"Cancel",0,1,KEY_ESC); // 7 Window_set_normal_button(123,128,51,14,"Cancel",0,1,KEY_ESC); // 7
// Scrolling speed // Scrolling speed
speed_scroller = Window_set_horizontal_scroller_button(99,111,130,106,1,Main_backups->Pages->Gradients->Range[Current_gradient].Speed); // 8 speed_scroller = Window_set_horizontal_scroller_button(99,111,130,106,1,Main.backups->Pages->Gradients->Range[Current_gradient].Speed); // 8
Num2str(Main_backups->Pages->Gradients->Range[Current_gradient].Speed,str,3); Num2str(Main.backups->Pages->Gradients->Range[Current_gradient].Speed,str,3);
Print_in_window(73,113,str,MC_Black,MC_Light); Print_in_window(73,113,str,MC_Black,MC_Light);
Print_in_window(5,58,"MIX",MC_Dark,MC_Light); Print_in_window(5,58,"MIX",MC_Dark,MC_Light);
@ -2572,7 +2572,7 @@ void Button_Gradients(void)
Print_in_window(11,112,"Cycling",cycling_mode?MC_Black:MC_Dark,MC_Light); Print_in_window(11,112,"Cycling",cycling_mode?MC_Black:MC_Dark,MC_Light);
// On tagge les couleurs qui vont avec // On tagge les couleurs qui vont avec
Tag_color_range(Main_backups->Pages->Gradients->Range[Current_gradient].Start,Main_backups->Pages->Gradients->Range[Current_gradient].End); Tag_color_range(Main.backups->Pages->Gradients->Range[Current_gradient].Start,Main.backups->Pages->Gradients->Range[Current_gradient].End);
Num2str(Current_gradient+1,str,2); Num2str(Current_gradient+1,str,2);
Print_in_window(215,100,str,MC_Black,MC_Light); Print_in_window(215,100,str,MC_Black,MC_Light);
@ -2582,7 +2582,7 @@ void Button_Gradients(void)
// On affiche la preview // On affiche la preview
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
first_color=last_color=(Main_backups->Pages->Gradients->Range[Current_gradient].Inverse)?Main_backups->Pages->Gradients->Range[Current_gradient].End:Main_backups->Pages->Gradients->Range[Current_gradient].Start; first_color=last_color=(Main.backups->Pages->Gradients->Range[Current_gradient].Inverse)?Main.backups->Pages->Gradients->Range[Current_gradient].End:Main.backups->Pages->Gradients->Range[Current_gradient].Start;
Update_window_area(0,0,Window_width, Window_height); Update_window_area(0,0,Window_width, Window_height);
Display_cursor(); Display_cursor();
@ -2604,19 +2604,19 @@ void Button_Gradients(void)
Print_in_window(215,100,str,MC_Black,MC_Light); Print_in_window(215,100,str,MC_Black,MC_Light);
// On tagge les couleurs qui vont avec // On tagge les couleurs qui vont avec
Tag_color_range(Main_backups->Pages->Gradients->Range[Current_gradient].Start,Main_backups->Pages->Gradients->Range[Current_gradient].End); Tag_color_range(Main.backups->Pages->Gradients->Range[Current_gradient].Start,Main.backups->Pages->Gradients->Range[Current_gradient].End);
// On affiche le sens qui va avec // On affiche le sens qui va avec
Print_in_window(12,23,(Main_backups->Pages->Gradients->Range[Current_gradient].Inverse)?"\033":"\032",MC_Black,MC_Light); Print_in_window(12,23,(Main.backups->Pages->Gradients->Range[Current_gradient].Inverse)?"\033":"\032",MC_Black,MC_Light);
// On raffiche le mélange (jauge) qui va avec // On raffiche le mélange (jauge) qui va avec
mix_scroller->Position=Main_backups->Pages->Gradients->Range[Current_gradient].Mix; mix_scroller->Position=Main.backups->Pages->Gradients->Range[Current_gradient].Mix;
Window_draw_slider(mix_scroller); Window_draw_slider(mix_scroller);
// Update speed // Update speed
speed_scroller->Position=Main_backups->Pages->Gradients->Range[Current_gradient].Speed; speed_scroller->Position=Main.backups->Pages->Gradients->Range[Current_gradient].Speed;
Window_draw_slider(speed_scroller); Window_draw_slider(speed_scroller);
Num2str(Main_backups->Pages->Gradients->Range[Current_gradient].Speed,str,3); Num2str(Main.backups->Pages->Gradients->Range[Current_gradient].Speed,str,3);
Print_in_window(73,113,str,MC_Black,MC_Light); Print_in_window(73,113,str,MC_Black,MC_Light);
// Gradient # // Gradient #
@ -2624,7 +2624,7 @@ void Button_Gradients(void)
Window_draw_slider(gradient_scroller); Window_draw_slider(gradient_scroller);
// Technique (flat, dithered, very dithered) // Technique (flat, dithered, very dithered)
Draw_button_gradient_style(8,90,Main_backups->Pages->Gradients->Range[Current_gradient].Technique); Draw_button_gradient_style(8,90,Main.backups->Pages->Gradients->Range[Current_gradient].Technique);
// Rectangular gradient preview // Rectangular gradient preview
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
@ -2654,9 +2654,9 @@ void Button_Gradients(void)
// On vient de clicker // On vient de clicker
// On met à jour l'intervalle du dégradé // On met à jour l'intervalle du dégradé
first_color=last_color=Main_backups->Pages->Gradients->Range[Current_gradient].Start=Main_backups->Pages->Gradients->Range[Current_gradient].End=temp_color; first_color=last_color=Main.backups->Pages->Gradients->Range[Current_gradient].Start=Main.backups->Pages->Gradients->Range[Current_gradient].End=temp_color;
// On tagge le bloc // On tagge le bloc
Tag_color_range(Main_backups->Pages->Gradients->Range[Current_gradient].Start,Main_backups->Pages->Gradients->Range[Current_gradient].End); Tag_color_range(Main.backups->Pages->Gradients->Range[Current_gradient].Start,Main.backups->Pages->Gradients->Range[Current_gradient].End);
// Tracé de la preview: // Tracé de la preview:
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
} }
@ -2668,18 +2668,18 @@ void Button_Gradients(void)
// On commence par ordonner la 1ère et dernière couleur du bloc // On commence par ordonner la 1ère et dernière couleur du bloc
if (first_color<temp_color) if (first_color<temp_color)
{ {
Main_backups->Pages->Gradients->Range[Current_gradient].Start=first_color; Main.backups->Pages->Gradients->Range[Current_gradient].Start=first_color;
Main_backups->Pages->Gradients->Range[Current_gradient].End =temp_color; Main.backups->Pages->Gradients->Range[Current_gradient].End =temp_color;
} }
else if (first_color>temp_color) else if (first_color>temp_color)
{ {
Main_backups->Pages->Gradients->Range[Current_gradient].Start=temp_color; Main.backups->Pages->Gradients->Range[Current_gradient].Start=temp_color;
Main_backups->Pages->Gradients->Range[Current_gradient].End =first_color; Main.backups->Pages->Gradients->Range[Current_gradient].End =first_color;
} }
else else
Main_backups->Pages->Gradients->Range[Current_gradient].Start=Main_backups->Pages->Gradients->Range[Current_gradient].End=first_color; Main.backups->Pages->Gradients->Range[Current_gradient].Start=Main.backups->Pages->Gradients->Range[Current_gradient].End=first_color;
// On tagge le bloc // On tagge le bloc
Tag_color_range(Main_backups->Pages->Gradients->Range[Current_gradient].Start,Main_backups->Pages->Gradients->Range[Current_gradient].End); Tag_color_range(Main.backups->Pages->Gradients->Range[Current_gradient].Start,Main.backups->Pages->Gradients->Range[Current_gradient].End);
// Tracé de la preview: // Tracé de la preview:
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
last_color=temp_color; last_color=temp_color;
@ -2696,7 +2696,7 @@ void Button_Gradients(void)
case 3 : // Nouveau mélange de dégradé case 3 : // Nouveau mélange de dégradé
Hide_cursor(); Hide_cursor();
// Nouvel mélange dans Window_attribute2 // Nouvel mélange dans Window_attribute2
Main_backups->Pages->Gradients->Range[Current_gradient].Mix=Window_attribute2; Main.backups->Pages->Gradients->Range[Current_gradient].Mix=Window_attribute2;
// On affiche la nouvelle preview // On affiche la nouvelle preview
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor(); Display_cursor();
@ -2704,8 +2704,8 @@ void Button_Gradients(void)
case 4 : // Changement de sens case 4 : // Changement de sens
Hide_cursor(); Hide_cursor();
// On inverse le sens (par un XOR de 1) // On inverse le sens (par un XOR de 1)
Main_backups->Pages->Gradients->Range[Current_gradient].Inverse^=1; Main.backups->Pages->Gradients->Range[Current_gradient].Inverse^=1;
Print_in_window(12,23,(Main_backups->Pages->Gradients->Range[Current_gradient].Inverse)?"\033":"\032",MC_Black,MC_Light); Print_in_window(12,23,(Main.backups->Pages->Gradients->Range[Current_gradient].Inverse)?"\033":"\032",MC_Black,MC_Light);
// On affiche la nouvelle preview // On affiche la nouvelle preview
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor(); Display_cursor();
@ -2713,14 +2713,14 @@ void Button_Gradients(void)
case 5 : // Changement de technique case 5 : // Changement de technique
Hide_cursor(); Hide_cursor();
// On change la technique par (+1)%3 // On change la technique par (+1)%3
Main_backups->Pages->Gradients->Range[Current_gradient].Technique=(Main_backups->Pages->Gradients->Range[Current_gradient].Technique+1)%3; Main.backups->Pages->Gradients->Range[Current_gradient].Technique=(Main.backups->Pages->Gradients->Range[Current_gradient].Technique+1)%3;
Draw_button_gradient_style(8,90,Main_backups->Pages->Gradients->Range[Current_gradient].Technique); Draw_button_gradient_style(8,90,Main.backups->Pages->Gradients->Range[Current_gradient].Technique);
// On affiche la nouvelle preview // On affiche la nouvelle preview
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor(); Display_cursor();
case 8 : // Speed case 8 : // Speed
Main_backups->Pages->Gradients->Range[Current_gradient].Speed=Window_attribute2; Main.backups->Pages->Gradients->Range[Current_gradient].Speed=Window_attribute2;
Num2str(Main_backups->Pages->Gradients->Range[Current_gradient].Speed,str,3); Num2str(Main.backups->Pages->Gradients->Range[Current_gradient].Speed,str,3);
Hide_cursor(); Hide_cursor();
Print_in_window(73,113,str,MC_Black,MC_Light); Print_in_window(73,113,str,MC_Black,MC_Light);
Display_cursor(); Display_cursor();
@ -2746,9 +2746,9 @@ void Button_Gradients(void)
temp_color=color; temp_color=color;
// On met à jour l'intervalle du dégradé // On met à jour l'intervalle du dégradé
first_color=last_color=Main_backups->Pages->Gradients->Range[Current_gradient].Start=Main_backups->Pages->Gradients->Range[Current_gradient].End=temp_color; first_color=last_color=Main.backups->Pages->Gradients->Range[Current_gradient].Start=Main.backups->Pages->Gradients->Range[Current_gradient].End=temp_color;
// On tagge le bloc // On tagge le bloc
Tag_color_range(Main_backups->Pages->Gradients->Range[Current_gradient].Start,Main_backups->Pages->Gradients->Range[Current_gradient].End); Tag_color_range(Main.backups->Pages->Gradients->Range[Current_gradient].Start,Main.backups->Pages->Gradients->Range[Current_gradient].End);
// Tracé de la preview: // Tracé de la preview:
Draw_gradient_preview(8,128,108,14,Current_gradient); Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor(); Display_cursor();
@ -2804,7 +2804,7 @@ void Button_Gradients(void)
if (clicked_button==7) // Cancel if (clicked_button==7) // Cancel
{ {
Current_gradient=old_current_gradient; Current_gradient=old_current_gradient;
memcpy(Main_backups->Pages->Gradients,&backup_gradients,sizeof(T_Gradient_array)); memcpy(Main.backups->Pages->Gradients,&backup_gradients,sizeof(T_Gradient_array));
} }
} }
@ -3158,8 +3158,8 @@ void Load_picture(byte image)
if (image) if (image)
{ {
strcpy(filename, Main_backups->Pages->Filename); strcpy(filename, Main.backups->Pages->Filename);
strcpy(directory, Main_backups->Pages->File_directory); strcpy(directory, Main.backups->Pages->File_directory);
Init_context_layered_image(&context, filename, directory); Init_context_layered_image(&context, filename, directory);
} }
else else
@ -3301,7 +3301,7 @@ void Button_Load(void)
{ {
// On sauve l'état actuel des paramètres de l'image pour pouvoir les // On sauve l'état actuel des paramètres de l'image pour pouvoir les
// restituer en cas d'erreur n'affectant pas l'image // restituer en cas d'erreur n'affectant pas l'image
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
Load_picture(1); Load_picture(1);
Tilemap_update(); Tilemap_update();
@ -3315,7 +3315,7 @@ void Button_Reload(void)
// On sauve l'état actuel des paramètres de l'image pour pouvoir les // On sauve l'état actuel des paramètres de l'image pour pouvoir les
// restituer en cas d'erreur n'affectant pas l'image // restituer en cas d'erreur n'affectant pas l'image
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
if ( (!Main.image_is_modified) || Confirmation_box("Discard unsaved changes ?") ) if ( (!Main.image_is_modified) || Confirmation_box("Discard unsaved changes ?") )
{ {
@ -3329,7 +3329,7 @@ void Button_Reload(void)
Original_screen_X=0; Original_screen_X=0;
Original_screen_Y=0; Original_screen_Y=0;
Init_context_layered_image(&context, Main_backups->Pages->Filename, Main_backups->Pages->File_directory); Init_context_layered_image(&context, Main.backups->Pages->Filename, Main.backups->Pages->File_directory);
Load_image(&context); Load_image(&context);
Hide_cursor(); Hide_cursor();
@ -3406,7 +3406,7 @@ void Backup_filename(char * fname, char * backup_name)
short i; short i;
strcpy(backup_name,fname); strcpy(backup_name,fname);
for (i=strlen(fname)-strlen(Main_backups->Pages->Filename); backup_name[i]!='.'; i++); for (i=strlen(fname)-strlen(Main.backups->Pages->Filename); backup_name[i]!='.'; i++);
backup_name[i+1]='\0'; backup_name[i+1]='\0';
strcat(backup_name,"BAK"); strcat(backup_name,"BAK");
} }
@ -3417,7 +3417,7 @@ void Backup_existing_file(void)
char filename[MAX_PATH_CHARACTERS]; // Nom complet du fichier char filename[MAX_PATH_CHARACTERS]; // Nom complet du fichier
char new_filename[MAX_PATH_CHARACTERS]; // Nom complet du fichier backup char new_filename[MAX_PATH_CHARACTERS]; // Nom complet du fichier backup
Get_full_filename(filename, Main_backups->Pages->Filename, Main_backups->Pages->File_directory); Get_full_filename(filename, Main.backups->Pages->Filename, Main.backups->Pages->File_directory);
// Calcul du nom complet du fichier backup // Calcul du nom complet du fichier backup
Backup_filename(filename,new_filename); Backup_filename(filename,new_filename);
@ -3449,8 +3449,8 @@ void Save_picture(enum CONTEXT_TYPE type)
if (type == CONTEXT_MAIN_IMAGE) if (type == CONTEXT_MAIN_IMAGE)
{ {
strcpy(filename, Main_backups->Pages->Filename); strcpy(filename, Main.backups->Pages->Filename);
strcpy(directory, Main_backups->Pages->File_directory); strcpy(directory, Main.backups->Pages->File_directory);
Init_context_layered_image(&save_context, filename, directory); Init_context_layered_image(&save_context, filename, directory);
save_context.Format = Main.fileformat; save_context.Format = Main.fileformat;
} }
@ -3464,7 +3464,7 @@ void Save_picture(enum CONTEXT_TYPE type)
else if (type == CONTEXT_PALETTE) else if (type == CONTEXT_PALETTE)
{ {
char* dotpos; char* dotpos;
strcpy(filename, Main_backups->Pages->Filename); strcpy(filename, Main.backups->Pages->Filename);
// Replace extension with PAL // Replace extension with PAL
dotpos = strrchr(filename, '.'); dotpos = strrchr(filename, '.');
@ -3472,7 +3472,7 @@ void Save_picture(enum CONTEXT_TYPE type)
dotpos = filename + strlen(filename); dotpos = filename + strlen(filename);
strcpy(dotpos, ".pal"); strcpy(dotpos, ".pal");
strcpy(directory, Main_backups->Pages->File_directory); strcpy(directory, Main.backups->Pages->File_directory);
Init_context_layered_image(&save_context, filename, directory); Init_context_layered_image(&save_context, filename, directory);
save_context.Type = CONTEXT_PALETTE; save_context.Type = CONTEXT_PALETTE;
@ -3510,12 +3510,12 @@ void Save_picture(enum CONTEXT_TYPE type)
Save_image(&save_context); Save_image(&save_context);
format=Get_fileformat(save_context.Format); format=Get_fileformat(save_context.Format);
if (!File_error && type == CONTEXT_MAIN_IMAGE && !format->Palette_only && (Main_backups->Pages->Nb_layers==1 || format->Supports_layers)) if (!File_error && type == CONTEXT_MAIN_IMAGE && !format->Palette_only && (Main.backups->Pages->Nb_layers==1 || format->Supports_layers))
{ {
Main.image_is_modified=0; Main.image_is_modified=0;
Main.fileformat=save_context.Format; Main.fileformat=save_context.Format;
strcpy(Main_backups->Pages->Filename, save_context.File_name); strcpy(Main.backups->Pages->Filename, save_context.File_name);
strcpy(Main_backups->Pages->File_directory, save_context.File_directory); strcpy(Main.backups->Pages->File_directory, save_context.File_directory);
} }
if (type == CONTEXT_BRUSH) if (type == CONTEXT_BRUSH)
{ {
@ -3547,7 +3547,7 @@ void Button_Autosave(void)
byte file_already_exists; byte file_already_exists;
Get_full_filename(filename, Main_backups->Pages->Filename, Main_backups->Pages->File_directory); Get_full_filename(filename, Main.backups->Pages->Filename, Main.backups->Pages->File_directory);
file_already_exists=File_exists(filename); file_already_exists=File_exists(filename);
if ( (!file_already_exists) || Confirmation_box("Erase old file ?") ) if ( (!file_already_exists) || Confirmation_box("Erase old file ?") )
@ -3567,7 +3567,7 @@ void Button_Autosave(void)
Cursor_shape=CURSOR_SHAPE_HOURGLASS; Cursor_shape=CURSOR_SHAPE_HOURGLASS;
Display_cursor(); Display_cursor();
Init_context_layered_image(&save_context, Main_backups->Pages->Filename, Main_backups->Pages->File_directory); Init_context_layered_image(&save_context, Main.backups->Pages->Filename, Main.backups->Pages->File_directory);
Save_image(&save_context); Save_image(&save_context);
if (!File_error) if (!File_error)
{ {
@ -4557,7 +4557,7 @@ void Display_effect_states(void)
Display_effect_state(C3, L2, "Snap" ,Snap_mode); Display_effect_state(C3, L2, "Snap" ,Snap_mode);
Display_effect_state(C3, L4, "Tiling" ,Tiling_mode); Display_effect_state(C3, L4, "Tiling" ,Tiling_mode);
Display_effect_state(C2,L4, "8 bit" ,Main_backups->Pages->Image_mode > IMAGE_MODE_ANIMATION); Display_effect_state(C2,L4, "8 bit" ,Main.backups->Pages->Image_mode > IMAGE_MODE_ANIMATION);
Display_effect_state(C3,L3, "Tilemap",Main.tilemap_mode); Display_effect_state(C3,L3, "Tilemap",Main.tilemap_mode);
} }
@ -4858,7 +4858,7 @@ void Button_Effects(void)
{ {
Button_Constraint_mode(); Button_Constraint_mode();
Hide_cursor(); Hide_cursor();
Display_effect_state(C2,L4, "8 bit" ,Main_backups->Pages->Image_mode > IMAGE_MODE_ANIMATION); Display_effect_state(C2,L4, "8 bit" ,Main.backups->Pages->Image_mode > IMAGE_MODE_ANIMATION);
Display_cursor(); Display_cursor();
} else { } else {
Close_window(); Close_window();
@ -5613,5 +5613,5 @@ void Button_Brush_container(void)
byte Any_effect_active(void) byte Any_effect_active(void)
{ {
return Shade_mode||Quick_shade_mode||Colorize_mode||Smooth_mode||Tiling_mode||Smear_mode return Shade_mode||Quick_shade_mode||Colorize_mode||Smooth_mode||Tiling_mode||Smear_mode
||Stencil_mode||Mask_mode||Sieve_mode||Snap_mode||Main.tilemap_mode || (Main_backups->Pages->Image_mode > IMAGE_MODE_ANIMATION); ||Stencil_mode||Mask_mode||Sieve_mode||Snap_mode||Main.tilemap_mode || (Main.backups->Pages->Image_mode > IMAGE_MODE_ANIMATION);
} }

10
src/buttons_effects.c
View File

@ -170,7 +170,7 @@ void Button_Constraint_mode()
{ {
int pixel; int pixel;
if (Main_backups->Pages->Image_mode > IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode > IMAGE_MODE_ANIMATION)
{ {
// Disable // Disable
Switch_layer_mode(IMAGE_MODE_LAYERED); Switch_layer_mode(IMAGE_MODE_LAYERED);
@ -182,15 +182,15 @@ void Button_Constraint_mode()
if (Selected_Constraint_Mode == IMAGE_MODE_MODE5) if (Selected_Constraint_Mode == IMAGE_MODE_MODE5)
{ {
if (Main_backups->Pages->Image_mode != IMAGE_MODE_LAYERED || if (Main.backups->Pages->Image_mode != IMAGE_MODE_LAYERED ||
Main_backups->Pages->Nb_layers!=5 || (Main.image_width%48)) Main.backups->Pages->Nb_layers!=5 || (Main.image_width%48))
{ {
Verbose_message("Error!", "This emulation of Amstrad CPC's Mode5 can only be used on a 5-layer image whose width is a multiple of 48."); Verbose_message("Error!", "This emulation of Amstrad CPC's Mode5 can only be used on a 5-layer image whose width is a multiple of 48.");
return; return;
} }
for (pixel=0; pixel < Main.image_width*Main.image_height; pixel++) for (pixel=0; pixel < Main.image_width*Main.image_height; pixel++)
{ {
if (Main_backups->Pages->Image[4].Pixels[pixel]>3) if (Main.backups->Pages->Image[4].Pixels[pixel]>3)
{ {
Verbose_message("Error!", "This emulation of Amstrad CPC's Mode5 needs all pixels of layer 5 to use colors 0-3."); Verbose_message("Error!", "This emulation of Amstrad CPC's Mode5 needs all pixels of layer 5 to use colors 0-3.");
return; return;
@ -239,7 +239,7 @@ void Button_Constraint_menu(void)
if (clicked_button==2) // OK if (clicked_button==2) // OK
{ {
if ((Selected_Constraint_Mode > IMAGE_MODE_ANIMATION) if ((Selected_Constraint_Mode > IMAGE_MODE_ANIMATION)
&& (Main_backups->Pages->Image_mode <= IMAGE_MODE_ANIMATION)) && (Main.backups->Pages->Image_mode <= IMAGE_MODE_ANIMATION))
Button_Constraint_mode(); Button_Constraint_mode();
} }

8
src/engine.c
View File

@ -584,7 +584,7 @@ void Layer_preview_on(int * preview_is_visible)
{ {
int x,y; int x,y;
short layer; short layer;
short layercount = Main_backups->Pages->Nb_layers; short layercount = Main.backups->Pages->Nb_layers;
static int previewW=0, previewH=0; static int previewW=0, previewH=0;
if (! *preview_is_visible && layercount>1) if (! *preview_is_visible && layercount>1)
@ -623,7 +623,7 @@ void Layer_preview_on(int * preview_is_visible)
int imgx = x * Main.image_width / (previewW*Pixel_width*Menu_factor_X-1); int imgx = x * Main.image_width / (previewW*Pixel_width*Menu_factor_X-1);
int imgy = y * Main.image_height / (previewH*Pixel_height*Menu_factor_Y-1); int imgy = y * Main.image_height / (previewH*Pixel_height*Menu_factor_Y-1);
// Use Pixel_simple() in order to get highest resolution // Use Pixel_simple() in order to get highest resolution
Pixel_simple(x+((layer*Layer_button_width+offset)*Menu_factor_X+Window_pos_X)*Pixel_width, y+Window_pos_Y*Pixel_height+1, *(Main_backups->Pages->Image[layer].Pixels Pixel_simple(x+((layer*Layer_button_width+offset)*Menu_factor_X+Window_pos_X)*Pixel_width, y+Window_pos_Y*Pixel_height+1, *(Main.backups->Pages->Image[layer].Pixels
+ imgx + imgy * Main.image_width)); + imgx + imgy * Main.image_width));
} }
} }
@ -685,7 +685,7 @@ void Main_handler(void)
char* flimit; char* flimit;
byte old_cursor_shape; byte old_cursor_shape;
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
flimit = Find_last_separator(Drop_file_name); flimit = Find_last_separator(Drop_file_name);
*(flimit++) = '\0'; *(flimit++) = '\0';
@ -3646,7 +3646,7 @@ void Set_bar_visibility(word bar, int visible, int with_redraw)
/// Display_menu() and Display_all_screen() /// Display_menu() and Display_all_screen()
int Check_menu_mode(void) int Check_menu_mode(void)
{ {
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
if (Menu_bars[MENUBAR_LAYERS].Visible) if (Menu_bars[MENUBAR_LAYERS].Visible)
{ {

56
src/factory.c
View File

@ -218,7 +218,7 @@ void Backup_if_necessary(lua_State* L, int layer)
Is_backed_up = 1; Is_backed_up = 1;
if (layer == Main.current_layer) if (layer == Main.current_layer)
{ {
Main_backup_page = Main_backups->Pages->Next; Main_backup_page = Main.backups->Pages->Next;
Main_backup_screen = Screen_backup; Main_backup_screen = Screen_backup;
Register_main_writable(L); Register_main_writable(L);
} }
@ -230,7 +230,7 @@ void Backup_if_necessary(lua_State* L, int layer)
// Already OK // Already OK
return; return;
} }
if (Dup_layer_if_shared(Main_backups->Pages, layer)) if (Dup_layer_if_shared(Main.backups->Pages, layer))
{ {
// Depth buffer etc to modify too ? // Depth buffer etc to modify too ?
@ -391,17 +391,17 @@ int L_SetPictureSize(lua_State* L)
Backup_with_new_dimensions(w, h); Backup_with_new_dimensions(w, h);
} }
// part of Resize_image() : the pixel copy part. // part of Resize_image() : the pixel copy part.
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
Copy_part_of_image_to_another( Copy_part_of_image_to_another(
Main_backups->Pages->Next->Image[i].Pixels,0,0,Min(Main_backups->Pages->Next->Width,Main.image_width), Main.backups->Pages->Next->Image[i].Pixels,0,0,Min(Main.backups->Pages->Next->Width,Main.image_width),
Min(Main_backups->Pages->Next->Height,Main.image_height),Main_backups->Pages->Next->Width, Min(Main.backups->Pages->Next->Height,Main.image_height),Main.backups->Pages->Next->Width,
Main_backups->Pages->Image[i].Pixels,0,0,Main.image_width); Main.backups->Pages->Image[i].Pixels,0,0,Main.image_width);
} }
Redraw_layered_image(); Redraw_layered_image();
Is_backed_up = 1; Is_backed_up = 1;
Main_backup_page = Main_backups->Pages->Next; Main_backup_page = Main.backups->Pages->Next;
Main_backup_screen = Screen_backup; Main_backup_screen = Screen_backup;
Register_main_writable(L); Register_main_writable(L);
lua_register(L,"setcolor",L_SetColor); lua_register(L,"setcolor",L_SetColor);
@ -424,12 +424,12 @@ int L_SetSparePictureSize(lua_State* L)
Backup_and_resize_the_spare(w, h); Backup_and_resize_the_spare(w, h);
// part of Resize_image() : the pixel copy part. // part of Resize_image() : the pixel copy part.
for (i=0; i<Spare_backups->Pages->Nb_layers; i++) for (i=0; i<Spare.backups->Pages->Nb_layers; i++)
{ {
Copy_part_of_image_to_another( Copy_part_of_image_to_another(
Spare_backups->Pages->Next->Image[i].Pixels,0,0,Min(Spare_backups->Pages->Next->Width,Spare.image_width), Spare.backups->Pages->Next->Image[i].Pixels,0,0,Min(Spare.backups->Pages->Next->Width,Spare.image_width),
Min(Spare_backups->Pages->Next->Height,Spare.image_height),Spare_backups->Pages->Next->Width, Min(Spare.backups->Pages->Next->Height,Spare.image_height),Spare.backups->Pages->Next->Width,
Spare_backups->Pages->Image[i].Pixels,0,0,Spare.image_width); Spare.backups->Pages->Image[i].Pixels,0,0,Spare.image_width);
} }
Redraw_spare_image(); Redraw_spare_image();
@ -660,7 +660,7 @@ int L_GetPicturePixel(lua_State* L)
if (x<0 || y<0 || x>=Main.image_width || y>=Main.image_height) if (x<0 || y<0 || x>=Main.image_width || y>=Main.image_height)
{ {
// Silently return the image's transparent color // Silently return the image's transparent color
lua_pushinteger(L, Main_backups->Pages->Transparent_color); lua_pushinteger(L, Main.backups->Pages->Transparent_color);
return 1; return 1;
} }
lua_pushinteger(L, Read_pixel_from_current_screen(x,y)); lua_pushinteger(L, Read_pixel_from_current_screen(x,y));
@ -705,7 +705,7 @@ int L_GetLayerPixel(lua_State* L)
if (x<0 || y<0 || x>=Main.image_width || y>=Main.image_height) if (x<0 || y<0 || x>=Main.image_width || y>=Main.image_height)
{ {
// Silently return the image's transparent color // Silently return the image's transparent color
lua_pushinteger(L, Main_backups->Pages->Transparent_color); lua_pushinteger(L, Main.backups->Pages->Transparent_color);
return 1; return 1;
} }
lua_pushinteger(L, Read_pixel_from_current_layer(x,y)); lua_pushinteger(L, Read_pixel_from_current_layer(x,y));
@ -735,10 +735,10 @@ int L_GetSpareLayerPixel(lua_State* L)
if (x<0 || y<0 || x>=Spare.image_width || y>=Spare.image_height) if (x<0 || y<0 || x>=Spare.image_width || y>=Spare.image_height)
{ {
// Silently return the image's transparent color // Silently return the image's transparent color
lua_pushinteger(L, Spare_backups->Pages->Transparent_color); lua_pushinteger(L, Spare.backups->Pages->Transparent_color);
return 1; return 1;
} }
lua_pushinteger(L, *(Spare_backups->Pages->Image[Spare.current_layer].Pixels + y*Spare.image_width + x)); lua_pushinteger(L, *(Spare.backups->Pages->Image[Spare.current_layer].Pixels + y*Spare.image_width + x));
return 1; return 1;
} }
@ -756,7 +756,7 @@ int L_GetSparePicturePixel(lua_State* L)
if (x<0 || y<0) if (x<0 || y<0)
{ {
// Silently return the image's transparent color // Silently return the image's transparent color
lua_pushinteger(L, Spare_backups->Pages->Transparent_color); lua_pushinteger(L, Spare.backups->Pages->Transparent_color);
return 1; return 1;
} }
lua_pushinteger(L, Read_pixel_from_spare_screen(x,y)); lua_pushinteger(L, Read_pixel_from_spare_screen(x,y));
@ -779,7 +779,7 @@ int L_GetSpareColor(lua_State* L)
int L_GetSpareTransColor(lua_State* L) int L_GetSpareTransColor(lua_State* L)
{ {
lua_pushinteger(L, Spare_backups->Pages->Transparent_color); lua_pushinteger(L, Spare.backups->Pages->Transparent_color);
return 1; return 1;
} }
@ -949,7 +949,7 @@ int L_GetBackColor(lua_State* L)
int L_GetTransColor(lua_State* L) int L_GetTransColor(lua_State* L)
{ {
lua_pushinteger(L, Main_backups->Pages->Transparent_color); lua_pushinteger(L, Main.backups->Pages->Transparent_color);
return 1; return 1;
} }
@ -1893,7 +1893,7 @@ int L_GetLayerCount(lua_State* L)
LUA_ARG_LIMIT (0, "layercount"); LUA_ARG_LIMIT (0, "layercount");
lua_pushinteger(L, Main_backups->Pages->Nb_layers); lua_pushinteger(L, Main.backups->Pages->Nb_layers);
return 1; return 1;
} }
@ -1904,7 +1904,7 @@ int L_GetSpareLayerCount(lua_State* L)
LUA_ARG_LIMIT (0, "layercount"); LUA_ARG_LIMIT (0, "layercount");
lua_pushinteger(L, Spare_backups->Pages->Nb_layers); lua_pushinteger(L, Spare.backups->Pages->Nb_layers);
return 1; return 1;
} }
@ -1914,9 +1914,9 @@ int L_SelectSpareLayer(lua_State* L)
int nb_args=lua_gettop(L); int nb_args=lua_gettop(L);
LUA_ARG_LIMIT (1, "selectsparelayer"); LUA_ARG_LIMIT (1, "selectsparelayer");
LUA_ARG_NUMBER(1, "selectsparelayer", Spare.current_layer, 0, Spare_backups->Pages->Nb_layers - 1); LUA_ARG_NUMBER(1, "selectsparelayer", Spare.current_layer, 0, Spare.backups->Pages->Nb_layers - 1);
if (Spare_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Spare.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
if (! ((1 << Spare.current_layer) & Spare.layers_visible)) if (! ((1 << Spare.current_layer) & Spare.layers_visible))
{ {
@ -1932,11 +1932,11 @@ int L_SelectLayer(lua_State* L)
int nb_args=lua_gettop(L); int nb_args=lua_gettop(L);
LUA_ARG_LIMIT (1, "selectlayer"); LUA_ARG_LIMIT (1, "selectlayer");
LUA_ARG_NUMBER(1, "selectlayer", Main.current_layer, 0, Main_backups->Pages->Nb_layers - 1); LUA_ARG_NUMBER(1, "selectlayer", Main.current_layer, 0, Main.backups->Pages->Nb_layers - 1);
Backup_if_necessary(L, Main.current_layer); Backup_if_necessary(L, Main.current_layer);
// //
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
if (! ((1 << Main.current_layer) & Main.layers_visible)) if (! ((1 << Main.current_layer) & Main.layers_visible))
{ {
@ -1965,7 +1965,7 @@ int L_FinalizePicture(lua_State* L)
End_of_modification(); End_of_modification();
} }
Is_backed_up = 0; Is_backed_up = 0;
Main_backup_page = Main_backups->Pages; Main_backup_page = Main.backups->Pages;
Main_backup_screen = Main_screen; Main_backup_screen = Main_screen;
Register_main_readonly(L); Register_main_readonly(L);
lua_register(L,"setcolor",L_SetColor_unsaved); lua_register(L,"setcolor",L_SetColor_unsaved);
@ -1980,8 +1980,8 @@ int L_GetFileName(lua_State* L)
LUA_ARG_LIMIT (0, "getfilename"); LUA_ARG_LIMIT (0, "getfilename");
lua_pushstring(L, Main_backups->Pages->Filename); lua_pushstring(L, Main.backups->Pages->Filename);
lua_pushstring(L, Main_backups->Pages->File_directory); lua_pushstring(L, Main.backups->Pages->File_directory);
return 2; return 2;
} }
@ -2428,7 +2428,7 @@ void Run_script(const char *script_subdirectory, const char *script_filename)
// like a feedback off effect (convolution matrix comes to mind). // like a feedback off effect (convolution matrix comes to mind).
//Backup(); //Backup();
Is_backed_up = 0; Is_backed_up = 0;
Main_backup_page = Main_backups->Pages; Main_backup_page = Main.backups->Pages;
Main_backup_screen = Main_screen; Main_backup_screen = Main_screen;
Backup_the_spare(LAYER_ALL); Backup_the_spare(LAYER_ALL);

22
src/fileformats.c
View File

@ -766,7 +766,7 @@ void Load_IFF(T_IO_Context * context)
if (context->Type == CONTEXT_MAIN_IMAGE) if (context->Type == CONTEXT_MAIN_IMAGE)
{ {
Main_backups->Pages->Image_mode = IMAGE_MODE_ANIMATION; Main.backups->Pages->Image_mode = IMAGE_MODE_ANIMATION;
Update_screen_targets(); Update_screen_targets();
} }
if (File_error==0) if (File_error==0)
@ -2639,7 +2639,7 @@ void Load_GIF(T_IO_Context * context)
// Load as an animation // Load as an animation
if (context->Type == CONTEXT_MAIN_IMAGE) if (context->Type == CONTEXT_MAIN_IMAGE)
{ {
Main_backups->Pages->Image_mode = IMAGE_MODE_ANIMATION; Main.backups->Pages->Image_mode = IMAGE_MODE_ANIMATION;
Update_screen_targets(); Update_screen_targets();
} }
// Skip sub-block // Skip sub-block
@ -2756,13 +2756,13 @@ void Load_GIF(T_IO_Context * context)
// Attempt to add a layer to current image // Attempt to add a layer to current image
current_layer++; current_layer++;
Set_loading_layer(context, current_layer); Set_loading_layer(context, current_layer);
if (context->Type == CONTEXT_MAIN_IMAGE && Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (context->Type == CONTEXT_MAIN_IMAGE && Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
// Copy the content of previous layer. // Copy the content of previous layer.
memcpy( memcpy(
Main_backups->Pages->Image[Main.current_layer].Pixels, Main.backups->Pages->Image[Main.current_layer].Pixels,
Main_backups->Pages->Image[Main.current_layer-1].Pixels, Main.backups->Pages->Image[Main.current_layer-1].Pixels,
Main_backups->Pages->Width*Main_backups->Pages->Height); Main.backups->Pages->Width*Main.backups->Pages->Height);
} }
else else
{ {
@ -2812,7 +2812,7 @@ void Load_GIF(T_IO_Context * context)
if (number_LID!=1) if (number_LID!=1)
{ {
// This a second layer/frame, or more. // This a second layer/frame, or more.
if (context->Type == CONTEXT_MAIN_IMAGE && Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (context->Type == CONTEXT_MAIN_IMAGE && Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
// Need to clear previous image to back-color. // Need to clear previous image to back-color.
if (previous_disposal_method==DISPOSAL_METHOD_RESTORE_BGCOLOR) if (previous_disposal_method==DISPOSAL_METHOD_RESTORE_BGCOLOR)
@ -2820,8 +2820,8 @@ void Load_GIF(T_IO_Context * context)
int y; int y;
for (y=0; y<previous_height; y++) for (y=0; y<previous_height; y++)
memset( memset(
Main_backups->Pages->Image[Main.current_layer].Pixels Main.backups->Pages->Image[Main.current_layer].Pixels
+ (previous_pos_y+y)* Main_backups->Pages->Width+previous_pos_x, + (previous_pos_y+y)* Main.backups->Pages->Width+previous_pos_x,
is_transparent ? context->Transparent_color : LSDB.Backcol, is_transparent ? context->Transparent_color : LSDB.Backcol,
previous_width); previous_width);
} }
@ -3152,7 +3152,7 @@ void Save_GIF(T_IO_Context * context)
// Write_bytes(GIF_file,"\x21\xFF\x0BNETSCAPE2.0\x03\xLL\xSS\xSS\x00",19); // Write_bytes(GIF_file,"\x21\xFF\x0BNETSCAPE2.0\x03\xLL\xSS\xSS\x00",19);
// LL : 01 to loop // LL : 01 to loop
// SSSS : number of loops // SSSS : number of loops
if (context->Type == CONTEXT_MAIN_IMAGE && Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (context->Type == CONTEXT_MAIN_IMAGE && Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
if (context->Nb_layers>1) if (context->Nb_layers>1)
Write_bytes(GIF_file,"\x21\xFF\x0BNETSCAPE2.0\x03\x01\x00\x00\x00",19); Write_bytes(GIF_file,"\x21\xFF\x0BNETSCAPE2.0\x03\x01\x00\x00\x00",19);
@ -3198,7 +3198,7 @@ void Save_GIF(T_IO_Context * context)
GCE.Function = 0xF9; GCE.Function = 0xF9;
GCE.Block_size=4; GCE.Block_size=4;
if (context->Type == CONTEXT_MAIN_IMAGE && Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (context->Type == CONTEXT_MAIN_IMAGE && Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
// Animation frame // Animation frame
int duration; int duration;

4
src/global.h
View File

@ -407,9 +407,9 @@ GFX2_GLOBAL byte Spare_safety_backup_prefix;
/// Backup of the current screen, used during drawing when FX feedback is OFF. /// Backup of the current screen, used during drawing when FX feedback is OFF.
GFX2_GLOBAL byte * Screen_backup; GFX2_GLOBAL byte * Screen_backup;
/// List of backup pages for the main image. /// List of backup pages for the main image.
GFX2_GLOBAL T_List_of_pages * Main_backups;//TODO //GFX2_GLOBAL T_List_of_pages * Main_backups;
/// List of backup pages for the spare page. /// List of backup pages for the spare page.
GFX2_GLOBAL T_List_of_pages * Spare_backups;//TODO //GFX2_GLOBAL T_List_of_pages * Spare_backups;
// -- Brush data // -- Brush data

130
src/graph.c
View File

@ -532,7 +532,7 @@ void Resize_image(word chosen_width,word chosen_height)
// |B| | C = Nouvelle image // |B| | C = Nouvelle image
// +-+-+ // +-+-+
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
if (Backup_with_new_dimensions(chosen_width,chosen_height)) if (Backup_with_new_dimensions(chosen_width,chosen_height))
{ {
// La nouvelle page a pu être allouée, elle est pour l'instant pleine de // La nouvelle page a pu être allouée, elle est pour l'instant pleine de
@ -541,12 +541,12 @@ void Resize_image(word chosen_width,word chosen_height)
Main.image_is_modified=1; Main.image_is_modified=1;
// On copie donc maintenant la partie C dans la nouvelle image. // On copie donc maintenant la partie C dans la nouvelle image.
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
Copy_part_of_image_to_another( Copy_part_of_image_to_another(
Main_backups->Pages->Next->Image[i].Pixels,0,0,Min(old_width,Main.image_width), Main.backups->Pages->Next->Image[i].Pixels,0,0,Min(old_width,Main.image_width),
Min(old_height,Main.image_height),old_width, Min(old_height,Main.image_height),old_width,
Main_backups->Pages->Image[i].Pixels,0,0,Main.image_width); Main.backups->Pages->Image[i].Pixels,0,0,Main.image_width);
} }
Redraw_layered_image(); Redraw_layered_image();
} }
@ -574,10 +574,10 @@ void Remap_spare(void)
used[color]=0; used[color]=0;
// On calcule la table d'utilisation des couleurs // On calcule la table d'utilisation des couleurs
for (layer=0; layer<Spare_backups->Pages->Nb_layers; layer++) for (layer=0; layer<Spare.backups->Pages->Nb_layers; layer++)
for (y_pos=0;y_pos<Spare.image_height;y_pos++) for (y_pos=0;y_pos<Spare.image_height;y_pos++)
for (x_pos=0;x_pos<Spare.image_width;x_pos++) for (x_pos=0;x_pos<Spare.image_width;x_pos++)
used[*(Spare_backups->Pages->Image[layer].Pixels+(y_pos*Spare.image_width+x_pos))]=1; used[*(Spare.backups->Pages->Image[layer].Pixels+(y_pos*Spare.image_width+x_pos))]=1;
// On va maintenant se servir de la table "used" comme table de // On va maintenant se servir de la table "used" comme table de
// conversion: pour chaque indice, la table donne une couleur de // conversion: pour chaque indice, la table donne une couleur de
@ -593,11 +593,11 @@ void Remap_spare(void)
// Maintenant qu'on a une super table de conversion qui n'a que le nom // Maintenant qu'on a une super table de conversion qui n'a que le nom
// qui craint un peu, on peut faire l'échange dans la brosse de toutes les // qui craint un peu, on peut faire l'échange dans la brosse de toutes les
// teintes. // teintes.
for (layer=0; layer<Spare_backups->Pages->Nb_layers; layer++) for (layer=0; layer<Spare.backups->Pages->Nb_layers; layer++)
Remap_general_lowlevel(used,Spare_backups->Pages->Image[layer].Pixels,Spare_backups->Pages->Image[layer].Pixels,Spare.image_width,Spare.image_height,Spare.image_width); Remap_general_lowlevel(used,Spare.backups->Pages->Image[layer].Pixels,Spare.backups->Pages->Image[layer].Pixels,Spare.image_width,Spare.image_height,Spare.image_width);
// Change transparent color index // Change transparent color index
Spare_backups->Pages->Transparent_color=used[Spare_backups->Pages->Transparent_color]; Spare.backups->Pages->Transparent_color=used[Spare.backups->Pages->Transparent_color];
} }
@ -891,7 +891,7 @@ void Fill(short * top_reached , short * bottom_reached,
byte Read_pixel_from_backup_layer(word x,word y) byte Read_pixel_from_backup_layer(word x,word y)
{ {
return *((y)*Main.image_width+(x)+Main_backups->Pages->Next->Image[Main.current_layer].Pixels); return *((y)*Main.image_width+(x)+Main.backups->Pages->Next->Image[Main.current_layer].Pixels);
} }
void Fill_general(byte fill_color) void Fill_general(byte fill_color)
@ -973,34 +973,34 @@ void Fill_general(byte fill_color)
// Il va maintenant falloir qu'on "turn" ce gros caca "into" un truc qui // Il va maintenant falloir qu'on "turn" ce gros caca "into" un truc qui
// ressemble un peu plus à ce à quoi l'utilisateur peut s'attendre. // ressemble un peu plus à ce à quoi l'utilisateur peut s'attendre.
if (top_reached>Limit_top) if (top_reached>Limit_top)
Copy_part_of_image_to_another(Main_backups->Pages->Next->Image[Main.current_layer].Pixels, // source Copy_part_of_image_to_another(Main.backups->Pages->Next->Image[Main.current_layer].Pixels, // source
Limit_left,Limit_top, // Pos X et Y dans source Limit_left,Limit_top, // Pos X et Y dans source
(Limit_right-Limit_left)+1, // width copie (Limit_right-Limit_left)+1, // width copie
top_reached-Limit_top,// height copie top_reached-Limit_top,// height copie
Main.image_width, // width de la source Main.image_width, // width de la source
Main_backups->Pages->Image[Main.current_layer].Pixels, // Destination Main.backups->Pages->Image[Main.current_layer].Pixels, // Destination
Limit_left,Limit_top, // Pos X et Y destination Limit_left,Limit_top, // Pos X et Y destination
Main.image_width); // width destination Main.image_width); // width destination
if (bottom_reached<Limit_bottom) if (bottom_reached<Limit_bottom)
Copy_part_of_image_to_another(Main_backups->Pages->Next->Image[Main.current_layer].Pixels, Copy_part_of_image_to_another(Main.backups->Pages->Next->Image[Main.current_layer].Pixels,
Limit_left,bottom_reached+1, Limit_left,bottom_reached+1,
(Limit_right-Limit_left)+1, (Limit_right-Limit_left)+1,
Limit_bottom-bottom_reached, Limit_bottom-bottom_reached,
Main.image_width,Main_backups->Pages->Image[Main.current_layer].Pixels, Main.image_width,Main.backups->Pages->Image[Main.current_layer].Pixels,
Limit_left,bottom_reached+1,Main.image_width); Limit_left,bottom_reached+1,Main.image_width);
if (left_reached>Limit_left) if (left_reached>Limit_left)
Copy_part_of_image_to_another(Main_backups->Pages->Next->Image[Main.current_layer].Pixels, Copy_part_of_image_to_another(Main.backups->Pages->Next->Image[Main.current_layer].Pixels,
Limit_left,top_reached, Limit_left,top_reached,
left_reached-Limit_left, left_reached-Limit_left,
(bottom_reached-top_reached)+1, (bottom_reached-top_reached)+1,
Main.image_width,Main_backups->Pages->Image[Main.current_layer].Pixels, Main.image_width,Main.backups->Pages->Image[Main.current_layer].Pixels,
Limit_left,top_reached,Main.image_width); Limit_left,top_reached,Main.image_width);
if (right_reached<Limit_right) if (right_reached<Limit_right)
Copy_part_of_image_to_another(Main_backups->Pages->Next->Image[Main.current_layer].Pixels, Copy_part_of_image_to_another(Main.backups->Pages->Next->Image[Main.current_layer].Pixels,
right_reached+1,top_reached, right_reached+1,top_reached,
Limit_right-right_reached, Limit_right-right_reached,
(bottom_reached-top_reached)+1, (bottom_reached-top_reached)+1,
Main.image_width,Main_backups->Pages->Image[Main.current_layer].Pixels, Main.image_width,Main.backups->Pages->Image[Main.current_layer].Pixels,
right_reached+1,top_reached,Main.image_width); right_reached+1,top_reached,Main.image_width);
// Restore image limits : this is needed by the tilemap effect, // Restore image limits : this is needed by the tilemap effect,
@ -2901,9 +2901,9 @@ byte Effect_smooth(word x,word y,byte color)
byte Effect_layer_copy(word x,word y,byte color) byte Effect_layer_copy(word x,word y,byte color)
{ {
if (color<Main_backups->Pages->Nb_layers) if (color<Main.backups->Pages->Nb_layers)
{ {
return *((y)*Main.image_width+(x)+Main_backups->Pages->Image[color].Pixels); return *((y)*Main.image_width+(x)+Main.backups->Pages->Image[color].Pixels);
} }
return Read_pixel_from_feedback_screen(x,y); return Read_pixel_from_feedback_screen(x,y);
} }
@ -2952,33 +2952,33 @@ byte Read_pixel_from_current_screen (word x,word y)
byte depth; byte depth;
byte color; byte color;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
return *((y)*Main.image_width+(x)+Main_backups->Pages->Image[Main.current_layer].Pixels); return *((y)*Main.image_width+(x)+Main.backups->Pages->Image[Main.current_layer].Pixels);
} }
if (Main_backups->Pages->Image_mode == IMAGE_MODE_MODE5) if (Main.backups->Pages->Image_mode == IMAGE_MODE_MODE5)
if (Main.current_layer==4) if (Main.current_layer==4)
return *(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width); return *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width);
color = *(Main_screen+y*Main.image_width+x); color = *(Main_screen+y*Main.image_width+x);
if (color != Main_backups->Pages->Transparent_color) // transparent color if (color != Main.backups->Pages->Transparent_color) // transparent color
return color; return color;
depth = *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width); depth = *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width);
return *(Main_backups->Pages->Image[depth].Pixels + x+y*Main.image_width); return *(Main.backups->Pages->Image[depth].Pixels + x+y*Main.image_width);
} }
/// Paint a a single pixel in image only : as-is. /// Paint a a single pixel in image only : as-is.
void Pixel_in_screen_direct(word x,word y,byte color) void Pixel_in_screen_direct(word x,word y,byte color)
{ {
*((y)*Main.image_width+(x)+Main_backups->Pages->Image[Main.current_layer].Pixels)=color; *((y)*Main.image_width+(x)+Main.backups->Pages->Image[Main.current_layer].Pixels)=color;
} }
/// Paint a a single pixel in image and on screen: as-is. /// Paint a a single pixel in image and on screen: as-is.
void Pixel_in_screen_direct_with_preview(word x,word y,byte color) void Pixel_in_screen_direct_with_preview(word x,word y,byte color)
{ {
*((y)*Main.image_width+(x)+Main_backups->Pages->Image[Main.current_layer].Pixels)=color; *((y)*Main.image_width+(x)+Main.backups->Pages->Image[Main.current_layer].Pixels)=color;
Pixel_preview(x,y,color); Pixel_preview(x,y,color);
} }
@ -2986,12 +2986,12 @@ void Pixel_in_screen_direct_with_preview(word x,word y,byte color)
void Pixel_in_screen_layered(word x,word y,byte color) void Pixel_in_screen_layered(word x,word y,byte color)
{ {
byte depth = *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width); byte depth = *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width);
*(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color; *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color;
if ( depth <= Main.current_layer) if ( depth <= Main.current_layer)
{ {
if (color == Main_backups->Pages->Transparent_color) // transparent color if (color == Main.backups->Pages->Transparent_color) // transparent color
// fetch pixel color from the topmost visible layer // fetch pixel color from the topmost visible layer
color=*(Main_backups->Pages->Image[depth].Pixels + x+y*Main.image_width); color=*(Main.backups->Pages->Image[depth].Pixels + x+y*Main.image_width);
*(x+y*Main.image_width+Main_screen)=color; *(x+y*Main.image_width+Main_screen)=color;
} }
@ -3001,12 +3001,12 @@ void Pixel_in_screen_layered(word x,word y,byte color)
void Pixel_in_screen_layered_with_preview(word x,word y,byte color) void Pixel_in_screen_layered_with_preview(word x,word y,byte color)
{ {
byte depth = *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width); byte depth = *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width);
*(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color; *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color;
if ( depth <= Main.current_layer) if ( depth <= Main.current_layer)
{ {
if (color == Main_backups->Pages->Transparent_color) // transparent color if (color == Main.backups->Pages->Transparent_color) // transparent color
// fetch pixel color from the topmost visible layer // fetch pixel color from the topmost visible layer
color=*(Main_backups->Pages->Image[depth].Pixels + x+y*Main.image_width); color=*(Main.backups->Pages->Image[depth].Pixels + x+y*Main.image_width);
*(x+y*Main.image_width+Main_screen)=color; *(x+y*Main.image_width+Main_screen)=color;
@ -3017,7 +3017,7 @@ void Pixel_in_screen_layered_with_preview(word x,word y,byte color)
void Pixel_in_screen_egx(word x,word y,byte color) void Pixel_in_screen_egx(word x,word y,byte color)
{ {
uint8_t mask; uint8_t mask;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_EGX) if (Main.backups->Pages->Image_mode == IMAGE_MODE_EGX)
{ {
mask = 0xF3; mask = 0xF3;
} else { } else {
@ -3036,7 +3036,7 @@ void Pixel_in_screen_egx(word x,word y,byte color)
void Pixel_in_screen_egx_with_preview(word x,word y,byte color) void Pixel_in_screen_egx_with_preview(word x,word y,byte color)
{ {
uint8_t mask; uint8_t mask;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_EGX) if (Main.backups->Pages->Image_mode == IMAGE_MODE_EGX)
{ {
mask = 0xF3; mask = 0xF3;
} else { } else {
@ -3059,14 +3059,14 @@ void Pixel_in_screen_thomson(word x,word y,byte color)
uint8_t c1, c2; uint8_t c1, c2;
// The color we are going to replace // The color we are going to replace
c1 = *(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width); c1 = *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width);
if (c1 == color) if (c1 == color)
return; return;
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width); c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width);
if (c2 == color) if (c2 == color)
continue; continue;
if (c2 != c1) if (c2 != c1)
@ -3082,7 +3082,7 @@ void Pixel_in_screen_thomson(word x,word y,byte color)
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width); c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width);
if (c2 == c1) { if (c2 == c1) {
Pixel_in_screen_layered(x2+start,y,color); Pixel_in_screen_layered(x2+start,y,color);
} }
@ -3096,14 +3096,14 @@ void Pixel_in_screen_thomson_with_preview(word x,word y,byte color)
uint8_t c1, c2; uint8_t c1, c2;
// The color we are going to replace // The color we are going to replace
c1 = *(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width); c1 = *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width);
if (c1 == color) if (c1 == color)
return; return;
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width); c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width);
if (c2 == color) if (c2 == color)
continue; continue;
if (c2 != c1) if (c2 != c1)
@ -3119,7 +3119,7 @@ void Pixel_in_screen_thomson_with_preview(word x,word y,byte color)
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width); c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels + (x2+start)+y*Main.image_width);
if (c2 == c1) { if (c2 == c1) {
Pixel_in_screen_layered_with_preview(x2+start,y,color); Pixel_in_screen_layered_with_preview(x2+start,y,color);
} }
@ -3134,7 +3134,7 @@ void Pixel_in_screen_zx(word x,word y,byte color)
uint8_t c1, c2; uint8_t c1, c2;
// The color we are going to replace // The color we are going to replace
c1 = *(Main_backups->Pages->Image[Main.current_layer].Pixels c1 = *(Main.backups->Pages->Image[Main.current_layer].Pixels
+ x + y * Main.image_width); + x + y * Main.image_width);
if (c1 == color) if (c1 == color)
@ -3144,7 +3144,7 @@ void Pixel_in_screen_zx(word x,word y,byte color)
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
for (y2 = 0; y2 < 8; y2++) for (y2 = 0; y2 < 8; y2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels
+ (x2 + start) + (y2 + starty) * Main.image_width); + (x2 + start) + (y2 + starty) * Main.image_width);
// Pixel is already of the color we are going to add, it is no problem // Pixel is already of the color we are going to add, it is no problem
if (c2 == color) if (c2 == color)
@ -3177,7 +3177,7 @@ done:
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
for (y2 = 0; y2 < 8; y2++) for (y2 = 0; y2 < 8; y2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels
+ (x2 + start) + (y2 + starty) * Main.image_width); + (x2 + start) + (y2 + starty) * Main.image_width);
if (c2 == c1) { if (c2 == c1) {
Pixel_in_screen_layered(x2+start,y2+starty,color); Pixel_in_screen_layered(x2+start,y2+starty,color);
@ -3196,7 +3196,7 @@ void Pixel_in_screen_zx_with_preview(word x,word y,byte color)
uint8_t c1, c2; uint8_t c1, c2;
// The color we are going to replace // The color we are going to replace
c1 = *(Main_backups->Pages->Image[Main.current_layer].Pixels c1 = *(Main.backups->Pages->Image[Main.current_layer].Pixels
+ x + y * Main.image_width); + x + y * Main.image_width);
// Pixel is already of the wanted color: nothing to do // Pixel is already of the wanted color: nothing to do
@ -3207,7 +3207,7 @@ void Pixel_in_screen_zx_with_preview(word x,word y,byte color)
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
for (y2 = 0; y2 < 8; y2++) for (y2 = 0; y2 < 8; y2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels
+ (x2 + start) + (y2 + starty) * Main.image_width); + (x2 + start) + (y2 + starty) * Main.image_width);
// Pixel is already of the color we are going to add, it is no problem // Pixel is already of the color we are going to add, it is no problem
if (c2 == color) if (c2 == color)
@ -3240,7 +3240,7 @@ done:
for (x2 = 0; x2 < 8; x2++) for (x2 = 0; x2 < 8; x2++)
for (y2 = 0; y2 < 8; y2++) for (y2 = 0; y2 < 8; y2++)
{ {
c2 = *(Main_backups->Pages->Image[Main.current_layer].Pixels c2 = *(Main.backups->Pages->Image[Main.current_layer].Pixels
+ (x2 + start) + (y2 + starty) * Main.image_width); + (x2 + start) + (y2 + starty) * Main.image_width);
if (c2 == c1) { if (c2 == c1) {
Pixel_in_screen_layered_with_preview(x2+start,y2+starty,color); Pixel_in_screen_layered_with_preview(x2+start,y2+starty,color);
@ -3257,9 +3257,9 @@ void Pixel_in_screen_underlay(word x,word y,byte color)
byte depth; byte depth;
// Paste in layer // Paste in layer
*(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color; *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color;
// Search depth // Search depth
depth = *(Main_backups->Pages->Image[4].Pixels + x+y*Main.image_width); depth = *(Main.backups->Pages->Image[4].Pixels + x+y*Main.image_width);
if ( depth == Main.current_layer) if ( depth == Main.current_layer)
{ {
@ -3274,9 +3274,9 @@ void Pixel_in_screen_underlay_with_preview(word x,word y,byte color)
byte depth; byte depth;
// Paste in layer // Paste in layer
*(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color; *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color;
// Search depth // Search depth
depth = *(Main_backups->Pages->Image[4].Pixels + x+y*Main.image_width); depth = *(Main.backups->Pages->Image[4].Pixels + x+y*Main.image_width);
if ( depth == Main.current_layer) if ( depth == Main.current_layer)
{ {
@ -3293,12 +3293,12 @@ void Pixel_in_screen_overlay(word x,word y,byte color)
if (color<4) if (color<4)
{ {
// Paste in layer // Paste in layer
*(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color; *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color;
// Paste in depth buffer // Paste in depth buffer
*(Main_visible_image_depth_buffer.Image+x+y*Main.image_width)=color; *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width)=color;
// Fetch pixel color from the target raster layer // Fetch pixel color from the target raster layer
if (Main.layers_visible & (1 << color)) if (Main.layers_visible & (1 << color))
color=*(Main_backups->Pages->Image[color].Pixels + x+y*Main.image_width); color=*(Main.backups->Pages->Image[color].Pixels + x+y*Main.image_width);
// Draw that color on the visible image buffer // Draw that color on the visible image buffer
*(x+y*Main.image_width+Main_screen)=color; *(x+y*Main.image_width+Main_screen)=color;
} }
@ -3310,12 +3310,12 @@ void Pixel_in_screen_overlay_with_preview(word x,word y,byte color)
if (color<4) if (color<4)
{ {
// Paste in layer // Paste in layer
*(Main_backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color; *(Main.backups->Pages->Image[Main.current_layer].Pixels + x+y*Main.image_width)=color;
// Paste in depth buffer // Paste in depth buffer
*(Main_visible_image_depth_buffer.Image+x+y*Main.image_width)=color; *(Main_visible_image_depth_buffer.Image+x+y*Main.image_width)=color;
// Fetch pixel color from the target raster layer // Fetch pixel color from the target raster layer
if (Main.layers_visible & (1 << color)) if (Main.layers_visible & (1 << color))
color=*(Main_backups->Pages->Image[color].Pixels + x+y*Main.image_width); color=*(Main.backups->Pages->Image[color].Pixels + x+y*Main.image_width);
// Draw that color on the visible image buffer // Draw that color on the visible image buffer
*(x+y*Main.image_width+Main_screen)=color; *(x+y*Main.image_width+Main_screen)=color;
@ -3328,50 +3328,50 @@ Func_pixel Pixel_in_current_screen_with_preview=Pixel_in_screen_direct_with_prev
void Pixel_in_spare(word x,word y, byte color) void Pixel_in_spare(word x,word y, byte color)
{ {
*((y)*Spare.image_width+(x)+Spare_backups->Pages->Image[Spare.current_layer].Pixels)=color; *((y)*Spare.image_width+(x)+Spare.backups->Pages->Image[Spare.current_layer].Pixels)=color;
} }
void Pixel_in_current_layer(word x,word y, byte color) void Pixel_in_current_layer(word x,word y, byte color)
{ {
*((y)*Main.image_width+(x)+Main_backups->Pages->Image[Main.current_layer].Pixels)=color; *((y)*Main.image_width+(x)+Main.backups->Pages->Image[Main.current_layer].Pixels)=color;
} }
byte Read_pixel_from_current_layer(word x,word y) byte Read_pixel_from_current_layer(word x,word y)
{ {
return *((y)*Main.image_width+(x)+Main_backups->Pages->Image[Main.current_layer].Pixels); return *((y)*Main.image_width+(x)+Main.backups->Pages->Image[Main.current_layer].Pixels);
} }
void Update_pixel_renderer(void) void Update_pixel_renderer(void)
{ {
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
// direct // direct
Pixel_in_current_screen = Pixel_in_screen_direct; Pixel_in_current_screen = Pixel_in_screen_direct;
Pixel_in_current_screen_with_preview = Pixel_in_screen_direct_with_preview; Pixel_in_current_screen_with_preview = Pixel_in_screen_direct_with_preview;
} }
else else
if (Main_backups->Pages->Image_mode == IMAGE_MODE_LAYERED) if (Main.backups->Pages->Image_mode == IMAGE_MODE_LAYERED)
{ {
// layered // layered
Pixel_in_current_screen = Pixel_in_screen_layered; Pixel_in_current_screen = Pixel_in_screen_layered;
Pixel_in_current_screen_with_preview = Pixel_in_screen_layered_with_preview; Pixel_in_current_screen_with_preview = Pixel_in_screen_layered_with_preview;
} }
else else
if (Main_backups->Pages->Image_mode == IMAGE_MODE_EGX if (Main.backups->Pages->Image_mode == IMAGE_MODE_EGX
|| Main_backups->Pages->Image_mode == IMAGE_MODE_EGX2) || Main.backups->Pages->Image_mode == IMAGE_MODE_EGX2)
{ {
// special "EGX" mode // special "EGX" mode
Pixel_in_current_screen = Pixel_in_screen_egx; Pixel_in_current_screen = Pixel_in_screen_egx;
Pixel_in_current_screen_with_preview = Pixel_in_screen_egx_with_preview; Pixel_in_current_screen_with_preview = Pixel_in_screen_egx_with_preview;
} }
else else
if (Main_backups->Pages->Image_mode == IMAGE_MODE_THOMSON) if (Main.backups->Pages->Image_mode == IMAGE_MODE_THOMSON)
{ {
Pixel_in_current_screen = Pixel_in_screen_thomson; Pixel_in_current_screen = Pixel_in_screen_thomson;
Pixel_in_current_screen_with_preview = Pixel_in_screen_thomson_with_preview; Pixel_in_current_screen_with_preview = Pixel_in_screen_thomson_with_preview;
} }
else else
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ZX) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ZX)
{ {
Pixel_in_current_screen = Pixel_in_screen_zx; Pixel_in_current_screen = Pixel_in_screen_zx;
Pixel_in_current_screen_with_preview = Pixel_in_screen_zx_with_preview; Pixel_in_current_screen_with_preview = Pixel_in_screen_zx_with_preview;

21
src/input.c
View File

@ -1091,13 +1091,13 @@ int Color_cycling(void)
{ {
int len; int len;
len=Main_backups->Pages->Gradients->Range[i].End-Main_backups->Pages->Gradients->Range[i].Start+1; len=Main.backups->Pages->Gradients->Range[i].End-Main.backups->Pages->Gradients->Range[i].Start+1;
if (len>1 && Main_backups->Pages->Gradients->Range[i].Speed) if (len>1 && Main.backups->Pages->Gradients->Range[i].Speed)
{ {
int new_offset; int new_offset;
new_offset=(now-start)/(int)(1000.0/(Main_backups->Pages->Gradients->Range[i].Speed*0.2856)) % len; new_offset=(now-start)/(int)(1000.0/(Main.backups->Pages->Gradients->Range[i].Speed*0.2856)) % len;
if (!Main_backups->Pages->Gradients->Range[i].Inverse) if (!Main.backups->Pages->Gradients->Range[i].Inverse)
new_offset=len - new_offset; new_offset=len - new_offset;
if (new_offset!=offset[i]) if (new_offset!=offset[i])
@ -1118,14 +1118,15 @@ int Color_cycling(void)
{ {
int len; int len;
len=Main_backups->Pages->Gradients->Range[i].End-Main_backups->Pages->Gradients->Range[i].Start+1; // TODO improve
if (len>1 && Main_backups->Pages->Gradients->Range[i].Speed) len=Main.backups->Pages->Gradients->Range[i].End-Main.backups->Pages->Gradients->Range[i].Start+1;
if (len>1 && Main.backups->Pages->Gradients->Range[i].Speed)
{ {
for(color=Main_backups->Pages->Gradients->Range[i].Start;color<=Main_backups->Pages->Gradients->Range[i].End;color++) for(color=Main.backups->Pages->Gradients->Range[i].Start;color<=Main.backups->Pages->Gradients->Range[i].End;color++)
{ {
PaletteSDL[color].r=Main.palette[Main_backups->Pages->Gradients->Range[i].Start+((color-Main_backups->Pages->Gradients->Range[i].Start+offset[i])%len)].R; PaletteSDL[color].r=Main.palette[Main.backups->Pages->Gradients->Range[i].Start+((color-Main.backups->Pages->Gradients->Range[i].Start+offset[i])%len)].R;
PaletteSDL[color].g=Main.palette[Main_backups->Pages->Gradients->Range[i].Start+((color-Main_backups->Pages->Gradients->Range[i].Start+offset[i])%len)].G; PaletteSDL[color].g=Main.palette[Main.backups->Pages->Gradients->Range[i].Start+((color-Main.backups->Pages->Gradients->Range[i].Start+offset[i])%len)].G;
PaletteSDL[color].b=Main.palette[Main_backups->Pages->Gradients->Range[i].Start+((color-Main_backups->Pages->Gradients->Range[i].Start+offset[i])%len)].B; PaletteSDL[color].b=Main.palette[Main.backups->Pages->Gradients->Range[i].Start+((color-Main.backups->Pages->Gradients->Range[i].Start+offset[i])%len)].B;
} }
} }
} }

106
src/layers.c
View File

@ -36,13 +36,13 @@ void Layer_activate(int layer, short side)
{ {
dword old_layers; dword old_layers;
if (layer >= Main_backups->Pages->Nb_layers) if (layer >= Main.backups->Pages->Nb_layers)
return; return;
// Keep a copy of which layers were visible // Keep a copy of which layers were visible
old_layers = Main.layers_visible; old_layers = Main.layers_visible;
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
if (side == RIGHT_SIDE) if (side == RIGHT_SIDE)
{ {
@ -92,7 +92,7 @@ void Layer_activate(int layer, short side)
Redraw_layered_image(); Redraw_layered_image();
else else
Update_depth_buffer(); // Only need the depth buffer Update_depth_buffer(); // Only need the depth buffer
//Download_infos_page_main(Main_backups->Pages); //Download_infos_page_main(Main.backups->Pages);
//Update_FX_feedback(Config.FX_Feedback); //Update_FX_feedback(Config.FX_Feedback);
Update_pixel_renderer(); Update_pixel_renderer();
Display_all_screen(); Display_all_screen();
@ -106,11 +106,11 @@ void Button_Layer_add(void)
Hide_cursor(); Hide_cursor();
if (Main_backups->Pages->Nb_layers < max[Main_backups->Pages->Image_mode]) if (Main.backups->Pages->Nb_layers < max[Main.backups->Pages->Image_mode])
{ {
// Backup with unchanged layers // Backup with unchanged layers
Backup_layers(LAYER_NONE); Backup_layers(LAYER_NONE);
if (!Add_layer(Main_backups,Main.current_layer+1)) if (!Add_layer(Main.backups,Main.current_layer+1))
{ {
Update_depth_buffer(); Update_depth_buffer();
// I just noticed this might be unneeded, since the new layer // I just noticed this might be unneeded, since the new layer
@ -133,19 +133,19 @@ void Button_Layer_duplicate(void)
Hide_cursor(); Hide_cursor();
if (Main_backups->Pages->Nb_layers < max[Main_backups->Pages->Image_mode]) if (Main.backups->Pages->Nb_layers < max[Main.backups->Pages->Image_mode])
{ {
// Backup with unchanged layers // Backup with unchanged layers
Backup_layers(LAYER_NONE); Backup_layers(LAYER_NONE);
if (!Add_layer(Main_backups,Main.current_layer+1)) if (!Add_layer(Main.backups,Main.current_layer+1))
{ {
// Make a copy of current image // Make a copy of current image
memcpy( memcpy(
Main_backups->Pages->Image[Main.current_layer].Pixels, Main.backups->Pages->Image[Main.current_layer].Pixels,
Main_backups->Pages->Image[Main.current_layer-1].Pixels, Main.backups->Pages->Image[Main.current_layer-1].Pixels,
Main_backups->Pages->Width*Main_backups->Pages->Height); Main.backups->Pages->Width*Main.backups->Pages->Height);
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) { if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) {
Update_depth_buffer(); Update_depth_buffer();
// I just noticed this might be unneeded, since the new layer // I just noticed this might be unneeded, since the new layer
// is transparent, it shouldn't have any visible effect. // is transparent, it shouldn't have any visible effect.
@ -165,11 +165,11 @@ void Button_Layer_remove(void)
{ {
Hide_cursor(); Hide_cursor();
if (Main_backups->Pages->Nb_layers > 1) if (Main.backups->Pages->Nb_layers > 1)
{ {
// Backup with unchanged layers // Backup with unchanged layers
Backup_layers(LAYER_NONE); Backup_layers(LAYER_NONE);
if (!Delete_layer(Main_backups,Main.current_layer)) if (!Delete_layer(Main.backups,Main.current_layer))
{ {
Update_screen_targets(); Update_screen_targets();
Redraw_layered_image(); Redraw_layered_image();
@ -194,8 +194,8 @@ short Layer_under_mouse(void)
// Safety required because the mouse cursor can have slided outside button. // Safety required because the mouse cursor can have slided outside button.
if (layer < 0) if (layer < 0)
layer=0; layer=0;
else if (layer > Main_backups->Pages->Nb_layers-1) else if (layer > Main.backups->Pages->Nb_layers-1)
layer=Main_backups->Pages->Nb_layers-1; layer=Main.backups->Pages->Nb_layers-1;
return layer; return layer;
} }
@ -217,8 +217,8 @@ void Button_Layer_toggle(void)
// Safety required because the mouse cursor can have slided outside button. // Safety required because the mouse cursor can have slided outside button.
if (layer < 0) if (layer < 0)
layer=0; layer=0;
else if (layer > Main_backups->Pages->Nb_layers-1) else if (layer > Main.backups->Pages->Nb_layers-1)
layer=Main_backups->Pages->Nb_layers-1; layer=Main.backups->Pages->Nb_layers-1;
Layer_activate(layer, RIGHT_SIDE); Layer_activate(layer, RIGHT_SIDE);
Mouse_K=0; Mouse_K=0;
@ -240,8 +240,8 @@ static void Draw_transparent_background(byte background)
void Button_Layer_menu(void) void Button_Layer_menu(void)
{ {
byte transparent_color = Main_backups->Pages->Transparent_color; byte transparent_color = Main.backups->Pages->Transparent_color;
byte transparent_background = Main_backups->Pages->Background_transparent; byte transparent_background = Main.backups->Pages->Background_transparent;
short clicked_button; short clicked_button;
byte color; byte color;
byte click; byte click;
@ -301,12 +301,12 @@ void Button_Layer_menu(void)
if (clicked_button==3) if (clicked_button==3)
{ {
// Accept changes // Accept changes
if (Main_backups->Pages->Transparent_color != transparent_color || if (Main.backups->Pages->Transparent_color != transparent_color ||
Main_backups->Pages->Background_transparent != transparent_background) Main.backups->Pages->Background_transparent != transparent_background)
{ {
Backup_layers(LAYER_NONE); Backup_layers(LAYER_NONE);
Main_backups->Pages->Transparent_color = transparent_color; Main.backups->Pages->Transparent_color = transparent_color;
Main_backups->Pages->Background_transparent = transparent_background; Main.backups->Pages->Background_transparent = transparent_background;
Redraw_layered_image(); Redraw_layered_image();
Display_all_screen(); Display_all_screen();
End_of_modification(); End_of_modification();
@ -321,10 +321,10 @@ void Button_Layer_set_transparent(void)
{ {
Hide_cursor(); Hide_cursor();
if (Main_backups->Pages->Transparent_color != Back_color) if (Main.backups->Pages->Transparent_color != Back_color)
{ {
Backup_layers(LAYER_ALL); Backup_layers(LAYER_ALL);
Main_backups->Pages->Transparent_color = Back_color; Main.backups->Pages->Transparent_color = Back_color;
Redraw_layered_image(); Redraw_layered_image();
Display_all_screen(); Display_all_screen();
@ -339,9 +339,9 @@ void Button_Layer_get_transparent(void)
{ {
Hide_cursor(); Hide_cursor();
if (Main_backups->Pages->Transparent_color != Back_color) if (Main.backups->Pages->Transparent_color != Back_color)
{ {
Set_back_color(Main_backups->Pages->Transparent_color); Set_back_color(Main.backups->Pages->Transparent_color);
} }
Unselect_button(BUTTON_LAYER_COLOR); Unselect_button(BUTTON_LAYER_COLOR);
@ -374,7 +374,7 @@ void Button_Layer_up(void)
{ {
Hide_cursor(); Hide_cursor();
if (Main.current_layer < (Main_backups->Pages->Nb_layers-1)) if (Main.current_layer < (Main.backups->Pages->Nb_layers-1))
{ {
T_Image tmp; T_Image tmp;
dword layer_flags; dword layer_flags;
@ -383,9 +383,9 @@ void Button_Layer_up(void)
Backup_layers(LAYER_NONE); Backup_layers(LAYER_NONE);
// swap // swap
tmp = Main_backups->Pages->Image[Main.current_layer]; tmp = Main.backups->Pages->Image[Main.current_layer];
Main_backups->Pages->Image[Main.current_layer] = Main_backups->Pages->Image[Main.current_layer+1]; Main.backups->Pages->Image[Main.current_layer] = Main.backups->Pages->Image[Main.current_layer+1];
Main_backups->Pages->Image[Main.current_layer+1] = tmp; Main.backups->Pages->Image[Main.current_layer+1] = tmp;
// Swap visibility indicators // Swap visibility indicators
layer_flags = (Main.layers_visible >> Main.current_layer) & 3; layer_flags = (Main.layers_visible >> Main.current_layer) & 3;
@ -423,9 +423,9 @@ void Button_Layer_down(void)
Backup_layers(LAYER_NONE); Backup_layers(LAYER_NONE);
// swap // swap
tmp = Main_backups->Pages->Image[Main.current_layer]; tmp = Main.backups->Pages->Image[Main.current_layer];
Main_backups->Pages->Image[Main.current_layer] = Main_backups->Pages->Image[Main.current_layer-1]; Main.backups->Pages->Image[Main.current_layer] = Main.backups->Pages->Image[Main.current_layer-1];
Main_backups->Pages->Image[Main.current_layer-1] = tmp; Main.backups->Pages->Image[Main.current_layer-1] = tmp;
// Swap visibility indicators // Swap visibility indicators
layer_flags = (Main.layers_visible >> (Main.current_layer-1)) & 3; layer_flags = (Main.layers_visible >> (Main.current_layer-1)) & 3;
@ -466,7 +466,7 @@ void Button_Anim_time(void)
int frame; int frame;
char buffer[6+1]; char buffer[6+1];
T_Special_button * input_duration_button; T_Special_button * input_duration_button;
int duration=Main_backups->Pages->Image[Main.current_layer].Duration; int duration=Main.backups->Pages->Image[Main.current_layer].Duration;
Open_window(166,110,"Animation speed"); Open_window(166,110,"Animation speed");
@ -547,27 +547,27 @@ void Button_Anim_time(void)
duration=0; duration=0;
else if (duration>655350) else if (duration>655350)
duration=655350; duration=655350;
Main_backups->Pages->Image[Main.current_layer].Duration = duration; Main.backups->Pages->Image[Main.current_layer].Duration = duration;
break; break;
case 1: case 1:
if (duration<0) if (duration<0)
duration=0; duration=0;
else if (duration>655350) else if (duration>655350)
duration=655350; duration=655350;
for (frame=0; frame<Main_backups->Pages->Nb_layers; frame++) for (frame=0; frame<Main.backups->Pages->Nb_layers; frame++)
{ {
Main_backups->Pages->Image[frame].Duration = duration; Main.backups->Pages->Image[frame].Duration = duration;
} }
break; break;
case 2: case 2:
for (frame=0; frame<Main_backups->Pages->Nb_layers; frame++) for (frame=0; frame<Main.backups->Pages->Nb_layers; frame++)
{ {
int cur_duration = Main_backups->Pages->Image[frame].Duration+duration; int cur_duration = Main.backups->Pages->Image[frame].Duration+duration;
if (cur_duration<0) if (cur_duration<0)
cur_duration=0; cur_duration=0;
else if (cur_duration>655350) else if (cur_duration>655350)
cur_duration=655350; cur_duration=655350;
Main_backups->Pages->Image[frame].Duration = cur_duration; Main.backups->Pages->Image[frame].Duration = cur_duration;
} }
break; break;
break; break;
@ -591,10 +591,10 @@ void Button_Anim_first_frame(void)
void Button_Anim_prev_frame(void) void Button_Anim_prev_frame(void)
{ {
if (Main_backups->Pages->Nb_layers>1) if (Main.backups->Pages->Nb_layers>1)
{ {
if (Main.current_layer==0) if (Main.current_layer==0)
Layer_activate(Main_backups->Pages->Nb_layers-1,LEFT_SIDE); Layer_activate(Main.backups->Pages->Nb_layers-1,LEFT_SIDE);
else else
Layer_activate(Main.current_layer-1,LEFT_SIDE); Layer_activate(Main.current_layer-1,LEFT_SIDE);
} }
@ -605,9 +605,9 @@ void Button_Anim_prev_frame(void)
void Button_Anim_next_frame(void) void Button_Anim_next_frame(void)
{ {
if (Main_backups->Pages->Nb_layers>1) if (Main.backups->Pages->Nb_layers>1)
{ {
if (Main.current_layer==Main_backups->Pages->Nb_layers-1) if (Main.current_layer==Main.backups->Pages->Nb_layers-1)
Layer_activate(0,LEFT_SIDE); Layer_activate(0,LEFT_SIDE);
else else
Layer_activate(Main.current_layer+1,LEFT_SIDE); Layer_activate(Main.current_layer+1,LEFT_SIDE);
@ -620,8 +620,8 @@ void Button_Anim_next_frame(void)
void Button_Anim_last_frame(void) void Button_Anim_last_frame(void)
{ {
if (Main.current_layer < (Main_backups->Pages->Nb_layers-1)) if (Main.current_layer < (Main.backups->Pages->Nb_layers-1))
Layer_activate((Main_backups->Pages->Nb_layers-1),LEFT_SIDE); Layer_activate((Main.backups->Pages->Nb_layers-1),LEFT_SIDE);
Hide_cursor(); Hide_cursor();
Unselect_button(BUTTON_ANIM_LAST_FRAME); Unselect_button(BUTTON_ANIM_LAST_FRAME);
@ -646,10 +646,10 @@ void Button_Anim_continuous_next(void)
time_in_current_frame += time_now-time_start; time_in_current_frame += time_now-time_start;
time_start=time_now; time_start=time_now;
target_frame = Main.current_layer; target_frame = Main.current_layer;
while (time_in_current_frame > Main_backups->Pages->Image[target_frame].Duration) while (time_in_current_frame > Main.backups->Pages->Image[target_frame].Duration)
{ {
time_in_current_frame -= Interpret_delay(Main_backups->Pages->Image[target_frame].Duration); time_in_current_frame -= Interpret_delay(Main.backups->Pages->Image[target_frame].Duration);
target_frame = (target_frame+1) % Main_backups->Pages->Nb_layers; target_frame = (target_frame+1) % Main.backups->Pages->Nb_layers;
} }
if (target_frame != Main.current_layer) if (target_frame != Main.current_layer)
{ {
@ -681,10 +681,10 @@ void Button_Anim_continuous_prev(void)
time_in_current_frame += time_now-time_start; time_in_current_frame += time_now-time_start;
time_start=time_now; time_start=time_now;
target_frame = Main.current_layer; target_frame = Main.current_layer;
while (time_in_current_frame > Main_backups->Pages->Image[target_frame].Duration) while (time_in_current_frame > Main.backups->Pages->Image[target_frame].Duration)
{ {
time_in_current_frame -= Interpret_delay(Main_backups->Pages->Image[target_frame].Duration); time_in_current_frame -= Interpret_delay(Main.backups->Pages->Image[target_frame].Duration);
target_frame = (target_frame+Main_backups->Pages->Nb_layers-1) % Main_backups->Pages->Nb_layers; target_frame = (target_frame+Main.backups->Pages->Nb_layers-1) % Main.backups->Pages->Nb_layers;
} }
if (target_frame != Main.current_layer) if (target_frame != Main.current_layer)
{ {

90
src/loadsave.c
View File

@ -276,9 +276,9 @@ void Fill_canvas(T_IO_Context *context, byte color)
break; break;
case CONTEXT_MAIN_IMAGE: case CONTEXT_MAIN_IMAGE:
memset( memset(
Main_backups->Pages->Image[Main.current_layer].Pixels, Main.backups->Pages->Image[Main.current_layer].Pixels,
color, color,
Main_backups->Pages->Width*Main_backups->Pages->Height); Main.backups->Pages->Width*Main.backups->Pages->Height);
break; break;
case CONTEXT_BRUSH: case CONTEXT_BRUSH:
memset(context->Buffer_image, color, (long)context->Height*context->Pitch); memset(context->Buffer_image, color, (long)context->Height*context->Pitch);
@ -356,7 +356,7 @@ void Set_frame_duration(T_IO_Context *context, int duration)
switch(context->Type) switch(context->Type)
{ {
case CONTEXT_MAIN_IMAGE: case CONTEXT_MAIN_IMAGE:
Main_backups->Pages->Image[context->Current_layer].Duration = duration; Main.backups->Pages->Image[context->Current_layer].Duration = duration;
break; break;
default: default:
break; break;
@ -368,7 +368,7 @@ int Get_frame_duration(T_IO_Context *context)
switch(context->Type) switch(context->Type)
{ {
case CONTEXT_MAIN_IMAGE: case CONTEXT_MAIN_IMAGE:
return Main_backups->Pages->Image[context->Current_layer].Duration; return Main.backups->Pages->Image[context->Current_layer].Duration;
default: default:
return 0; return 0;
} }
@ -683,7 +683,7 @@ void Load_image(T_IO_Context *context)
Cursor_shape=CURSOR_SHAPE_HOURGLASS; Cursor_shape=CURSOR_SHAPE_HOURGLASS;
Display_cursor(); Display_cursor();
Flush_update(); Flush_update();
if (Convert_24b_bitmap_to_256(Main_backups->Pages->Image[0].Pixels,context->Buffer_image_24b,context->Width,context->Height,context->Palette)) if (Convert_24b_bitmap_to_256(Main.backups->Pages->Image[0].Pixels,context->Buffer_image_24b,context->Width,context->Height,context->Palette))
File_error=2; File_error=2;
Hide_cursor(); Hide_cursor();
Cursor_shape=old_cursor_shape; Cursor_shape=old_cursor_shape;
@ -778,7 +778,7 @@ void Load_image(T_IO_Context *context)
} }
// Copy the loaded palette // Copy the loaded palette
memcpy(Main.palette, context->Palette, sizeof(T_Palette)); memcpy(Main.palette, context->Palette, sizeof(T_Palette));
memcpy(Main_backups->Pages->Palette, context->Palette, sizeof(T_Palette)); memcpy(Main.backups->Pages->Palette, context->Palette, sizeof(T_Palette));
// For formats that handle more than just the palette: // For formats that handle more than just the palette:
// Transfer the data to main image. // Transfer the data to main image.
@ -787,13 +787,13 @@ void Load_image(T_IO_Context *context)
if (context->Original_file_name && context->Original_file_name[0] if (context->Original_file_name && context->Original_file_name[0]
&& context->Original_file_directory && context->Original_file_directory[0]) && context->Original_file_directory && context->Original_file_directory[0])
{ {
strcpy(Main_backups->Pages->Filename,context->Original_file_name); strcpy(Main.backups->Pages->Filename,context->Original_file_name);
strcpy(Main_backups->Pages->File_directory,context->Original_file_directory); strcpy(Main.backups->Pages->File_directory,context->Original_file_directory);
} }
else else
{ {
strcpy(Main_backups->Pages->Filename,context->File_name); strcpy(Main.backups->Pages->Filename,context->File_name);
strcpy(Main_backups->Pages->File_directory,context->File_directory); strcpy(Main.backups->Pages->File_directory,context->File_directory);
} }
// On considère que l'image chargée n'est plus modifiée // On considère que l'image chargée n'est plus modifiée
@ -805,7 +805,7 @@ void Load_image(T_IO_Context *context)
//Main_image_width= context->Width; //Main_image_width= context->Width;
//Main_image_height= context->Height; //Main_image_height= context->Height;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
Main.current_layer = 0; Main.current_layer = 0;
} }
@ -816,8 +816,8 @@ void Load_image(T_IO_Context *context)
} }
// Load the transparency data // Load the transparency data
Main_backups->Pages->Transparent_color = context->Transparent_color; Main.backups->Pages->Transparent_color = context->Transparent_color;
Main_backups->Pages->Background_transparent = context->Background_transparent; Main.backups->Pages->Background_transparent = context->Background_transparent;
// Correction des dimensions // Correction des dimensions
if (Main.image_width<1) if (Main.image_width<1)
@ -827,17 +827,17 @@ void Load_image(T_IO_Context *context)
// Color cyling ranges: // Color cyling ranges:
for (i=0; i<16; i++) for (i=0; i<16; i++)
Main_backups->Pages->Gradients->Range[i].Speed=0; Main.backups->Pages->Gradients->Range[i].Speed=0;
for (i=0; i<context->Color_cycles; i++) for (i=0; i<context->Color_cycles; i++)
{ {
Main_backups->Pages->Gradients->Range[i].Start=context->Cycle_range[i].Start; Main.backups->Pages->Gradients->Range[i].Start=context->Cycle_range[i].Start;
Main_backups->Pages->Gradients->Range[i].End=context->Cycle_range[i].End; Main.backups->Pages->Gradients->Range[i].End=context->Cycle_range[i].End;
Main_backups->Pages->Gradients->Range[i].Inverse=context->Cycle_range[i].Inverse; Main.backups->Pages->Gradients->Range[i].Inverse=context->Cycle_range[i].Inverse;
Main_backups->Pages->Gradients->Range[i].Speed=context->Cycle_range[i].Speed; Main.backups->Pages->Gradients->Range[i].Speed=context->Cycle_range[i].Speed;
} }
// Comment // Comment
strcpy(Main_backups->Pages->Comment, context->Comment); strcpy(Main.backups->Pages->Comment, context->Comment);
} }
} }
@ -852,7 +852,7 @@ void Load_image(T_IO_Context *context)
{ {
// Dans ce cas, on sait que l'image n'a pas changé, mais ses // Dans ce cas, on sait que l'image n'a pas changé, mais ses
// paramètres (dimension, palette, ...) si. Donc on les restaures. // paramètres (dimension, palette, ...) si. Donc on les restaures.
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
} }
} }
else if (context->Type == CONTEXT_BRUSH && File_error==0) else if (context->Type == CONTEXT_BRUSH && File_error==0)
@ -987,10 +987,10 @@ void Save_image(T_IO_Context *context)
{ {
case CONTEXT_MAIN_IMAGE: case CONTEXT_MAIN_IMAGE:
if ((!Get_fileformat(context->Format)->Supports_layers) if ((!Get_fileformat(context->Format)->Supports_layers)
&& (Main_backups->Pages->Nb_layers > 1) && (Main.backups->Pages->Nb_layers > 1)
&& (!Get_fileformat(context->Format)->Palette_only)) && (!Get_fileformat(context->Format)->Palette_only))
{ {
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
if (! Confirmation_box("This format doesn't support\nanimation and will save only\ncurrent frame. Proceed?")) if (! Confirmation_box("This format doesn't support\nanimation and will save only\ncurrent frame. Proceed?"))
{ {
@ -999,7 +999,7 @@ void Save_image(T_IO_Context *context)
} }
// current layer // current layer
context->Nb_layers=1; context->Nb_layers=1;
context->Target_address=Main_backups->Pages->Image[Main.current_layer].Pixels; context->Target_address=Main.backups->Pages->Image[Main.current_layer].Pixels;
} }
else // all other layer-based formats else // all other layer-based formats
{ {
@ -1031,11 +1031,11 @@ void Save_image(T_IO_Context *context)
{ {
case 1: // flatten case 1: // flatten
context->Nb_layers=1; context->Nb_layers=1;
context->Target_address=Main_visible_image.Image; context->Target_address=Main.visible_image.Image;
break; break;
case 2: // current layer case 2: // current layer
context->Nb_layers=1; context->Nb_layers=1;
context->Target_address=Main_backups->Pages->Image[Main.current_layer].Pixels; context->Target_address=Main.backups->Pages->Image[Main.current_layer].Pixels;
break; break;
default: // Cancel default: // Cancel
// File_error is already set to 1. // File_error is already set to 1.
@ -1232,10 +1232,10 @@ void Emergency_backup(const char *fname, byte *source, int width, int height, T_
void Image_emergency_backup() void Image_emergency_backup()
{ {
if (Main_backups && Main_backups->Pages && Main_backups->Pages->Nb_layers == 1) if (Main.backups && Main.backups->Pages && Main.backups->Pages->Nb_layers == 1)
Emergency_backup(SAFETYBACKUP_PREFIX_A "999999" BACKUP_FILE_EXTENSION,Main_screen, Main.image_width, Main.image_height, &Main.palette); Emergency_backup(SAFETYBACKUP_PREFIX_A "999999" BACKUP_FILE_EXTENSION,Main_screen, Main.image_width, Main.image_height, &Main.palette);
if (Spare_backups && Spare_backups->Pages && Spare_backups->Pages->Nb_layers == 1) if (Spare.backups && Spare.backups->Pages && Spare.backups->Pages->Nb_layers == 1)
Emergency_backup(SAFETYBACKUP_PREFIX_B "999999" BACKUP_FILE_EXTENSION,Spare_visible_image.Image, Spare.image_width, Spare.image_height, &Spare.palette); Emergency_backup(SAFETYBACKUP_PREFIX_B "999999" BACKUP_FILE_EXTENSION,Spare.visible_image.Image, Spare.image_width, Spare.image_height, &Spare.palette);
} }
T_Format * Get_fileformat(byte format) T_Format * Get_fileformat(byte format)
@ -1302,28 +1302,28 @@ void Init_context_layered_image(T_IO_Context * context, char *file_name, char *f
memcpy(context->Palette, Main.palette, sizeof(T_Palette)); memcpy(context->Palette, Main.palette, sizeof(T_Palette));
context->Width = Main.image_width; context->Width = Main.image_width;
context->Height = Main.image_height; context->Height = Main.image_height;
context->Nb_layers = Main_backups->Pages->Nb_layers; context->Nb_layers = Main.backups->Pages->Nb_layers;
strcpy(context->Comment, Main_backups->Pages->Comment); strcpy(context->Comment, Main.backups->Pages->Comment);
context->Transparent_color=Main_backups->Pages->Transparent_color; context->Transparent_color=Main.backups->Pages->Transparent_color;
context->Background_transparent=Main_backups->Pages->Background_transparent; context->Background_transparent=Main.backups->Pages->Background_transparent;
if (Pixel_ratio == PIXEL_WIDE || Pixel_ratio == PIXEL_WIDE2) if (Pixel_ratio == PIXEL_WIDE || Pixel_ratio == PIXEL_WIDE2)
context->Ratio=PIXEL_WIDE; context->Ratio=PIXEL_WIDE;
else if (Pixel_ratio == PIXEL_TALL || Pixel_ratio == PIXEL_TALL2 || Pixel_ratio == PIXEL_TALL3) else if (Pixel_ratio == PIXEL_TALL || Pixel_ratio == PIXEL_TALL2 || Pixel_ratio == PIXEL_TALL3)
context->Ratio=PIXEL_TALL; context->Ratio=PIXEL_TALL;
else else
context->Ratio=PIXEL_SIMPLE; context->Ratio=PIXEL_SIMPLE;
context->Target_address=Main_backups->Pages->Image[0].Pixels; context->Target_address=Main.backups->Pages->Image[0].Pixels;
context->Pitch=Main.image_width; context->Pitch=Main.image_width;
// Color cyling ranges: // Color cyling ranges:
for (i=0; i<16; i++) for (i=0; i<16; i++)
{ {
if (Main_backups->Pages->Gradients->Range[i].Start!=Main_backups->Pages->Gradients->Range[i].End) if (Main.backups->Pages->Gradients->Range[i].Start!=Main.backups->Pages->Gradients->Range[i].End)
{ {
context->Cycle_range[context->Color_cycles].Start=Main_backups->Pages->Gradients->Range[i].Start; context->Cycle_range[context->Color_cycles].Start=Main.backups->Pages->Gradients->Range[i].Start;
context->Cycle_range[context->Color_cycles].End=Main_backups->Pages->Gradients->Range[i].End; context->Cycle_range[context->Color_cycles].End=Main.backups->Pages->Gradients->Range[i].End;
context->Cycle_range[context->Color_cycles].Inverse=Main_backups->Pages->Gradients->Range[i].Inverse; context->Cycle_range[context->Color_cycles].Inverse=Main.backups->Pages->Gradients->Range[i].Inverse;
context->Cycle_range[context->Color_cycles].Speed=Main_backups->Pages->Gradients->Range[i].Speed; context->Cycle_range[context->Color_cycles].Speed=Main.backups->Pages->Gradients->Range[i].Speed;
context->Color_cycles++; context->Color_cycles++;
} }
} }
@ -1385,13 +1385,13 @@ void Set_saving_layer(T_IO_Context *context, int layer)
if (context->Type == CONTEXT_MAIN_IMAGE) if (context->Type == CONTEXT_MAIN_IMAGE)
{ {
if (context->Nb_layers==1 && Main_backups->Pages->Nb_layers!=1) if (context->Nb_layers==1 && Main.backups->Pages->Nb_layers!=1)
{ {
// Context is set to saving a single layer: do nothing // Context is set to saving a single layer: do nothing
} }
else else
{ {
context->Target_address=Main_backups->Pages->Image[layer].Pixels; context->Target_address=Main.backups->Pages->Image[layer].Pixels;
} }
} }
} }
@ -1406,18 +1406,18 @@ void Set_loading_layer(T_IO_Context *context, int layer)
// This awful thing is the part that happens on load // This awful thing is the part that happens on load
while (layer >= context->Nb_layers) while (layer >= context->Nb_layers)
{ {
if (Add_layer(Main_backups, layer)) if (Add_layer(Main.backups, layer))
{ {
// Failure to add a layer on load: // Failure to add a layer on load:
// Position on last layer // Position on last layer
layer = context->Nb_layers-1; layer = context->Nb_layers-1;
break; break;
} }
context->Nb_layers = Main_backups->Pages->Nb_layers; context->Nb_layers = Main.backups->Pages->Nb_layers;
Main.layers_visible = (2<<layer)-1; Main.layers_visible = (2<<layer)-1;
} }
Main.current_layer = layer; Main.current_layer = layer;
context->Target_address=Main_backups->Pages->Image[layer].Pixels; context->Target_address=Main.backups->Pages->Image[layer].Pixels;
Update_pixel_renderer(); Update_pixel_renderer();
} }
@ -1667,8 +1667,8 @@ void Rotate_safety_backups(void)
Init_context_backup_image(&context, file_name, Config_directory); Init_context_backup_image(&context, file_name, Config_directory);
context.Format=FORMAT_GIF; context.Format=FORMAT_GIF;
// Provide original file data, to store as a GIF Application Extension // Provide original file data, to store as a GIF Application Extension
context.Original_file_name = Main_backups->Pages->Filename; context.Original_file_name = Main.backups->Pages->Filename;
context.Original_file_directory = Main_backups->Pages->File_directory; context.Original_file_directory = Main.backups->Pages->File_directory;
Save_image(&context); Save_image(&context);
Destroy_context(&context); Destroy_context(&context);

18
src/main.c
View File

@ -478,10 +478,10 @@ int Init_program(int argc,char * argv[])
// principale et la page de brouillon afin que leurs champs ne soient pas // principale et la page de brouillon afin que leurs champs ne soient pas
// invalide lors des appels aux multiples fonctions manipulées à // invalide lors des appels aux multiples fonctions manipulées à
// l'initialisation du programme. // l'initialisation du programme.
Main_backups=(T_List_of_pages *)malloc(sizeof(T_List_of_pages)); Main.backups=(T_List_of_pages *)malloc(sizeof(T_List_of_pages));
Spare_backups=(T_List_of_pages *)malloc(sizeof(T_List_of_pages)); Spare.backups=(T_List_of_pages *)malloc(sizeof(T_List_of_pages));
Init_list_of_pages(Main_backups); Init_list_of_pages(Main.backups);
Init_list_of_pages(Spare_backups); Init_list_of_pages(Spare.backups);
// Determine the executable directory // Determine the executable directory
Set_program_directory(argv[0],program_directory); Set_program_directory(argv[0],program_directory);
@ -802,8 +802,8 @@ int Init_program(int argc,char * argv[])
memset(Main_screen,0,Main.image_width*Main.image_height); memset(Main_screen,0,Main.image_width*Main.image_height);
// Now that the backup system is there, we can store the gradients. // Now that the backup system is there, we can store the gradients.
memcpy(Main_backups->Pages->Gradients->Range, initial_gradients.Range, sizeof(initial_gradients.Range)); memcpy(Main.backups->Pages->Gradients->Range, initial_gradients.Range, sizeof(initial_gradients.Range));
memcpy(Spare_backups->Pages->Gradients->Range, initial_gradients.Range, sizeof(initial_gradients.Range)); memcpy(Spare.backups->Pages->Gradients->Range, initial_gradients.Range, sizeof(initial_gradients.Range));
Gradient_function=Gradient_basic; Gradient_function=Gradient_basic;
Gradient_lower_bound=0; Gradient_lower_bound=0;
@ -915,12 +915,12 @@ int Init_program(int argc,char * argv[])
// If only one image was loaded, assume the spare has same image type // If only one image was loaded, assume the spare has same image type
if (file_in_command_line==1) if (file_in_command_line==1)
Spare_backups->Pages->Image_mode = Main_backups->Pages->Image_mode; Spare.backups->Pages->Image_mode = Main.backups->Pages->Image_mode;
Hide_cursor(); Hide_cursor();
Compute_optimal_menu_colors(Main.palette); Compute_optimal_menu_colors(Main.palette);
Back_color=Main_backups->Pages->Background_transparent ? Back_color=Main.backups->Pages->Background_transparent ?
Main_backups->Pages->Transparent_color : Main.backups->Pages->Transparent_color :
Best_color_range(0,0,0,Config.Palette_cells_X*Config.Palette_cells_Y); Best_color_range(0,0,0,Config.Palette_cells_X*Config.Palette_cells_Y);
Fore_color=Main.palette[Back_color].R+Main.palette[Back_color].G+Main.palette[Back_color].B < 3*127 ? Fore_color=Main.palette[Back_color].R+Main.palette[Back_color].G+Main.palette[Back_color].B < 3*127 ?
Best_color_range(255,255,255,Config.Palette_cells_X*Config.Palette_cells_Y) : Best_color_range(255,255,255,Config.Palette_cells_X*Config.Palette_cells_Y) :

20
src/misc.c
View File

@ -59,9 +59,9 @@ word Count_used_colors(dword* usage)
nb_pixels = Main.image_height * Main.image_width; nb_pixels = Main.image_height * Main.image_width;
// For each layer // For each layer
for (layer = 0; layer < Main_backups->Pages->Nb_layers; layer++) for (layer = 0; layer < Main.backups->Pages->Nb_layers; layer++)
{ {
current_pixel = Main_backups->Pages->Image[layer].Pixels; current_pixel = Main.backups->Pages->Image[layer].Pixels;
// For each pixel in picture // For each pixel in picture
for (i = 0; i < nb_pixels; i++) for (i = 0; i < nb_pixels; i++)
{ {
@ -204,7 +204,7 @@ void Clear_current_image_with_stencil(byte color, byte * stencil)
int nb_pixels=0; //ECX int nb_pixels=0; //ECX
//al=color //al=color
//edi=Screen_pixels //edi=Screen_pixels
byte* pixel=Main_backups->Pages->Image[Main.current_layer].Pixels; byte* pixel=Main.backups->Pages->Image[Main.current_layer].Pixels;
int i; int i;
nb_pixels=Main.image_height*Main.image_width; nb_pixels=Main.image_height*Main.image_width;
@ -221,7 +221,7 @@ void Clear_current_image(byte color)
// Effacer l'image courante avec une certaine couleur // Effacer l'image courante avec une certaine couleur
{ {
memset( memset(
Main_backups->Pages->Image[Main.current_layer].Pixels, Main.backups->Pages->Image[Main.current_layer].Pixels,
color , color ,
Main.image_width * Main.image_height Main.image_width * Main.image_height
); );
@ -303,14 +303,14 @@ byte Read_pixel_from_spare_screen(word x,word y)
// Clipping is required as this can be called with coordinates from main image // Clipping is required as this can be called with coordinates from main image
// (can be a bigger or smaller image) // (can be a bigger or smaller image)
if (x>=Spare.image_width || y>=Spare.image_height) if (x>=Spare.image_width || y>=Spare.image_height)
return Spare_backups->Pages->Transparent_color; return Spare.backups->Pages->Transparent_color;
if (Spare_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION) if (Spare.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{ {
return *(Spare_backups->Pages->Image[Spare.current_layer].Pixels + y*Spare.image_width + x); return *(Spare.backups->Pages->Image[Spare.current_layer].Pixels + y*Spare.image_width + x);
} }
else else
{ {
return *(Spare_visible_image.Image + y*Spare.image_width + x); return *(Spare.visible_image.Image + y*Spare.image_width + x);
} }
} }
@ -365,7 +365,7 @@ void Remap_general_lowlevel(byte * conversion_table,byte * in_buffer, byte *out_
void Copy_image_to_brush(short start_x,short start_y,short Brush_width,short Brush_height,word image_width) void Copy_image_to_brush(short start_x,short start_y,short Brush_width,short Brush_height,word image_width)
{ {
byte* src=start_y*image_width+start_x+Main_backups->Pages->Image[Main.current_layer].Pixels; //Adr départ image (ESI) byte* src=start_y*image_width+start_x+Main.backups->Pages->Image[Main.current_layer].Pixels; //Adr départ image (ESI)
byte* dest=Brush_original_pixels; //Adr dest brosse (EDI) byte* dest=Brush_original_pixels; //Adr dest brosse (EDI)
int dx; int dx;
@ -410,7 +410,7 @@ void Replace_colors_within_limits(byte * replace_table)
// Pour chaque pixel sur la ligne : // Pour chaque pixel sur la ligne :
for (x = Limit_left;x <= Limit_right;x ++) for (x = Limit_left;x <= Limit_right;x ++)
{ {
pixel = Main_backups->Pages->Image[Main.current_layer].Pixels+y*Main.image_width+x; pixel = Main.backups->Pages->Image[Main.current_layer].Pixels+y*Main.image_width+x;
*pixel = replace_table[*pixel]; *pixel = replace_table[*pixel];
} }
} }

2
src/miscfileformats.c
View File

@ -3368,7 +3368,7 @@ void Load_CM5(T_IO_Context* context)
Set_loading_layer(context, 0); Set_loading_layer(context, 0);
if (context->Type == CONTEXT_MAIN_IMAGE) if (context->Type == CONTEXT_MAIN_IMAGE)
Main_backups->Pages->Image_mode = IMAGE_MODE_MODE5; Main.backups->Pages->Image_mode = IMAGE_MODE_MODE5;
for(ty=0; ty<context->Height; ty++) for(ty=0; ty<context->Height; ty++)
for(tx=0; tx<context->Width; tx++) for(tx=0; tx<context->Width; tx++)

14
src/oldies.c
View File

@ -36,7 +36,7 @@
void Pixel_in_layer(word x,word y, byte layer, byte color) void Pixel_in_layer(word x,word y, byte layer, byte color)
{ {
*((y)*Main.image_width+(x)+Main_backups->Pages->Image[layer].Pixels)=color; *((y)*Main.image_width+(x)+Main.backups->Pages->Image[layer].Pixels)=color;
} }
byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background) byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
@ -55,7 +55,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
const byte no_color=16; const byte no_color=16;
// Prerequisites // Prerequisites
if (Main_backups->Pages->Nb_layers < 3) if (Main.backups->Pages->Nb_layers < 3)
return 1; return 1;
if (Main.image_width != 160 || Main.image_height != 200) if (Main.image_width != 160 || Main.image_height != 200)
return 2; return 2;
@ -76,7 +76,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
{ {
for (x=0;x<4;x++) for (x=0;x<4;x++)
{ {
byte c=*((row)*Main.image_width+(col*4+x)+Main_backups->Pages->Image[2].Pixels); byte c=*((row)*Main.image_width+(col*4+x)+Main.backups->Pages->Image[2].Pixels);
used_colors[row][col] |= 1<<c; used_colors[row][col] |= 1<<c;
} }
} }
@ -84,7 +84,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
// Get "mandatory colors" from layer 1 // Get "mandatory colors" from layer 1
for (row=0;row<200;row++) for (row=0;row<200;row++)
{ {
byte c=*((row)*Main.image_width+0+Main_backups->Pages->Image[0].Pixels); byte c=*((row)*Main.image_width+0+Main.backups->Pages->Image[0].Pixels);
if (c<16) if (c<16)
{ {
line_color[row]=c; line_color[row]=c;
@ -100,7 +100,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
{ {
for (col=0;col<40;col++) for (col=0;col<40;col++)
{ {
byte c=*((row)*Main.image_width+(col*4)+Main_backups->Pages->Image[1].Pixels); byte c=*((row)*Main.image_width+(col*4)+Main.backups->Pages->Image[1].Pixels);
if (c<16) if (c<16)
{ {
block_color[row/8][col]=c; block_color[row/8][col]=c;
@ -312,7 +312,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
for(x=0; x<4; x++) for(x=0; x<4; x++)
{ {
byte bits; byte bits;
byte c=*((row*8+y)*Main.image_width+(col*4+x)+Main_backups->Pages->Image[2].Pixels); byte c=*((row*8+y)*Main.image_width+(col*4+x)+Main.backups->Pages->Image[2].Pixels);
if (c==line_color[row*8+y]) if (c==line_color[row*8+y])
// BG color // BG color
@ -360,7 +360,7 @@ byte C64_FLI_enforcer(void)
return 1; return 1;
if (Main.image_height != 200) if (Main.image_height != 200)
return 1; return 1;
if (Main_backups->Pages->Nb_layers != 4) if (Main.backups->Pages->Nb_layers != 4)
return 2; return 2;
Backup_layers(3); Backup_layers(3);

10
src/operatio.c
View File

@ -2785,12 +2785,12 @@ void Scroll_12_0(void)
else else
{ {
Backup_layers(LAYER_ALL); // Main.layers_visible Backup_layers(LAYER_ALL); // Main.layers_visible
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// Ensure the backup visible image is up-to-date // Ensure the backup visible image is up-to-date
// (after swapping some layers on/off, it gets outdated) // (after swapping some layers on/off, it gets outdated)
memcpy(Main_visible_image_backup.Image, memcpy(Main_visible_image_backup.Image,
Main_visible_image.Image, Main.visible_image.Image,
Main.image_width*Main.image_height); Main.image_width*Main.image_height);
} }
} }
@ -2851,7 +2851,7 @@ void Scroll_12_5(void)
else else
{ {
// One layer at once // One layer at once
Scroll_picture(Main_backups->Pages->Next->Image[Main.current_layer].Pixels, Main_backups->Pages->Image[Main.current_layer].Pixels, x_offset, y_offset); Scroll_picture(Main.backups->Pages->Next->Image[Main.current_layer].Pixels, Main.backups->Pages->Image[Main.current_layer].Pixels, x_offset, y_offset);
Redraw_current_layer(); Redraw_current_layer();
} }
@ -2905,9 +2905,9 @@ void Scroll_0_5(void)
y_offset=Main.image_height-((center_y-y_pos)%Main.image_height); y_offset=Main.image_height-((center_y-y_pos)%Main.image_height);
// Do the actual scroll operation on all layers. // Do the actual scroll operation on all layers.
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
//if ((1<<i) & Main.layers_visible) //if ((1<<i) & Main.layers_visible)
Scroll_picture(Main_backups->Pages->Next->Image[i].Pixels, Main_backups->Pages->Image[i].Pixels, x_offset, y_offset); Scroll_picture(Main.backups->Pages->Next->Image[i].Pixels, Main.backups->Pages->Image[i].Pixels, x_offset, y_offset);
// Update the depth buffer too ... // Update the depth buffer too ...
// It would be faster to scroll it, but we don't have method // It would be faster to scroll it, but we don't have method
// for in-place scrolling. // for in-place scrolling.

372
src/pages.c
View File

@ -39,10 +39,10 @@
// -- Layers data // -- Layers data
/// Array of two images, that contains the "flattened" version of the visible layers. /// Array of two images, that contains the "flattened" version of the visible layers.
T_Bitmap Main_visible_image; //T_Bitmap Main_visible_image;
T_Bitmap Main_visible_image_backup; T_Bitmap Main_visible_image_backup;
T_Bitmap Main_visible_image_depth_buffer; T_Bitmap Main_visible_image_depth_buffer;
T_Bitmap Spare_visible_image; //T_Bitmap Spare_visible_image;
/// ///
/// GESTION DES PAGES /// GESTION DES PAGES
@ -198,28 +198,28 @@ void Download_infos_page_main(T_Page * page)
void Redraw_layered_image(void) void Redraw_layered_image(void)
{ {
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// Re-construct the image with the visible layers // Re-construct the image with the visible layers
byte layer=0; byte layer=0;
// First layer // First layer
if (Main_backups->Pages->Image_mode == IMAGE_MODE_MODE5 && Main.layers_visible & (1<<4)) if (Main.backups->Pages->Image_mode == IMAGE_MODE_MODE5 && Main.layers_visible & (1<<4))
{ {
// The raster result layer is visible: start there // The raster result layer is visible: start there
// Copy it in Main_visible_image // Copy it in Main_visible_image
int i; int i;
for (i=0; i< Main.image_width*Main.image_height; i++) for (i=0; i< Main.image_width*Main.image_height; i++)
{ {
layer = *(Main_backups->Pages->Image[4].Pixels+i); layer = *(Main.backups->Pages->Image[4].Pixels+i);
if (Main.layers_visible & (1 << layer)) if (Main.layers_visible & (1 << layer))
Main_visible_image.Image[i]=*(Main_backups->Pages->Image[layer].Pixels+i); Main.visible_image.Image[i]=*(Main.backups->Pages->Image[layer].Pixels+i);
else else
Main_visible_image.Image[i] = layer; Main.visible_image.Image[i] = layer;
} }
// Copy it to the depth buffer // Copy it to the depth buffer
memcpy(Main_visible_image_depth_buffer.Image, memcpy(Main_visible_image_depth_buffer.Image,
Main_backups->Pages->Image[4].Pixels, Main.backups->Pages->Image[4].Pixels,
Main.image_width*Main.image_height); Main.image_width*Main.image_height);
// Next // Next
@ -227,13 +227,13 @@ void Redraw_layered_image(void)
} }
else else
{ {
for (layer=0; layer<Main_backups->Pages->Nb_layers; layer++) for (layer=0; layer<Main.backups->Pages->Nb_layers; layer++)
{ {
if ((1<<layer) & Main.layers_visible) if ((1<<layer) & Main.layers_visible)
{ {
// Copy it in Main_visible_image // Copy it in Main_visible_image
memcpy(Main_visible_image.Image, memcpy(Main.visible_image.Image,
Main_backups->Pages->Image[layer].Pixels, Main.backups->Pages->Image[layer].Pixels,
Main.image_width*Main.image_height); Main.image_width*Main.image_height);
// Initialize the depth buffer // Initialize the depth buffer
@ -248,17 +248,17 @@ void Redraw_layered_image(void)
} }
} }
// subsequent layer(s) // subsequent layer(s)
for (; layer<Main_backups->Pages->Nb_layers; layer++) for (; layer<Main.backups->Pages->Nb_layers; layer++)
{ {
if ((1<<layer) & Main.layers_visible) if ((1<<layer) & Main.layers_visible)
{ {
int i; int i;
for (i=0; i<Main.image_width*Main.image_height; i++) for (i=0; i<Main.image_width*Main.image_height; i++)
{ {
byte color = *(Main_backups->Pages->Image[layer].Pixels+i); byte color = *(Main.backups->Pages->Image[layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color if (color != Main.backups->Pages->Transparent_color) // transparent color
{ {
*(Main_visible_image.Image+i) = color; *(Main.visible_image.Image+i) = color;
if (layer != Main.current_layer) if (layer != Main.current_layer)
*(Main_visible_image_depth_buffer.Image+i) = layer; *(Main_visible_image_depth_buffer.Image+i) = layer;
} }
@ -275,7 +275,7 @@ void Redraw_layered_image(void)
void Update_depth_buffer(void) void Update_depth_buffer(void)
{ {
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// Re-construct the depth buffer with the visible layers. // Re-construct the depth buffer with the visible layers.
// This function doesn't touch the visible buffer, it assumes // This function doesn't touch the visible buffer, it assumes
@ -283,7 +283,7 @@ void Update_depth_buffer(void)
int layer; int layer;
// First layer // First layer
for (layer=0; layer<Main_backups->Pages->Nb_layers; layer++) for (layer=0; layer<Main.backups->Pages->Nb_layers; layer++)
{ {
if ((1<<layer) & Main.layers_visible) if ((1<<layer) & Main.layers_visible)
{ {
@ -298,7 +298,7 @@ void Update_depth_buffer(void)
} }
} }
// subsequent layer(s) // subsequent layer(s)
for (; layer<Main_backups->Pages->Nb_layers; layer++) for (; layer<Main.backups->Pages->Nb_layers; layer++)
{ {
// skip the current layer, whenever we reach it // skip the current layer, whenever we reach it
if (layer == Main.current_layer) if (layer == Main.current_layer)
@ -309,8 +309,8 @@ void Update_depth_buffer(void)
int i; int i;
for (i=0; i<Main.image_width*Main.image_height; i++) for (i=0; i<Main.image_width*Main.image_height; i++)
{ {
byte color = *(Main_backups->Pages->Image[layer].Pixels+i); byte color = *(Main.backups->Pages->Image[layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color if (color != Main.backups->Pages->Transparent_color) // transparent color
{ {
*(Main_visible_image_depth_buffer.Image+i) = layer; *(Main_visible_image_depth_buffer.Image+i) = layer;
} }
@ -323,18 +323,18 @@ void Update_depth_buffer(void)
void Redraw_spare_image(void) void Redraw_spare_image(void)
{ {
if (Spare_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Spare.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// Re-construct the image with the visible layers // Re-construct the image with the visible layers
byte layer; byte layer;
// First layer // First layer
for (layer=0; layer<Spare_backups->Pages->Nb_layers; layer++) for (layer=0; layer<Spare.backups->Pages->Nb_layers; layer++)
{ {
if ((1<<layer) & Spare.layers_visible) if ((1<<layer) & Spare.layers_visible)
{ {
// Copy it in Spare_visible_image // Copy it in Spare_visible_image
memcpy(Spare_visible_image.Image, memcpy(Spare.visible_image.Image,
Spare_backups->Pages->Image[layer].Pixels, Spare.backups->Pages->Image[layer].Pixels,
Spare.image_width*Spare.image_height); Spare.image_width*Spare.image_height);
// No depth buffer in the spare // No depth buffer in the spare
@ -348,17 +348,17 @@ void Redraw_spare_image(void)
} }
} }
// subsequent layer(s) // subsequent layer(s)
for (; layer<Spare_backups->Pages->Nb_layers; layer++) for (; layer<Spare.backups->Pages->Nb_layers; layer++)
{ {
if ((1<<layer) & Spare.layers_visible) if ((1<<layer) & Spare.layers_visible)
{ {
int i; int i;
for (i=0; i<Spare.image_width*Spare.image_height; i++) for (i=0; i<Spare.image_width*Spare.image_height; i++)
{ {
byte color = *(Spare_backups->Pages->Image[layer].Pixels+i); byte color = *(Spare.backups->Pages->Image[layer].Pixels+i);
if (color != Spare_backups->Pages->Transparent_color) // transparent color if (color != Spare.backups->Pages->Transparent_color) // transparent color
{ {
*(Spare_visible_image.Image+i) = color; *(Spare.visible_image.Image+i) = color;
//if (layer != Spare.current_layer) //if (layer != Spare.current_layer)
// *(Spare_visible_image_depth_buffer.Image+i) = layer; // *(Spare_visible_image_depth_buffer.Image+i) = layer;
} }
@ -370,7 +370,7 @@ void Redraw_spare_image(void)
void Redraw_current_layer(void) void Redraw_current_layer(void)
{ {
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
int i; int i;
for (i=0; i<Main.image_width*Main.image_height; i++) for (i=0; i<Main.image_width*Main.image_height; i++)
@ -378,14 +378,14 @@ void Redraw_current_layer(void)
byte depth = *(Main_visible_image_depth_buffer.Image+i); byte depth = *(Main_visible_image_depth_buffer.Image+i);
if (depth<=Main.current_layer) if (depth<=Main.current_layer)
{ {
byte color = *(Main_backups->Pages->Image[Main.current_layer].Pixels+i); byte color = *(Main.backups->Pages->Image[Main.current_layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color if (color != Main.backups->Pages->Transparent_color) // transparent color
{ {
*(Main_visible_image.Image+i) = color; *(Main.visible_image.Image+i) = color;
} }
else else
{ {
*(Main_visible_image.Image+i) = *(Main_backups->Pages->Image[depth].Pixels+i); *(Main.visible_image.Image+i) = *(Main.backups->Pages->Image[depth].Pixels+i);
} }
} }
} }
@ -436,9 +436,9 @@ void Update_FX_feedback(byte with_feedback)
{ {
if (with_feedback) if (with_feedback)
FX_feedback_screen=Main_backups->Pages->Image[Main.current_layer].Pixels; FX_feedback_screen=Main.backups->Pages->Image[Main.current_layer].Pixels;
else else
FX_feedback_screen=Main_backups->Pages->Next->Image[Main.current_layer].Pixels; FX_feedback_screen=Main.backups->Pages->Next->Image[Main.current_layer].Pixels;
} }
void Clear_page(T_Page * page) void Clear_page(T_Page * page)
@ -672,7 +672,7 @@ void Free_page_of_a_list(T_List_of_pages * list)
{ {
// On fait faire un undo à la liste, comme ça, la nouvelle page courante // On fait faire un undo à la liste, comme ça, la nouvelle page courante
// est la page précédente // est la page précédente
Backward_in_list_of_pages(Main_backups); Backward_in_list_of_pages(Main.backups);
// Puis on détruit la dernière page, qui est l'ancienne page courante // Puis on détruit la dernière page, qui est l'ancienne page courante
Free_last_page_of_list(list); Free_last_page_of_list(list);
@ -681,25 +681,25 @@ void Free_page_of_a_list(T_List_of_pages * list)
void Update_screen_targets(void) void Update_screen_targets(void)
{ {
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
Main_screen=Main_visible_image.Image; Main_screen=Main.visible_image.Image;
Screen_backup=Main_visible_image_backup.Image; Screen_backup=Main_visible_image_backup.Image;
} }
else else
{ {
Main_screen=Main_backups->Pages->Image[Main.current_layer].Pixels; Main_screen=Main.backups->Pages->Image[Main.current_layer].Pixels;
// Sometimes this function will be called in situations where the // Sometimes this function will be called in situations where the
// current history step and previous one don't have as many layers. // current history step and previous one don't have as many layers.
// I don't like the idea of letting Screen_backup NULL or dangling, // I don't like the idea of letting Screen_backup NULL or dangling,
// so in case Screen_backup was queried, it will point to a valid // so in case Screen_backup was queried, it will point to a valid
// readable bitmap of correct size : current image. // readable bitmap of correct size : current image.
if (Main_backups->Pages->Nb_layers != Main_backups->Pages->Next->Nb_layers if (Main.backups->Pages->Nb_layers != Main.backups->Pages->Next->Nb_layers
|| Main_backups->Pages->Width != Main_backups->Pages->Next->Width || Main.backups->Pages->Width != Main.backups->Pages->Next->Width
|| Main_backups->Pages->Height != Main_backups->Pages->Next->Height) || Main.backups->Pages->Height != Main.backups->Pages->Next->Height)
Screen_backup=Main_screen; Screen_backup=Main_screen;
else else
Screen_backup=Main_backups->Pages->Next->Image[Main.current_layer].Pixels; Screen_backup=Main.backups->Pages->Next->Image[Main.current_layer].Pixels;
} }
Update_pixel_renderer(); Update_pixel_renderer();
} }
@ -707,19 +707,19 @@ void Update_screen_targets(void)
/// Update all the special image buffers, if necessary. /// Update all the special image buffers, if necessary.
int Update_buffers(int width, int height) int Update_buffers(int width, int height)
{ {
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// At least one dimension is different // At least one dimension is different
if (Main_visible_image.Width*Main_visible_image.Height != width*height) if (Main.visible_image.Width*Main.visible_image.Height != width*height)
{ {
// Current image // Current image
free(Main_visible_image.Image); free(Main.visible_image.Image);
Main_visible_image.Image = (byte *)malloc(width * height); Main.visible_image.Image = (byte *)malloc(width * height);
if (Main_visible_image.Image == NULL) if (Main.visible_image.Image == NULL)
return 0; return 0;
} }
Main_visible_image.Width = width; Main.visible_image.Width = width;
Main_visible_image.Height = height; Main.visible_image.Height = height;
if (Main_visible_image_backup.Width*Main_visible_image_backup.Height != width*height) if (Main_visible_image_backup.Width*Main_visible_image_backup.Height != width*height)
{ {
@ -749,19 +749,19 @@ int Update_buffers(int width, int height)
/// Update all the special image buffers of the spare page, if necessary. /// Update all the special image buffers of the spare page, if necessary.
int Update_spare_buffers(int width, int height) int Update_spare_buffers(int width, int height)
{ {
if (Spare_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Spare.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// At least one dimension is different // At least one dimension is different
if (Spare_visible_image.Width*Spare_visible_image.Height != width*height) if (Spare.visible_image.Width*Spare.visible_image.Height != width*height)
{ {
// Current image // Current image
free(Spare_visible_image.Image); free(Spare.visible_image.Image);
Spare_visible_image.Image = (byte *)malloc(width * height); Spare.visible_image.Image = (byte *)malloc(width * height);
if (Spare_visible_image.Image == NULL) if (Spare.visible_image.Image == NULL)
return 0; return 0;
} }
Spare_visible_image.Width = width; Spare.visible_image.Width = width;
Spare_visible_image.Height = height; Spare.visible_image.Height = height;
} }
return 1; return 1;
@ -776,38 +776,38 @@ int Init_all_backup_lists(enum IMAGE_MODES image_mode, int width, int height)
// width et height correspondent à la dimension des images de départ. // width et height correspondent à la dimension des images de départ.
int i; int i;
if (! Allocate_list_of_pages(Main_backups) || if (! Allocate_list_of_pages(Main.backups) ||
! Allocate_list_of_pages(Spare_backups)) ! Allocate_list_of_pages(Spare.backups))
return 0; return 0;
// On a réussi à allouer deux listes de pages dont la taille correspond à // On a réussi à allouer deux listes de pages dont la taille correspond à
// celle demandée par l'utilisateur. // celle demandée par l'utilisateur.
// On crée un descripteur de page correspondant à la page principale // On crée un descripteur de page correspondant à la page principale
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
// On y met les infos sur la dimension de démarrage // On y met les infos sur la dimension de démarrage
Main_backups->Pages->Width=width; Main.backups->Pages->Width=width;
Main_backups->Pages->Height=height; Main.backups->Pages->Height=height;
strcpy(Main_backups->Pages->File_directory,Main.selector.Directory); strcpy(Main.backups->Pages->File_directory,Main.selector.Directory);
strcpy(Main_backups->Pages->Filename,"NO_NAME.GIF"); strcpy(Main.backups->Pages->Filename,"NO_NAME.GIF");
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
Main_backups->Pages->Image[i].Pixels=New_layer(width*height); Main.backups->Pages->Image[i].Pixels=New_layer(width*height);
if (! Main_backups->Pages->Image[i].Pixels) if (! Main.backups->Pages->Image[i].Pixels)
return 0; return 0;
memset(Main_backups->Pages->Image[i].Pixels, 0, width*height); memset(Main.backups->Pages->Image[i].Pixels, 0, width*height);
} }
Main_visible_image.Width = 0; Main.visible_image.Width = 0;
Main_visible_image.Height = 0; Main.visible_image.Height = 0;
Main_visible_image.Image = NULL; Main.visible_image.Image = NULL;
Main_visible_image_backup.Image = NULL; Main_visible_image_backup.Image = NULL;
Main_visible_image_depth_buffer.Image = NULL; Main_visible_image_depth_buffer.Image = NULL;
Main_backups->Pages->Image_mode = image_mode; Main.backups->Pages->Image_mode = image_mode;
Spare_visible_image.Width = 0; Spare.visible_image.Width = 0;
Spare_visible_image.Height = 0; Spare.visible_image.Height = 0;
Spare_visible_image.Image = NULL; Spare.visible_image.Image = NULL;
Spare_backups->Pages->Image_mode = image_mode; Spare.backups->Pages->Image_mode = image_mode;
if (!Update_buffers(width, height)) if (!Update_buffers(width, height))
return 0; return 0;
@ -815,28 +815,28 @@ int Init_all_backup_lists(enum IMAGE_MODES image_mode, int width, int height)
return 0; return 0;
// For speed, instead of Redraw_layered_image() we'll directly set the buffers. // For speed, instead of Redraw_layered_image() we'll directly set the buffers.
if (Main_visible_image.Image != NULL) if (Main.visible_image.Image != NULL)
{ {
memset(Main_visible_image.Image, 0, width*height); memset(Main.visible_image.Image, 0, width*height);
memset(Main_visible_image_backup.Image, 0, width*height); memset(Main_visible_image_backup.Image, 0, width*height);
memset(Main_visible_image_depth_buffer.Image, 0, width*height); memset(Main_visible_image_depth_buffer.Image, 0, width*height);
} }
if (Spare_visible_image.Image != NULL) if (Spare.visible_image.Image != NULL)
memset(Spare_visible_image.Image, 0, width*height); memset(Spare.visible_image.Image, 0, width*height);
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
Update_FX_feedback(Config.FX_Feedback); Update_FX_feedback(Config.FX_Feedback);
// Default values for spare page // Default values for spare page
Spare_backups->Pages->Width = width; Spare.backups->Pages->Width = width;
Spare_backups->Pages->Height = height; Spare.backups->Pages->Height = height;
memcpy(Spare_backups->Pages->Palette,Main.palette,sizeof(T_Palette)); memcpy(Spare.backups->Pages->Palette,Main.palette,sizeof(T_Palette));
strcpy(Spare_backups->Pages->Comment,""); strcpy(Spare.backups->Pages->Comment,"");
strcpy(Spare_backups->Pages->File_directory,Main.selector.Directory); strcpy(Spare.backups->Pages->File_directory,Main.selector.Directory);
strcpy(Spare_backups->Pages->Filename,"NO_NAME2.GIF"); strcpy(Spare.backups->Pages->Filename,"NO_NAME2.GIF");
Spare_backups->Pages->File_format=DEFAULT_FILEFORMAT; Spare.backups->Pages->File_format=DEFAULT_FILEFORMAT;
// Copy this informations in the global Spare_ variables // Copy this informations in the global Spare_ variables
Download_infos_page_spare(Spare_backups->Pages); Download_infos_page_spare(Spare.backups->Pages);
// Clear the initial Visible buffer // Clear the initial Visible buffer
//memset(Main_screen,0,Main.image_width*Main.image_height); //memset(Main_screen,0,Main.image_width*Main.image_height);
@ -844,10 +844,10 @@ int Init_all_backup_lists(enum IMAGE_MODES image_mode, int width, int height)
// Spare // Spare
for (i=0; i<NB_LAYERS; i++) for (i=0; i<NB_LAYERS; i++)
{ {
Spare_backups->Pages->Image[i].Pixels=New_layer(width*height); Spare.backups->Pages->Image[i].Pixels=New_layer(width*height);
if (! Spare_backups->Pages->Image[i].Pixels) if (! Spare.backups->Pages->Image[i].Pixels)
return 0; return 0;
memset(Spare_backups->Pages->Image[i].Pixels, 0, width*height); memset(Spare.backups->Pages->Image[i].Pixels, 0, width*height);
} }
//memset(Spare_screen,0,Spare.image_width*Spare.image_height); //memset(Spare_screen,0,Spare.image_width*Spare.image_height);
@ -858,8 +858,8 @@ int Init_all_backup_lists(enum IMAGE_MODES image_mode, int width, int height)
void Set_number_of_backups(int nb_backups) void Set_number_of_backups(int nb_backups)
{ {
Change_page_number_of_list(Main_backups,nb_backups+1); Change_page_number_of_list(Main.backups,nb_backups+1);
Change_page_number_of_list(Spare_backups,nb_backups+1); Change_page_number_of_list(Spare.backups,nb_backups+1);
// Le +1 vient du fait que dans chaque liste, en 1ère position on retrouve // Le +1 vient du fait que dans chaque liste, en 1ère position on retrouve
// les infos de la page courante sur le brouillon et la page principale. // les infos de la page courante sur le brouillon et la page principale.
@ -882,7 +882,7 @@ int Backup_new_image(int layers,int width,int height)
new_page->Height=height; new_page->Height=height;
new_page->Transparent_color=0; new_page->Transparent_color=0;
new_page->Gradients=Dup_gradient(NULL); new_page->Gradients=Dup_gradient(NULL);
if (!Create_new_page(new_page,Main_backups,LAYER_ALL)) if (!Create_new_page(new_page,Main.backups,LAYER_ALL))
{ {
Error(0); Error(0);
return 0; return 0;
@ -891,7 +891,7 @@ int Backup_new_image(int layers,int width,int height)
Update_buffers(width, height); Update_buffers(width, height);
memset(Main_visible_image_depth_buffer.Image, 0, width*height); memset(Main_visible_image_depth_buffer.Image, 0, width*height);
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
return 1; return 1;
} }
@ -906,7 +906,7 @@ int Backup_with_new_dimensions(int width,int height)
int i; int i;
// On crée un descripteur pour la nouvelle page courante // On crée un descripteur pour la nouvelle page courante
new_page=New_page(Main_backups->Pages->Nb_layers); new_page=New_page(Main.backups->Pages->Nb_layers);
if (!new_page) if (!new_page)
{ {
Error(0); Error(0);
@ -915,39 +915,39 @@ int Backup_with_new_dimensions(int width,int height)
new_page->Width=width; new_page->Width=width;
new_page->Height=height; new_page->Height=height;
new_page->Transparent_color=0; new_page->Transparent_color=0;
if (!Create_new_page(new_page,Main_backups,LAYER_ALL)) if (!Create_new_page(new_page,Main.backups,LAYER_ALL))
{ {
Error(0); Error(0);
return 0; return 0;
} }
// Copy data from previous history step // Copy data from previous history step
memcpy(Main_backups->Pages->Palette,Main_backups->Pages->Next->Palette,sizeof(T_Palette)); memcpy(Main.backups->Pages->Palette,Main.backups->Pages->Next->Palette,sizeof(T_Palette));
strcpy(Main_backups->Pages->Comment,Main_backups->Pages->Next->Comment); strcpy(Main.backups->Pages->Comment,Main.backups->Pages->Next->Comment);
Main_backups->Pages->File_format=Main_backups->Pages->Next->File_format; Main.backups->Pages->File_format=Main.backups->Pages->Next->File_format;
strcpy(Main_backups->Pages->Filename, Main_backups->Pages->Next->Filename); strcpy(Main.backups->Pages->Filename, Main.backups->Pages->Next->Filename);
strcpy(Main_backups->Pages->File_directory, Main_backups->Pages->Next->File_directory); strcpy(Main.backups->Pages->File_directory, Main.backups->Pages->Next->File_directory);
Main_backups->Pages->Gradients=Dup_gradient(Main_backups->Pages->Next); Main.backups->Pages->Gradients=Dup_gradient(Main.backups->Pages->Next);
Main_backups->Pages->Background_transparent=Main_backups->Pages->Next->Background_transparent; Main.backups->Pages->Background_transparent=Main.backups->Pages->Next->Background_transparent;
Main_backups->Pages->Transparent_color=Main_backups->Pages->Next->Transparent_color; Main.backups->Pages->Transparent_color=Main.backups->Pages->Next->Transparent_color;
Main_backups->Pages->Image_mode=Main_backups->Pages->Next->Image_mode; Main.backups->Pages->Image_mode=Main.backups->Pages->Next->Image_mode;
// Fill with transparent color // Fill with transparent color
for (i=0; i<Main_backups->Pages->Nb_layers;i++) for (i=0; i<Main.backups->Pages->Nb_layers;i++)
{ {
memset(Main_backups->Pages->Image[i].Pixels, Main_backups->Pages->Transparent_color, width*height); memset(Main.backups->Pages->Image[i].Pixels, Main.backups->Pages->Transparent_color, width*height);
} }
Update_buffers(width, height); Update_buffers(width, height);
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
// Same code as in End_of_modification(), // Same code as in End_of_modification(),
// Without saving a safety backup: // Without saving a safety backup:
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
memcpy(Main_visible_image_backup.Image, memcpy(Main_visible_image_backup.Image,
Main_visible_image.Image, Main.visible_image.Image,
Main.image_width*Main.image_height); Main.image_width*Main.image_height);
} }
else else
@ -974,11 +974,11 @@ int Backup_in_place(int width,int height)
// Perform all allocations first // Perform all allocations first
new_layer=calloc(Main_backups->Pages->Nb_layers,sizeof(byte *)); new_layer=calloc(Main.backups->Pages->Nb_layers,sizeof(byte *));
if (!new_layer) if (!new_layer)
return 0; return 0;
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
new_layer[i]=New_layer(height*width); new_layer[i]=New_layer(height*width);
if (!new_layer[i]) if (!new_layer[i])
@ -993,36 +993,36 @@ int Backup_in_place(int width,int height)
// Now ok to proceed // Now ok to proceed
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
// Replace layers // Replace layers
Free_layer(Main_backups->Pages,i); Free_layer(Main.backups->Pages,i);
Main_backups->Pages->Image[i].Pixels=new_layer[i]; Main.backups->Pages->Image[i].Pixels=new_layer[i];
// Fill with transparency // Fill with transparency
memset(Main_backups->Pages->Image[i].Pixels, Main_backups->Pages->Transparent_color, width*height); memset(Main.backups->Pages->Image[i].Pixels, Main.backups->Pages->Transparent_color, width*height);
} }
Main_backups->Pages->Width=width; Main.backups->Pages->Width=width;
Main_backups->Pages->Height=height; Main.backups->Pages->Height=height;
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
// The following is part of Update_buffers() // The following is part of Update_buffers()
// (without changing the backup buffer) // (without changing the backup buffer)
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// At least one dimension is different // At least one dimension is different
if (Main_visible_image.Width*Main_visible_image.Height != width*height) if (Main.visible_image.Width*Main.visible_image.Height != width*height)
{ {
// Current image // Current image
free(Main_visible_image.Image); free(Main.visible_image.Image);
Main_visible_image.Image = (byte *)malloc(width * height); Main.visible_image.Image = (byte *)malloc(width * height);
if (Main_visible_image.Image == NULL) if (Main.visible_image.Image == NULL)
return 0; return 0;
} }
Main_visible_image.Width = width; Main.visible_image.Width = width;
Main_visible_image.Height = height; Main.visible_image.Height = height;
if (Main_visible_image_depth_buffer.Width*Main_visible_image_depth_buffer.Height != width*height) if (Main_visible_image_depth_buffer.Width*Main_visible_image_depth_buffer.Height != width*height)
{ {
@ -1050,7 +1050,7 @@ int Backup_and_resize_the_spare(int width,int height)
int return_code=0; int return_code=0;
int nb_layers; int nb_layers;
nb_layers=Spare_backups->Pages->Nb_layers; nb_layers=Spare.backups->Pages->Nb_layers;
// On crée un descripteur pour la nouvelle page de brouillon // On crée un descripteur pour la nouvelle page de brouillon
new_page=New_page(nb_layers); new_page=New_page(nb_layers);
if (!new_page) if (!new_page)
@ -1060,23 +1060,23 @@ int Backup_and_resize_the_spare(int width,int height)
} }
// Fill it with a copy of the latest history // Fill it with a copy of the latest history
Copy_S_page(new_page,Spare_backups->Pages); Copy_S_page(new_page,Spare.backups->Pages);
new_page->Gradients=Dup_gradient(Spare_backups->Pages); new_page->Gradients=Dup_gradient(Spare.backups->Pages);
new_page->Width=width; new_page->Width=width;
new_page->Height=height; new_page->Height=height;
if (Create_new_page(new_page,Spare_backups,LAYER_ALL)) if (Create_new_page(new_page,Spare.backups,LAYER_ALL))
{ {
byte i; byte i;
for (i=0; i<nb_layers;i++) for (i=0; i<nb_layers;i++)
{ {
memset(Spare_backups->Pages->Image[i].Pixels, Spare_backups->Pages->Transparent_color, width*height); memset(Spare.backups->Pages->Image[i].Pixels, Spare.backups->Pages->Transparent_color, width*height);
} }
// Update_buffers(width, height); // Not for spare // Update_buffers(width, height); // Not for spare
Download_infos_page_spare(Spare_backups->Pages); Download_infos_page_spare(Spare.backups->Pages);
// Light up the 'has unsaved changes' indicator // Light up the 'has unsaved changes' indicator
Spare.image_is_modified=1; Spare.image_is_modified=1;
@ -1105,10 +1105,10 @@ void Backup_layers(int layer)
// On remet à jour l'état des infos de la page courante (pour pouvoir les // On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard) // retrouver plus tard)
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
// Create a fresh Page descriptor // Create a fresh Page descriptor
new_page=New_page(Main_backups->Pages->Nb_layers); new_page=New_page(Main.backups->Pages->Nb_layers);
if (!new_page) if (!new_page)
{ {
Error(0); Error(0);
@ -1116,9 +1116,9 @@ void Backup_layers(int layer)
} }
// Fill it with a copy of the latest history // Fill it with a copy of the latest history
Copy_S_page(new_page,Main_backups->Pages); Copy_S_page(new_page,Main.backups->Pages);
new_page->Gradients=Dup_gradient(Main_backups->Pages); new_page->Gradients=Dup_gradient(Main.backups->Pages);
Create_new_page(new_page,Main_backups,layer); Create_new_page(new_page,Main.backups,layer);
Download_infos_page_main(new_page); Download_infos_page_main(new_page);
Update_FX_feedback(Config.FX_Feedback); Update_FX_feedback(Config.FX_Feedback);
@ -1126,11 +1126,11 @@ void Backup_layers(int layer)
// Copy the actual pixels from the backup to the latest page // Copy the actual pixels from the backup to the latest page
if (layer != LAYER_NONE) if (layer != LAYER_NONE)
{ {
for (i=0; i<Main_backups->Pages->Nb_layers;i++) for (i=0; i<Main.backups->Pages->Nb_layers;i++)
{ {
if (layer == LAYER_ALL || i == layer) if (layer == LAYER_ALL || i == layer)
memcpy(Main_backups->Pages->Image[i].Pixels, memcpy(Main.backups->Pages->Image[i].Pixels,
Main_backups->Pages->Next->Image[i].Pixels, Main.backups->Pages->Next->Image[i].Pixels,
Main.image_width*Main.image_height); Main.image_width*Main.image_height);
} }
} }
@ -1168,7 +1168,7 @@ void Backup_the_spare(int layer)
T_Page *new_page; T_Page *new_page;
// Create a fresh Page descriptor // Create a fresh Page descriptor
new_page=New_page(Spare_backups->Pages->Nb_layers); new_page=New_page(Spare.backups->Pages->Nb_layers);
if (!new_page) if (!new_page)
{ {
Error(0); Error(0);
@ -1176,18 +1176,18 @@ void Backup_the_spare(int layer)
} }
// Fill it with a copy of the latest history // Fill it with a copy of the latest history
Copy_S_page(new_page,Spare_backups->Pages); Copy_S_page(new_page,Spare.backups->Pages);
new_page->Gradients=Dup_gradient(Spare_backups->Pages); new_page->Gradients=Dup_gradient(Spare.backups->Pages);
Create_new_page(new_page,Spare_backups,layer); Create_new_page(new_page,Spare.backups,layer);
// Copy the actual pixels from the backup to the latest page // Copy the actual pixels from the backup to the latest page
if (layer != LAYER_NONE) if (layer != LAYER_NONE)
{ {
for (i=0; i<Spare_backups->Pages->Nb_layers;i++) for (i=0; i<Spare.backups->Pages->Nb_layers;i++)
{ {
if (layer == LAYER_ALL || i == layer) if (layer == LAYER_ALL || i == layer)
memcpy(Spare_backups->Pages->Image[i].Pixels, memcpy(Spare.backups->Pages->Image[i].Pixels,
Spare_backups->Pages->Next->Image[i].Pixels, Spare.backups->Pages->Next->Image[i].Pixels,
Spare.image_width*Spare.image_height); Spare.image_width*Spare.image_height);
} }
} }
@ -1198,9 +1198,9 @@ void Backup_the_spare(int layer)
void Check_layers_limits() void Check_layers_limits()
{ {
if (Main.current_layer > Main_backups->Pages->Nb_layers-1) if (Main.current_layer > Main.backups->Pages->Nb_layers-1)
{ {
Main.current_layer = Main_backups->Pages->Nb_layers-1; Main.current_layer = Main.backups->Pages->Nb_layers-1;
Main.layers_visible |= 1<<Main.current_layer; Main.layers_visible |= 1<<Main.current_layer;
} }
} }
@ -1212,20 +1212,20 @@ void Undo(void)
if (Last_backed_up_layers) if (Last_backed_up_layers)
{ {
Free_page_of_a_list(Main_backups); Free_page_of_a_list(Main.backups);
Last_backed_up_layers=0; Last_backed_up_layers=0;
} }
// On remet à jour l'état des infos de la page courante (pour pouvoir les // On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard) // retrouver plus tard)
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
// On fait faire un undo à la liste des backups de la page principale // On fait faire un undo à la liste des backups de la page principale
Backward_in_list_of_pages(Main_backups); Backward_in_list_of_pages(Main.backups);
Update_buffers(Main_backups->Pages->Width, Main_backups->Pages->Height); Update_buffers(Main.backups->Pages->Width, Main.backups->Pages->Height);
// On extrait ensuite les infos sur la nouvelle page courante // On extrait ensuite les infos sur la nouvelle page courante
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
// Note: le backup n'a pas obligatoirement les mêmes dimensions ni la même // Note: le backup n'a pas obligatoirement les mêmes dimensions ni la même
// palette que la page courante. Mais en temps normal, le backup // palette que la page courante. Mais en temps normal, le backup
// n'est pas utilisé à la suite d'un Undo. Donc ça ne devrait pas // n'est pas utilisé à la suite d'un Undo. Donc ça ne devrait pas
@ -1246,19 +1246,19 @@ void Redo(void)
if (Last_backed_up_layers) if (Last_backed_up_layers)
{ {
Free_page_of_a_list(Main_backups); Free_page_of_a_list(Main.backups);
Last_backed_up_layers=0; Last_backed_up_layers=0;
} }
// On remet à jour l'état des infos de la page courante (pour pouvoir les // On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard) // retrouver plus tard)
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
// On fait faire un redo à la liste des backups de la page principale // On fait faire un redo à la liste des backups de la page principale
Advance_in_list_of_pages(Main_backups); Advance_in_list_of_pages(Main.backups);
Update_buffers(Main_backups->Pages->Width, Main_backups->Pages->Height); Update_buffers(Main.backups->Pages->Width, Main.backups->Pages->Height);
// On extrait ensuite les infos sur la nouvelle page courante // On extrait ensuite les infos sur la nouvelle page courante
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
// Note: le backup n'a pas obligatoirement les mêmes dimensions ni la même // Note: le backup n'a pas obligatoirement les mêmes dimensions ni la même
// palette que la page courante. Mais en temps normal, le backup // palette que la page courante. Mais en temps normal, le backup
// n'est pas utilisé à la suite d'un Redo. Donc ça ne devrait pas // n'est pas utilisé à la suite d'un Redo. Donc ça ne devrait pas
@ -1275,16 +1275,16 @@ void Redo(void)
void Free_current_page(void) void Free_current_page(void)
{ {
// On détruit la page courante de la liste principale // On détruit la page courante de la liste principale
Free_page_of_a_list(Main_backups); Free_page_of_a_list(Main.backups);
// On extrait ensuite les infos sur la nouvelle page courante // On extrait ensuite les infos sur la nouvelle page courante
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
// Note: le backup n'a pas obligatoirement les mêmes dimensions ni la même // Note: le backup n'a pas obligatoirement les mêmes dimensions ni la même
// palette que la page courante. Mais en temps normal, le backup // palette que la page courante. Mais en temps normal, le backup
// n'est pas utilisé à la suite d'une destruction de page. Donc ça ne // n'est pas utilisé à la suite d'une destruction de page. Donc ça ne
// devrait pas poser de problèmes. // devrait pas poser de problèmes.
Update_buffers(Main_backups->Pages->Width, Main_backups->Pages->Height); Update_buffers(Main.backups->Pages->Width, Main.backups->Pages->Height);
Check_layers_limits(); Check_layers_limits();
Redraw_layered_image(); Redraw_layered_image();
End_of_modification(); End_of_modification();
@ -1297,14 +1297,14 @@ void Exchange_main_and_spare(void)
// On commence par mettre à jour dans les descripteurs les infos sur les // On commence par mettre à jour dans les descripteurs les infos sur les
// pages qu'on s'apprête à échanger, pour qu'on se retrouve pas avec de // pages qu'on s'apprête à échanger, pour qu'on se retrouve pas avec de
// vieilles valeurs qui datent de mathuzalem. // vieilles valeurs qui datent de mathuzalem.
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
Upload_infos_page_spare(Spare_backups->Pages); Upload_infos_page_spare(Spare.backups->Pages);
// On inverse les listes de pages // On inverse les listes de pages
//TODO //TODO
temp_list=Main_backups; temp_list=Main.backups;
Main_backups=Spare_backups; Main.backups=Spare.backups;
Spare_backups=temp_list; Spare.backups=temp_list;
// On extrait ensuite les infos sur les nouvelles pages courante, brouillon // On extrait ensuite les infos sur les nouvelles pages courante, brouillon
// et backup. // et backup.
@ -1315,11 +1315,11 @@ void Exchange_main_and_spare(void)
// un changement de dimensions et va bêtement sortir du mode loupe, alors // un changement de dimensions et va bêtement sortir du mode loupe, alors
// que lors d'un changement de page, on veut bien conserver l'état du mode // que lors d'un changement de page, on veut bien conserver l'état du mode
// loupe du brouillon. // loupe du brouillon.
Main.image_width=Main_backups->Pages->Width; Main.image_width=Main.backups->Pages->Width;
Main.image_height=Main_backups->Pages->Height; Main.image_height=Main.backups->Pages->Height;
Download_infos_page_main(Main_backups->Pages); Download_infos_page_main(Main.backups->Pages);
Download_infos_page_spare(Spare_backups->Pages); Download_infos_page_spare(Spare.backups->Pages);
} }
void End_of_modification(void) void End_of_modification(void)
@ -1327,7 +1327,7 @@ void End_of_modification(void)
//Update_buffers(Main.image_width, Main.image_height); //Update_buffers(Main.image_width, Main.image_height);
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION) if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION)
{ {
// Backup buffer can have "wrong" size if a Lua script // Backup buffer can have "wrong" size if a Lua script
// performs a resize. // performs a resize.
@ -1335,7 +1335,7 @@ void End_of_modification(void)
// //
memcpy(Main_visible_image_backup.Image, memcpy(Main_visible_image_backup.Image,
Main_visible_image.Image, Main.visible_image.Image,
Main.image_width*Main.image_height); Main.image_width*Main.image_height);
} }
else else
@ -1411,7 +1411,7 @@ byte Add_layer(T_List_of_pages *list, int layer)
duration=new_page->Image[1].Duration; duration=new_page->Image[1].Duration;
new_page->Image[layer].Duration=duration; new_page->Image[layer].Duration=duration;
// Fill with transparency, initially // Fill with transparency, initially
memset(new_image, Main_backups->Pages->Transparent_color, list->Pages->Height*list->Pages->Width); // transparent color memset(new_image, Main.backups->Pages->Transparent_color, list->Pages->Height*list->Pages->Width); // transparent color
// Done. Note that the visible buffer is already ok since we // Done. Note that the visible buffer is already ok since we
// only inserted a transparent "slide" somewhere. // only inserted a transparent "slide" somewhere.
@ -1424,7 +1424,7 @@ byte Add_layer(T_List_of_pages *list, int layer)
dword *visible_layers_flag; dword *visible_layers_flag;
// Determine if we're modifying the spare or the main page. // Determine if we're modifying the spare or the main page.
if (list == Main_backups) if (list == Main.backups)
{ {
visible_layers_flag = &Main.layers_visible; visible_layers_flag = &Main.layers_visible;
Main.current_layer = layer; Main.current_layer = layer;
@ -1483,7 +1483,7 @@ byte Delete_layer(T_List_of_pages *list, int layer)
byte new_current_layer; byte new_current_layer;
// Determine if we're modifying the spare or the main page. // Determine if we're modifying the spare or the main page.
if (list == Main_backups) if (list == Main.backups)
{ {
visible_layers_flag = &Main.layers_visible; visible_layers_flag = &Main.layers_visible;
if (Main.current_layer>=layer && Main.current_layer>0) if (Main.current_layer>=layer && Main.current_layer>0)
@ -1516,19 +1516,19 @@ byte Merge_layer()
int i; int i;
for (i=0; i<Main.image_width*Main.image_height; i++) for (i=0; i<Main.image_width*Main.image_height; i++)
{ {
byte color = *(Main_backups->Pages->Image[Main.current_layer].Pixels+i); byte color = *(Main.backups->Pages->Image[Main.current_layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color if (color != Main.backups->Pages->Transparent_color) // transparent color
*(Main_backups->Pages->Image[Main.current_layer-1].Pixels+i) = color; *(Main.backups->Pages->Image[Main.current_layer-1].Pixels+i) = color;
} }
return Delete_layer(Main_backups,Main.current_layer); return Delete_layer(Main.backups,Main.current_layer);
} }
void Switch_layer_mode(enum IMAGE_MODES new_mode) void Switch_layer_mode(enum IMAGE_MODES new_mode)
{ {
if (new_mode == Main_backups->Pages->Image_mode) if (new_mode == Main.backups->Pages->Image_mode)
return; return;
Main_backups->Pages->Image_mode = new_mode; Main.backups->Pages->Image_mode = new_mode;
switch (new_mode) switch (new_mode)
{ {

4
src/pages.h
View File

@ -41,13 +41,13 @@ extern byte * FX_feedback_screen;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/// The pixels of visible layers, flattened copy. /// The pixels of visible layers, flattened copy.
extern T_Bitmap Main_visible_image; //extern T_Bitmap Main_visible_image;
/// The pixels of visible layers, flattened copy, used for no-feedback effects. /// The pixels of visible layers, flattened copy, used for no-feedback effects.
extern T_Bitmap Main_visible_image_backup; extern T_Bitmap Main_visible_image_backup;
/// The index of visible pixels from ::Main_visible_image. Points to the right layer. /// The index of visible pixels from ::Main_visible_image. Points to the right layer.
extern T_Bitmap Main_visible_image_depth_buffer; extern T_Bitmap Main_visible_image_depth_buffer;
/// The pixels of visible layers for the spare page, flattened copy. /// The pixels of visible layers for the spare page, flattened copy.
extern T_Bitmap Spare_visible_image; //extern T_Bitmap Spare_visible_image;
/// ///
/// INDIVIDUAL PAGES /// INDIVIDUAL PAGES

14
src/palette.c
View File

@ -344,19 +344,19 @@ void Remap_image_highlevel(byte * conversion_table)
int layer; int layer;
// Remap the flatenned image view // Remap the flatenned image view
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION
&& Main_backups->Pages->Image_mode != IMAGE_MODE_MODE5) && Main.backups->Pages->Image_mode != IMAGE_MODE_MODE5)
{ {
Remap_general_lowlevel(conversion_table,Main_visible_image.Image,Main_visible_image.Image, Remap_general_lowlevel(conversion_table,Main.visible_image.Image,Main.visible_image.Image,
Main.image_width,Main.image_height,Main.image_width); Main.image_width,Main.image_height,Main.image_width);
} }
// Remap all layers // Remap all layers
for (layer=0; layer<Main_backups->Pages->Nb_layers; layer++) for (layer=0; layer<Main.backups->Pages->Nb_layers; layer++)
Remap_general_lowlevel(conversion_table,Main_backups->Pages->Image[layer].Pixels,Main_backups->Pages->Image[layer].Pixels,Main.image_width,Main.image_height,Main.image_width); Remap_general_lowlevel(conversion_table,Main.backups->Pages->Image[layer].Pixels,Main.backups->Pages->Image[layer].Pixels,Main.image_width,Main.image_height,Main.image_width);
// Remap transparent color // Remap transparent color
Main_backups->Pages->Transparent_color = Main.backups->Pages->Transparent_color =
conversion_table[Main_backups->Pages->Transparent_color]; conversion_table[Main.backups->Pages->Transparent_color];
// On calcule les limites à l'écran de l'image // On calcule les limites à l'écran de l'image
if (Main.image_height>=Menu_Y_before_window) if (Main.image_height>=Menu_Y_before_window)

4
src/struct.h
View File

@ -606,6 +606,10 @@ typedef struct
byte safety_backup_prefix; byte safety_backup_prefix;
/// Tilemap mode /// Tilemap mode
byte tilemap_mode; byte tilemap_mode;
/// The pixels of visible layers, flattened copy.
T_Bitmap visible_image;
/// List of backup pages for the main image.
T_List_of_pages * backups;
} T_Document; } T_Document;
#endif #endif

16
src/tiles.c
View File

@ -118,8 +118,8 @@ int Tile_is_same(int t1, int t2)
byte *bmp1,*bmp2; byte *bmp1,*bmp2;
int y; int y;
bmp1 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1)); bmp1 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2))*Main.image_width+(TILE_X(t2)); bmp2 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2))*Main.image_width+(TILE_X(t2));
for (y=0; y < Snap_height; y++) for (y=0; y < Snap_height; y++)
{ {
@ -135,8 +135,8 @@ int Tile_is_same_flipped_x(int t1, int t2)
byte *bmp1,*bmp2; byte *bmp1,*bmp2;
int y, x; int y, x;
bmp1 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1)); bmp1 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2))*Main.image_width+(TILE_X(t2)+Snap_width-1); bmp2 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2))*Main.image_width+(TILE_X(t2)+Snap_width-1);
for (y=0; y < Snap_height; y++) for (y=0; y < Snap_height; y++)
{ {
@ -153,8 +153,8 @@ int Tile_is_same_flipped_y(int t1, int t2)
byte *bmp1,*bmp2; byte *bmp1,*bmp2;
int y; int y;
bmp1 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1)); bmp1 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2)+Snap_height-1)*Main.image_width+(TILE_X(t2)); bmp2 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2)+Snap_height-1)*Main.image_width+(TILE_X(t2));
for (y=0; y < Snap_height; y++) for (y=0; y < Snap_height; y++)
{ {
@ -171,8 +171,8 @@ int Tile_is_same_flipped_xy(int t1, int t2)
byte *bmp1,*bmp2; byte *bmp1,*bmp2;
int y, x; int y, x;
bmp1 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1)); bmp1 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t1))*Main.image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2)+Snap_height-1)*Main.image_width+(TILE_X(t2)+Snap_width-1); bmp2 = Main.backups->Pages->Image[Main.current_layer].Pixels+(TILE_Y(t2)+Snap_height-1)*Main.image_width+(TILE_X(t2)+Snap_width-1);
for (y=0; y < Snap_height; y++) for (y=0; y < Snap_height; y++)
{ {

36
src/transform.c
View File

@ -371,7 +371,7 @@ void Button_Transform_menu(void)
old_width=Main.image_width; old_width=Main.image_width;
old_height=Main.image_height; old_height=Main.image_height;
Upload_infos_page_main(Main_backups->Pages); Upload_infos_page_main(Main.backups->Pages);
// Allocate a new page // Allocate a new page
if (Backup_with_new_dimensions(new_width,new_height)) if (Backup_with_new_dimensions(new_width,new_height))
{ {
@ -385,42 +385,42 @@ void Button_Transform_menu(void)
int i; int i;
case 2 : // Flip X case 2 : // Flip X
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
memcpy(Main_backups->Pages->Image[i].Pixels,Main_backups->Pages->Next->Image[i].Pixels,Main.image_width*Main.image_height); memcpy(Main.backups->Pages->Image[i].Pixels,Main.backups->Pages->Next->Image[i].Pixels,Main.image_width*Main.image_height);
Flip_X_lowlevel(Main_backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height); Flip_X_lowlevel(Main.backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height);
} }
break; break;
case 3 : // Flip Y case 3 : // Flip Y
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
memcpy(Main_backups->Pages->Image[i].Pixels,Main_backups->Pages->Next->Image[i].Pixels,Main.image_width*Main.image_height); memcpy(Main.backups->Pages->Image[i].Pixels,Main.backups->Pages->Next->Image[i].Pixels,Main.image_width*Main.image_height);
Flip_Y_lowlevel(Main_backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height); Flip_Y_lowlevel(Main.backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height);
} }
break; break;
case 4 : // -90° Rotation case 4 : // -90° Rotation
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
Rotate_270_deg_lowlevel(Main_backups->Pages->Next->Image[i].Pixels, Main_backups->Pages->Image[i].Pixels, old_width, old_height); Rotate_270_deg_lowlevel(Main.backups->Pages->Next->Image[i].Pixels, Main.backups->Pages->Image[i].Pixels, old_width, old_height);
} }
break; break;
case 5 : // +90° Rotation case 5 : // +90° Rotation
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
Rotate_90_deg_lowlevel(Main_backups->Pages->Next->Image[i].Pixels, Main_backups->Pages->Image[i].Pixels, old_width, old_height); Rotate_90_deg_lowlevel(Main.backups->Pages->Next->Image[i].Pixels, Main.backups->Pages->Image[i].Pixels, old_width, old_height);
} }
break; break;
case 6 : // 180° Rotation case 6 : // 180° Rotation
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
memcpy(Main_backups->Pages->Image[i].Pixels,Main_backups->Pages->Next->Image[i].Pixels,Main.image_width*Main.image_height); memcpy(Main.backups->Pages->Image[i].Pixels,Main.backups->Pages->Next->Image[i].Pixels,Main.image_width*Main.image_height);
Rotate_180_deg_lowlevel(Main_backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height); Rotate_180_deg_lowlevel(Main.backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height);
} }
break; break;
case 7 : // Resize case 7 : // Resize
for (i=0; i<Main_backups->Pages->Nb_layers; i++) for (i=0; i<Main.backups->Pages->Nb_layers; i++)
{ {
Rescale(Main_backups->Pages->Next->Image[i].Pixels, old_width, old_height, Main_backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height, 0, 0); Rescale(Main.backups->Pages->Next->Image[i].Pixels, old_width, old_height, Main.backups->Pages->Image[i].Pixels, Main.image_width, Main.image_height, 0, 0);
} }
break; break;
} }
@ -428,9 +428,9 @@ void Button_Transform_menu(void)
for (i=0; i<NB_LAYERS; i++) for (i=0; i<NB_LAYERS; i++)
{ {
Copy_part_of_image_to_another( Copy_part_of_image_to_another(
Main_backups->Pages->Next->Image[i].Pixels,0,0,Min(old_width,Main.image_width), Main.backups->Pages->Next->Image[i].Pixels,0,0,Min(old_width,Main.image_width),
Min(old_height,Main.image_height),old_width, Min(old_height,Main.image_height),old_width,
Main_backups->Pages->Image[i].Pixels,0,0,Main.image_width); Main.backups->Pages->Image[i].Pixels,0,0,Main.image_width);
} }
*/ */
Redraw_layered_image(); Redraw_layered_image();

28
src/windows.c
View File

@ -282,8 +282,8 @@ void Frame_menu_color(byte id)
int cw = (Menu_palette_cell_width)*Menu_factor_X; int cw = (Menu_palette_cell_width)*Menu_factor_X;
int ch = (cell_height)*Menu_factor_Y; int ch = (cell_height)*Menu_factor_Y;
if (Main_backups->Pages->Image_mode == 0 && Main_backups->Pages->Nb_layers > 1) if (Main.backups->Pages->Image_mode == 0 && Main.backups->Pages->Nb_layers > 1)
transparent = Main_backups->Pages->Transparent_color; transparent = Main.backups->Pages->Transparent_color;
// Color is not selected, no dotted lines // Color is not selected, no dotted lines
Block(start_x,start_y,Menu_palette_cell_width*Menu_factor_X, Block(start_x,start_y,Menu_palette_cell_width*Menu_factor_X,
@ -352,9 +352,9 @@ void Display_menu_palette(void)
(Menu_bars[MENUBAR_TOOLS].Height)*Menu_factor_Y, (Menu_bars[MENUBAR_TOOLS].Height)*Menu_factor_Y,
MC_Black); MC_Black);
if (Main_backups->Pages->Image_mode == 0 if (Main.backups->Pages->Image_mode == 0
&& Main_backups->Pages->Nb_layers > 1) && Main.backups->Pages->Nb_layers > 1)
transparent = Main_backups->Pages->Transparent_color; transparent = Main.backups->Pages->Transparent_color;
// Compute the size of the color cells (they are smaller by 1px when using // Compute the size of the color cells (they are smaller by 1px when using
// 'separate colors" // 'separate colors"
@ -505,7 +505,7 @@ void Display_layerbar(void)
{ {
word x_off=0; word x_off=0;
word button_width = LAYER_SPRITE_WIDTH; word button_width = LAYER_SPRITE_WIDTH;
word button_number = Main_backups->Pages->Nb_layers; word button_number = Main.backups->Pages->Nb_layers;
word horiz_space; word horiz_space;
word current_button; word current_button;
word repeats=1; word repeats=1;
@ -592,7 +592,7 @@ void Display_layerbar(void)
// Frame# background rectangle // Frame# background rectangle
// Block((Menu_bars[MENUBAR_ANIMATION].Skin_width)*Menu_factor_X,(0+Menu_bars[MENUBAR_ANIMATION].Top)*Menu_factor_Y+Menu_Y,8*8*Menu_factor_X,8*Menu_factor_Y,MC_Light); // Block((Menu_bars[MENUBAR_ANIMATION].Skin_width)*Menu_factor_X,(0+Menu_bars[MENUBAR_ANIMATION].Top)*Menu_factor_Y+Menu_Y,8*8*Menu_factor_X,8*Menu_factor_Y,MC_Light);
// Frame #/# // Frame #/#
snprintf(str, 8, "%3d/%3d", Main.current_layer+1, Main_backups->Pages->Nb_layers); snprintf(str, 8, "%3d/%3d", Main.current_layer+1, Main.backups->Pages->Nb_layers);
Print_general((59)*Menu_factor_X,(Menu_bars[MENUBAR_ANIMATION].Top+3)*Menu_factor_Y+Menu_Y,str,MC_Black,MC_Light); Print_general((59)*Menu_factor_X,(Menu_bars[MENUBAR_ANIMATION].Top+3)*Menu_factor_Y+Menu_Y,str,MC_Black,MC_Light);
Update_rect( Update_rect(
(59)*Menu_factor_X, (59)*Menu_factor_X,
@ -802,7 +802,7 @@ void Print_filename(void)
// Partial copy of the name // Partial copy of the name
{ {
#ifdef ENABLE_FILENAMES_ICONV #ifdef ENABLE_FILENAMES_ICONV
char * input = Main_backups->Pages->Filename; char * input = Main.backups->Pages->Filename;
size_t inbytesleft = strlen(input); size_t inbytesleft = strlen(input);
char * output = display_string; char * output = display_string;
size_t outbytesleft = sizeof(display_string)-1; size_t outbytesleft = sizeof(display_string)-1;
@ -811,7 +811,7 @@ void Print_filename(void)
else else
#endif /* ENABLE_FILENAMES_ICONV */ #endif /* ENABLE_FILENAMES_ICONV */
{ {
strncpy(display_string, Main_backups->Pages->Filename, sizeof(display_string)-1); strncpy(display_string, Main.backups->Pages->Filename, sizeof(display_string)-1);
display_string[sizeof(display_string)-1] = '\0'; display_string[sizeof(display_string)-1] = '\0';
} }
} }
@ -2628,15 +2628,15 @@ void Display_all_screen(void)
if (Main.magnifier_mode) if (Main.magnifier_mode)
{ {
if (Main.image_width<Main.separator_position && Main.image_width < Screen_width) if (Main.image_width<Main.separator_position && Main.image_width < Screen_width)
Block(Main.image_width,0,(Main.separator_position-Main.image_width),Menu_Y,Main_backups->Pages->Transparent_color); Block(Main.image_width,0,(Main.separator_position-Main.image_width),Menu_Y,Main.backups->Pages->Transparent_color);
} }
else else
{ {
if (Main.image_width<Screen_width) if (Main.image_width<Screen_width)
Block(Main.image_width,0,(Screen_width-Main.image_width),Menu_Y,Main_backups->Pages->Transparent_color); Block(Main.image_width,0,(Screen_width-Main.image_width),Menu_Y,Main.backups->Pages->Transparent_color);
} }
if (Main.image_height<Menu_Y) if (Main.image_height<Menu_Y)
Block(0,Main.image_height,width,(Menu_Y-height),Main_backups->Pages->Transparent_color); Block(0,Main.image_height,width,(Menu_Y-height),Main.backups->Pages->Transparent_color);
// ---/\/\/\ Partie zoomée: /\/\/\--- // ---/\/\/\ Partie zoomée: /\/\/\---
if (Main.magnifier_mode) if (Main.magnifier_mode)
@ -2665,9 +2665,9 @@ void Display_all_screen(void)
if (Main.image_width<Main.magnifier_width) if (Main.image_width<Main.magnifier_width)
Block(Main.X_zoom+(Main.image_width*Main.magnifier_factor),0, Block(Main.X_zoom+(Main.image_width*Main.magnifier_factor),0,
(Main.magnifier_width-Main.image_width)*Main.magnifier_factor, (Main.magnifier_width-Main.image_width)*Main.magnifier_factor,
Menu_Y,Main_backups->Pages->Transparent_color); Menu_Y,Main.backups->Pages->Transparent_color);
if (height<Menu_Y) if (height<Menu_Y)
Block(Main.X_zoom,height,width*Main.magnifier_factor,(Menu_Y-height),Main_backups->Pages->Transparent_color); Block(Main.X_zoom,height,width*Main.magnifier_factor,(Menu_Y-height),Main.backups->Pages->Transparent_color);
} }
// ---/\/\/\ Affichage des limites /\/\/\--- // ---/\/\/\ Affichage des limites /\/\/\---