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
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;
}
@ -284,7 +284,7 @@ void Draw_paintbrush(short x,short y,byte color)
int position;
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
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(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(133, 151, 71, 14, "Layers", 0, (Main_backups->Pages->Image_mode != IMAGE_MODE_LAYERED), 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);
Update_window_area(0,0,Window_width, Window_height);
@ -187,7 +187,7 @@ void Button_Message_initial(void)
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);
Config.Default_mode_layers = 0;
@ -203,7 +203,7 @@ void Button_Message_initial(void)
Display_all_screen();
}
// 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);
Redraw_spare_image();
}
@ -506,12 +506,12 @@ void Button_Toggle_toolbar(void)
Window_dropdown_add_item(&dropdown, 0, menu_name_tools);
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION ||
Main_backups->Pages->Nb_layers==1)
if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION ||
Main.backups->Pages->Nb_layers==1)
Window_dropdown_add_item(&dropdown, 1, menu_name_layers);
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION ||
(Main_backups->Pages->Image_mode == IMAGE_MODE_LAYERED && Main_backups->Pages->Nb_layers==1))
if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION ||
(Main.backups->Pages->Image_mode == IMAGE_MODE_LAYERED && Main.backups->Pages->Nb_layers==1))
Window_dropdown_add_item(&dropdown, 2, menu_name_anim);
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);
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
Switch_layer_mode(IMAGE_MODE_LAYERED);
break;
@ -543,7 +543,7 @@ void Button_Toggle_toolbar(void)
}
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);
break;
@ -631,7 +631,7 @@ byte Button_Quit_local_function(void)
{
case 1 : return 0; // Rester
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 ?") )
{
T_IO_Context save_context;
@ -641,7 +641,7 @@ byte Button_Quit_local_function(void)
Cursor_shape=CURSOR_SHAPE_HOURGLASS;
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);
Destroy_context(&save_context);
@ -698,9 +698,9 @@ void Button_Clear(void)
Hide_cursor();
Backup();
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
Clear_current_image(Main_backups->Pages->Transparent_color);
Clear_current_image(Main.backups->Pages->Transparent_color);
Redraw_layered_image();
End_of_modification();
Display_all_screen();
@ -1565,9 +1565,9 @@ void Button_Page(void)
// On fait le reste du travail "à la main":
// TODO
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.Height,Spare_visible_image.Height)// !
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.Height,Spare.visible_image.Height)
SWAP_SHORTS(Main.offset_X,Spare.offset_X)
SWAP_SHORTS(Main.offset_Y,Spare.offset_Y)
SWAP_SHORTS(Main.separator_position,Spare.separator_position)
@ -1652,20 +1652,20 @@ void Copy_image_only(void)
{
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)
{
// 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
{
// Resize the original layer
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,
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 -------------------------------------------------
void Button_Kill(void)
{
if ( (Main_backups->List_size==1)
if ( (Main.backups->List_size==1)
|| (!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.");
Hide_cursor();
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)
{
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);
Gradient_lower_bound =Main_backups->Pages->Gradients->Range[index].Start;
Gradient_upper_bound =Main_backups->Pages->Gradients->Range[index].End;
Gradient_is_inverted =Main_backups->Pages->Gradients->Range[index].Inverse;
Gradient_random_factor=Main_backups->Pages->Gradients->Range[index].Mix+1;
Gradient_lower_bound =Main.backups->Pages->Gradients->Range[index].Start;
Gradient_upper_bound =Main.backups->Pages->Gradients->Range[index].End;
Gradient_is_inverted =Main.backups->Pages->Gradients->Range[index].Inverse;
Gradient_random_factor=Main.backups->Pages->Gradients->Range[index].Mix+1;
Gradient_bounds_range=(Gradient_lower_bound<Gradient_upper_bound)?
Gradient_upper_bound-Gradient_lower_bound:
Gradient_lower_bound-Gradient_upper_bound;
Gradient_bounds_range++;
switch(Main_backups->Pages->Gradients->Range[index].Technique)
switch(Main.backups->Pages->Gradients->Range[index].Technique)
{
case 0 : // Degradé de base
Gradient_function=Gradient_basic;
@ -2541,7 +2541,7 @@ void Button_Gradients(void)
Gradient_pixel=Pixel;
old_current_gradient=Current_gradient;
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");
@ -2550,19 +2550,19 @@ void Button_Gradients(void)
gradient_scroller=Window_set_scroller_button(218,20,75,16,1,Current_gradient); // 2
// Slider for mix
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
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
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(123,128,51,14,"Cancel",0,1,KEY_ESC); // 7
// Scrolling speed
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);
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);
Print_in_window(73,113,str,MC_Black,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);
// 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);
Print_in_window(215,100,str,MC_Black,MC_Light);
@ -2582,7 +2582,7 @@ void Button_Gradients(void)
// On affiche la preview
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);
Display_cursor();
@ -2604,19 +2604,19 @@ void Button_Gradients(void)
Print_in_window(215,100,str,MC_Black,MC_Light);
// 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
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
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);
// 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);
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);
// Gradient #
@ -2624,7 +2624,7 @@ void Button_Gradients(void)
Window_draw_slider(gradient_scroller);
// 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
Draw_gradient_preview(8,128,108,14,Current_gradient);
@ -2654,9 +2654,9 @@ void Button_Gradients(void)
// On vient de clicker
// 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
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:
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
if (first_color<temp_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].Start=first_color;
Main.backups->Pages->Gradients->Range[Current_gradient].End =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].End =first_color;
Main.backups->Pages->Gradients->Range[Current_gradient].Start=temp_color;
Main.backups->Pages->Gradients->Range[Current_gradient].End =first_color;
}
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
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:
Draw_gradient_preview(8,128,108,14,Current_gradient);
last_color=temp_color;
@ -2696,7 +2696,7 @@ void Button_Gradients(void)
case 3 : // Nouveau mélange de dégradé
Hide_cursor();
// 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
Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor();
@ -2704,8 +2704,8 @@ void Button_Gradients(void)
case 4 : // Changement de sens
Hide_cursor();
// On inverse le sens (par un XOR de 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);
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);
// On affiche la nouvelle preview
Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor();
@ -2713,14 +2713,14 @@ void Button_Gradients(void)
case 5 : // Changement de technique
Hide_cursor();
// 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;
Draw_button_gradient_style(8,90,Main_backups->Pages->Gradients->Range[Current_gradient].Technique);
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);
// On affiche la nouvelle preview
Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor();
case 8 : // Speed
Main_backups->Pages->Gradients->Range[Current_gradient].Speed=Window_attribute2;
Num2str(Main_backups->Pages->Gradients->Range[Current_gradient].Speed,str,3);
Main.backups->Pages->Gradients->Range[Current_gradient].Speed=Window_attribute2;
Num2str(Main.backups->Pages->Gradients->Range[Current_gradient].Speed,str,3);
Hide_cursor();
Print_in_window(73,113,str,MC_Black,MC_Light);
Display_cursor();
@ -2746,9 +2746,9 @@ void Button_Gradients(void)
temp_color=color;
// 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
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:
Draw_gradient_preview(8,128,108,14,Current_gradient);
Display_cursor();
@ -2804,7 +2804,7 @@ void Button_Gradients(void)
if (clicked_button==7) // Cancel
{
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)
{
strcpy(filename, Main_backups->Pages->Filename);
strcpy(directory, Main_backups->Pages->File_directory);
strcpy(filename, Main.backups->Pages->Filename);
strcpy(directory, Main.backups->Pages->File_directory);
Init_context_layered_image(&context, filename, directory);
}
else
@ -3301,7 +3301,7 @@ void Button_Load(void)
{
// On sauve l'état actuel des paramètres de l'image pour pouvoir les
// 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);
Tilemap_update();
@ -3315,7 +3315,7 @@ void Button_Reload(void)
// On sauve l'état actuel des paramètres de l'image pour pouvoir les
// 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 ?") )
{
@ -3329,7 +3329,7 @@ void Button_Reload(void)
Original_screen_X=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);
Hide_cursor();
@ -3406,7 +3406,7 @@ void Backup_filename(char * fname, char * backup_name)
short i;
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';
strcat(backup_name,"BAK");
}
@ -3417,7 +3417,7 @@ void Backup_existing_file(void)
char filename[MAX_PATH_CHARACTERS]; // Nom complet du fichier
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
Backup_filename(filename,new_filename);
@ -3449,8 +3449,8 @@ void Save_picture(enum CONTEXT_TYPE type)
if (type == CONTEXT_MAIN_IMAGE)
{
strcpy(filename, Main_backups->Pages->Filename);
strcpy(directory, Main_backups->Pages->File_directory);
strcpy(filename, Main.backups->Pages->Filename);
strcpy(directory, Main.backups->Pages->File_directory);
Init_context_layered_image(&save_context, filename, directory);
save_context.Format = Main.fileformat;
}
@ -3464,7 +3464,7 @@ void Save_picture(enum CONTEXT_TYPE type)
else if (type == CONTEXT_PALETTE)
{
char* dotpos;
strcpy(filename, Main_backups->Pages->Filename);
strcpy(filename, Main.backups->Pages->Filename);
// Replace extension with PAL
dotpos = strrchr(filename, '.');
@ -3472,7 +3472,7 @@ void Save_picture(enum CONTEXT_TYPE type)
dotpos = filename + strlen(filename);
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);
save_context.Type = CONTEXT_PALETTE;
@ -3510,12 +3510,12 @@ void Save_picture(enum CONTEXT_TYPE type)
Save_image(&save_context);
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.fileformat=save_context.Format;
strcpy(Main_backups->Pages->Filename, save_context.File_name);
strcpy(Main_backups->Pages->File_directory, save_context.File_directory);
strcpy(Main.backups->Pages->Filename, save_context.File_name);
strcpy(Main.backups->Pages->File_directory, save_context.File_directory);
}
if (type == CONTEXT_BRUSH)
{
@ -3547,7 +3547,7 @@ void Button_Autosave(void)
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);
if ( (!file_already_exists) || Confirmation_box("Erase old file ?") )
@ -3567,7 +3567,7 @@ void Button_Autosave(void)
Cursor_shape=CURSOR_SHAPE_HOURGLASS;
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);
if (!File_error)
{
@ -4557,7 +4557,7 @@ void Display_effect_states(void)
Display_effect_state(C3, L2, "Snap" ,Snap_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);
}
@ -4858,7 +4858,7 @@ void Button_Effects(void)
{
Button_Constraint_mode();
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();
} else {
Close_window();
@ -5613,5 +5613,5 @@ void Button_Brush_container(void)
byte Any_effect_active(void)
{
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;
if (Main_backups->Pages->Image_mode > IMAGE_MODE_ANIMATION)
if (Main.backups->Pages->Image_mode > IMAGE_MODE_ANIMATION)
{
// Disable
Switch_layer_mode(IMAGE_MODE_LAYERED);
@ -182,15 +182,15 @@ void Button_Constraint_mode()
if (Selected_Constraint_Mode == IMAGE_MODE_MODE5)
{
if (Main_backups->Pages->Image_mode != IMAGE_MODE_LAYERED ||
Main_backups->Pages->Nb_layers!=5 || (Main.image_width%48))
if (Main.backups->Pages->Image_mode != IMAGE_MODE_LAYERED ||
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.");
return;
}
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.");
return;
@ -239,7 +239,7 @@ void Button_Constraint_menu(void)
if (clicked_button==2) // OK
{
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();
}

8
src/engine.c
View File

@ -584,7 +584,7 @@ void Layer_preview_on(int * preview_is_visible)
{
int x,y;
short layer;
short layercount = Main_backups->Pages->Nb_layers;
short layercount = Main.backups->Pages->Nb_layers;
static int previewW=0, previewH=0;
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 imgy = y * Main.image_height / (previewH*Pixel_height*Menu_factor_Y-1);
// 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));
}
}
@ -685,7 +685,7 @@ void Main_handler(void)
char* flimit;
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++) = '\0';
@ -3646,7 +3646,7 @@ void Set_bar_visibility(word bar, int visible, int with_redraw)
/// Display_menu() and Display_all_screen()
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)
{

56
src/factory.c
View File

@ -218,7 +218,7 @@ void Backup_if_necessary(lua_State* L, int layer)
Is_backed_up = 1;
if (layer == Main.current_layer)
{
Main_backup_page = Main_backups->Pages->Next;
Main_backup_page = Main.backups->Pages->Next;
Main_backup_screen = Screen_backup;
Register_main_writable(L);
}
@ -230,7 +230,7 @@ void Backup_if_necessary(lua_State* L, int layer)
// Already OK
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 ?
@ -391,17 +391,17 @@ int L_SetPictureSize(lua_State* L)
Backup_with_new_dimensions(w, h);
}
// 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(
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,
Main_backups->Pages->Image[i].Pixels,0,0,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,
Main.backups->Pages->Image[i].Pixels,0,0,Main.image_width);
}
Redraw_layered_image();
Is_backed_up = 1;
Main_backup_page = Main_backups->Pages->Next;
Main_backup_page = Main.backups->Pages->Next;
Main_backup_screen = Screen_backup;
Register_main_writable(L);
lua_register(L,"setcolor",L_SetColor);
@ -424,12 +424,12 @@ int L_SetSparePictureSize(lua_State* L)
Backup_and_resize_the_spare(w, h);
// 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(
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,
Spare_backups->Pages->Image[i].Pixels,0,0,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,
Spare.backups->Pages->Image[i].Pixels,0,0,Spare.image_width);
}
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)
{
// 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;
}
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)
{
// 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;
}
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)
{
// 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;
}
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;
}
@ -756,7 +756,7 @@ int L_GetSparePicturePixel(lua_State* L)
if (x<0 || y<0)
{
// 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;
}
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)
{
lua_pushinteger(L, Spare_backups->Pages->Transparent_color);
lua_pushinteger(L, Spare.backups->Pages->Transparent_color);
return 1;
}
@ -949,7 +949,7 @@ int L_GetBackColor(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;
}
@ -1893,7 +1893,7 @@ int L_GetLayerCount(lua_State* L)
LUA_ARG_LIMIT (0, "layercount");
lua_pushinteger(L, Main_backups->Pages->Nb_layers);
lua_pushinteger(L, Main.backups->Pages->Nb_layers);
return 1;
}
@ -1904,7 +1904,7 @@ int L_GetSpareLayerCount(lua_State* L)
LUA_ARG_LIMIT (0, "layercount");
lua_pushinteger(L, Spare_backups->Pages->Nb_layers);
lua_pushinteger(L, Spare.backups->Pages->Nb_layers);
return 1;
}
@ -1914,9 +1914,9 @@ int L_SelectSpareLayer(lua_State* L)
int nb_args=lua_gettop(L);
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))
{
@ -1932,11 +1932,11 @@ int L_SelectLayer(lua_State* L)
int nb_args=lua_gettop(L);
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);
//
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))
{
@ -1965,7 +1965,7 @@ int L_FinalizePicture(lua_State* L)
End_of_modification();
}
Is_backed_up = 0;
Main_backup_page = Main_backups->Pages;
Main_backup_page = Main.backups->Pages;
Main_backup_screen = Main_screen;
Register_main_readonly(L);
lua_register(L,"setcolor",L_SetColor_unsaved);
@ -1980,8 +1980,8 @@ int L_GetFileName(lua_State* L)
LUA_ARG_LIMIT (0, "getfilename");
lua_pushstring(L, Main_backups->Pages->Filename);
lua_pushstring(L, Main_backups->Pages->File_directory);
lua_pushstring(L, Main.backups->Pages->Filename);
lua_pushstring(L, Main.backups->Pages->File_directory);
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).
//Backup();
Is_backed_up = 0;
Main_backup_page = Main_backups->Pages;
Main_backup_page = Main.backups->Pages;
Main_backup_screen = Main_screen;
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)
{
Main_backups->Pages->Image_mode = IMAGE_MODE_ANIMATION;
Main.backups->Pages->Image_mode = IMAGE_MODE_ANIMATION;
Update_screen_targets();
}
if (File_error==0)
@ -2639,7 +2639,7 @@ void Load_GIF(T_IO_Context * context)
// Load as an animation
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();
}
// Skip sub-block
@ -2756,13 +2756,13 @@ void Load_GIF(T_IO_Context * context)
// Attempt to add a layer to current image
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.
memcpy(
Main_backups->Pages->Image[Main.current_layer].Pixels,
Main_backups->Pages->Image[Main.current_layer-1].Pixels,
Main_backups->Pages->Width*Main_backups->Pages->Height);
Main.backups->Pages->Image[Main.current_layer].Pixels,
Main.backups->Pages->Image[Main.current_layer-1].Pixels,
Main.backups->Pages->Width*Main.backups->Pages->Height);
}
else
{
@ -2812,7 +2812,7 @@ void Load_GIF(T_IO_Context * context)
if (number_LID!=1)
{
// 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.
if (previous_disposal_method==DISPOSAL_METHOD_RESTORE_BGCOLOR)
@ -2820,8 +2820,8 @@ void Load_GIF(T_IO_Context * context)
int y;
for (y=0; y<previous_height; y++)
memset(
Main_backups->Pages->Image[Main.current_layer].Pixels
+ (previous_pos_y+y)* Main_backups->Pages->Width+previous_pos_x,
Main.backups->Pages->Image[Main.current_layer].Pixels
+ (previous_pos_y+y)* Main.backups->Pages->Width+previous_pos_x,
is_transparent ? context->Transparent_color : LSDB.Backcol,
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);
// LL : 01 to loop
// 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)
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.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
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.
GFX2_GLOBAL byte * Screen_backup;
/// 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.
GFX2_GLOBAL T_List_of_pages * Spare_backups;//TODO
//GFX2_GLOBAL T_List_of_pages * Spare_backups;
// -- 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
// +-+-+
Upload_infos_page_main(Main_backups->Pages);
Upload_infos_page_main(Main.backups->Pages);
if (Backup_with_new_dimensions(chosen_width,chosen_height))
{
// 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;
// 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(
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,
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();
}
@ -574,10 +574,10 @@ void Remap_spare(void)
used[color]=0;
// 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 (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
// 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
// qui craint un peu, on peut faire l'échange dans la brosse de toutes les
// teintes.
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);
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);
// 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)
{
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)
@ -973,34 +973,34 @@ void Fill_general(byte fill_color)
// 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.
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_right-Limit_left)+1, // width copie
top_reached-Limit_top,// height copie
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
Main.image_width); // width destination
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_right-Limit_left)+1,
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);
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,
left_reached-Limit_left,
(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);
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,
Limit_right-right_reached,
(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);
// 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)
{
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);
}
@ -2952,33 +2952,33 @@ byte Read_pixel_from_current_screen (word x,word y)
byte depth;
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)
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);
if (color != Main_backups->Pages->Transparent_color) // transparent color
if (color != Main.backups->Pages->Transparent_color) // transparent color
return color;
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.
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.
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);
}
@ -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)
{
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 (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
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;
}
@ -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)
{
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 (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
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;
@ -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)
{
uint8_t mask;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_EGX)
if (Main.backups->Pages->Image_mode == IMAGE_MODE_EGX)
{
mask = 0xF3;
} 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)
{
uint8_t mask;
if (Main_backups->Pages->Image_mode == IMAGE_MODE_EGX)
if (Main.backups->Pages->Image_mode == IMAGE_MODE_EGX)
{
mask = 0xF3;
} else {
@ -3059,14 +3059,14 @@ void Pixel_in_screen_thomson(word x,word y,byte color)
uint8_t c1, c2;
// 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)
return;
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)
continue;
if (c2 != c1)
@ -3082,7 +3082,7 @@ void Pixel_in_screen_thomson(word x,word y,byte color)
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) {
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;
// 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)
return;
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)
continue;
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++)
{
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) {
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;
// 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);
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 (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);
// Pixel is already of the color we are going to add, it is no problem
if (c2 == color)
@ -3177,7 +3177,7 @@ done:
for (x2 = 0; x2 < 8; x2++)
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);
if (c2 == c1) {
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;
// 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);
// 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 (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);
// Pixel is already of the color we are going to add, it is no problem
if (c2 == color)
@ -3240,7 +3240,7 @@ done:
for (x2 = 0; x2 < 8; x2++)
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);
if (c2 == c1) {
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;
// 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
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)
{
@ -3274,9 +3274,9 @@ void Pixel_in_screen_underlay_with_preview(word x,word y,byte color)
byte depth;
// 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
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)
{
@ -3293,12 +3293,12 @@ void Pixel_in_screen_overlay(word x,word y,byte color)
if (color<4)
{
// 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
*(Main_visible_image_depth_buffer.Image+x+y*Main.image_width)=color;
// Fetch pixel color from the target raster layer
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
*(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)
{
// 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
*(Main_visible_image_depth_buffer.Image+x+y*Main.image_width)=color;
// Fetch pixel color from the target raster layer
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
*(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)
{
*((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)
{
*((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)
{
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)
{
if (Main_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
if (Main.backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
{
// direct
Pixel_in_current_screen = Pixel_in_screen_direct;
Pixel_in_current_screen_with_preview = Pixel_in_screen_direct_with_preview;
}
else
if (Main_backups->Pages->Image_mode == IMAGE_MODE_LAYERED)
if (Main.backups->Pages->Image_mode == IMAGE_MODE_LAYERED)
{
// layered
Pixel_in_current_screen = Pixel_in_screen_layered;
Pixel_in_current_screen_with_preview = Pixel_in_screen_layered_with_preview;
}
else
if (Main_backups->Pages->Image_mode == IMAGE_MODE_EGX
|| Main_backups->Pages->Image_mode == IMAGE_MODE_EGX2)
if (Main.backups->Pages->Image_mode == IMAGE_MODE_EGX
|| Main.backups->Pages->Image_mode == IMAGE_MODE_EGX2)
{
// special "EGX" mode
Pixel_in_current_screen = Pixel_in_screen_egx;
Pixel_in_current_screen_with_preview = Pixel_in_screen_egx_with_preview;
}
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_with_preview = Pixel_in_screen_thomson_with_preview;
}
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_with_preview = Pixel_in_screen_zx_with_preview;

21
src/input.c
View File

@ -1091,13 +1091,13 @@ int Color_cycling(void)
{
int len;
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)
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)
{
int new_offset;
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)
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)
new_offset=len - new_offset;
if (new_offset!=offset[i])
@ -1118,14 +1118,15 @@ int Color_cycling(void)
{
int len;
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)
// TODO improve
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].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].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].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;
if (layer >= Main_backups->Pages->Nb_layers)
if (layer >= Main.backups->Pages->Nb_layers)
return;
// Keep a copy of which layers were 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)
{
@ -92,7 +92,7 @@ void Layer_activate(int layer, short side)
Redraw_layered_image();
else
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_pixel_renderer();
Display_all_screen();
@ -106,11 +106,11 @@ void Button_Layer_add(void)
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_layers(LAYER_NONE);
if (!Add_layer(Main_backups,Main.current_layer+1))
if (!Add_layer(Main.backups,Main.current_layer+1))
{
Update_depth_buffer();
// I just noticed this might be unneeded, since the new layer
@ -133,19 +133,19 @@ void Button_Layer_duplicate(void)
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_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
memcpy(
Main_backups->Pages->Image[Main.current_layer].Pixels,
Main_backups->Pages->Image[Main.current_layer-1].Pixels,
Main_backups->Pages->Width*Main_backups->Pages->Height);
Main.backups->Pages->Image[Main.current_layer].Pixels,
Main.backups->Pages->Image[Main.current_layer-1].Pixels,
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();
// I just noticed this might be unneeded, since the new layer
// is transparent, it shouldn't have any visible effect.
@ -165,11 +165,11 @@ void Button_Layer_remove(void)
{
Hide_cursor();
if (Main_backups->Pages->Nb_layers > 1)
if (Main.backups->Pages->Nb_layers > 1)
{
// Backup with unchanged layers
Backup_layers(LAYER_NONE);
if (!Delete_layer(Main_backups,Main.current_layer))
if (!Delete_layer(Main.backups,Main.current_layer))
{
Update_screen_targets();
Redraw_layered_image();
@ -194,8 +194,8 @@ short Layer_under_mouse(void)
// Safety required because the mouse cursor can have slided outside button.
if (layer < 0)
layer=0;
else if (layer > Main_backups->Pages->Nb_layers-1)
layer=Main_backups->Pages->Nb_layers-1;
else if (layer > Main.backups->Pages->Nb_layers-1)
layer=Main.backups->Pages->Nb_layers-1;
return layer;
}
@ -217,8 +217,8 @@ void Button_Layer_toggle(void)
// Safety required because the mouse cursor can have slided outside button.
if (layer < 0)
layer=0;
else if (layer > Main_backups->Pages->Nb_layers-1)
layer=Main_backups->Pages->Nb_layers-1;
else if (layer > Main.backups->Pages->Nb_layers-1)
layer=Main.backups->Pages->Nb_layers-1;
Layer_activate(layer, RIGHT_SIDE);
Mouse_K=0;
@ -240,8 +240,8 @@ static void Draw_transparent_background(byte background)
void Button_Layer_menu(void)
{
byte transparent_color = Main_backups->Pages->Transparent_color;
byte transparent_background = Main_backups->Pages->Background_transparent;
byte transparent_color = Main.backups->Pages->Transparent_color;
byte transparent_background = Main.backups->Pages->Background_transparent;
short clicked_button;
byte color;
byte click;
@ -301,12 +301,12 @@ void Button_Layer_menu(void)
if (clicked_button==3)
{
// Accept changes
if (Main_backups->Pages->Transparent_color != transparent_color ||
Main_backups->Pages->Background_transparent != transparent_background)
if (Main.backups->Pages->Transparent_color != transparent_color ||
Main.backups->Pages->Background_transparent != transparent_background)
{
Backup_layers(LAYER_NONE);
Main_backups->Pages->Transparent_color = transparent_color;
Main_backups->Pages->Background_transparent = transparent_background;
Main.backups->Pages->Transparent_color = transparent_color;
Main.backups->Pages->Background_transparent = transparent_background;
Redraw_layered_image();
Display_all_screen();
End_of_modification();
@ -321,10 +321,10 @@ void Button_Layer_set_transparent(void)
{
Hide_cursor();
if (Main_backups->Pages->Transparent_color != Back_color)
if (Main.backups->Pages->Transparent_color != Back_color)
{
Backup_layers(LAYER_ALL);
Main_backups->Pages->Transparent_color = Back_color;
Main.backups->Pages->Transparent_color = Back_color;
Redraw_layered_image();
Display_all_screen();
@ -339,9 +339,9 @@ void Button_Layer_get_transparent(void)
{
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);
@ -374,7 +374,7 @@ void Button_Layer_up(void)
{
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;
dword layer_flags;
@ -383,9 +383,9 @@ void Button_Layer_up(void)
Backup_layers(LAYER_NONE);
// swap
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+1] = tmp;
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+1] = tmp;
// Swap visibility indicators
layer_flags = (Main.layers_visible >> Main.current_layer) & 3;
@ -423,9 +423,9 @@ void Button_Layer_down(void)
Backup_layers(LAYER_NONE);
// swap
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-1] = tmp;
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-1] = tmp;
// Swap visibility indicators
layer_flags = (Main.layers_visible >> (Main.current_layer-1)) & 3;
@ -466,7 +466,7 @@ void Button_Anim_time(void)
int frame;
char buffer[6+1];
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");
@ -547,27 +547,27 @@ void Button_Anim_time(void)
duration=0;
else if (duration>655350)
duration=655350;
Main_backups->Pages->Image[Main.current_layer].Duration = duration;
Main.backups->Pages->Image[Main.current_layer].Duration = duration;
break;
case 1:
if (duration<0)
duration=0;
else if (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;
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)
cur_duration=0;
else if (cur_duration>655350)
cur_duration=655350;
Main_backups->Pages->Image[frame].Duration = cur_duration;
Main.backups->Pages->Image[frame].Duration = cur_duration;
}
break;
break;
@ -591,10 +591,10 @@ void Button_Anim_first_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)
Layer_activate(Main_backups->Pages->Nb_layers-1,LEFT_SIDE);
Layer_activate(Main.backups->Pages->Nb_layers-1,LEFT_SIDE);
else
Layer_activate(Main.current_layer-1,LEFT_SIDE);
}
@ -605,9 +605,9 @@ void Button_Anim_prev_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);
else
Layer_activate(Main.current_layer+1,LEFT_SIDE);
@ -620,8 +620,8 @@ void Button_Anim_next_frame(void)
void Button_Anim_last_frame(void)
{
if (Main.current_layer < (Main_backups->Pages->Nb_layers-1))
Layer_activate((Main_backups->Pages->Nb_layers-1),LEFT_SIDE);
if (Main.current_layer < (Main.backups->Pages->Nb_layers-1))
Layer_activate((Main.backups->Pages->Nb_layers-1),LEFT_SIDE);
Hide_cursor();
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_start=time_now;
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);
target_frame = (target_frame+1) % Main_backups->Pages->Nb_layers;
time_in_current_frame -= Interpret_delay(Main.backups->Pages->Image[target_frame].Duration);
target_frame = (target_frame+1) % Main.backups->Pages->Nb_layers;
}
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_start=time_now;
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);
target_frame = (target_frame+Main_backups->Pages->Nb_layers-1) % Main_backups->Pages->Nb_layers;
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;
}
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;
case CONTEXT_MAIN_IMAGE:
memset(
Main_backups->Pages->Image[Main.current_layer].Pixels,
Main.backups->Pages->Image[Main.current_layer].Pixels,
color,
Main_backups->Pages->Width*Main_backups->Pages->Height);
Main.backups->Pages->Width*Main.backups->Pages->Height);
break;
case CONTEXT_BRUSH:
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)
{
case CONTEXT_MAIN_IMAGE:
Main_backups->Pages->Image[context->Current_layer].Duration = duration;
Main.backups->Pages->Image[context->Current_layer].Duration = duration;
break;
default:
break;
@ -368,7 +368,7 @@ int Get_frame_duration(T_IO_Context *context)
switch(context->Type)
{
case CONTEXT_MAIN_IMAGE:
return Main_backups->Pages->Image[context->Current_layer].Duration;
return Main.backups->Pages->Image[context->Current_layer].Duration;
default:
return 0;
}
@ -683,7 +683,7 @@ void Load_image(T_IO_Context *context)
Cursor_shape=CURSOR_SHAPE_HOURGLASS;
Display_cursor();
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;
Hide_cursor();
Cursor_shape=old_cursor_shape;
@ -778,7 +778,7 @@ void Load_image(T_IO_Context *context)
}
// Copy the loaded 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:
// 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]
&& context->Original_file_directory && context->Original_file_directory[0])
{
strcpy(Main_backups->Pages->Filename,context->Original_file_name);
strcpy(Main_backups->Pages->File_directory,context->Original_file_directory);
strcpy(Main.backups->Pages->Filename,context->Original_file_name);
strcpy(Main.backups->Pages->File_directory,context->Original_file_directory);
}
else
{
strcpy(Main_backups->Pages->Filename,context->File_name);
strcpy(Main_backups->Pages->File_directory,context->File_directory);
strcpy(Main.backups->Pages->Filename,context->File_name);
strcpy(Main.backups->Pages->File_directory,context->File_directory);
}
// 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_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;
}
@ -816,8 +816,8 @@ void Load_image(T_IO_Context *context)
}
// Load the transparency data
Main_backups->Pages->Transparent_color = context->Transparent_color;
Main_backups->Pages->Background_transparent = context->Background_transparent;
Main.backups->Pages->Transparent_color = context->Transparent_color;
Main.backups->Pages->Background_transparent = context->Background_transparent;
// Correction des dimensions
if (Main.image_width<1)
@ -827,17 +827,17 @@ void Load_image(T_IO_Context *context)
// Color cyling ranges:
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++)
{
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].Inverse=context->Cycle_range[i].Inverse;
Main_backups->Pages->Gradients->Range[i].Speed=context->Cycle_range[i].Speed;
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].Inverse=context->Cycle_range[i].Inverse;
Main.backups->Pages->Gradients->Range[i].Speed=context->Cycle_range[i].Speed;
}
// 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
// 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)
@ -987,10 +987,10 @@ void Save_image(T_IO_Context *context)
{
case CONTEXT_MAIN_IMAGE:
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))
{
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?"))
{
@ -999,7 +999,7 @@ void Save_image(T_IO_Context *context)
}
// current layer
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
{
@ -1031,11 +1031,11 @@ void Save_image(T_IO_Context *context)
{
case 1: // flatten
context->Nb_layers=1;
context->Target_address=Main_visible_image.Image;
context->Target_address=Main.visible_image.Image;
break;
case 2: // current layer
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;
default: // Cancel
// 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()
{
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);
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);
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);
}
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));
context->Width = Main.image_width;
context->Height = Main.image_height;
context->Nb_layers = Main_backups->Pages->Nb_layers;
strcpy(context->Comment, Main_backups->Pages->Comment);
context->Transparent_color=Main_backups->Pages->Transparent_color;
context->Background_transparent=Main_backups->Pages->Background_transparent;
context->Nb_layers = Main.backups->Pages->Nb_layers;
strcpy(context->Comment, Main.backups->Pages->Comment);
context->Transparent_color=Main.backups->Pages->Transparent_color;
context->Background_transparent=Main.backups->Pages->Background_transparent;
if (Pixel_ratio == PIXEL_WIDE || Pixel_ratio == PIXEL_WIDE2)
context->Ratio=PIXEL_WIDE;
else if (Pixel_ratio == PIXEL_TALL || Pixel_ratio == PIXEL_TALL2 || Pixel_ratio == PIXEL_TALL3)
context->Ratio=PIXEL_TALL;
else
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;
// Color cyling ranges:
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].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].Speed=Main_backups->Pages->Gradients->Range[i].Speed;
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].Inverse=Main.backups->Pages->Gradients->Range[i].Inverse;
context->Cycle_range[context->Color_cycles].Speed=Main.backups->Pages->Gradients->Range[i].Speed;
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->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
}
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
while (layer >= context->Nb_layers)
{
if (Add_layer(Main_backups, layer))
if (Add_layer(Main.backups, layer))
{
// Failure to add a layer on load:
// Position on last layer
layer = context->Nb_layers-1;
break;
}
context->Nb_layers = Main_backups->Pages->Nb_layers;
context->Nb_layers = Main.backups->Pages->Nb_layers;
Main.layers_visible = (2<<layer)-1;
}
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();
}
@ -1667,8 +1667,8 @@ void Rotate_safety_backups(void)
Init_context_backup_image(&context, file_name, Config_directory);
context.Format=FORMAT_GIF;
// Provide original file data, to store as a GIF Application Extension
context.Original_file_name = Main_backups->Pages->Filename;
context.Original_file_directory = Main_backups->Pages->File_directory;
context.Original_file_name = Main.backups->Pages->Filename;
context.Original_file_directory = Main.backups->Pages->File_directory;
Save_image(&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
// invalide lors des appels aux multiples fonctions manipulées à
// l'initialisation du programme.
Main_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(Spare_backups);
Main.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(Spare.backups);
// Determine the executable 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);
// 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(Spare_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));
Gradient_function=Gradient_basic;
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 (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();
Compute_optimal_menu_colors(Main.palette);
Back_color=Main_backups->Pages->Background_transparent ?
Main_backups->Pages->Transparent_color :
Back_color=Main.backups->Pages->Background_transparent ?
Main.backups->Pages->Transparent_color :
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 ?
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;
// 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 (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
//al=color
//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;
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
{
memset(
Main_backups->Pages->Image[Main.current_layer].Pixels,
Main.backups->Pages->Image[Main.current_layer].Pixels,
color ,
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
// (can be a bigger or smaller image)
if (x>=Spare.image_width || y>=Spare.image_height)
return Spare_backups->Pages->Transparent_color;
if (Spare_backups->Pages->Image_mode == IMAGE_MODE_ANIMATION)
return Spare.backups->Pages->Transparent_color;
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
{
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)
{
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)
int dx;
@ -410,7 +410,7 @@ void Replace_colors_within_limits(byte * replace_table)
// Pour chaque pixel sur la ligne :
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];
}
}

2
src/miscfileformats.c
View File

@ -3368,7 +3368,7 @@ void Load_CM5(T_IO_Context* context)
Set_loading_layer(context, 0);
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(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)
{
*((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)
@ -55,7 +55,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
const byte no_color=16;
// Prerequisites
if (Main_backups->Pages->Nb_layers < 3)
if (Main.backups->Pages->Nb_layers < 3)
return 1;
if (Main.image_width != 160 || Main.image_height != 200)
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++)
{
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;
}
}
@ -84,7 +84,7 @@ byte C64_FLI(byte *bitmap, byte *screen_ram, byte *color_ram, byte *background)
// Get "mandatory colors" from layer 1
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)
{
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++)
{
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)
{
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++)
{
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])
// BG color
@ -360,7 +360,7 @@ byte C64_FLI_enforcer(void)
return 1;
if (Main.image_height != 200)
return 1;
if (Main_backups->Pages->Nb_layers != 4)
if (Main.backups->Pages->Nb_layers != 4)
return 2;
Backup_layers(3);

