m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
grafX2/pages.c
Adrien Destugues e6e698c2bd Added vim modelines to all files. 
Set them to 2-space indent, I hope this is ok.


git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@1161 416bcca6-2ee7-4201-b75f-2eb2f807beb1
2009-11-10 20:08:11 +00:00

939 lines
29 KiB
C
Raw Blame History

/* vim:expandtab:ts=2 sw=2:
*/
/* Grafx2 - The Ultimate 256-color bitmap paint program
Copyright 2008 Franck Charlet
Copyright 2007 Adrien Destugues
Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
Grafx2 is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2
of the License.
Grafx2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Grafx2; if not, see <http://www.gnu.org/licenses/>
*/
//////////////////////////////////////////////////////////////////////////
/////////////////////////// GESTION DU BACKUP ////////////////////////////
//////////////////////////////////////////////////////////////////////////
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include "global.h"
#include "pages.h"
#include "errors.h"
#include "misc.h"
#include "windows.h"
///
/// GESTION DES PAGES
///
void Init_page(T_Page * page)
{
// Important: appeler cette fonction sur toute nouvelle structure T_Page!
if (page!=NULL)
{
page->Image=NULL;
page->Width=0;
page->Height=0;
memset(page->Palette,0,sizeof(T_Palette));
page->Comment[0]='\0';
page->File_directory[0]='\0';
page->Filename[0]='\0';
page->File_format=DEFAULT_FILEFORMAT;
}
}
void Download_infos_page_main(T_Page * page)
// Affiche la page à l'écran
{
//int factor_index;
int size_is_modified;
if (page!=NULL)
{
size_is_modified=(Main_image_width!=page->Width) ||
(Main_image_height!=page->Height);
Main_screen=page->Image;
Main_image_width=page->Width;
Main_image_height=page->Height;
memcpy(Main_palette,page->Palette,sizeof(T_Palette));
strcpy(Main_comment,page->Comment);
strcpy(Main_file_directory,page->File_directory);
strcpy(Main_filename,page->Filename);
Main_fileformat=page->File_format;
if (size_is_modified)
{
Main_magnifier_mode=0;
Main_offset_X=0;
Main_offset_Y=0;
Pixel_preview=Pixel_preview_normal;
Compute_limits();
Compute_paintbrush_coordinates();
}
}
}
void Upload_infos_page_main(T_Page * page)
// Sauve l'écran courant dans la page
{
if (page!=NULL)
{
page->Image=Main_screen;
page->Width=Main_image_width;
page->Height=Main_image_height;
memcpy(page->Palette,Main_palette,sizeof(T_Palette));
strcpy(page->Comment,Main_comment);
strcpy(page->File_directory,Main_file_directory);
strcpy(page->Filename,Main_filename);
page->File_format=Main_fileformat;
}
}
void Download_infos_page_spare(T_Page * page)
{
if (page!=NULL)
{
Spare_screen=page->Image;
Spare_image_width=page->Width;
Spare_image_height=page->Height;
memcpy(Spare_palette,page->Palette,sizeof(T_Palette));
strcpy(Spare_comment,page->Comment);
strcpy(Spare_file_directory,page->File_directory);
strcpy(Spare_filename,page->Filename);
Spare_fileformat=page->File_format;
}
}
void Upload_infos_page_spare(T_Page * page)
{
if (page!=NULL)
{
page->Image=Spare_screen;
page->Width=Spare_image_width;
page->Height=Spare_image_height;
memcpy(page->Palette,Spare_palette,sizeof(T_Palette));
strcpy(page->Comment,Spare_comment);
strcpy(page->File_directory,Spare_file_directory);
strcpy(page->Filename,Spare_filename);
page->File_format=Spare_fileformat;
}
}
void Download_infos_backup(T_List_of_pages * list)
{
Screen_backup=list->Pages[1].Image;
if (Config.FX_Feedback)
FX_feedback_screen=list->Pages[0].Image;
else
FX_feedback_screen=list->Pages[1].Image;
}
void Free_a_page(T_Page * page)
{
// On peut appeler cette fonction sur une page non allouée.
if (page->Image!=NULL)
free(page->Image);
page->Image=NULL;
page->Width=0;
page->Height=0;
// On ne se préoccupe pas de ce que deviens le reste des infos de l'image.
}
void Copy_S_page(T_Page * dest,T_Page * source)
{
*dest=*source;
}
int Size_of_a_page(T_Page * page)
{
return sizeof(T_Page)+(page->Width*page->Height)+8;
// 8 = 4 + 4
// (Toute zone allouée en mémoire est précédée d'un mot double indiquant sa
// taille, or la taille d'un mot double est de 4 octets, et on utilise deux
// allocations de mémoires: une pour la T_Page et une pour l'image)
}
///
/// GESTION DES LISTES DE PAGES
///
void Init_list_of_pages(T_List_of_pages * list)
{
// Important: appeler cette fonction sur toute nouvelle structure
// T_List_of_pages!
list->List_size=0;
list->Nb_pages_allocated=0;
list->Pages=NULL;
}
int Allocate_list_of_pages(T_List_of_pages * list,int size)
{
// Important: la T_List_of_pages ne doit pas déjà désigner une liste de
// pages allouée auquel cas celle-ci serait perdue.
int index;
/* Debug : if (list->Pages!=NULL) exit(666); */
// On alloue la mémoire pour la liste
list->Pages=(T_Page *)malloc(size*sizeof(T_Page));
// On vérifie que l'allocation se soit bien passée
if (list->Pages==NULL)
return 0; // Echec
else
{
// On initialise chacune des nouvelles pages
for (index=0;index<size;index++)
Init_page(list->Pages+index);
list->List_size=size;
list->Nb_pages_allocated=0;
return 1; // Succès
}
}
void Free_a_list_of_pages(T_List_of_pages * list)
{
// On peut appeler cette fonction sur une liste de pages non allouée.
// Important: cette fonction ne libère pas les pages de la liste. Il faut
// donc le faire préalablement si nécessaire.
if (list->Pages!=NULL)
free(list->Pages);
list->Pages=NULL;
list->List_size=0;
list->Nb_pages_allocated=0;
}
int Size_of_a_list_of_pages(T_List_of_pages * list)
{
int result=0;
int index;
for (index=0;index<list->Nb_pages_allocated;index++)
result+=Size_of_a_page(list->Pages+index);
return result+sizeof(T_List_of_pages)+4;
// C.F. la remarque à propos de Size_of_a_page pour la valeur 4.
}
void Backward_in_list_of_pages(T_List_of_pages * list)
{
// Cette fonction fait l'équivalent d'un "Undo" dans la liste de pages.
// Elle effectue une sorte de ROL (Rotation Left) sur la liste:
// +---+-+-+-+-+-+-+-+-+-+ |
// ¦0¦1¦2¦3¦4¦5¦6¦7¦8¦9¦A¦ |
// +---+-+-+-+-+-+-+-+-+-+ | 0=page courante
// ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ |_ A=page la plus ancienne
// v v v v v v v v v v v | 1=DerniÞre page (1er backup)
// +---+-+-+-+-+-+-+-+-+-+ |
// ¦1¦2¦3¦4¦5¦6¦7¦8¦9¦A¦0¦ |
// +---+-+-+-+-+-+-+-+-+-+ |
// Pour simuler un véritable Undo, l'appelant doit mettre la structure
// de page courante à jour avant l'appel, puis en réextraire les infos en
// sortie, ainsi que celles relatives à la plus récente page d'undo (1ère
// page de la liste).
int index;
T_Page * temp_page;
if (list->Nb_pages_allocated>1)
{
// On crée la page tempo
temp_page=(T_Page *)malloc(sizeof(T_Page));
Init_page(temp_page);
// On copie la 1ère page (page 0) dans la page temporaire
Copy_S_page(temp_page,list->Pages);
// On copie toutes les pages 1-A à leur gauche
for (index=1;index<list->Nb_pages_allocated;index++)
Copy_S_page(list->Pages+index-1,list->Pages+index);
// On copie la page 0 (dont la sauvegarde a été effectuée dans la page
// temporaire) en dernière position
Copy_S_page(list->Pages+list->Nb_pages_allocated-1,temp_page);
// On détruit la page tempo
free(temp_page);
}
}
void Advance_in_list_of_pages(T_List_of_pages * list)
{
// Cette fonction fait l'équivalent d'un "Redo" dans la liste de pages.
// Elle effectue une sorte de ROR (Rotation Right) sur la liste:
// +-+-+-+-+-+-+-+-+-+-+-+ |
// |0|1|2|3|4|5|6|7|8|9|A| |
// +-+-+-+-+-+-+-+-+-+-+-+ | 0=page courante
// | | | | | | | | | | | |_ A=page la plus ancienne
// v v v v v v v v v v v | 1=Dernière page (1er backup)
// +-+-+-+-+-+-+-+-+-+-+-+ |
// |A|0|1|2|3|4|5|6|7|8|9| |
// +-+-+-+-+-+-+-+-+-+-+-+ |
// Pour simuler un véritable Redo, l'appelant doit mettre la structure
// de page courante à jour avant l'appel, puis en réextraire les infos en
// sortie, ainsi que celles relatives à la plus récente page d'undo (1ère
// page de la liste).
int index;
T_Page * temp_page;
if (list->Nb_pages_allocated>1)
{
// On crée la page tempo
temp_page=(T_Page *)malloc(sizeof(T_Page));
Init_page(temp_page);
// On copie la dernière page dans la page temporaire
Copy_S_page(temp_page,list->Pages+list->Nb_pages_allocated-1);
// On copie toutes les pages 0-9 à leur droite
for (index=list->Nb_pages_allocated-1;index>0;index--)
Copy_S_page(list->Pages+index,list->Pages+index-1);
// On copie la page plus ancienne page (la "A", dont la sauvegarde a été
// effectuée dans la page temporaire) en 1ère position
Copy_S_page(list->Pages,temp_page);
// On détruit la page tempo
free(temp_page);
}
}
int New_page_is_possible(
T_Page * new_page,
T_List_of_pages * current_list,
T_List_of_pages * secondary_list
)
{
long long mem_available_now;
unsigned long current_list_size;
unsigned long spare_list_size;
unsigned long current_page_size;
unsigned long spare_page_size;
unsigned long new_page_size;
mem_available_now = Memory_free()
- MINIMAL_MEMORY_TO_RESERVE;
current_list_size =Size_of_a_list_of_pages(current_list);
spare_list_size=Size_of_a_list_of_pages(secondary_list);
current_page_size =Size_of_a_page(current_list->Pages);
spare_page_size =Size_of_a_page(secondary_list->Pages);
new_page_size =Size_of_a_page(new_page);
// Il faut pouvoir loger la nouvelle page et son backup dans la page
// courante, en conservant au pire la 1ère page de brouillon.
if ( (mem_available_now + current_list_size +
spare_list_size - spare_page_size)
< (2*new_page_size) )
return 0;
// Il faut pouvoir loger le brouillon et son backup dans la page de
// brouillon, en conservant au pire un exemplaire de la nouvelle page dans
// la page courante. (pour permettre à l'utilisateur de travailler sur son
// brouillon)
if ((mem_available_now+current_list_size+
spare_list_size-new_page_size)<(2*spare_page_size))
return 0;
return 1;
}
void Free_last_page_of_list(T_List_of_pages * list)
{
if (list!=NULL)
{
if (list->Nb_pages_allocated>0)
{
list->Nb_pages_allocated--;
Free_a_page(list->Pages+list->Nb_pages_allocated);
}
}
}
void Create_new_page(T_Page * new_page,T_List_of_pages * current_list,T_List_of_pages * secondary_list)
{
// Cette fonction crée une nouvelle page dont les attributs correspondent à
// ceux de new_page (width,height,...) (le champ Image est invalide
// à l'appel, c'est la fonction qui le met à jour), et l'enfile dans
// current_list.
// Il est impératif que la création de cette page soit possible,
// éventuellement au détriment des backups de la page de brouillon
// (secondary_list). Afin de s'en assurer, il faut vérifier cette
// possibilité à l'aide de
// New_page_is_possible(new_page,current_list,secondary_list) avant
// l'appel à cette fonction.
// De plus, il faut qu'il y ait au moins une page dans chacune des listes.
int need_to_free;
T_List_of_pages * list_to_reduce=NULL;
T_Page * page_to_delete;
int index;
// On regarde s'il faut libérer des pages:
need_to_free=
// C'est le cas si la current_list est pleine
( (current_list->List_size==current_list->Nb_pages_allocated)
// ou qu'il ne reste plus assez de place pour allouer la new_page
|| ( (Memory_free()-MINIMAL_MEMORY_TO_RESERVE)<
(unsigned long)(new_page->Height*new_page->Width) ) );
if (!need_to_free)
{
// On a assez de place pour allouer une page, et de plus la current_list
// n'est pas pleine. On n'a donc aucune page à supprimer. On peut en
// allouer une directement.
new_page->Image=(byte *)malloc(new_page->Height*new_page->Width);
}
else
{
// On manque de mémoire ou la current_list est pleine. Dans tous les
// cas, il faut libérer une page... qui peut-être pourra re-servir.
// Tant qu'il faut libérer
while (need_to_free)
{
// On cherche sur quelle liste on va virer une page
// S'il reste des pages à libérer dans la current_list
if (current_list->Nb_pages_allocated>1)
// Alors on va détruire la dernière page allouée de la current_list
list_to_reduce=current_list;
else
{
if (secondary_list->Nb_pages_allocated>1)
{
// Sinon on va détruire la dernière page allouée de la
// secondary_list
list_to_reduce=secondary_list;
}
else
{
// Bon, alors là, on vient de vider toutes les pages et on a toujours pas asez de mémoire... C'est donc qu'un vilain programmeur a oublié de vérifier avec Noiuvelle_page_possible avant de venir ici.
// On sort méchament du programme sans sauvegarde ni rien. De toutes façons, ça ne devrait jamais se produire...
Error(ERROR_SORRY_SORRY_SORRY);
}
}
// Puis on détermine la page que l'on va supprimer (c'est la dernière de
// la liste)
page_to_delete=list_to_reduce->Pages+(list_to_reduce->Nb_pages_allocated)-1;
// On regarde si on peut recycler directement la page (cas où elle
// aurait la même surface que la new_page)
if ((page_to_delete->Height*page_to_delete->Width)==
(new_page->Height*new_page->Width))
{
// Alors
// On récupère le bitmap de la page à supprimer (évite de faire des
// allocations/désallocations fastidieuses et inutiles)
new_page->Image=page_to_delete->Image;
// On fait semblant que la dernière page allouée ne l'est pas
list_to_reduce->Nb_pages_allocated--;
// On n'a plus besoin de libérer de la mémoire puisqu'on a refilé à
// new_page un bitmap valide
need_to_free=0;
}
else
{
// Sinon
// Détruire la dernière page allouée dans la Liste_à_raboter
Free_last_page_of_list(list_to_reduce);
// On regarde s'il faut continuer à libérer de la place
need_to_free=(Memory_free()-MINIMAL_MEMORY_TO_RESERVE)
<(unsigned long)(new_page->Height*new_page->Width);
// S'il ne faut pas, c'est qu'on peut allouer un bitmap
// pour la new_page
if (!need_to_free)
new_page->Image=(byte *)malloc(new_page->Height*new_page->Width);
}
}
}
// D'après l'hypothèse de départ, la boucle ci-dessus doit s'arrêter car
// on a assez de mémoire pour allouer la nouvelle page.
// Désormais new_page contient un pointeur sur une zone bitmap valide.
// Décaler la current_list d'un cran vers le passé.
for (index=current_list->List_size-1;index>0;index--)
Copy_S_page(current_list->Pages+index,current_list->Pages+index-1);
// Recopier la new_page en 1ère position de la current_list
Copy_S_page(current_list->Pages,new_page);
current_list->Nb_pages_allocated++;
}
void Change_page_number_of_list(T_List_of_pages * list,int number)
{
int index;
T_Page * new_pages;
// Si la liste a déjà la taille demandée
if (list->List_size==number)
// Alors il n'y a rien à faire
return;
// Si la liste contient plus de pages que souhaité
if (list->List_size>number)
// Alors pour chaque page en excés
for (index=number;index<list->List_size;index++)
// On libère la page
Free_a_page(list->Pages+index);
// On fait une nouvelle liste de pages:
new_pages=(T_Page *)malloc(number*sizeof(T_Page));
for (index=0;index<number;index++)
Init_page(new_pages+index);
// On recopie les pages à conserver de l'ancienne liste
for (index=0;index<Min(number,list->List_size);index++)
Copy_S_page(new_pages+index,list->Pages+index);
// On libère l'ancienne liste
free(list->Pages);
// On met à jour les champs de la nouvelle liste
list->Pages=new_pages;
list->List_size=number;
if (list->Nb_pages_allocated>number)
list->Nb_pages_allocated=number;
}
void Free_page_of_a_list(T_List_of_pages * list)
{
// On ne peut pas détruire la page courante de la liste si après
// destruction il ne reste pas encore au moins une page.
if (list->Nb_pages_allocated>1)
{
// 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);
// Puis on détruit la dernière page, qui est l'ancienne page courante
Free_last_page_of_list(list);
}
}
///
/// GESTION DES BACKUPS
///
int Init_all_backup_lists(int size,int width,int height)
{
// size correspond au nombre de pages que l'on souhaite dans chaque liste
// (1 pour la page courante, puis 1 pour chaque backup, soit 2 au minimum).
// width et height correspondent à la dimension des images de départ.
T_Page * page;
int return_code=0;
if (Allocate_list_of_pages(Main_backups,size) &&
Allocate_list_of_pages(Spare_backups,size))
{
// 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
page=(T_Page *)malloc(sizeof(T_Page));
Init_page(page);
Upload_infos_page_main(page);
// On y met les infos sur la dimension de démarrage
page->Width=width;
page->Height=height;
// On regarde si on peut ajouter cette page
if (New_page_is_possible(page,Main_backups,Spare_backups))
{
// On peut, donc on va la créer
Create_new_page(page,Main_backups,Spare_backups);
Download_infos_page_main(page);
Download_infos_backup(Main_backups);
// Maintenant, on regarde si on a le droit de créer la même page dans
// la page de brouillon.
if (New_page_is_possible(page,Spare_backups,Main_backups))
{
// On peut donc on le fait
Create_new_page(page,Spare_backups,Main_backups);
Download_infos_page_spare(page);
// Et on efface les 2 images en les remplacant de "0"
memset(Main_screen,0,Main_image_width*Main_image_height);
memset(Spare_screen,0,Spare_image_width*Spare_image_height);
return_code=1;
}
else
{
// Il n'est pas possible de démarrer le programme avec la page
// principale et la page de brouillon aux dimensions demandée par
// l'utilisateur. ==> On l'envoie ballader
return_code=0;
}
}
else
{
// On ne peut pas démarrer le programme avec ne serait-ce qu'une
// page de la dimension souhaitée, donc on laisse tout tomber et on
// le renvoie chier.
free(page);
return_code=0;
}
}
else
{
// On n'a même pas réussi à créer les listes. Donc c'est même pas la
// peine de continuer : l'utilisateur ne pourra jamais rien faire,
// autant avorter le chargement du programme.
return_code=0;
}
return return_code;
}
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);
// 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.
// (nb_backups = Nombre de backups, sans compter les pages courantes)
}
int Backup_with_new_dimensions(int upload,int width,int height)
{
// Retourne 1 si une nouvelle page est disponible (alors pleine de 0) et
// 0 sinon.
T_Page * new_page;
int return_code=0;
if (upload)
// On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard)
Upload_infos_page_main(Main_backups->Pages);
// On crée un descripteur pour la nouvelle page courante
new_page=(T_Page *)malloc(sizeof(T_Page));
Init_page(new_page);
Upload_infos_page_main(new_page);
new_page->Width=width;
new_page->Height=height;
if (New_page_is_possible(new_page,Main_backups,Spare_backups))
{
Create_new_page(new_page,Main_backups,Spare_backups);
Download_infos_page_main(new_page);
Download_infos_backup(Main_backups);
// On nettoie la nouvelle image:
memset(Main_screen,0,Main_image_width*Main_image_height);
return_code=1;
}
// On détruit le descripteur de la page courante
free(new_page);
return return_code;
}
int Backup_and_resize_the_spare(int width,int height)
{
// Retourne 1 si la page de dimension souhaitee est disponible en brouillon
// et 0 sinon.
T_Page * new_page;
int return_code=0;
// On remet à jour l'état des infos de la page de brouillon (pour pouvoir
// les retrouver plus tard)
Upload_infos_page_spare(Spare_backups->Pages);
// On crée un descripteur pour la nouvelle page de brouillon
new_page=(T_Page *)malloc(sizeof(T_Page));
Init_page(new_page);
Upload_infos_page_spare(new_page);
new_page->Width=width;
new_page->Height=height;
if (New_page_is_possible(new_page,Spare_backups,Main_backups))
{
Create_new_page(new_page,Spare_backups,Main_backups);
Download_infos_page_spare(new_page);
return_code=1;
}
// On détruit le descripteur de la page courante
free(new_page);
return return_code;
}
void Backup(void)
// Sauve la page courante comme première page de backup et crée une nouvelle page
// pur continuer à dessiner. Utilisé par exemple pour le fill
{
#if defined(__macosx__) || defined(__FreeBSD__)
T_Page new_page;
#else
T_Page *new_page;
#endif
// On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard)
Upload_infos_page_main(Main_backups->Pages);
// On crée un descripteur pour la nouvelle page courante
#if defined(__macosx__) || defined(__FreeBSD__)
Init_page(&new_page);
// Enrichissement de l'historique
Copy_S_page(&new_page,Main_backups->Pages);
Create_new_page(&new_page,Main_backups,Spare_backups);
Download_infos_page_main(&new_page);
#else
new_page=(T_Page *)malloc(sizeof(T_Page));
Init_page(new_page);
// Enrichissement de l'historique
Copy_S_page(new_page,Main_backups->Pages);
Create_new_page(new_page,Main_backups,Spare_backups);
Download_infos_page_main(new_page);
#endif
Download_infos_backup(Main_backups);
// On copie l'image du backup vers la page courante:
memcpy(Main_screen,Screen_backup,Main_image_width*Main_image_height);
// On détruit le descripteur de la page courante
#if !(defined(__macosx__) || defined(__FreeBSD__))
free(new_page);
#endif
// On allume l'indicateur de modification de l'image
Main_image_is_modified=1;
}
void Undo(void)
{
// On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard)
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);
// On extrait ensuite les infos sur la nouvelle page courante
Download_infos_page_main(Main_backups->Pages);
// Et celles du backup
Download_infos_backup(Main_backups);
// 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
// poser de problèmes.
}
void Redo(void)
{
// On remet à jour l'état des infos de la page courante (pour pouvoir les
// retrouver plus tard)
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);
// On extrait ensuite les infos sur la nouvelle page courante
Download_infos_page_main(Main_backups->Pages);
// Et celles du backup
Download_infos_backup(Main_backups);
// 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
// poser de problèmes.
}
void Free_current_page(void)
{
// On détruit la page courante de la liste principale
Free_page_of_a_list(Main_backups);
// On extrait ensuite les infos sur la nouvelle page courante
Download_infos_page_main(Main_backups->Pages);
// Et celles du backup
Download_infos_backup(Main_backups);
// 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.
}
void Exchange_main_and_spare(void)
{
T_List_of_pages * temp_list;
// 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);
// On inverse les listes de pages
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.
/* SECTION GROS CACA PROUT PROUT */
// Auparavant on ruse en mettant déjà à jour les dimensions de la
// nouvelle page courante. Si on ne le fait pas, le "Download" va détecter
// 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;
Download_infos_page_main(Main_backups->Pages);
Download_infos_page_spare(Spare_backups->Pages);
Download_infos_backup(Main_backups);
}
int Can_borrow_memory_from_page(int size)
{
int mem_available_now;
int current_list_size;
int spare_list_size;
int current_page_size;
int spare_page_size;
mem_available_now=Memory_free()-MINIMAL_MEMORY_TO_RESERVE;
current_list_size =Size_of_a_list_of_pages(Main_backups);
spare_list_size=Size_of_a_list_of_pages(Spare_backups);
current_page_size =Size_of_a_page(Main_backups->Pages);
spare_page_size =Size_of_a_page(Spare_backups->Pages);
// Il faut pouvoir loger la zone mémoire ainsi qu'un exemplaire de la page
// courante, en conservant au pire la 1ère page de brouillon.
if ((mem_available_now
+current_list_size
+spare_list_size
-current_page_size
-spare_page_size)<size)
return 0;
return 1;
}
void * Borrow_memory_from_page(int size)
{
int need_to_free;
T_List_of_pages * list_to_reduce;
T_Page * page_to_delete;
//int index;
if (Can_borrow_memory_from_page(size))
{
// On regarde s'il faut libérer des pages:
need_to_free=
(Memory_free()-MINIMAL_MEMORY_TO_RESERVE)<(unsigned long)size;
if (!need_to_free)
{
// On a assez de place pour allouer une page. On n'a donc aucune page
// à supprimer. On peut allouer de la mémoire directement.
return malloc(size);
}
else
{
// On manque de mémoire. Il faut libérer une page...
// Tant qu'il faut libérer
while (need_to_free)
{
// On cherche sur quelle liste on va virer une page
// S'il reste des pages à libérer dans la liste des brouillons
if (Spare_backups->Nb_pages_allocated>1)
// Alors on va détruire la dernière page allouée de la liste des
// brouillons
list_to_reduce=Spare_backups;
else
{
if (Main_backups->Nb_pages_allocated>1)
{
// Sinon on va détruire la dernière page allouée de la
// liste principale
list_to_reduce=Main_backups;
}
else
{
// Dans cette branche, il était prévu qu'on obtienne la mémoire
// nécessaire mais on n'arrive pas à la trouver. On indique donc
// qu'elle n'est pas disponible, et on aura perdu des backups
// pour rien
return 0;
}
}
// Puis on détermine la page que l'on va supprimer (c'est la dernière
// de la liste)
page_to_delete=list_to_reduce->Pages+(list_to_reduce->Nb_pages_allocated)-1;
// Détruire la dernière page allouée dans la Liste_à_raboter
Free_last_page_of_list(list_to_reduce);
// On regarde s'il faut continuer à libérer de la place
need_to_free=
(Memory_free()-MINIMAL_MEMORY_TO_RESERVE)<(unsigned long)size;
// S'il ne faut pas, c'est qu'on peut allouer un bitmap
// pour la new_page
if (!need_to_free)
return malloc(size);
}
}
}
else
{
// Il n'y a pas assez de place pour allouer la mémoire temporaire dans
// la mémoire réservée aux pages.
return 0;
}
// Pour que le compilateur ne dise pas qu'il manque une valeur de sortie:
return 0;
}
void End_of_modification(void)
{
}
Reference in New Issue View Git Blame Copy Permalink