10
src/operatio.c
View File

@ -2785,12 +2785,12 @@ void Scroll_12_0(void)
else
{
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
// (after swapping some layers on/off, it gets outdated)
memcpy(Main_visible_image_backup.Image,
Main_visible_image.Image,
Main.visible_image.Image,
Main.image_width*Main.image_height);
}
}
@ -2851,7 +2851,7 @@ void Scroll_12_5(void)
else
{
// 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();
}
@ -2905,9 +2905,9 @@ void Scroll_0_5(void)
y_offset=Main.image_height-((center_y-y_pos)%Main.image_height);
// 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)
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 ...
// It would be faster to scroll it, but we don't have method
// for in-place scrolling.

376
src/pages.c
View File

@ -39,10 +39,10 @@
// -- Layers data
/// 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_depth_buffer;
T_Bitmap Spare_visible_image;
//T_Bitmap Spare_visible_image;
///
/// GESTION DES PAGES
@ -198,28 +198,28 @@ void Download_infos_page_main(T_Page * page)
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
byte layer=0;
// 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
// Copy it in Main_visible_image
int i;
for (i=0; i< Main.image_width*Main.image_height; i++)
{
layer = *(Main_backups->Pages->Image[4].Pixels+i);
if (Main.layers_visible & (1 << layer))
Main_visible_image.Image[i]=*(Main_backups->Pages->Image[layer].Pixels+i);
else
Main_visible_image.Image[i] = layer;
layer = *(Main.backups->Pages->Image[4].Pixels+i);
if (Main.layers_visible & (1 << layer))
Main.visible_image.Image[i]=*(Main.backups->Pages->Image[layer].Pixels+i);
else
Main.visible_image.Image[i] = layer;
}
// Copy it to the depth buffer
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);
// Next
@ -227,13 +227,13 @@ void Redraw_layered_image(void)
}
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)
{
// Copy it in Main_visible_image
memcpy(Main_visible_image.Image,
Main_backups->Pages->Image[layer].Pixels,
memcpy(Main.visible_image.Image,
Main.backups->Pages->Image[layer].Pixels,
Main.image_width*Main.image_height);
// Initialize the depth buffer
@ -248,17 +248,17 @@ void Redraw_layered_image(void)
}
}
// 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)
{
int i;
for (i=0; i<Main.image_width*Main.image_height; i++)
{
byte color = *(Main_backups->Pages->Image[layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color
byte color = *(Main.backups->Pages->Image[layer].Pixels+i);
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)
*(Main_visible_image_depth_buffer.Image+i) = layer;
}
@ -275,7 +275,7 @@ void Redraw_layered_image(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.
// This function doesn't touch the visible buffer, it assumes
@ -283,7 +283,7 @@ void Update_depth_buffer(void)
int 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)
{
@ -298,7 +298,7 @@ void Update_depth_buffer(void)
}
}
// 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
if (layer == Main.current_layer)
@ -309,8 +309,8 @@ void Update_depth_buffer(void)
int i;
for (i=0; i<Main.image_width*Main.image_height; i++)
{
byte color = *(Main_backups->Pages->Image[layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color
byte color = *(Main.backups->Pages->Image[layer].Pixels+i);
if (color != Main.backups->Pages->Transparent_color) // transparent color
{
*(Main_visible_image_depth_buffer.Image+i) = layer;
}
@ -323,18 +323,18 @@ void Update_depth_buffer(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
byte 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)
{
// Copy it in Spare_visible_image
memcpy(Spare_visible_image.Image,
Spare_backups->Pages->Image[layer].Pixels,
memcpy(Spare.visible_image.Image,
Spare.backups->Pages->Image[layer].Pixels,
Spare.image_width*Spare.image_height);
// No depth buffer in the spare
@ -348,17 +348,17 @@ void Redraw_spare_image(void)
}
}
// 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)
{
int i;
for (i=0; i<Spare.image_width*Spare.image_height; i++)
{
byte color = *(Spare_backups->Pages->Image[layer].Pixels+i);
if (color != Spare_backups->Pages->Transparent_color) // transparent color
byte color = *(Spare.backups->Pages->Image[layer].Pixels+i);
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)
// *(Spare_visible_image_depth_buffer.Image+i) = layer;
}
@ -370,7 +370,7 @@ void Redraw_spare_image(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;
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);
if (depth<=Main.current_layer)
{
byte color = *(Main_backups->Pages->Image[Main.current_layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color
byte color = *(Main.backups->Pages->Image[Main.current_layer].Pixels+i);
if (color != Main.backups->Pages->Transparent_color) // transparent color
{
*(Main_visible_image.Image+i) = color;
*(Main.visible_image.Image+i) = color;
}
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)
FX_feedback_screen=Main_backups->Pages->Image[Main.current_layer].Pixels;
FX_feedback_screen=Main.backups->Pages->Image[Main.current_layer].Pixels;
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)
@ -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
// 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
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)
{
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;
}
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
// 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,
// so in case Screen_backup was queried, it will point to a valid
// readable bitmap of correct size : current image.
if (Main_backups->Pages->Nb_layers != Main_backups->Pages->Next->Nb_layers
|| Main_backups->Pages->Width != Main_backups->Pages->Next->Width
|| Main_backups->Pages->Height != Main_backups->Pages->Next->Height)
if (Main.backups->Pages->Nb_layers != Main.backups->Pages->Next->Nb_layers
|| Main.backups->Pages->Width != Main.backups->Pages->Next->Width
|| Main.backups->Pages->Height != Main.backups->Pages->Next->Height)
Screen_backup=Main_screen;
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();
}
@ -707,20 +707,20 @@ void Update_screen_targets(void)
/// Update all the special image buffers, if necessary.
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
if (Main_visible_image.Width*Main_visible_image.Height != width*height)
if (Main.visible_image.Width*Main.visible_image.Height != width*height)
{
// Current image
free(Main_visible_image.Image);
Main_visible_image.Image = (byte *)malloc(width * height);
if (Main_visible_image.Image == NULL)
free(Main.visible_image.Image);
Main.visible_image.Image = (byte *)malloc(width * height);
if (Main.visible_image.Image == NULL)
return 0;
}
Main_visible_image.Width = width;
Main_visible_image.Height = height;
Main.visible_image.Width = width;
Main.visible_image.Height = height;
if (Main_visible_image_backup.Width*Main_visible_image_backup.Height != width*height)
{
// Previous image
@ -749,19 +749,19 @@ int Update_buffers(int width, int height)
/// Update all the special image buffers of the spare page, if necessary.
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
if (Spare_visible_image.Width*Spare_visible_image.Height != width*height)
if (Spare.visible_image.Width*Spare.visible_image.Height != width*height)
{
// Current image
free(Spare_visible_image.Image);
Spare_visible_image.Image = (byte *)malloc(width * height);
if (Spare_visible_image.Image == NULL)
free(Spare.visible_image.Image);
Spare.visible_image.Image = (byte *)malloc(width * height);
if (Spare.visible_image.Image == NULL)
return 0;
}
Spare_visible_image.Width = width;
Spare_visible_image.Height = height;
Spare.visible_image.Width = width;
Spare.visible_image.Height = height;
}
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.
int i;
if (! Allocate_list_of_pages(Main_backups) ||
! Allocate_list_of_pages(Spare_backups))
if (! Allocate_list_of_pages(Main.backups) ||
! Allocate_list_of_pages(Spare.backups))
return 0;
// On a réussi à allouer deux listes de pages dont la taille correspond à
// celle demandée par l'utilisateur.
// 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
Main_backups->Pages->Width=width;
Main_backups->Pages->Height=height;
strcpy(Main_backups->Pages->File_directory,Main.selector.Directory);
strcpy(Main_backups->Pages->Filename,"NO_NAME.GIF");
Main.backups->Pages->Width=width;
Main.backups->Pages->Height=height;
strcpy(Main.backups->Pages->File_directory,Main.selector.Directory);
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);
if (! Main_backups->Pages->Image[i].Pixels)
Main.backups->Pages->Image[i].Pixels=New_layer(width*height);
if (! Main.backups->Pages->Image[i].Pixels)
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.Height = 0;
Main_visible_image.Image = NULL;
Main.visible_image.Width = 0;
Main.visible_image.Height = 0;
Main.visible_image.Image = NULL;
Main_visible_image_backup.Image = NULL;
Main_visible_image_depth_buffer.Image = NULL;
Main_backups->Pages->Image_mode = image_mode;
Spare_visible_image.Width = 0;
Spare_visible_image.Height = 0;
Spare_visible_image.Image = NULL;
Spare_backups->Pages->Image_mode = image_mode;
Main.backups->Pages->Image_mode = image_mode;
Spare.visible_image.Width = 0;
Spare.visible_image.Height = 0;
Spare.visible_image.Image = NULL;
Spare.backups->Pages->Image_mode = image_mode;
if (!Update_buffers(width, height))
return 0;
@ -815,28 +815,28 @@ int Init_all_backup_lists(enum IMAGE_MODES image_mode, int width, int height)
return 0;
// 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_depth_buffer.Image, 0, width*height);
}
if (Spare_visible_image.Image != NULL)
memset(Spare_visible_image.Image, 0, width*height);
Download_infos_page_main(Main_backups->Pages);
if (Spare.visible_image.Image != NULL)
memset(Spare.visible_image.Image, 0, width*height);
Download_infos_page_main(Main.backups->Pages);
Update_FX_feedback(Config.FX_Feedback);
// Default values for spare page
Spare_backups->Pages->Width = width;
Spare_backups->Pages->Height = height;
memcpy(Spare_backups->Pages->Palette,Main.palette,sizeof(T_Palette));
strcpy(Spare_backups->Pages->Comment,"");
strcpy(Spare_backups->Pages->File_directory,Main.selector.Directory);
strcpy(Spare_backups->Pages->Filename,"NO_NAME2.GIF");
Spare_backups->Pages->File_format=DEFAULT_FILEFORMAT;
Spare.backups->Pages->Width = width;
Spare.backups->Pages->Height = height;
memcpy(Spare.backups->Pages->Palette,Main.palette,sizeof(T_Palette));
strcpy(Spare.backups->Pages->Comment,"");
strcpy(Spare.backups->Pages->File_directory,Main.selector.Directory);
strcpy(Spare.backups->Pages->Filename,"NO_NAME2.GIF");
Spare.backups->Pages->File_format=DEFAULT_FILEFORMAT;
// 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
//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
for (i=0; i<NB_LAYERS; i++)
{
Spare_backups->Pages->Image[i].Pixels=New_layer(width*height);
if (! Spare_backups->Pages->Image[i].Pixels)
Spare.backups->Pages->Image[i].Pixels=New_layer(width*height);
if (! Spare.backups->Pages->Image[i].Pixels)
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);
@ -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)
{
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(Main.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
// 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->Transparent_color=0;
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);
return 0;
@ -891,7 +891,7 @@ int Backup_new_image(int layers,int width,int height)
Update_buffers(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;
}
@ -906,7 +906,7 @@ int Backup_with_new_dimensions(int width,int height)
int i;
// 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)
{
Error(0);
@ -915,39 +915,39 @@ int Backup_with_new_dimensions(int width,int height)
new_page->Width=width;
new_page->Height=height;
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);
return 0;
}
// Copy data from previous history step
memcpy(Main_backups->Pages->Palette,Main_backups->Pages->Next->Palette,sizeof(T_Palette));
strcpy(Main_backups->Pages->Comment,Main_backups->Pages->Next->Comment);
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->File_directory, Main_backups->Pages->Next->File_directory);
Main_backups->Pages->Gradients=Dup_gradient(Main_backups->Pages->Next);
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->Image_mode=Main_backups->Pages->Next->Image_mode;
memcpy(Main.backups->Pages->Palette,Main.backups->Pages->Next->Palette,sizeof(T_Palette));
strcpy(Main.backups->Pages->Comment,Main.backups->Pages->Next->Comment);
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->File_directory, Main.backups->Pages->Next->File_directory);
Main.backups->Pages->Gradients=Dup_gradient(Main.backups->Pages->Next);
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->Image_mode=Main.backups->Pages->Next->Image_mode;
// 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);
Download_infos_page_main(Main_backups->Pages);
Download_infos_page_main(Main.backups->Pages);
// Same code as in End_of_modification(),
// 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,
Main_visible_image.Image,
Main.visible_image.Image,
Main.image_width*Main.image_height);
}
else
@ -974,11 +974,11 @@ int Backup_in_place(int width,int height)
// 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)
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);
if (!new_layer[i])
@ -993,36 +993,36 @@ int Backup_in_place(int width,int height)
// 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
Free_layer(Main_backups->Pages,i);
Main_backups->Pages->Image[i].Pixels=new_layer[i];
Free_layer(Main.backups->Pages,i);
Main.backups->Pages->Image[i].Pixels=new_layer[i];
// 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->Height=height;
Main.backups->Pages->Width=width;
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()
// (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
if (Main_visible_image.Width*Main_visible_image.Height != width*height)
if (Main.visible_image.Width*Main.visible_image.Height != width*height)
{
// Current image
free(Main_visible_image.Image);
Main_visible_image.Image = (byte *)malloc(width * height);
if (Main_visible_image.Image == NULL)
free(Main.visible_image.Image);
Main.visible_image.Image = (byte *)malloc(width * height);
if (Main.visible_image.Image == NULL)
return 0;
}
Main_visible_image.Width = width;
Main_visible_image.Height = height;
Main.visible_image.Width = width;
Main.visible_image.Height = 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 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
new_page=New_page(nb_layers);
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
Copy_S_page(new_page,Spare_backups->Pages);
new_page->Gradients=Dup_gradient(Spare_backups->Pages);
Copy_S_page(new_page,Spare.backups->Pages);
new_page->Gradients=Dup_gradient(Spare.backups->Pages);
new_page->Width=width;
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;
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
Download_infos_page_spare(Spare_backups->Pages);
Download_infos_page_spare(Spare.backups->Pages);
// Light up the 'has unsaved changes' indicator
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
// retrouver plus tard)
Upload_infos_page_main(Main_backups->Pages);
Upload_infos_page_main(Main.backups->Pages);
// 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)
{
Error(0);
@ -1116,9 +1116,9 @@ void Backup_layers(int layer)
}
// Fill it with a copy of the latest history
Copy_S_page(new_page,Main_backups->Pages);
new_page->Gradients=Dup_gradient(Main_backups->Pages);
Create_new_page(new_page,Main_backups,layer);
Copy_S_page(new_page,Main.backups->Pages);
new_page->Gradients=Dup_gradient(Main.backups->Pages);
Create_new_page(new_page,Main.backups,layer);
Download_infos_page_main(new_page);
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
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)
memcpy(Main_backups->Pages->Image[i].Pixels,
Main_backups->Pages->Next->Image[i].Pixels,
memcpy(Main.backups->Pages->Image[i].Pixels,
Main.backups->Pages->Next->Image[i].Pixels,
Main.image_width*Main.image_height);
}
}
@ -1168,7 +1168,7 @@ void Backup_the_spare(int layer)
T_Page *new_page;
// 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)
{
Error(0);
@ -1176,18 +1176,18 @@ void Backup_the_spare(int layer)
}
// Fill it with a copy of the latest history
Copy_S_page(new_page,Spare_backups->Pages);
new_page->Gradients=Dup_gradient(Spare_backups->Pages);
Create_new_page(new_page,Spare_backups,layer);
Copy_S_page(new_page,Spare.backups->Pages);
new_page->Gradients=Dup_gradient(Spare.backups->Pages);
Create_new_page(new_page,Spare.backups,layer);
// Copy the actual pixels from the backup to the latest page
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)
memcpy(Spare_backups->Pages->Image[i].Pixels,
Spare_backups->Pages->Next->Image[i].Pixels,
memcpy(Spare.backups->Pages->Image[i].Pixels,
Spare.backups->Pages->Next->Image[i].Pixels,
Spare.image_width*Spare.image_height);
}
}
@ -1198,9 +1198,9 @@ void Backup_the_spare(int layer)
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;
}
}
@ -1212,20 +1212,20 @@ void Undo(void)
if (Last_backed_up_layers)
{
Free_page_of_a_list(Main_backups);
Free_page_of_a_list(Main.backups);
Last_backed_up_layers=0;
}
// On remet à jour l'état des infos de la page courante (pour pouvoir les
// 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
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
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
// 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
@ -1246,19 +1246,19 @@ void Redo(void)
if (Last_backed_up_layers)
{
Free_page_of_a_list(Main_backups);
Free_page_of_a_list(Main.backups);
Last_backed_up_layers=0;
}
// On remet à jour l'état des infos de la page courante (pour pouvoir les
// 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
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
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
// 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
@ -1275,16 +1275,16 @@ void Redo(void)
void Free_current_page(void)
{
// 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
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
// 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
// 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();
Redraw_layered_image();
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
// pages qu'on s'apprête à échanger, pour qu'on se retrouve pas avec de
// vieilles valeurs qui datent de mathuzalem.
Upload_infos_page_main(Main_backups->Pages);
Upload_infos_page_spare(Spare_backups->Pages);
Upload_infos_page_main(Main.backups->Pages);
Upload_infos_page_spare(Spare.backups->Pages);
// On inverse les listes de pages
//TODO
temp_list=Main_backups;
Main_backups=Spare_backups;
Spare_backups=temp_list;
temp_list=Main.backups;
Main.backups=Spare.backups;
Spare.backups=temp_list;
// On extrait ensuite les infos sur les nouvelles pages courante, brouillon
// 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
// que lors d'un changement de page, on veut bien conserver l'état du mode
// loupe du brouillon.
Main.image_width=Main_backups->Pages->Width;
Main.image_height=Main_backups->Pages->Height;
Main.image_width=Main.backups->Pages->Width;
Main.image_height=Main.backups->Pages->Height;
Download_infos_page_main(Main_backups->Pages);
Download_infos_page_spare(Spare_backups->Pages);
Download_infos_page_main(Main.backups->Pages);
Download_infos_page_spare(Spare.backups->Pages);
}
void End_of_modification(void)
@ -1327,7 +1327,7 @@ void End_of_modification(void)
//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
// performs a resize.
@ -1335,7 +1335,7 @@ void End_of_modification(void)
//
memcpy(Main_visible_image_backup.Image,
Main_visible_image.Image,
Main.visible_image.Image,
Main.image_width*Main.image_height);
}
else
@ -1411,7 +1411,7 @@ byte Add_layer(T_List_of_pages *list, int layer)
duration=new_page->Image[1].Duration;
new_page->Image[layer].Duration=duration;
// 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
// only inserted a transparent "slide" somewhere.
@ -1424,7 +1424,7 @@ byte Add_layer(T_List_of_pages *list, int layer)
dword *visible_layers_flag;
// 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;
Main.current_layer = layer;
@ -1483,7 +1483,7 @@ byte Delete_layer(T_List_of_pages *list, int layer)
byte new_current_layer;
// 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;
if (Main.current_layer>=layer && Main.current_layer>0)
@ -1516,19 +1516,19 @@ byte Merge_layer()
int i;
for (i=0; i<Main.image_width*Main.image_height; i++)
{
byte color = *(Main_backups->Pages->Image[Main.current_layer].Pixels+i);
if (color != Main_backups->Pages->Transparent_color) // transparent color
*(Main_backups->Pages->Image[Main.current_layer-1].Pixels+i) = color;
byte color = *(Main.backups->Pages->Image[Main.current_layer].Pixels+i);
if (color != Main.backups->Pages->Transparent_color) // transparent 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)
{
if (new_mode == Main_backups->Pages->Image_mode)
if (new_mode == Main.backups->Pages->Image_mode)
return;
Main_backups->Pages->Image_mode = new_mode;
Main.backups->Pages->Image_mode = 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.
extern T_Bitmap Main_visible_image;
//extern T_Bitmap Main_visible_image;
/// The pixels of visible layers, flattened copy, used for no-feedback effects.
extern T_Bitmap Main_visible_image_backup;
/// The index of visible pixels from ::Main_visible_image. Points to the right layer.
extern T_Bitmap Main_visible_image_depth_buffer;
/// 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

14
src/palette.c
View File

@ -344,19 +344,19 @@ void Remap_image_highlevel(byte * conversion_table)
int layer;
// Remap the flatenned image view
if (Main_backups->Pages->Image_mode != IMAGE_MODE_ANIMATION
&& Main_backups->Pages->Image_mode != IMAGE_MODE_MODE5)
if (Main.backups->Pages->Image_mode != IMAGE_MODE_ANIMATION
&& 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);
}
// Remap all layers
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);
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 transparent color
Main_backups->Pages->Transparent_color =
conversion_table[Main_backups->Pages->Transparent_color];
Main.backups->Pages->Transparent_color =
conversion_table[Main.backups->Pages->Transparent_color];
// On calcule les limites à l'écran de l'image
if (Main.image_height>=Menu_Y_before_window)

4
src/struct.h
View File

@ -606,6 +606,10 @@ typedef struct
byte safety_backup_prefix;
/// 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;
#endif

16
src/tiles.c
View File

@ -118,8 +118,8 @@ int Tile_is_same(int t1, int t2)
byte *bmp1,*bmp2;
int y;
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));
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));
for (y=0; y < Snap_height; y++)
{
@ -135,8 +135,8 @@ int Tile_is_same_flipped_x(int t1, int t2)
byte *bmp1,*bmp2;
int y, x;
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);
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);
for (y=0; y < Snap_height; y++)
{
@ -153,8 +153,8 @@ int Tile_is_same_flipped_y(int t1, int t2)
byte *bmp1,*bmp2;
int y;
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));
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));
for (y=0; y < Snap_height; y++)
{
@ -171,8 +171,8 @@ int Tile_is_same_flipped_xy(int t1, int t2)
byte *bmp1,*bmp2;
int y, x;
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);
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);
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_height=Main.image_height;
Upload_infos_page_main(Main_backups->Pages);
Upload_infos_page_main(Main.backups->Pages);
// Allocate a new page
if (Backup_with_new_dimensions(new_width,new_height))
{
@ -385,42 +385,42 @@ void Button_Transform_menu(void)
int i;
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);
Flip_X_lowlevel(Main_backups->Pages->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);
}
break;
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);
Flip_Y_lowlevel(Main_backups->Pages->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);
}
break;
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;
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;
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);
Rotate_180_deg_lowlevel(Main_backups->Pages->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);
}
break;
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;
}
@ -428,9 +428,9 @@ void Button_Transform_menu(void)
for (i=0; i<NB_LAYERS; i++)
{
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,
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();

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 ch = (cell_height)*Menu_factor_Y;
if (Main_backups->Pages->Image_mode == 0 && Main_backups->Pages->Nb_layers > 1)
transparent = Main_backups->Pages->Transparent_color;
if (Main.backups->Pages->Image_mode == 0 && Main.backups->Pages->Nb_layers > 1)
transparent = Main.backups->Pages->Transparent_color;
// Color is not selected, no dotted lines
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,
MC_Black);
if (Main_backups->Pages->Image_mode == 0
&& Main_backups->Pages->Nb_layers > 1)
transparent = Main_backups->Pages->Transparent_color;
if (Main.backups->Pages->Image_mode == 0
&& Main.backups->Pages->Nb_layers > 1)
transparent = Main.backups->Pages->Transparent_color;
// Compute the size of the color cells (they are smaller by 1px when using
// 'separate colors"
@ -505,7 +505,7 @@ void Display_layerbar(void)
{
word x_off=0;
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 current_button;
word repeats=1;
@ -592,7 +592,7 @@ void Display_layerbar(void)
// 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);
// 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);
Update_rect(
(59)*Menu_factor_X,
@ -802,7 +802,7 @@ void Print_filename(void)
// Partial copy of the name
{
#ifdef ENABLE_FILENAMES_ICONV
char * input = Main_backups->Pages->Filename;
char * input = Main.backups->Pages->Filename;
size_t inbytesleft = strlen(input);
char * output = display_string;
size_t outbytesleft = sizeof(display_string)-1;
@ -811,7 +811,7 @@ void Print_filename(void)
else
#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';
}
}
@ -2628,15 +2628,15 @@ void Display_all_screen(void)
if (Main.magnifier_mode)
{
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
{
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)
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: /\/\/\---
if (Main.magnifier_mode)
@ -2665,9 +2665,9 @@ void Display_all_screen(void)
if (Main.image_width<Main.magnifier_width)
Block(Main.X_zoom+(Main.image_width*Main.magnifier_factor),0,
(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)
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 /\/\/\---