Lightemerald/snake2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Initial commit for tp2

Browse Source
This commit is contained in:
Lightemerald
2025-05-09 08:46:25 +02:00
parent cc53a75b39
commit a9ed5e2e01
73 changed files with 155 additions and 27431 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@@ -1,2 +1,2 @@
maison.o
maison
*.o
game

199
MLV/MLV_all.h
View File

@@ -1,199 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_all.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Fichier d'entête principal incluant tous les autres fichiers entêtes
* de la bibliothèque MLV.
*
* Vous trouverez tous les prototypes des fonctions proprées par la bibliothèque
* MLV dans les fichiers entêtes (.h) suivants :
*
* MLV_animation.h : permet de mettre en oeuvre des animations.
*
*
* MLV_audio.h : permet de jouer de la musique.
*
*
* MLV_color.h : definit les différentes couleurs de la bibliothèque MLV.
*
*
* MLV_event.h : propose une gestion avancée des évènements. Avec les fonctions
* proposées par MLV_evenement.h, il est possible de traiter les évènements
* sans intérrompre l'exécution du programme.
*
*
* MLV_image.h : charger, modifier et afficher des images.
*
*
* MLV_information.h : permet d'obtenir quelques informations concernant la
* bibliothèque MLV (web, auteurs, version).
*
*
* MLV_input_box.h : définit différents outils pour créer et utiliser des
* boîtes de saisies.
*
*
* MLV_keyboard.h : définit les types concerant le clavier et définit la
* fonction MLV_keyboard_wait pour récuperer des évènements
* provenant du clavier.
*
*
* MLV_mouse.h : définit les types concerant la souris ainsi que la fonction
* MLV_mouse_wait pour récuperer des évènements provenant de la
* souris.
*
*
* MLV_path.h : définit différents outils pour utiliser des chemins d'accès aux
* fichiers.
*
*
* MLV_random.h : propose des outils pour engendrer des nombres aléatoires.
*
*
* MLV_shape.h : permet de créer des figures ( cercle, ellipse, polygone,
* courbe de bezier, rectangle, ligne , point).
*
*
* MLV_text.h : définit differents outils permettant d'afficher du texte seul ou
* dans une boîte.
*
* MLV_text_va.h : définit les même outils que MLV_text.h mais en prenant une
* comme argument suplémentaire une liste d'arguments.
*
* MLV_time.h : propose des outils pour gérer le temps.
*
* MLV_xml.h : propose des outils pour lire des fichiers XML.
*
* MLV_xml_va.h : définit les même outils que MLV_xml.h mais en prenant une
* comme argument suplémentaire une liste d'arguments.
*
* MLV_window.h : propose des fonctions pour
* - initialiser, créer et fermer une fenêtre
* - actualiser l'affichage de la fenêtre
* - exécuter du code à la fermeture de la fenêtre
*
* \see MLV_animation.h MLV_audio.h MLV_color.h MLV_event.h MLV_image.h
* MLV_information.h MLV_input_box.h MLV_keyboard.h MLV_mouse.h
* MLV_path.h MLV_random.h MLV_shape.h MLV_text.h MLV_text_va.h MLV_time.h
* MLV_xml.h MLV_xml_va.h MLV_window.h
*/
/** \~spanish
* \file MLV_all.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Archivo principal de cabecera incluyendo todos los otros archivos de
* cabecera de la biblioteca informática MLV.
*
* Puede encontrar todos los prototipos des las subrutinas propuestas para la
* biblioteca MLV en los archivos de cabecera (.h) suiquiente :
*
* MLV_animation.h : permite de añadir animaciónes.
*
* MLV_audio.h : permite de tocar música.
*
*
* MLV_color.h : défine los differentes colores de la biblioteca MLV.
*
*
* MLV_event.h : proppone una gestión advencada des los eventos. Con las
* subrutinas propuestas para MLV_evenment.h, es possible de
* tratar los eventos sin interrumpir la ejecución del programa
* informático.
*
*
* MLV_shape.h : permite de creer figuras geométricas (círculo, elipse,
* polígono, Curva de Bézier, rectángulo, linea recta, punto).
*
*
* MLV_image.h : modificar and fijara las imagenes.
*
*
* MLV_information.h : permite de obtener algunas noticias concerniendo la
* biblioteca MLV. concernant la
*
*
* MLV_keyboard.h : define los tipos de dato por el teclado y la subrutina
* MLV_keyboard_wait para obtener los eventos del teclado.
*
*
* MLV_mouse.h : define los tipos de dato por el ratón y la subrutina
* MLV_mouse_wait para obtener eventos des ratón.
*
*
* MLV_input_box.h : define algunas herramientas para creer y utilisar caja de
* texto
*
*
* MLV_text.h : define algunas herramientas para fijar textos.
*
* MLV_text_va.h : TODO
*
* MLV_time.h : propone herramientas para utilisar el tiempo.
*
* MLV_xml.h : TODO
*
* MLV_xml_va.h : TODO
*
* MLV_random.h : propone herramientas para generar números aleatorios.
*
*
* MLV_window.h : propone las subrutina para
* - creer, inicializar, cerrar ventanas
* - actualizar la visualización de una ventana
* - ejecutar código al fin del programa
*
*
* \see MLV_animation.h MLV_audio.h MLV_color.h MLV_event.h MLV_shape.h
* MLV_image.h MLV_keyboard.h MLV_mouse.h MLV_input_box.h MLV_random.h
* MLV_text.h MLV_text_va.h MLV_time.h MLV_xml.h MLV_xml_va.h MLV_window.h
*/
#ifndef __MLV__MLV_ALL_H__
#define __MLV__MLV_ALL_H__
#include "MLV_animation.h"
#include "MLV_audio.h"
#include "MLV_color.h"
#include "MLV_event.h"
#include "MLV_shape.h"
#include "MLV_image.h"
#include "MLV_information.h"
#include "MLV_keyboard.h"
#include "MLV_mouse.h"
#include "MLV_path.h"
#include "MLV_playlist.h"
#include "MLV_input_box.h"
#include "MLV_random.h"
#include "MLV_text.h"
#include "MLV_text_va.h"
#include "MLV_time.h"
#include "MLV_xml.h"
#include "MLV_xml_va.h"
#include "MLV_window.h"
#endif

655
MLV/MLV_animation.h
View File

@@ -1,655 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_animation.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* Cette interface est inspiré du tutoriel :
* http://www.gnurou.org/writing/linuxmag/sdl/partie3
*
* \brief Ce fichier définit les prototypes des fonctions permettant de mettre
* en oeuvre des animations.
*/
#ifndef __MLV__MLV_ANIMATION_H__
#define __MLV__MLV_ANIMATION_H__
#include "MLV_image.h"
#include "MLV_audio.h"
#ifdef __cplusplus
extern "C" {
#endif
////////////////////////////////////////////////
// Animation data
///////////////////////////////////////////////
/** \~french
* \brief Ce type code une animation.
*
* Une animation est une succéssion de k+l+1 uplets.
* Chaque uplet contient :
* - k images,
* - l sons,
* - 1 temps d'affichage
* Les k images correspondent à k représentations différentes d'une
* même scène animée.
* Les l sons correspondent à l différents fonds sonores pour la
* même scène animée.
* Le temps d'affichage est le temps d'affichage des images dans
* l'animation.
*
* On appelle "couche graphique i", l'ensemble des images situées à la
* position i du k+l+1-uplet.
* On appelle "couche sonore j", l'ensemble des sons situées à la
* position k+j du k+l+1-uplet.
*
* Voici la Structure d'une animatione représentée à l'aide d'un tableau :
*
* \verbatim
|-------------------------------------------------------------|
| MLV_Animation |
|-------------------------------------------------------------|
| |
| Couche graphique 0 | Image Image Image ... |
| Couche graphique 1 | Image Image Image ... |
| ... | ... ... ... ... |
| Couche graphique k-1 | Image Image Image ... |
| ------------------------------------------------------- |
| Couche sonore 0 | Son Son Son ... |
| Couche sonore 1 | Son Son Son ... |
| ... | ... ... ... ... |
| Couche sonore k-1 | Son Son Son ... |
| ------------------------------------------------------- |
| Temps d'affichage | 1 3 1 ... |
| |
|-------------------------------------------------------------|
\endverbatim
*
*/
typedef struct _MLV_Animation MLV_Animation;
/** \~french
* \brief Créé une animation comportant un nombre d'image donné
*
* Une animationV est une succession d'image où à chaque image est
* associé un temps. Ce temps code le temps d'affichage de chaque image,
* lors du rendu de de l'animation.
* Pour des raisons de commodité, nos séquence d'animations sont composés de
* plusieurs couches. Elles sont donc des successions de couches contenant
* chacunes une image.
*
* Une sequence d'animation (à ne pas confondre avec une animation) est une
* pure structure de donnée. Elle peut donc pas s'animer, ni s'afficher à
* l'ecran.
* Pour afficher une séquence d'animation, il faut utiliser une animation,
* qui s'aidera de la séquence d'animation pour s'afficher ou pour mettre en
* mouvement les images de la séquence d'animation.
*
* Le temps d'une s'quence d'animation n'est pas codée en secondes. Il s'agit
* d'un entier. Lorsque vous utilisez une animation, l'animateur à un temps qui
* lui est propre et qui est codé à l'aide d'un entier qui croit. Les duree que
* vous ajouterez dans l'animation sont donc définit par rapport au temps de
* l'animation qui utilise la séquence d'animation.
*
* \param nb_frames Le nombre d'image que doit contenir l'animation
* \param nb_layers Nombre de couches graphique de l'animation.
* \param nb_channels Nombre de canaux sonore de l'animation.
* \return Un pointeur vers une animation.
*/
MLV_Animation* MLV_create_animation(
unsigned int nb_frames, unsigned int nb_layers, unsigned int nb_channels
);
/** \~french
* \brief Cette fonction libère les données allouées pour l'animation
*
* \param animation L'animation à fermer.
*/
void MLV_free_animation( MLV_Animation* animation );
/** \~french
* \brief Change un animation en remplacant une image et son temps d'affichage
* associé. L'image concerné est repéré à l'aide de son index et de
* l'index de la couche où elle appartient.
*
* \param array_of_images Un tableau d'adresse contenant les addresses de images
* correspondat aux différentes couches d'une animation.
* \param array_of_sounds Un tableau d'adresse contenant les addresses de sons
* correspondant aux différentes canaux d'une animation.
* \param delay temps d'affichage de l'image
* \param animation Animation à modifier
* \param position position de l'image dans l'animation
*/
void MLV_change_frame_in_animation(
MLV_Image** array_of_images, MLV_Sound** array_of_sounds, unsigned int delay,
MLV_Animation* animation, unsigned int position
);
/** \~french
* \brief Change un animation en remplacant uniquement une image.
* L'image concerné est repéré à l'aide de son index et de
* de l'index de sa couche.
*
* \param image image a ajouter dans l'animation
* \param animation Animation à modifier
* \param position position de l'image dans l'animation
* \param layer Couche de l'image.
*/
void MLV_change_frame_image_in_animation(
MLV_Image* image, MLV_Animation* animation, unsigned int position,
unsigned int layer
);
/** \~french
* \brief Change un animation en remplacant uniquement un bruitage.
* Le son image concerné est repéré à l'aide de son index et de
* de l'index de son canaul.
*
* \param sound son a ajouter dans l'animation
* \param animation Animation à modifier
* \param position position de l'image dans l'animation
* \param channel Canal du son.
*/
void MLV_change_frame_sound_in_animation(
MLV_Sound* sound, MLV_Animation* animation, unsigned int position,
unsigned int channel
);
/** \~french
* \brief Change le temps d'affichage d'une image donnée d'une animation.
*
* \param delay temps d'affichage de l'image
* \param animation Animation à modifier
* \param position position de l'image dans l'animation
*/
void MLV_change_frame_delay_in_animation(
unsigned int delay, MLV_Animation* animation, unsigned int position
);
/** \~french
* \brief Recupère l'image et le temps présents à une position et une couche
* donnée d'une animation.
*
* \param animation Animation à modifier
* \param layer Couche de l'image.
* \param position position de l'image dans l'animation
* \param image image a ajouter dans l'animation
* \param delay temps d'affichage de l'image
*/
void MLV_get_frame_from_animation(
MLV_Animation* animation, unsigned int position,
unsigned int layer,
MLV_Image** image, unsigned int* delay
);
/** \~french
* \brief Renvoie le temps d'affichage de l'image présente à une position
* donnée d'une animation donnée.
*
* \param animation Animation à modifier
* \param position position de l'image dans l'animation
*
* \return le temps d'affichage de l'image
*/
int MLV_get_frame_delay_from_animation(
MLV_Animation* animation, unsigned int position
);
/** \~french
* \brief Renvoie l'image présente à une position et une couche donnée d'une
* animation donnée.
*
* \param animation Animation à modifier
* \param position position de l'image dans l'animation
* \param layer Couche de l'image.
*
* \return l'image extraite.
*/
MLV_Image* MLV_get_frame_image_from_animation(
MLV_Animation* animation, unsigned int position,
unsigned int layer
);
////////////////////////////////////////////////
// Animation engine
///////////////////////////////////////////////
/** \~french
* \brief Ce type code un lecteur d'animation.
*
* Un lecteur d'animation est une structure qui permet d'animer une animation.
* Cette structure contient :
* - un pointeur vers une animation
* - la position de l'image courante de l'animation
* - une horloge interne ( dont le temps est discret et indépendant du temps courant )
*
*
*
* L'aiguille de l'horologe interne d'une animation avance d'une unité
* à chaque appel de la fonction MLV_update_animation_player().
* Les animations sont alors jouée en fonction de l'évolution du temps de chaque
* animateur. Ainsi, deux lecteurs différents peuvent avoir une courbe du
* temps différente.
*
* La bonne façon d'utiliser des lecteurs est de mettre a jour tous les
* lecteurs en même temps à un intervalle de temps régulier.
* Pour cela vous pouvez utiliser la fonction framerate qui endort le programme
* de façon a assurer l'execution d'un tour de boucle à une fréquence donnée
*
* Voici un exemple d'utilisation du lecteur :
* \code
* MLV_Image* creature1 = MLV_load_image("creature1.png");
* MLV_Image* creature2 = MLV_load_image("creature2.png");
* int time_per_image = 1;
*
* MLV_Animation* animation;
* animation = MLV_create_animation( 2 );
* MLV_change_frame_in_animation( creature1, time_per_image, animation, 0 );
* MLV_change_frame_in_animation( creature2, time_per_image, animation, 0 );
*
* MLV_Animation_player* animation_player;
* animation_player = MLV_create_animation_player( animation );
*
* int frequence = 24; // nombre d'images par secondes
* MLV_change_frame_rate( frequence );
* while( 1 ){
* MLV_update_animation_player( animation_player );
* MLV_draw_image_from_animation_player(0, 0, 0, animation_player);
* MLV_frame_rate_delay();
* }
* \endcode
*
*/
typedef struct _MLV_Animation_player MLV_Animation_player;
/** \~french
* \brief Cree un lecteur d'animation et l'initialise avec une animation donnée en
* paramètre.
*
* \param animation L'animation que devra animer l'animateur.
*
* \return L'animateur créé.
*/
MLV_Animation_player* MLV_create_animation_player( MLV_Animation* animation );
/** \~french
* \brief Libère l'espace mémoire alloué pour un animateur donné.
*
* \param animation_player Le lecteur d'animation à suprimer
*/
void MLV_free_animation_player( MLV_Animation_player* animation_player );
/** \~french
* \brief Demare la lecture de l'animation lu par le lecteur d'animation.
*
* \param animation_player Le lecteur d'animation
*/
void MLV_play_animation_player( MLV_Animation_player* animation_player );
/** \~french
* \brief Demande à un lecteur d'animation donné de jouer l'animation à l'envers.
*
* \param animation_player Le lecteur d'animation
*/
void MLV_play_revert_animation_player( MLV_Animation_player* animation_player );
/** \~french
* \brief Met en pause la lecture d'un lecteur d'animation donné.
*
* \param animation_player Le lecteur d'animation
*/
void MLV_stop_animation_player( MLV_Animation_player* animation_player );
/** \~french
* \brief Demande à l'animateur de reprendre la lecture de l'animation depuis le
* début.
*
* \param animation_player Le lecteur d'animation
*/
void MLV_rewind_animation_player( MLV_Animation_player* animation_player );
/** \~french
* \brief Force le lecteur d'animation à passer à l'image suivante.
*
* \param animation_player Le lecteur d'animation
*/
void MLV_next_frame( MLV_Animation_player* animation_player );
/** \~french
* \brief Force l'animateur à revenir sur l'image précédente.
*
* \param animation_player Le lecteur d'animation
*/
void MLV_previous_frame( MLV_Animation_player* animation_player );
/** \~french
* \brief Met a jour un lecteur d'animation.
*
* L'horloge interne du lecteur voit son temps incrémenter de 1 unité
* exactement.
*
* La position de lecture de l'animation est mis a jour en conséquence de la
* mis à jour de l'horloge interne.
*
* \param animation_player Le lecteur d'animation à mettre à jour
*/
void MLV_update_animation_player( MLV_Animation_player* animation_player );
/** \~french
* \brief Change le volume sonore d'un bruitage.
*
* \param animation_player L'animateur dans lequel se trouve le son.
* \param channel Le canal concerné.
* \param volume le nouveau volume sonore.
*/
void MLV_change_sound_volume_of_animation_player(
MLV_Animation_player* animation_player, unsigned int channel, float volume
);
/** \~french
* \brief Active le son du canal d'un lecteur d'animation donnée.
*
* \param animation_player L'animateur concerné.
* \param channel Le canal concerné.
*/
void MLV_turn_on_sound_of_animation_player(
MLV_Animation_player* animation_player, unsigned int channel
);
/** \~french
* \brief Désactive le son du canal d'une animation donnée.
*
* \param animation_player L'animateur concerné.
* \param channel Le canal concerné.
*/
void MLV_turn_off_sound_of_animation_player(
MLV_Animation_player* animation_player, unsigned int channel
);
////////////////////////////////////////////////
// Drawing animation
///////////////////////////////////////////////
/** \~french
* \brief Dessine à une position donnée l'image actuellement lue par
* l'animateur. Cette image est situè à une couche donnée en paramètre.
*
* \param animation_player Le lecteur de l'animation à aficher
* \param layer Couche de l'image.
* \param x Coordonnée en X de la position du sommet Nord-Ouest de
* l'image à afficher.
* \param y Coordonnée en Y de la position du sommet Nord-Ouest de
* l'image à afficher.
*/
void MLV_draw_image_from_animation_player(
MLV_Animation_player* animation_player, unsigned int layer,
int x, int y
);
/** \~french
* \brief Joue le son d'une couche sonore donnée correspondant à l'image en
* cours de lecture dans l'animation.
*
* Si le son a déjà été joué, cette fonction ne fait rien.
*
* \param animation_player Le lecteur de l'animation à aficher.
* \param layer Couche du son.
*/
void MLV_play_sound_from_animation_player(
MLV_Animation_player* animation_player, unsigned int layer
);
/** \~french
* \brief Même chose que MLV_play_sound_from_animation_player() sauf que cette
* fonction permet de lancer plusieurs sons en même temps.
*
* La liste des couches sonores à jouer doivent être passé en paramètre
* (un paramètre par couche), et le dernier paramètre doit valoir -1 pour
* dire à la fonction quand il doit s'arrêter.
*
* Par exemple, pour jouer les couches 2, 3 et 5 d'une animation,
* il suffit d'écrire:
*
* \code
* MLV_play_sounds_from_animation_player(
* animation,
* 2, 3, 5,
* -1
* );
* \endcode
*
* \param animation_player Le lecteur de l'animation à aficher.
* \param ... la liste des couches sonores, dont la veleure finale doit toujours être -1.
*/
void MLV_play_sounds_from_animation_player(
MLV_Animation_player* animation_player,
...
);
/** \~french
* \brief Même chose que MLV_play_sound_from_animation_player() sauf que cette
* fonction permet de lancer plusieurs sons en même temps.
*
* \param animation_player Le lecteur de l'animation à aficher.
* \param layers Tableau contenant les couches du son à jouer.
* \param nb_layers Nombre de couches dans le tableau.
* \
*/
void MLV_play_list_of_sounds_from_animation_player(
MLV_Animation_player* animation_player, unsigned int* layers,
unsigned int nb_layers
);
/** \~french
* \brief Dessine à l'écran à une position donnée, une portion de
* l'image actuellement lue par l'animateur et extraite de la
* couche spécifiée en paramètre.
*
* \param animation_player Le lecteur de l'animation à aficher
* \param layer Couche de l'image.
* \param image image sur laquel il faut dessiner l'animation
* \param source_x Coordonnée en X de la position de la portion à recopier
* \param source_y Coordonnée en Y de la position de la portion à recopier
* \param source_width Largeur de la portion à recopier
* \param source_height Hauteur de la portion à recopier
* \param x Coordonnée en X de la position du sommet Nord-Ouest de
* l'image à afficher.
* \param y Coordonnée en Y de la position du sommet Nord-Ouest de
* l'image à afficher.
*/
void MLV_draw_partial_image_from_animation_player(
MLV_Animation_player* animation_player, unsigned int layer,
int source_x, int source_y, int source_width, int source_height,
MLV_Image* image,
int x, int y
);
/** \~french
* \brief Dessine sur une image donnée à une position donnée l'image
* actuellement lue par l'animateur et située à une couche donnée.
*
* \param animation_player Le lecteur de l'animation à aficher
* \param layer Couche de l'image.
* \param image image sur laquel il faut dessiner l'animation
* \param x Coordonnée en X de la position du sommet Nord-Ouest de
* l'image à afficher.
* \param y Coordonnée en Y de la position du sommet Nord-Ouest de
* l'image à afficher.
*/
void MLV_draw_image_from_animation_player_on_image(
MLV_Animation_player* animation_player, unsigned int layer,
MLV_Image* image,
int x, int y
);
/** \~french
* \brief Dessine sur une image donnée à une position donnée une portion de
* l'image actuellement lue par l'animateur et située à une couche
* donnée.
*
* \param animation_player Le lecteru de l'animation à aficher
* \param layer Couche de l'image.
* \param image image sur laquel il faut dessiner l'animation
* \param source_x Coordonnée en X de la position de la portion à recopier
* \param source_y Coordonnée en Y de la position de la portion à recopier
* \param source_width Largeur de la portion à recopier
* \param source_height Hauteur de la portion à recopier
* \param x Coordonnée en X de la position du sommet Nord-Ouest de
* l'image à afficher.
* \param y Coordonnée en Y de la position du sommet Nord-Ouest de
* l'image à afficher.
*/
void MLV_draw_partial_image_from_animation_player_on_image(
MLV_Animation_player* animation_player, unsigned int layer,
int source_x, int source_y, int source_width, int source_height,
MLV_Image* image,
int x, int y
);
////////////////////////////////////////////////
// Loading animations from files
///////////////////////////////////////////////
/** \~french
* \brief Ce type correspond à un livre contenant de nombreuses animations.
*
* Un livre d'animations est un fichier XML qui code des animations.
* Le type MLV_Animation_book code le contenu d'un live d'animation.
*
*/
typedef struct _MLV_Animation_book MLV_Animation_book;
/** \~french
* \brief Charge en memoire un livre contenant une multitude d'animations.
*
* \param xml_file Fichiers xml.
* \param image_directory Le dossier ou se trouve toutes les images du livre
* d'animation. Si NULL est passe en parametre, alors le programme
* cherche dans le repertoire du fichier de configuration du livre
* d'animation.
* \param sound_directory Le dossier ou se trouve toutes les échantillons
* sonore du livre d'animation. Si NULL est passe en parametre,
* alors le programme cherche dans le repertoire du fichier de
* configuration du livre d'animation.
* \return L'adresse de la sructure de données contenant toutes les animations.
*/
MLV_Animation_book* MLV_load_animation_book(
const char* xml_file,
const char* image_directory,
const char* sound_directory
);
/** \~french
* \brief Libère la memoire contenue par le livre d'animation.
*
* \param animation_book Le livre d'animation.
*/
void MLV_free_animation_book(
MLV_Animation_book* animation_book
);
/** \~french
* \brief Détermine le nombre d'animations contenus par le livre d'animation.
*
* \param animation_book Le livre d'animation.
* \return le nombre d'animations contenus par le livre d'animation.
*/
int MLV_get_number_of_animations(
MLV_Animation_book* animation_book
);
/** \~french
* \brief Renvoie une animation donnée contenue dans le livre d'animation.
*
* \param animation_book Le livre d'animation.
* \param id L'identifiant
* \return La séquence d'animation.
*/
MLV_Animation* MLV_get_animation_from_id(
MLV_Animation_book* animation_book,
int id
);
/** \~french
* \brief Renvoie une animation donnée contenue dans le livre d'animation.
*
* \param animation_book Le livre d'animation.
* \param name Le nom de l'animation
* \return La séquence d'animation.
*/
MLV_Animation* MLV_get_animation_from_name(
MLV_Animation_book* animation_book,
const char* name
);
/** \~french
* \brief Renvoie le nom d'un animation à partir de son identifiant dans le
* livre d'animation.
*
* \param animation_book Le livre d'animation.
* \param id_animation L'identifiant de l'animation dans le livre.
* \return Le nom de l'animation.
*/
const char* MLV_get_name_from_id_animation(
MLV_Animation_book* animation_book, int id_animation
);
/** \~french
* \brief Ajoute un image dans la séquence d'animation.
* Cette fonction ne peux pas augmenter le nombre d'image d'une
* animation.
*
* \param array_of_images Liste d'image à ajouter. Il s'agit de toutes les
* images assiciée à toutes les couches correspondnant de
* l'animation.
* \param array_of_sounds Liste de sons à ajouter. Il s'agit de toutes les
* sons assiciées à tous les cannaux correspondnant de
* l'animation.
* \param delay le temps d'afficahge d'une image.
* \param animation La sequence d'animation à moifier.
*/
void MLV_add_frame_in_animation(
MLV_Image** array_of_images, MLV_Sound** array_of_sounds, unsigned int delay,
MLV_Animation* animation
);
#ifdef __cplusplus
}
#endif
#endif

187
MLV/MLV_audio.h
View File

@@ -1,187 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_audio.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant de faire
* jouer de la musique et des échantillons sonores à l'aide de la bibliothèque
* MLV.
*/
#ifndef __MLV__MLV_AUDIO_H__
#define __MLV__MLV_AUDIO_H__
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Ce type code un morceau de musique.
*/
typedef struct _MLV_Music MLV_Music;
/** \~french
* \brief Ce type code un échantillon sonore.
*/
typedef struct _MLV_Sound MLV_Sound;
/** \~french
* \brief Cette fonction initialise la bibliothèque MLV pour pouvoir jouer de la
* musique et des sons.
*
* \return Renvoie 0 si l'infrastructure audio a été correctement initialisé,
* renvoie -1 sinon.
*/
int MLV_init_audio();
/** \~french
* \brief Ferme proprement les différents périphériques audios.
*/
void MLV_free_audio();
/** \~french
* \brief Change la taille du buffer audio. La taille doit être une puissance
* de 2.
*
* Le porgramme rempli périodiquement un buffer audio à faire jouer par la
* carte son. Plus la taille du buffer audio est grande, plus le programme
* à le temps de remplir le buffer avant qu'il se vide. Plus le buffer est
* grand, plus le programme met du temps à le remplir.
*
* Ainsi, si il y a un temps de latence entre une action et l'execution sonore
* du son correspondant, c'est que vous devez réduire la taille du buffer audio.
*
* Si le son est coupé et crépite, c'est que le buffer est trop petit et que le
* processeur est trop lent pour remplir le buffer avant qu'il se vide.
* Vous devez donc agrandir la taille du buffer.
*
* MLV_change_buffer_size vous permet d'ajuster la taille de ce buffer.
* par default la taille du buffer est mis à 1024.
*
* Si vous utilisez le programme uniquement pour jouer de la musique, nous vous
* vous conseillons de configurer la taille du buffer à 4096.
*
* \param buffer_size Taille du buffer audio ( une puissance de 2 )
*
* \return Renvoie 0 si l'infrastructure audio a été correctement initialisé,
* renvoie -1 sinon.
*/
int MLV_change_audio_buffer_size( int buffer_size );
/** \~french
* \brief Change le nombre d'écahantillons sonores qui peuvent être joués en
* même temps.
*
* \param n Le nombre d'échantillons sonores.
*/
void MLV_change_number_of_parallel_sounds( unsigned int n );
/** \~french
* \brief Charge un ficher contenant de la musique en mémoire.
*
* Cette fonction prends en paramètre le chemin d'accès du
* fichier contenant la musique et renvoie un pointeur vers l'espace mémoire où
* a été chargé la musique.
*
* Les formats de fichier acceptés sont les suivants .ogg, .mp3, .wav, etc ...
*
* \param file_music Chemin d'accès vers un fichier contenant de la musique
* codée en format .wav.
* \return Un pointeur vers la musique chargée en mémoire, ou NULL si la
* bibliothèque n'a pas réussi à charger la musique en mémoire.
*/
MLV_Music* MLV_load_music( const char* file_music );
/** \~french
* \brief Ferme un morceau de musique chargé en mémoire.
*
* \param music Le morceau de musique à fermer
*/
void MLV_free_music( MLV_Music* music );
/** \~french
* \brief Joue un morceau de musique qui est chargée en mémoire.
*
* \param music Le morceau de musique à jouer.
* \param volume Le volume sonore.
* \param loop Le nombre de fois que le morceau doit être joué. Si loop est
* strictement négatif, le morceau sera joué indéfiniment.
*/
void MLV_play_music( const MLV_Music* music, float volume, int loop );
/** \~french
* \brief Arrête toutes les musiques.
*/
void MLV_stop_music();
/** \~french
* \brief Charge un ficher contenant un échantillon sonore en mémoire.
*
* Cette fonction prends en paramètre le chemin d'accès du
* fichier contenant l'échantillon sonore et renvoie un pointeur vers l'espace
* mémoire où a été chargé l'échantillon sonore.
*
* Les formats de fichier acceptés sont les suivants : WAVE, AIFF, RIFF, OGG, and
* VOC.
*
* \param file_sound Chemin d'accès vers un fichier contenant un échantillon
* sonore.
* \return Null si le fichier n'a pas pu être chargé en mémoire. Un pointeur vers
* l'échantllon sonore sinon.
*/
MLV_Sound* MLV_load_sound( const char* file_sound );
/** \~french
* \brief Ferme un échantillon sonore chargé en mémoire.
*
* \param sound L'échantillon sonore à fermer
*/
void MLV_free_sound( MLV_Sound* sound );
/** \~french
* \brief Joue un échantillon sonore chargé en mémoire.
*
* \param sound L'échantillon sonore à jouer.
* \param volume Le volume sonore.
*/
void MLV_play_sound( const MLV_Sound* sound, float volume );
/** \~french
* \brief Arrête tous les échantillons sonores.
*/
void MLV_stop_all_sounds();
#ifdef __cplusplus
}
#endif
#endif

4652
MLV/MLV_color.h
View File

File diff suppressed because it is too large Load Diff

53
MLV/MLV_device_with_buttons.h
View File

@@ -1,53 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_device_with_buttons.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit des énumérations et des prototypes de fonctions pour
* manipuler des boutons de différents matériels (bouttons de souris,
* boutons de claviers, etc ...)
*
*/
#ifndef __MLV__MLV_DEVICE_WITH_BUTTONS_H__
#define __MLV__MLV_DEVICE_WITH_BUTTONS_H__
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Énumère les différents états possibles d'un bouton.
*/
typedef enum {
MLV_PRESSED, /**< \~french Le bouton est en position appuyée */
MLV_RELEASED /**< \~french Le bouton est en position relachée */
} MLV_Button_state;
#ifdef __cplusplus
}
#endif
#endif

361
MLV/MLV_event.h
View File

@@ -1,361 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_event.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant d'utiliser
* les évènements dans la bibliothèque MLV.
*/
#ifndef __MLV__MLV_EVENT_H__
#define __MLV__MLV_EVENT_H__
#include "MLV_device_with_buttons.h"
#include "MLV_keyboard.h"
#include "MLV_mouse.h"
#include "MLV_input_box.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Énumère les différents types d'évènement de la bibliothèque MLV.
*/
typedef enum {
MLV_NONE = 0, /**< \~french Aucun évènement */
MLV_KEY = 1, /**< \~french Evnènement provenant du clavier */
MLV_INPUT_BOX = 2, /**< \~french Évènement provenant de la validation d'un texte dans
* une boîte de saisie. */
MLV_MOUSE_BUTTON = 3, /**< \~french Évènement provenant d'un clique de souris. */
MLV_MOUSE_MOTION = 4 /**< \~french Évènement provenant du déplacement de la souris.*/
} MLV_Event;
/** \~french
* \brief Cette fonction récupère un évènement dans la file d'attente, remplit
* en fonction de l'évènement récupéré une partie des paramètres de la
* fonction et renvoie un entier codant le type de l'évènement qui a été
* récupéré.
*
* Le type des évènements est défini par :
*
* MLV_Event
*
* et peut valoir les valeurs suivantes:
*
* Valeur ........... Signification
*
* ----------------------------------
*
* MLV_NONE .......... Aucun évènement récupéré
*
* MLV_KEY ........... Une touche du clavier a été appuyée ou
* relachée.
*
* MLV_INPUT_BOX ..... L'utilisateur a écrit une chaîne de
* caractères et validé cette chaîne par
* la touche entrée.
*
* MLV_MOUSE_BUTTON .. Un des boutons de la souris a été
* appuyé.
*
* MLV_MOUS_MOTION ... La souris a été déplacée.
*
*
*
* Voici un tableau qui donne les champs modifiés en fonction
* de l'évènement qui a été récupéré.
*
* Type Évènement .... Paramètres modifiés
*
* ---------------------------------------
*
* MLV_NONE .......... AUCUN
*
* MLV_KEY ........... key_sym, key_mod, state
*
* MLV_INPUT_BOX ..... texte, input_box
*
* MLV_MOUSE_BUTTON .. mouse_x, mouse_y, mouse_button, state
*
* MLV_MOUSE_MOTION .. mouse_x, mouse_y
*
*
* L'utilisateur n'est pas obligé d'utiliser un champs s'il
* n'en a pas l'utilité. Dans ce cas, il peut mettre la valeur
* NULL. Le champs est alors ignoré.
*
* \bug Il est possible que la récuperation du caractère unicode sous Windows
* ne fonctionne pas bien. En effet, aucun code de portage spécifique n'a été
* fait à ce sujet.
*
* \bug Sous WINDOWS, le clavier est configuré en "qwerty".
*
* \return La fonction renvoie un entier codant le type de l'évènement qui a
* été récupéré.
*
* \param key_sym Code de la touche qui a été appuyée ou relachée. La valeur de
* ce champs est définie par l'énumération : MLV_Keyboard_button.
* \param key_mod Mode dans lequel se trouve le clavier lorsqu'une touche est
* appuyée ou relachée. La valeur de ce champs est définie par
* l'énumération : MLV_Keyboard_modifier.
* \param unicode Caractère codé en unicode de la lettre obtenue en combinant
* le code et le mode précédent
* \param texte Texte récupéré par la boîte de saisie. L'allocation est
* affectée par la fonction elle-même. La désallocation est à
* la charge de l'utilisateur.
* \param input_box La boîte de saisie qui a récupérée le texte
* \param mouse_x Coordonnée en X de la position de la souris
* \param mouse_y Coordonnée en Y de la position de la souris
* \param mouse_button Bouton de la souris qui a été appuyé ou relaché.
* Ce champs est défini par l'énumération MLV_Mouse_button.
* \param state Etat de la touche concernée par l'évènement. La valeur de ce
* champs est défini par l'énumération: MLV_Button_state.
*/
MLV_Event MLV_get_event(
MLV_Keyboard_button* key_sym, MLV_Keyboard_modifier* key_mod, int* unicode,
char** texte, MLV_Input_box** input_box,
int* mouse_x, int* mouse_y, MLV_Mouse_button* mouse_button,
MLV_Button_state* state
);
/** \~french
* \brief Cette fonction suspends l'éxecution du programme jusqu'à ce qu'un
* évènement apparaît dans la file d'attente. Lorsqu'un nouvel
* évènement apparaît, la fonction
* - remplit ses paramètres et renvoie un entier codant le type de
* l'évènement qui a été récupéré, si les paramètres passés en
* argument concernent l'évènement récupéré.
* - se rendort en l'attente d'un nouvel évènement, dans le cas
* contraire.
*
* Pour plus d'informations sur les différents types d'évènements et leurs
* liens avec les paramètres de la fonction, veuillez consulter la
* documentation de la fonction MLV_get_event().
*
* L'utilisateur n'est pas obligé d'utiliser un champs s'il
* n'en a pas l'utilité. Dans ce cas, il peut mettre la valeur
* NULL et le paramètre est ignoré.
*
* \bug Voir les bugs de la fonction MLV_get_event().
*
* \param key_sym Code de la touche qui a été appuyée ou relachée. La valeur de
* ce champs est définie par l'énumération : MLV_Keyboard_button.
* \param key_mod Mode dans lequel se trouve le clavier lorsqu'une touche est
* appuyée ou relachée. La valeur de ce champs est définie par
* l'énumération : MLV_Keyboard_modifier.
* \param unicode Caractère codé en unicode de la lettre obtenue en combinant
* le code et le mode précédent
* \param texte Texte récupéré par la boîte de saisie. L'allocation est affecté par la
* la fonction elle même. La désallocation est à la charge de
* l'utilisateur.
* \param input_box La boîte de saisie qui a récupérée le texte
* \param mouse_x Coordonnée en X de la position de la souris
* \param mouse_y Coordonnée en Y de la position de la souris
* \param mouse_button Bouton de la souris qui a été appuyé ou relaché.
* Ce champs est défini par l'énumération MLV_Mouse_button.
* \param state Etat de la touche concernée par l'évènement. La valeur de ce
* champs est défini par l'énumération: MLV_Button_state.
*
* \return La fonction renvoie un entier codant le type de l'évènement qui
* a été récupéré.
*/
MLV_Event MLV_wait_event(
MLV_Keyboard_button* key_sym, MLV_Keyboard_modifier* key_mod, int* unicode,
char** texte, MLV_Input_box** input_box,
int* mouse_x, int* mouse_y, MLV_Mouse_button* mouse_button,
MLV_Button_state* state
);
/** \~french
* \brief Cette fonction suspends l'éxecution du programme jusqu'à ce qu'un
* évènement apparaît dans la file d'attente ou jusqu'à ce qu'un certain
* nombre de secondes se soient écoulées.
* Si le temps s'est complètement écoulé, la fonction renvoie MLV_NONE.
* Si un nouvel évènement apparaît et que les paramètres passés en arguments
* sont en rapport avec l'évènement récupéré, alors la fonction
* remplit les paramètres et renvoie un entier codant le type de
* l'évènement qui a été récupéré.
* Si un nouvel évènement apparaît et qu'il n'est pas en rapport
* avec les paramètres de la fonction, alors il se rendort dans
* l'attente d'un nouvel évènement ou de la fin du temps.
*
* Pour plus d'informations sur les différents types d'évènements et leurs
* liens avec les paramètres de la fonction, veuillez consulter la
* documentation de la fonction MLV_get_event().
*
* L'utilisateur n'est pas obligé d'utiliser un champs s'il
* n'en a pas l'utilité. Dans ce cas, il peut mettre la valeur
* NULL. Le champs est alors ignoré.
*
* \bug Voir les bugs de la fonction MLV_get_event().
*
* \param key_sym Code de la touche qui a été appuyée ou relachée. La valeur de
* ce champs est définie par l'énumération : MLV_Keyboard_button.
* \param key_mod Mode dans lequel se trouve le clavier lorsqu'une touche est
* appuyée ou relachée. La valeur de ce champs est définie par
* l'énumération : MLV_Keyboard_modifier.
* \param unicode Caractère codé en unicode de la lettre obtenue en combinant
* le code et le mode précédent
* \param texte Texte récupéré par la boîte de saisie. L'allocation est affecté par la
* la fonction elle même. La désallocation est à la charge de
* l'utilisateur.
* \param input_box La boîte de saisie qui a récupérée le texte
* \param mouse_x Coordonnée en X de la position de la souris
* \param mouse_y Coordonnée en Y de la position de la souris
* \param mouse_button Bouton de la souris qui a été appuyé ou relaché.
* Ce champs est défini par l'énumération MLV_Mouse_button.
* \param state Etat de la touche concernée par l'évènement. La valeur de ce
* champs est défini par l'énumération: MLV_Button_state.
* \param seconds Nombre de secondes à attendre avant de terminer l'execution de
* la fonction en renvoyant MLV_NONE.
* \return La fonction renvoie un entier codant le type de l'évènement qui
* a été récupéré ou MLV_NONE si le temps s'est écoulé.
*/
MLV_Event MLV_wait_event_or_seconds(
MLV_Keyboard_button* key_sym, MLV_Keyboard_modifier* key_mod, int* unicode,
char** texte, MLV_Input_box** input_box,
int* mouse_x, int* mouse_y, MLV_Mouse_button* mouse_button,
MLV_Button_state* state, int seconds
);
/** \~french
* \brief Cette fonction vide la file d'évènements.
*
*/
void MLV_flush_event_queue();
/** \~french
* \brief Suspend l'exécution jusqu'à ce que l'utilisateur appuie sur une touche
* du clavier ou sur le bouton gauche de la souris.
*
* Cette fonction renvoie un entier codant le type de l'évènement qui a été
* récupéré ( clavier ou souris )
*
* Lorsque l'utilisateur appuie sur une touche, la fonction retourne trois
* valeurs ( sym, mod et unicode ) correspondant respectivement au code de la
* touche, au mode dans lequel se trouve le clavier (majuscule etc ...) et au
* caractère unicode correspondnant obtenu en combinant le mode du clavier et le
* code de la touche appuyée.
*
* Lorsque l'utilisateur appuie sur le bouton gauche de la souris, la fonction
* remplit les parametres correspondant aux coordonnées en X et Y de la position
* de la souris sur l'écran.
*
* \bug Voir les bugs de la fonction MLV_get_event().
*
* \param sym Code de la touche qui a été appuyée ou relachée. La valeur de ce
* champs est définie par l'énumération : MLV_Keyboard_button.
* \param mod Mode dans lequel se trouve le clavier lorsqu'une touche est
* appuyée ou relachée. La valeur de ce champs est définie par
* l'énumération : MLV_Keyboard_modifier.
* \param unicode Caractère codé en unicode de la lettre obtenue en combinant
* le code et le mode précédent
* \param mouse_x Coordonnée en X de la position de la souris
* \param mouse_y Coordonnée en Y de la position de la souris
* \return un entier codant le type de l'évènement qui a été récupéré ( MLV_KEY
* ou MLV_MOUSE_BUTTON )
*/
MLV_Event MLV_wait_keyboard_or_mouse(
MLV_Keyboard_button* sym, MLV_Keyboard_modifier* mod, int* unicode,
int* mouse_x, int* mouse_y
);
/** \~french
* \brief Suspend l'exécution jusqu'à ce que l'utilisateur appuie sur une touche
* du clavier, sur le bouton gauche de la souris ou qu'un certain nombre
* de secondes passées en paramètres se soient écoulées.
*
* Cette fonction renvoie un entier codant le type de l'évènement qui a été
* récupéré ( clavier, souris ou aucun des deux ).
*
* Voir les fonctions MLV_wait_keyboard_seconds() et MLV_wait_mouse_seconds()
* pour plus d'informations.
*
* \bug Voir les bugs de la fonction MLV_get_event().
*
* \param sym Code de la touche qui a été appuyée ou relachée. La valeur de ce
* champs est définie par l'énumération : MLV_Keyboard_button.
* \param mod Mode dans lequel se trouve le clavier lorsqu'une touche est
* appuyée ou relachée. La valeur de ce champs est définie par
* l'énumération : MLV_Keyboard_modifier.
* \param unicode Caractère codé en unicode de la lettre obtenue en combinant le
* code et le mode précédent
* \param mouse_x Coordonnée en X de la position de la souris
* \param mouse_y Coordonnée en Y de la position de la souris
* \param seconds Le nombre de seconde à attendre avant d'arrêter la fonction
* \return un entier codant le type de l'évènement qui a été récupéré ( MLV_KEY
* ou MLV_MOUSE_BUTTON ), ou MLV_NONE si le temps s'est écoulé.
*/
MLV_Event MLV_wait_keyboard_or_mouse_or_seconds(
MLV_Keyboard_button* sym, MLV_Keyboard_modifier* mod, int* unicode,
int* mouse_x, int* mouse_y,
int seconds
);
/** \~french
* \brief Convertit le code d'un évènement en une chaîne de caractères.
*
* \param event_code le code de l'évènement
* \return La chaîne de caractères associée au code de l'évènement.
*/
const char* MLV_convert_event_to_string( MLV_Event event_code );
/** \~french
* \brief Convertit le nom d'un évènement en son code associé.
*
* \param event_string le nom de l'évènement.
* \return Le code de l'évènement associé à la chaîne de caractères.
*/
MLV_Event MLV_convert_string_to_event( const char* event_string );
/** \~french
* \brief Convertit le code d'un état en une chaîne de caractères.
*
* \param state_code le code de l'état
* \return La chaîne de caractères associée au code de l'état.
*/
const char* MLV_convert_button_state_to_string( MLV_Button_state state_code );
/** \~french
* \brief Convertit le nom d'un état en son code associé.
*
* \param state_string le nom de l'état.
* \return Le code de l'état associé à la chaîne de caractères.
*/
MLV_Button_state MLV_convert_string_to_button_state( const char* state_string );
#ifdef __cplusplus
}
#endif
#endif

623
MLV/MLV_image.h
View File

@@ -1,623 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_image.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit tous les prototypes concernant les fonctions
* permettant d'insérer des images.
*/
#ifndef __MLV__MLV_IMAGE_H__
#define __MLV__MLV_IMAGE_H__
#include "MLV_color.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Définit le type Image dans la bibliothèque MLV.
*
* Une image dans la bibliothèque MLV est un tableau à deux dimentions
* dont chaque entée contient une couleur (voir MLV_Color).
* Nous rapellons que dans MLV les couleurs sont définies à l'aide de 4
* entiers compris entre 0 et 256 exclu, que l'on appelle composantes :
* - la composante Rouge ( R );
* - la composante Verte ( G );
* - la composant Blue ( B );
* - la composante Alpha, c'est la transparence ( A ).
*
*/
typedef struct _MLV_Image MLV_Image;
/** \~french
* \brief Charge en mémoire une image contenue dans un fichier.
*
* Cette fonction permet de charger les images des formats suivants:
* ICO(Icon)/CUR(Cursor)/BMP, PNM (PPM/PGM/PBM), XPM, LBM(IFF ILBM), PCX, GIF,
* JPEG, PNG, TGA, TIFF, and XV.
*
* \bug Cette fonction provoque une erreur de segmentation si elle est utilisée
* avant MLV_create_window(). Pour l'instant, nous vous conseillons
* d'utiliser cette fonction apres MLV_create_window().
*
* \bug Il est possible que cette fonction n'arrive pas à charger correctement
* les images qui ne sont pas en 32 bits (RGBA) - bug à tester.
*
* \bug BUG PRESENT SOUS WINDOWS ET MACOS X : Lorsque la composante alpha d'un
* pixel est à 0, MLV_load_image met à 0 les composantes Rouge, Verte
* et bleue du pixel associé. Ce bug provient de la bibliothèque SDL_image.
*
* \param file_image Chemin d'accès du fichier contenant l'image.
* \return L'image chargée.
*/
MLV_Image* MLV_load_image( const char* file_image );
/** \~french
* \brief Sauvegarde une image dans une fichier BMP.
*
* \bug Cette fonction ne sauvegarde pas la composante alpha.
*
* \param image Image à sauvegarder
* \param file_image Chemin d'accès du fichier contenant l'image.
* \return 0 si c'est un succés, -1 s'il y a eut une erreur.
*/
int MLV_save_image_as_bmp( const MLV_Image* image, const char* file_image );
/** \~french
* \brief Créer une image de composante alpha opaque.
*
* \param width Largeur de l'image
* \param height Hauteur de l'image
* \return L'image créé.
*/
MLV_Image* MLV_create_image( int width, int height );
/** \~french
* \brief Libère la mémoire utilisée par l'image.
*
* \param image Image à supprimer de la mémoire
*/
void MLV_free_image( MLV_Image *image );
/** \~french
* \brief Copie une image.
*
* Cette fonction créé une nouvelle image qui est la copie conforme de l'image
* passée en paramètre.
* La gestion de la mémoire de l'image créée est laissée à l'utilisateur.
*
* \param image L'image à copier.
* \return La copie de l'image.
*/
MLV_Image* MLV_copy_image( const MLV_Image* image );
/** \~french
* \brief Copie une partie de l'image.
*
* Cette fonction créé une nouvelle image qui est la copie conforme d'une partie
* de l'image passée en paramètre.
* La gestion de la mémoire de l'image créée est laissée à l'utilisateur.
*
* \param image L'image à copier.
* \param x Abscisse du sommet Nord-Ouest de la partie de l'image à copier
* \param y Ordonnée du sommet Nord-Ouest de la partie de l'image à copier
* \param width Largeur de la partie de l'image à copier
* \param height Hauteur de la partie de l'image à copier
* \return La copie de l'image.
*/
MLV_Image* MLV_copy_partial_image(
const MLV_Image* image, int x, int y, int width, int height
);
/** \~french
* \brief Retourne la taille d'une image donnée.
*
* \param image L'image pour laquelle la fonction doit retourner sa taille.
* \param width La largeur de l'image.
* \param height La hauteur de l'image.
*/
void MLV_get_image_size( const MLV_Image* image, int* width, int* height );
/** \~french
* \brief Retourne la largeur d'une image donnée.
*
* \param image L'image à analyser.
* \return La largeur de l'image.
*/
int MLV_get_image_width( const MLV_Image* image );
/** \~french
* \brief Retourne la hauteur d'une image donnée.
*
* \param image L'image à analyser.
* \return La hauteur de l'image
*/
int MLV_get_image_height( const MLV_Image* image );
/** \~french
* \brief Redimensionne l'image en ne respectant pas les proportions de l'image
* originale.
*
* La hauteur et la largeur de la nouvelle image deviennent respectivement la
* hauteur et la largeur passées en paramètres.
*
* \param image L'image à redimentionner.
* \param width La largeur de l'image.
* \param height La hauteur de l'image.
*/
void MLV_resize_image( MLV_Image* image, int width, int height );
/** \~french
* \brief Modifie l'image en réalisant une réflexion verticale.
*
* \param image L'image à modifier.
*/
void MLV_vertical_image_mirror( MLV_Image* image );
/** \~french
* \brief Modifie l'image en réalisant une réflexion horizontale.
*
* \param image L'image à modifier.
*/
void MLV_horizontal_image_mirror( MLV_Image* image );
/** \~french
* \brief Cette fonction redimensionne l'image en repsectant les proportions
* de l'image originale.
*
* L'image résultat est la plus grande image possible incluse dans le rectangle
* de largeur width et de hauteur height.
*
* L'utilisateur peut entrer un entier négatif pour les champs width et height.
* Ces champs ne sont alors pas pris en compte dans le redimensionnement de
* l'image. Dans ce cas, si le paramètre width (resp. height) est
* négatif, alors l'image finale aura pour largeur (resp. hauteur) la taille
* spécifiée dans le paramètre width (resp. height).
*
* \param image L'image à redimentionner.
* \param width La nouvelle largeur de l'image.
* \param height La nouvlle hauteur de l'image.
*/
void MLV_resize_image_with_proportions(
MLV_Image* image, int width, int height
);
/** \~french
* \brief Modifie l'image à l'aide d'une homotétie ( Étire l'image )
*
* \param image L'image à modifier.
* \param scalar Coefficient de proportionalité de l'homotétie ( >1 l'image est
* agrandie, <1 l'image est rétrécie ).
*/
void MLV_scale_image( MLV_Image* image, double scalar );
/** \~french
* \brief Éffectue une rotation sur une image donnée.
*
* \param image L'image à modifier.
* \param rotation L'angle de la rotation.
*/
void MLV_rotate_image( MLV_Image* image, double rotation );
/** \~french
* \brief Éffectue une rotation suivie d'une homotétie
*
* \param image L'image à modifier.
* \param rotation L'angle de la rotation.
* \param scalar Le coéfficient de proportionnalité de l'homotétie.
*/
void MLV_rotate_and_scale_image( MLV_Image* image, double rotation, double scalar );
/** \~french
* \brief Étire l'image suivant l'axe X et l'axe Y avec des coefficients de
* proportionnalité différents pour les deux axes.
*
* \param image L'image à modifier.
* \param scalar_x Le coéfficient de proportionnalité de l'axe X.
* \param scalar_y Le coéfficient de proportionnalité de l'axe Y.
*/
void MLV_scale_xy_image( MLV_Image* image, double scalar_x, double scalar_y );
/** \~french
* \brief Éffectue une rotation, puis étire l'image suivant l'axe X et l'axe Y
* avec des coefficients de proportionnalité différents pour les deux
* axes.
*
* \param image L'image à modifier.
* \param rotation L'angle de la rotaiton.
* \param scalar_x Le coéfficient de proportionnalité de l'axe X.
* \param scalar_y Le coéfficient de proportionnalité de l'axe Y.
*
*/
void MLV_rotate_and_scale_xy_image(
MLV_Image* image, double rotation, double scalar_x, double scalar_y
);
/** \~french
* \brief Dessine une image donnée à une position donnée de la fenêtre.
*
* \param image Image à dessiner.
* \param x Coordonnée en X de la position dans la fenêtre de sommet Nord-Ouest
* de l'image.
* \param y Coordonnée en Y de la position dans la fenêtre du sommet Nord-Ouest
* de l'image.
*/
void MLV_draw_image( const MLV_Image *image, int x, int y );
/** \~french
* \brief Dessine une partie d'une image donnée à une position donnée sur la
* fenêtre.
* \param image L'image à afficher sur la fenêtre
* \param x_source La coordonnée en X du sommet Nord-Ouest de la partie de
* l'image à afficher.
* \param y_source La coordonnée en Y du sommet Nord-Ouest de la partie de
* l'image à afficher.
* \param width_source La largeur de la partie de l'image à afficher.
* \param height_source La hauteur de la partie de l'image à afficher.
* \param x Coordonnée en X de la position dans la fenêtre du sommet Nord-Ouest
* de la partie de l'image à afficher.
* \param y Coordonnée en Y de la position dans la fenêtre du sommet Nord-Ouest
* de la partie de l'image à afficher.
*/
void MLV_draw_partial_image(
const MLV_Image *image, int x_source, int y_source,
int width_source, int height_source,
int x, int y
);
/** \~french
* \brief La composante alpha de l'image est remplacée par une composante
* alpha homogène dont la valeur est donnée en paramètre.
*
* La transparence joue un role lorsqu'une image est dessinée à l'écran, ou
* lorsqu'une image est recopiée à l'intérieure d'une autre image.
* Lorsque l'on recopie une image, les pixels du résultat final sont obtenus en
* faisant un barycentre entre le pixel de l'image source avec celui de l'image
* destination. Les poids des barycentres sont définis par la composante
* transparente ( composante alpha ) de l'image source.
* La transparence de l'image destination reste inchangée.
*
* Par exemple,
* \verbatim
couleur pixel source : RGBA( 60,80,100,128 )
couleur destination : RGBA( 0,20,40,30 )
couleur final après recopie :
RGBA(
barycentre( 60, 128, 0, 256-128 ),
barycentre( 80, 128, 20, 256-128 ),
barycentre( 100, 128, 40, 256-128 ),
30
) =
RGBA(
( 60 * 128 + 0 * (256-128) ) / 256,
( 80 * 128 + 20 * (256-128) ) / 256,
( 100 * 128 + 40 * (256-128) ) / 256,
30
) =
RGBA( 30, 50, 70, 30 )
\endverbatim
*
* \param image L'image à modifier.
* \param alpha La nouvelle composante alpha de l'image.
*/
void MLV_set_alpha_on_image( MLV_Alpha alpha, MLV_Image *image );
/** \~french
*
* \brief Écrase les composantes rouge, bleue, vert et alpha d'un pixel par
* celles passées en paramètre de la fonction.
*
* \param x La coordonnée en x du pixel à modifier.
* \param y La coordonnée en y du pixel à modifier.
* \param color La nouvelle couleur du pixel.
* \param image L'image à modifier.
*/
void MLV_set_pixel_on_image(
int x, int y,
MLV_Color color,
MLV_Image *image
);
/** \~french
* \brief Renvoie la couleur du pixel de l'écran pour une position donnée.
*
* Les paramètres red, blue, green et alpha peuvent être égaux à 0. Dans ce
* cas, ils sont ignorés.
*
* \param x Coordonnée en X de la position du pixel.
* \param y Coordonnée en Y de la position du pixel.
* \param red Composante rouge du pixel.
* \param green Composante verte du pixel.
* \param blue Composante bleue du pixel.
* \param alpha Composante alpha (transparence) du pixel.
*/
void MLV_get_pixel(
int x, int y, int* red, int* green, int* blue, int* alpha
);
/** \~french
* \brief Renvoie la couleur du pixel présent à une position donnée d'une image
* donnée.
*
* Les paramètres red, blue, green et alpha peuvent être égaux à NULL. Dans ce
* cas, ils sont ignorés.
*
* \param image Image à inspecter.
* \param x Coordonnée en X de la position du pixel à inspecter.
* \param y Coordonnée en Y de la position du pixel à inspecter.
* \param red Composante rouge du pixel.
* \param green Composante verte du pixel.
* \param blue Composante bleue du pixel.
* \param alpha Composante alpha (transparence) du pixel.
*/
void MLV_get_pixel_on_image(
const MLV_Image* image, int x, int y,
int* red, int* green, int* blue, int* alpha
);
/** \~french
* \brief Dessine une image dans une image destination
*
* \param source_image Image source
* \param source_x Abscisse du sommet nord-Ouest de la position de la portion
* d'image à recopier
* \param source_y Ordonné du sommet nord-Ouest de la position de la portion
* d'image à recopier
* \param width Largeur de la position à recopier
* \param height Hauteur de la position à recopier
* \param destination_image Image destination
* \param destination_x Abscisse de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
* \param destination_y Ordonnée de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
*/
void MLV_draw_partial_image_on_image(
const MLV_Image* source_image,
int source_x, int source_y,
int width, int height,
MLV_Image* destination_image,
int destination_x, int destination_y
);
/** \~french
* \brief Dessine une image dans une image destination
*
* \param source_image Image source
* \param destination_image Image destination
* \param destination_x Abscisse de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
* \param destination_y Ordonnée de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
*/
void MLV_draw_image_on_image(
const MLV_Image* source_image,
MLV_Image* destination_image,
int destination_x, int destination_y
);
/** \~french
* \brief Renvoie les données internes de l'image.
*
* Cette fonction renvoie un pointeur vers la structure de donnée
* de la libriaire SDL codant une image.
*
* N'utilisez cette fonction que si vous souhaitez effectuer une opération
* sur une image qui n'existe pas dans la bibliothèque MLV.
* En effet, modifier les données internes d'une image de type MLV_Image
* peut corrompre le fonctionnement de la bibliothèque MLV.
*
* Vous pouvez alors utiliser les routines de la lirairie SDL pour
* modifier l'image. (http://libsdl.org)
*
* Voici un exemple de code montrant comment il est possible de récupérer les
* composantes rouge, vert, bleu et alpha du pixel (3,4) de l'image.
*
* \code
* int x=3, y=4;
*
* SDL_Surface* surface = MLV_get_image_data( image );
* Uint32 red, blue, green, alpha;
*
* // Extracting color components from a 32-bit color value
* SDL_PixelFormat *fmt;
* Uint32 pixel;
*
* SDL_LockSurface(surface);
* fmt = surface->format;
* pixel = *(((Uint32*) surface->pixels)+ y*surface->pitch/4 + x );
*
* // Get Red component
* red = pixel & fmt->Rmask; // Isolate red component
* red = red >> fmt->Rshift; // Shift it down to 8-bit
* red = red << fmt->Rloss; // Expand to a full 8-bit number
*
* // Get Green component
* green = pixel & fmt->Gmask; // Isolate green component
* green = green >> fmt->Gshift; // Shift it down to 8-bit
* green = green << fmt->Gloss; // Expand to a full 8-bit number
*
* // Get Blue component
* blue = pixel & fmt->Bmask; // Isolate blue component
* blue = blue >> fmt->Bshift; // Shift it down to 8-bit
* blue = blue << fmt->Bloss; // Expand to a full 8-bit number
*
* // Get Alpha component
* alpha = pixel & fmt->Amask; // Isolate alpha component
* alpha = alpha >> fmt->Ashift; // Shift it down to 8-bit
* alpha = alpha << fmt->Aloss; // Expand to a full 8-bit number
*
* MLV_unlock_image( image );
* \endcode
*
* \param image L'image dont vous souhaitez récuperer les données internes.
* \return un pointeur vers une image de la bibliothèque SDL.
*/
SDL_Surface* MLV_get_image_data( MLV_Image* image );
/** \~french
* \brief Enregistre l'image de l'écran dans un presse papier interne à la
* bibliothèque MLV..
*
*/
void MLV_save_screen();
/** \~french
* \brief Charge l'image présent dans le presse papier interne de la bibliothèque
* MLV.
*
*/
void MLV_load_screen();
// TODO
#if 0
/** \~french
* \brief Enmére différents types d'opérations mathématiques.
*
*/
typedef enum {
MLV_NONE,
MLV_REPLACE,
MLV_MAX,
MLV_MIN,
MLV_BARYCENTER
} MLV_Mathematic_operations;
/** \~french
* \brief Dessine une image dans une image destination
*
* Cette fonction offre diférentes façon de dessiner une image
* dans une autre.
* Ces différentes façon concerne d'une part les couveh RGB
* ( rouge-vert-bleue) de l'image et d'autre part la couche alpha
* Les différentes façons sont décrites par les paramètres : rgb_treatment
* et alpha_treatment
* Voici un tableau récapitulatif des effets obtenus
* Opération ........ Éffet
* MLV_NONE ........ Les composante destination sont laissée intactes
* MLV_REPLACE ..... Les composantes contenues dans l'image destinatiion sont
* remplacées par celle de l'image source
* MLV_MAX ......... La composante maximale entre source et destination est
* stocké dans l'image destination
* MLV_MIN ......... La composante minimale entre source et destination est
* stocké dans l'image destination
* MLV_BARYCENTER .. Cette opération n'est définit que pour les composantes
* RGB. La composane destination est obtenu en faisant un
* barycentre entre l'image source et l'image destination
* en utilisant la composante alpha de l'image source.
*
*
* \param source_image Image source
* \param source_x Abscisse du sommet nord-Ouest de la position de la portion
* d'image à recopier
* \param source_y Ordonné du sommet nord-Ouest de la position de la portion
* d'image à recopier
* \param with Largeur de la position à recopier
* \param height Hauteur de la position à recopier
* \param destination_image Image destination
* \param destination_x Abscisse de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
* \param destination_y Ordonnée de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
* \param rgb_treatment Opération mathématique à appliquer pour traiter les
* composantes RGB de l'image
* \param alpha_treatment Opération mathématique à appliquer pour traiter la
* composante alpha de l'image
*/
void MLV_draw_partial_image_on_image(
const MLV_Image* source_image,
int source_x, int source_y,
int with, int height,
MLV_Image* destination_image,
int destination_x, int destination_y,
MLV_Mathematic_operations rgb_treatment,
MLV_Mathematic_operations alpha_treatment
);
/** \~french
* \brief Dessine une image dans une image destination en utilisant
* l'accélération de la carte graphique.
*
* Les couleurs RGB des images sources et destinations sont mélangé suivant
* les proportions préssentes dans la couches alpha de l'image" source.
* Par exemple, si pour un pixel de l'image, la composant alpha
* vaut 200, alors le pixal final sera composé à 200/255 de la couleur de
* l'image source et de 255-200/255 = 55/200 de l'image destination.
* La composant alpha de l'image destination reste inchangée.
*
* Cette opération est identique à
* MLV_draw_partial_image_on_image(
* X,X,X,X,X,X,X,X,
* MLV_BARYCENTER,
* MLV_NONE,
* );
* Cependant, MLV_draw_partial_image_on_image_FAST est un opération
* qui bénéficie d'optimisation par la carte graphique.
*
* \param source_image Image source
* \param source_x Abscisse du sommet nord-Ouest de la position de la portion
* d'image à recopier
* \param source_y Ordonné du sommet nord-Ouest de la position de la portion
* d'image à recopier
* \param with Largeur de la position à recopier
* \param height Hauteur de la position à recopier
* \param destination_image Image destination
* \param destination_x Abscisse de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
* \param destination_y Ordonnée de la position où devra être recopier l'image.
* Il s'agit de la futur position du sommet nord-Ouest de
* la portion d'image à recopier.
*/
void MLV_draw_partial_image_on_image_FAST(
const MLV_Image* source_image,
int source_x, int source_y,
int with, int height,
const MLV_Image* destination_image,
int destination_x, int destination_y
);
#endif
/* TODO : A Vérifier !
void MLV_draw_rotated_image( MLV_Image *image, int x, int y, double rotation );
void MLV_draw_scaled_image( MLV_Image *image, int x, int y, double scalar );
void MLV_draw_scaled_rotated_image( MLV_Image *image, int x, int y, double roation, double scalar );
*/
#ifdef __cplusplus
}
#endif
#endif

98
MLV/MLV_information.h
View File

@@ -1,98 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_information.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant de récupérer
* des informations sur la bibliothèque.
*/
#ifndef __MLV__MLV_INFORMATIONS_H__
#define __MLV__MLV_INFORMATIONS_H__
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Renvoie le nom de la bibliothèque.
*
* \return Le nom de la bibliothèque.
*/
const char* MLV_get_package_name( );
/** \~french
* \brief Renvoie la version de la bibliothèque
*
* \return La version de la bibliothèque.
*/
const char* MLV_get_version( );
/** \~french
* \brief Renvoie la révision du dépot du logiciel de gestion de version de
* mlv.
*
* \return La révision du dépot du logiciel de gestion de version de mlv.
*/
const char* MLV_get_revision_of_revision_control_software( );
/** \~french
* \brief Renvoie l'adresse du dépot de code source où se trouve la
* bibliothèque.
*
* \return Le dépôt de la bibliothèque.
*/
const char* MLV_get_repository( );
/** \~french
* \brief Renvoie l'addresse mail à laquelle vous pouvez envoyer les bugs que
* vous rencontrez.
*
* \return L'addresse mail.
*/
const char* MLV_get_bug_report_address( );
/** \~french
* \brief Renvoie le nom de la licence de la bibliothèque.
*
* \return Le nom de la licence de la bibliothèque.
*/
const char* MLV_get_licence( );
/** \~french
* \brief Renvoie l'addresse internet où l'on peut trouver le code source de la
* bibliothèque.
*
* \return L'addresse internet où l'on peut trouver le code source de la
* bibliothèque.
*/
const char* MLV_get_web_distribution( );
#ifdef __cplusplus
}
#endif
#endif

317
MLV/MLV_input_box.h
View File

@@ -1,317 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_input_box.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant de
* demander à l'utilisateur du texte par l'intermédiaire de boîtes
* de saisie.
*
*/
#ifndef __MLV__MLV_INPUT_BOX_H__
#define __MLV__MLV_INPUT_BOX_H__
#include "MLV_color.h"
#include "MLV_text.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Définition du type des boîtes de saisies
*
*/
typedef struct _MLV_Input_box MLV_Input_box;
/** \~french
*
* \brief Cette fonction suspend l'exécution du programme, affiche une boîte
* de saisie et attends que l'utilisateur rentre une phrase dans le
* champs de la boîte.
*
* La boîte de saisie contient deux zones de textes.
* La première zone ne peut pas être éditée par l'utilisateur et sert à
* afficher un message d'information.
* La deuxième est vide et peut être éditée par l'utilisateur.
* Lorsque l'utilisateur appuie sur la touche entrée, le texte qui
* se trouve dans la zone de texte est renvoyé par la fonction
* grâce au paramètre text.
* Le texte, la taille et les couleurs de la boîte de saisie sont
* paramétrables.
*
* MLV_wait_input_box() alloue lui même la mémoire associée au paramètre "text".
* Par contre, après utilisation, vous devez libérer l'espace mémoire qui a été
* alloué.
*
* \param sommetHautGaucheX La coordonnée en X du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetHautGaucheY La coordonnée en Y du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetBasDroitX La coordonnée en X du coin Sud-Est de la
* boîte de saisie.
* \param sommetBasDroitY La coordonnée en Y du coin Sud-Est de la
* boîte de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte de la boîte de saisie.
* \param backgroundColor La couleur de fond de la boîte de saisie.
* \param informativeMessage Le message à afficher devant la boîte de saisie.
* \param text L'addresse où sera placé la réponse donnée par
* l'utilisateur.
*/
void MLV_wait_input_box(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text, ...
);
/** \~french
*
* \brief Même chose que MLV_wait_input_box(), mais il est possible de
* changer la fonte du du texte.
*
* MLV_wait_input_box_with_font() alloue lui même la mémoire associée au
* paramètre "text".
* Par contre, après utilisation, vous devez libérer l'espace mémoire qui a
* été alloué.
*
* \param sommetHautGaucheX La coordonnée en X du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetHautGaucheY La coordonnée en Y du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetBasDroitX La coordonnée en X du coin Sud-Est de la boîte
* de saisie.
* \param sommetBasDroitY La coordonnée en Y du coin Sud-Est de la boîte
* de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte de la boîte de saisie.
* \param backgroundColor La couleur de fond de la boîte de saisie.
* \param informativeMessage Le message à afficher devant la boîte de saisie.
* \param text L'addresse où sera placé la réponse donnée par
* l'utilisateur.
* \param font La font du texte à utiliser.
*/
void MLV_wait_input_box_with_font(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text,
const MLV_Font* font, ...
);
/** \~french
* \brief Cette fonction suspend l'exécution du programme jusqu'à ce que
* l'utilisateur écrive une phrase dans le champs de la boîte de
* saisie passée en paramètre de la fonction.
*
* \param input_box La boîte de saisie qui doit être observée.
* \param text Le texte récupéré par la boîte de saisie.
*/
void MLV_wait_particular_input_box( MLV_Input_box* input_box, char** text);
/** \~french
* \brief Cette fonction créé une boîte de saisie.
*
* Une fois la boîte de saisie créé, si l'utilisateur clique sur la boîte
* de saisie, la boîte de saisie devient active.
* Cela veux dire que tout les évènements clavier sont récupérés par la
* boîte de saisie qui s'en sert pour enregistrer le texte tapé par
* l'utilisateur.
* De même, tout clique de souris réalisé sur la boîte de saisie est
* acaparé par la boîte de saisie.
*
* Pour dessiner une ou toutes les boîtes de saisies, dans la zone où vous
* les avez créées, vous devez utiliser les fonctions :
* - MLV_draw_input_box()
* - MLV_draw_all_input_boxes()
*
* \param sommetHautGaucheX La coordonnée en X du sommet Nord-Ouest de la boîte
* de saisie.
* \param sommetHautGaucheY La coordonnée en Y du sommet Nord-Ouest de la boîte
* de saisie.
* \param width La largeur de la boîte de saisie.
* \param height La hauteur de la boîte de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond.
* \param informativeMessage La message d'entête de la boîte de saisie.
*/
MLV_Input_box* MLV_create_input_box(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage, ...
);
/** \~french
* \brief Cette fonction créé une boîte de saisie avec une font spécifique.
*
* \param sommetHautGaucheX La coordonnée en X du sommet Nord-Ouest de la boîte de saisie.
* \param sommetHautGaucheY La coordonnée en Y du sommet Nord-Ouest de la boîte de saisie.
* \param width La largeur de la boîte de saisie.
* \param height La hauteur de la boîte de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond.
* \param informativeMessage Le message d'entête de la boîte de saisie.
* \param font La font à utiliser pour le texte.
*/
MLV_Input_box* MLV_create_input_box_with_font(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
const MLV_Font* font, ...
);
/** \~french
* \brief Cette fonction ferme une boîte de saisie précédement créée.
*
* L'espace mémoire allouée à la boîte de saisie est libéré.
*
* \param input_box La boîte de saisie à fermer.
*/
void MLV_free_input_box( MLV_Input_box* input_box );
/** \~french
* \brief Cette fonction change le message d'entête d'une boîte de saisie.
*
* \param input_box La boîte de saisie à modifier.
* \param message Le message d'entête.
*/
void MLV_change_informative_message_of_input_box(
MLV_Input_box* input_box, const char* message, ...
);
/** \~french
* \brief Cette fonction dessine une boîte de saisie particulière.
*
* \param input_box La boîte de saisie à dessiner.
*/
void MLV_draw_input_box( MLV_Input_box* input_box );
/** \~french
* \brief Cette fonction dessine tous les boîtes de saisies.
*
*/
void MLV_draw_all_input_boxes();
/** \~french
* \brief Cette fonction supprime l'historique d'une boîte de saisie.
*
* \param input_box La boîte de saisie dont l'histoirque doit être supprimé
*/
void MLV_suppress_history( MLV_Input_box* input_box );
/** \~french
* \brief Cette fonction change la taille et la position d'une boîte de saisie donnée en paramètre.
*
* \param input_box La boîte de saisie à modifier.
* \param sommetHautGaucheX La nouvelle coordonnée en X de la position du sommet
* Nord-Ouest de la boîte de saisie.
* \param sommetHautGaucheY La nouvelle coordonnée en Y de la position du sommet
* Nord-Ouest de la boîte de saisie.
* \param width La nouvelle largeur de la boîte de saisie.
* \param height La nouvelle hauteur de la boîte de saisie.
*/
void MLV_change_input_box_geometry(
MLV_Input_box* input_box, int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height
);
/** \~french
* \brief Cette fonction change la taille d'une boîte de saisie.
*
* \param input_box La boîte de saisie à modifier.
* \param width La nouvelle largeur de la boîte de saisie.
* \param height La nouvelle hauteur de la boîte de saisie.
*/
void MLV_change_input_box_size(MLV_Input_box* input_box, int width, int height);
/** \~french
* \brief Cette fonction change la position d'une boîte de saisie donnée en paramètre.
*
* \param input_box La boîte de saisie à modifier.
* \param sommetHautGaucheX La nouvelle coordonnée en X de la position du sommet
* Nord-Ouest de la boîte de saisie.
* \param sommetHautGaucheY La nouvelle coordonnée en Y de la position du sommet
* Nord-Ouest de la boîte de saisie.
*/
void MLV_change_input_box_position(
MLV_Input_box* input_box, int sommetHautGaucheX, int sommetHautGaucheY
);
/** \~french
* \brief Cette fonction change les différentes couleurs d'une boîte de saisie donnée
*
* \param input_box La boîte de saisie à modifier.
* \param borderColor La nouvelle couleur du bord de la boîte de saisie.
* \param textColor La nouvelle couleur du texte de la boîte de saisie.
* \param backgroundColor La nouvelle couleur de fond de la boîte de saisie.
*/
void MLV_change_input_box_colors(
MLV_Input_box* input_box, MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor
);
/** \~french
* \brief Cette fonction active une boîte de saisie.
*
* Cette opération agit comme si l'utilisateur avait cliqué sur la boîte de
* saisie en question (action qui rend active une boîte de saisie).
*
* Lorsque une boîte de saisie est active, les évènements du clavier sont
* récupérés par la boîte de saisie et sont utilisés pour enregistrer le
* texte tapé par l'utilisateur.
* Les cliques de souris sur la boîte de saisie sont aussi récupérés par
* la boîte de saisie.
*
* \param input_box La boîte de saisie à activer.
*/
void MLV_activate_input_box( MLV_Input_box* input_box );
/** \~french
* \brief Cette fonction désactive la boîte de saisie qui est active.
*
* Si il n'y a pas de boîte de saisie active, cette fonction ne fait rien.
*/
void MLV_desactivate_input_box( );
#ifdef __cplusplus
}
#endif
#endif

204
MLV/MLV_input_box_va.h
View File

@@ -1,204 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2013-2014 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_input_box_va.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant de
* demander à l'utilisateur du texte par l'intermédiaire de boîtes
* de saisie.
*
*/
#ifndef __MLV__MLV_INPUT_BOX_VA_H__
#define __MLV__MLV_INPUT_BOX_VA_H__
#include "MLV_color.h"
#include "MLV_text.h"
#include "MLV_input_box.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
*
* \brief Cette fonction suspend l'exécution du programme, affiche une boîte
* de saisie et attends que l'utilisateur rentre une phrase dans le
* champs de la boîte.
*
* La boîte de saisie contient deux zones de textes.
* La première zone ne peut pas être éditée par l'utilisateur et sert à
* afficher un message d'information.
* La deuxième est vide et peut être éditée par l'utilisateur.
* Lorsque l'utilisateur appuie sur la touche entrée, le texte qui
* se trouve dans la zone de texte est renvoyé par la fonction
* grâce au paramètre text.
* Le texte, la taille et les couleurs de la boîte de saisie sont
* paramétrables.
*
* MLV_wait_input_box() alloue lui même la mémoire associée au paramètre "text".
* Par contre, après utilisation, vous devez libérer l'espace mémoire qui a été
* alloué.
*
* \param sommetHautGaucheX La coordonnée en X du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetHautGaucheY La coordonnée en Y du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetBasDroitX La coordonnée en X du coin Sud-Est de la
* boîte de saisie.
* \param sommetBasDroitY La coordonnée en Y du coin Sud-Est de la
* boîte de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte de la boîte de saisie.
* \param backgroundColor La couleur de fond de la boîte de saisie.
* \param informativeMessage Le message à afficher devant la boîte de saisie.
* \param text L'addresse où sera placé la réponse donnée par
* l'utilisateur.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*/
void MLV_wait_input_box_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text,
va_list pile
);
/** \~french
*
* \brief Même chose que MLV_wait_input_box(), mais il est possible de
* changer la fonte du du texte.
*
* MLV_wait_input_box_with_font() alloue lui même la mémoire associée au
* paramètre "text".
* Par contre, après utilisation, vous devez libérer l'espace mémoire qui a
* été alloué.
*
* \param sommetHautGaucheX La coordonnée en X du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetHautGaucheY La coordonnée en Y du coin Nord-Ouest de la
* boîte de saisie.
* \param sommetBasDroitX La coordonnée en X du coin Sud-Est de la boîte
* de saisie.
* \param sommetBasDroitY La coordonnée en Y du coin Sud-Est de la boîte
* de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte de la boîte de saisie.
* \param backgroundColor La couleur de fond de la boîte de saisie.
* \param informativeMessage Le message à afficher devant la boîte de saisie.
* \param text L'addresse où sera placé la réponse donnée par
* l'utilisateur.
* \param font La font du texte à utiliser.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*/
void MLV_wait_input_box_with_font_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text,
const MLV_Font* font,
va_list pile
);
/** \~french
* \brief Cette fonction créé une boîte de saisie.
*
* Une fois la boîte de saisie créé, si l'utilisateur clique sur la boîte
* de saisie, la boîte de saisie devient active.
* Cela veux dire que tout les évènements clavier sont récupérés par la
* boîte de saisie qui s'en sert pour enregistrer le texte tapé par
* l'utilisateur.
* De même, tout clique de souris réalisé sur la boîte de saisie est
* acaparé par la boîte de saisie.
*
* Pour dessiner une ou toutes les boîtes de saisies, dans la zone où vous
* les avez créées, vous devez utiliser les fonctions :
* - MLV_draw_input_box()
* - MLV_draw_all_input_boxes()
*
* \param sommetHautGaucheX La coordonnée en X du sommet Nord-Ouest de la boîte
* de saisie.
* \param sommetHautGaucheY La coordonnée en Y du sommet Nord-Ouest de la boîte
* de saisie.
* \param width La largeur de la boîte de saisie.
* \param height La hauteur de la boîte de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond.
* \param informativeMessage La message d'entête de la boîte de saisie.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*/
MLV_Input_box* MLV_create_input_box_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
va_list pile
);
/** \~french
* \brief Cette fonction créé une boîte de saisie avec une font spécifique.
*
* \param sommetHautGaucheX La coordonnée en X du sommet Nord-Ouest de la boîte de saisie.
* \param sommetHautGaucheY La coordonnée en Y du sommet Nord-Ouest de la boîte de saisie.
* \param width La largeur de la boîte de saisie.
* \param height La hauteur de la boîte de saisie.
* \param borderColor La couleur de la bordure de la boîte de saisie.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond.
* \param informativeMessage Le message d'entête de la boîte de saisie.
* \param font La font à utiliser pour le texte.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*/
MLV_Input_box* MLV_create_input_box_with_font_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
const MLV_Font* font,
va_list pile
);
/** \~french
* \brief Cette fonction change le message d'entête d'une boîte de saisie.
*
* \param input_box La boîte de saisie à modifier.
* \param message Le message d'entête.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*/
void MLV_change_informative_message_of_input_box_va(
MLV_Input_box* input_box, const char* message, va_list pile
);
#ifdef __cplusplus
}
#endif
#endif

545
MLV/MLV_keyboard.h
View File

@@ -1,545 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_keyboard.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant
* d'utiliser le clavier.
*
*/
#ifndef __MLV__MLV_KEYBOARD_H__
#define __MLV__MLV_KEYBOARD_H__
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
#include "MLV_device_with_buttons.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Énumère l'ensemble des codes des touches du clavier
*/
typedef enum {
MLV_KEYBOARD_NONE = SDLK_UNKNOWN,
MLV_KEYBOARD_UNKNOWN = SDLK_UNKNOWN,
MLV_KEYBOARD_FIRST = SDLK_FIRST,
MLV_KEYBOARD_BACKSPACE = SDLK_BACKSPACE,
MLV_KEYBOARD_TAB = SDLK_TAB,
MLV_KEYBOARD_CLEAR = SDLK_CLEAR,
MLV_KEYBOARD_RETURN = SDLK_RETURN,
MLV_KEYBOARD_PAUSE = SDLK_PAUSE,
MLV_KEYBOARD_ESCAPE = SDLK_ESCAPE,
MLV_KEYBOARD_SPACE = SDLK_SPACE,
MLV_KEYBOARD_EXCLAIM = SDLK_EXCLAIM,
MLV_KEYBOARD_QUOTEDBL = SDLK_QUOTEDBL,
MLV_KEYBOARD_HASH = SDLK_HASH,
MLV_KEYBOARD_DOLLAR = SDLK_DOLLAR,
MLV_KEYBOARD_AMPERSAND = SDLK_AMPERSAND,
MLV_KEYBOARD_QUOTE = SDLK_QUOTE,
MLV_KEYBOARD_LEFTPAREN = SDLK_LEFTPAREN,
MLV_KEYBOARD_RIGHTPAREN = SDLK_RIGHTPAREN,
MLV_KEYBOARD_ASTERISK = SDLK_ASTERISK,
MLV_KEYBOARD_PLUS = SDLK_PLUS,
MLV_KEYBOARD_COMMA = SDLK_COMMA,
MLV_KEYBOARD_MINUS = SDLK_MINUS,
MLV_KEYBOARD_PERIOD = SDLK_PERIOD,
MLV_KEYBOARD_SLASH = SDLK_SLASH,
MLV_KEYBOARD_0 = SDLK_0,
MLV_KEYBOARD_1 = SDLK_1,
MLV_KEYBOARD_2 = SDLK_2,
MLV_KEYBOARD_3 = SDLK_3,
MLV_KEYBOARD_4 = SDLK_4,
MLV_KEYBOARD_5 = SDLK_5,
MLV_KEYBOARD_6 = SDLK_6,
MLV_KEYBOARD_7 = SDLK_7,
MLV_KEYBOARD_8 = SDLK_8,
MLV_KEYBOARD_9 = SDLK_9,
MLV_KEYBOARD_COLON = SDLK_COLON,
MLV_KEYBOARD_SEMICOLON = SDLK_SEMICOLON,
MLV_KEYBOARD_LESS = SDLK_LESS,
MLV_KEYBOARD_EQUALS = SDLK_EQUALS,
MLV_KEYBOARD_GREATER = SDLK_GREATER,
MLV_KEYBOARD_QUESTION = SDLK_QUESTION,
MLV_KEYBOARD_AT = SDLK_AT,
MLV_KEYBOARD_LEFTBRACKET = SDLK_LEFTBRACKET,
MLV_KEYBOARD_BACKSLASH = SDLK_BACKSLASH,
MLV_KEYBOARD_RIGHTBRACKET = SDLK_RIGHTBRACKET,
MLV_KEYBOARD_CARET = SDLK_CARET,
MLV_KEYBOARD_UNDERSCORE = SDLK_UNDERSCORE,
MLV_KEYBOARD_BACKQUOTE = SDLK_BACKQUOTE,
MLV_KEYBOARD_a = SDLK_a,
MLV_KEYBOARD_b = SDLK_b,
MLV_KEYBOARD_c = SDLK_c,
MLV_KEYBOARD_d = SDLK_d,
MLV_KEYBOARD_e = SDLK_e,
MLV_KEYBOARD_f = SDLK_f,
MLV_KEYBOARD_g = SDLK_g,
MLV_KEYBOARD_h = SDLK_h,
MLV_KEYBOARD_i = SDLK_i,
MLV_KEYBOARD_j = SDLK_j,
MLV_KEYBOARD_k = SDLK_k,
MLV_KEYBOARD_l = SDLK_l,
MLV_KEYBOARD_m = SDLK_m,
MLV_KEYBOARD_n = SDLK_n,
MLV_KEYBOARD_o = SDLK_o,
MLV_KEYBOARD_p = SDLK_p,
MLV_KEYBOARD_q = SDLK_q,
MLV_KEYBOARD_r = SDLK_r,
MLV_KEYBOARD_s = SDLK_s,
MLV_KEYBOARD_t = SDLK_t,
MLV_KEYBOARD_u = SDLK_u,
MLV_KEYBOARD_v = SDLK_v,
MLV_KEYBOARD_w = SDLK_w,
MLV_KEYBOARD_x = SDLK_x,
MLV_KEYBOARD_y = SDLK_y,
MLV_KEYBOARD_z = SDLK_z,
MLV_KEYBOARD_DELETE = SDLK_DELETE,
MLV_KEYBOARD_WORLD_0 = SDLK_WORLD_0,
MLV_KEYBOARD_WORLD_1 = SDLK_WORLD_1,
MLV_KEYBOARD_WORLD_2 = SDLK_WORLD_2,
MLV_KEYBOARD_WORLD_3 = SDLK_WORLD_3,
MLV_KEYBOARD_WORLD_4 = SDLK_WORLD_4,
MLV_KEYBOARD_WORLD_5 = SDLK_WORLD_5,
MLV_KEYBOARD_WORLD_6 = SDLK_WORLD_6,
MLV_KEYBOARD_WORLD_7 = SDLK_WORLD_7,
MLV_KEYBOARD_WORLD_8 = SDLK_WORLD_8,
MLV_KEYBOARD_WORLD_9 = SDLK_WORLD_9,
MLV_KEYBOARD_WORLD_10 = SDLK_WORLD_10,
MLV_KEYBOARD_WORLD_11 = SDLK_WORLD_11,
MLV_KEYBOARD_WORLD_12 = SDLK_WORLD_12,
MLV_KEYBOARD_WORLD_13 = SDLK_WORLD_13,
MLV_KEYBOARD_WORLD_14 = SDLK_WORLD_14,
MLV_KEYBOARD_WORLD_15 = SDLK_WORLD_15,
MLV_KEYBOARD_WORLD_16 = SDLK_WORLD_16,
MLV_KEYBOARD_WORLD_17 = SDLK_WORLD_17,
MLV_KEYBOARD_WORLD_18 = SDLK_WORLD_18,
MLV_KEYBOARD_WORLD_19 = SDLK_WORLD_19,
MLV_KEYBOARD_WORLD_20 = SDLK_WORLD_20,
MLV_KEYBOARD_WORLD_21 = SDLK_WORLD_21,
MLV_KEYBOARD_WORLD_22 = SDLK_WORLD_22,
MLV_KEYBOARD_WORLD_23 = SDLK_WORLD_23,
MLV_KEYBOARD_WORLD_24 = SDLK_WORLD_24,
MLV_KEYBOARD_WORLD_25 = SDLK_WORLD_25,
MLV_KEYBOARD_WORLD_26 = SDLK_WORLD_26,
MLV_KEYBOARD_WORLD_27 = SDLK_WORLD_27,
MLV_KEYBOARD_WORLD_28 = SDLK_WORLD_28,
MLV_KEYBOARD_WORLD_29 = SDLK_WORLD_29,
MLV_KEYBOARD_WORLD_30 = SDLK_WORLD_30,
MLV_KEYBOARD_WORLD_31 = SDLK_WORLD_31,
MLV_KEYBOARD_WORLD_32 = SDLK_WORLD_32,
MLV_KEYBOARD_WORLD_33 = SDLK_WORLD_33,
MLV_KEYBOARD_WORLD_34 = SDLK_WORLD_34,
MLV_KEYBOARD_WORLD_35 = SDLK_WORLD_35,
MLV_KEYBOARD_WORLD_36 = SDLK_WORLD_36,
MLV_KEYBOARD_WORLD_37 = SDLK_WORLD_37,
MLV_KEYBOARD_WORLD_38 = SDLK_WORLD_38,
MLV_KEYBOARD_WORLD_39 = SDLK_WORLD_39,
MLV_KEYBOARD_WORLD_40 = SDLK_WORLD_40,
MLV_KEYBOARD_WORLD_41 = SDLK_WORLD_41,
MLV_KEYBOARD_WORLD_42 = SDLK_WORLD_42,
MLV_KEYBOARD_WORLD_43 = SDLK_WORLD_43,
MLV_KEYBOARD_WORLD_44 = SDLK_WORLD_44,
MLV_KEYBOARD_WORLD_45 = SDLK_WORLD_45,
MLV_KEYBOARD_WORLD_46 = SDLK_WORLD_46,
MLV_KEYBOARD_WORLD_47 = SDLK_WORLD_47,
MLV_KEYBOARD_WORLD_48 = SDLK_WORLD_48,
MLV_KEYBOARD_WORLD_49 = SDLK_WORLD_49,
MLV_KEYBOARD_WORLD_50 = SDLK_WORLD_50,
MLV_KEYBOARD_WORLD_51 = SDLK_WORLD_51,
MLV_KEYBOARD_WORLD_52 = SDLK_WORLD_52,
MLV_KEYBOARD_WORLD_53 = SDLK_WORLD_53,
MLV_KEYBOARD_WORLD_54 = SDLK_WORLD_54,
MLV_KEYBOARD_WORLD_55 = SDLK_WORLD_55,
MLV_KEYBOARD_WORLD_56 = SDLK_WORLD_56,
MLV_KEYBOARD_WORLD_57 = SDLK_WORLD_57,
MLV_KEYBOARD_WORLD_58 = SDLK_WORLD_58,
MLV_KEYBOARD_WORLD_59 = SDLK_WORLD_59,
MLV_KEYBOARD_WORLD_60 = SDLK_WORLD_60,
MLV_KEYBOARD_WORLD_61 = SDLK_WORLD_61,
MLV_KEYBOARD_WORLD_62 = SDLK_WORLD_62,
MLV_KEYBOARD_WORLD_63 = SDLK_WORLD_63,
MLV_KEYBOARD_WORLD_64 = SDLK_WORLD_64,
MLV_KEYBOARD_WORLD_65 = SDLK_WORLD_65,
MLV_KEYBOARD_WORLD_66 = SDLK_WORLD_66,
MLV_KEYBOARD_WORLD_67 = SDLK_WORLD_67,
MLV_KEYBOARD_WORLD_68 = SDLK_WORLD_68,
MLV_KEYBOARD_WORLD_69 = SDLK_WORLD_69,
MLV_KEYBOARD_WORLD_70 = SDLK_WORLD_70,
MLV_KEYBOARD_WORLD_71 = SDLK_WORLD_71,
MLV_KEYBOARD_WORLD_72 = SDLK_WORLD_72,
MLV_KEYBOARD_WORLD_73 = SDLK_WORLD_73,
MLV_KEYBOARD_WORLD_74 = SDLK_WORLD_74,
MLV_KEYBOARD_WORLD_75 = SDLK_WORLD_75,
MLV_KEYBOARD_WORLD_76 = SDLK_WORLD_76,
MLV_KEYBOARD_WORLD_77 = SDLK_WORLD_77,
MLV_KEYBOARD_WORLD_78 = SDLK_WORLD_78,
MLV_KEYBOARD_WORLD_79 = SDLK_WORLD_79,
MLV_KEYBOARD_WORLD_80 = SDLK_WORLD_80,
MLV_KEYBOARD_WORLD_81 = SDLK_WORLD_81,
MLV_KEYBOARD_WORLD_82 = SDLK_WORLD_82,
MLV_KEYBOARD_WORLD_83 = SDLK_WORLD_83,
MLV_KEYBOARD_WORLD_84 = SDLK_WORLD_84,
MLV_KEYBOARD_WORLD_85 = SDLK_WORLD_85,
MLV_KEYBOARD_WORLD_86 = SDLK_WORLD_86,
MLV_KEYBOARD_WORLD_87 = SDLK_WORLD_87,
MLV_KEYBOARD_WORLD_88 = SDLK_WORLD_88,
MLV_KEYBOARD_WORLD_89 = SDLK_WORLD_89,
MLV_KEYBOARD_WORLD_90 = SDLK_WORLD_90,
MLV_KEYBOARD_WORLD_91 = SDLK_WORLD_91,
MLV_KEYBOARD_WORLD_92 = SDLK_WORLD_92,
MLV_KEYBOARD_WORLD_93 = SDLK_WORLD_93,
MLV_KEYBOARD_WORLD_94 = SDLK_WORLD_94,
MLV_KEYBOARD_WORLD_95 = SDLK_WORLD_95,
MLV_KEYBOARD_KP0 = SDLK_KP0,
MLV_KEYBOARD_KP1 = SDLK_KP1,
MLV_KEYBOARD_KP2 = SDLK_KP2,
MLV_KEYBOARD_KP3 = SDLK_KP3,
MLV_KEYBOARD_KP4 = SDLK_KP4,
MLV_KEYBOARD_KP5 = SDLK_KP5,
MLV_KEYBOARD_KP6 = SDLK_KP6,
MLV_KEYBOARD_KP7 = SDLK_KP7,
MLV_KEYBOARD_KP8 = SDLK_KP8,
MLV_KEYBOARD_KP9 = SDLK_KP9,
MLV_KEYBOARD_KP_PERIOD = SDLK_KP_PERIOD,
MLV_KEYBOARD_KP_DIVIDE = SDLK_KP_DIVIDE,
MLV_KEYBOARD_KP_MULTIPLY = SDLK_KP_MULTIPLY,
MLV_KEYBOARD_KP_MINUS = SDLK_KP_MINUS,
MLV_KEYBOARD_KP_PLUS = SDLK_KP_PLUS,
MLV_KEYBOARD_KP_ENTER = SDLK_KP_ENTER,
MLV_KEYBOARD_KP_EQUALS = SDLK_KP_EQUALS,
MLV_KEYBOARD_UP = SDLK_UP,
MLV_KEYBOARD_DOWN = SDLK_DOWN,
MLV_KEYBOARD_RIGHT = SDLK_RIGHT,
MLV_KEYBOARD_LEFT = SDLK_LEFT,
MLV_KEYBOARD_INSERT = SDLK_INSERT,
MLV_KEYBOARD_HOME = SDLK_HOME,
MLV_KEYBOARD_END = SDLK_END,
MLV_KEYBOARD_PAGEUP = SDLK_PAGEUP,
MLV_KEYBOARD_PAGEDOWN = SDLK_PAGEDOWN,
MLV_KEYBOARD_F1 = SDLK_F1,
MLV_KEYBOARD_F2 = SDLK_F2,
MLV_KEYBOARD_F3 = SDLK_F3,
MLV_KEYBOARD_F4 = SDLK_F4,
MLV_KEYBOARD_F5 = SDLK_F5,
MLV_KEYBOARD_F6 = SDLK_F6,
MLV_KEYBOARD_F7 = SDLK_F7,
MLV_KEYBOARD_F8 = SDLK_F8,
MLV_KEYBOARD_F9 = SDLK_F9,
MLV_KEYBOARD_F10 = SDLK_F10,
MLV_KEYBOARD_F11 = SDLK_F11,
MLV_KEYBOARD_F12 = SDLK_F12,
MLV_KEYBOARD_F13 = SDLK_F13,
MLV_KEYBOARD_F14 = SDLK_F14,
MLV_KEYBOARD_F15 = SDLK_F15,
MLV_KEYBOARD_NUMLOCK = SDLK_NUMLOCK,
MLV_KEYBOARD_CAPSLOCK = SDLK_CAPSLOCK,
MLV_KEYBOARD_SCROLLOCK = SDLK_SCROLLOCK,
MLV_KEYBOARD_RSHIFT = SDLK_RSHIFT,
MLV_KEYBOARD_LSHIFT = SDLK_LSHIFT,
MLV_KEYBOARD_RCTRL = SDLK_RCTRL,
MLV_KEYBOARD_LCTRL = SDLK_LCTRL,
MLV_KEYBOARD_RALT = SDLK_RALT,
MLV_KEYBOARD_LALT = SDLK_LALT,
MLV_KEYBOARD_RMETA = SDLK_RMETA,
MLV_KEYBOARD_LMETA = SDLK_LMETA,
MLV_KEYBOARD_LSUPER = SDLK_LSUPER,
MLV_KEYBOARD_RSUPER = SDLK_RSUPER,
MLV_KEYBOARD_MODE = SDLK_MODE,
MLV_KEYBOARD_COMPOSE = SDLK_COMPOSE,
MLV_KEYBOARD_HELP = SDLK_HELP,
MLV_KEYBOARD_PRINT = SDLK_PRINT,
MLV_KEYBOARD_SYSREQ = SDLK_SYSREQ,
MLV_KEYBOARD_BREAK = SDLK_BREAK,
MLV_KEYBOARD_MENU = SDLK_MENU,
MLV_KEYBOARD_POWER = SDLK_POWER,
MLV_KEYBOARD_EURO = SDLK_EURO,
MLV_KEYBOARD_UNDO = SDLK_UNDO,
MLV_KEYBOARD_LAST = SDLK_LAST
} MLV_Keyboard_button;
/** \~french
* \brief Énumère l'ensemble des codes associées aux différents modes du clavier
*/
typedef enum {
MLV_KEYBOARD_KMOD_NONE = KMOD_NONE,
MLV_KEYBOARD_KMOD_LSHIFT = KMOD_LSHIFT,
MLV_KEYBOARD_KMOD_RSHIFT = KMOD_RSHIFT,
MLV_KEYBOARD_KMOD_LCTRL = KMOD_LCTRL,
MLV_KEYBOARD_KMOD_RCTRL = KMOD_RCTRL,
MLV_KEYBOARD_KMOD_LALT = KMOD_LALT,
MLV_KEYBOARD_KMOD_RALT = KMOD_RALT,
MLV_KEYBOARD_KMOD_LMETA = KMOD_LMETA,
MLV_KEYBOARD_KMOD_RMETA = KMOD_RMETA,
MLV_KEYBOARD_KMOD_NUM = KMOD_NUM,
MLV_KEYBOARD_KMOD_CAPS = KMOD_CAPS,
MLV_KEYBOARD_KMOD_MODE = KMOD_MODE,
MLV_KEYBOARD_KMOD_RESERVED = KMOD_RESERVED
} MLV_Keyboard_modifier;
/** \~french
* \brief Suspend l'exécution jusqu'à ce que l'utilisateur appuie sur une touche
* du clavier.
*
* Lorsque l'utilisateur appuie sur une touche, la fonction remplit le contenu
* des trois paramètres sym, mod et unicode correspondant respectivement au
* code de la touche, au mode dans lequel se trouve le clavier
* (majuscule etc ...) et au caractère unicode obtenu en combinant le mode du
* clavier et le code de la touche appuyée.
*
* La fonction accepte des valeurs nulles pour les pointeurs sym, mod et
* unicode.
* Dans ce cas la fonction ignore les champs en questions.
*
* \bug Voir les bugs de la fonction MLV_get_event().
*
* \param sym Le code de la touche.
* \param mod Le mode dans lequel se trouve le clavier.
* \param unicode Le caractère codé en unicode de la lettre obtenue en combinant
* le code et le mode précédent.
*/
void MLV_wait_keyboard( MLV_Keyboard_button* sym, MLV_Keyboard_modifier* mod, int* unicode );
/** \~french
* \brief Suspend l'exécution jusqu'à ce que l'utilisateur appuie sur une touche
* du clavier ou jusq'à ce q'un nombre de secondes passées en paramètres
* soient écoulées.
*
* Pour plus d'informations sur le fonctionnement de cette fonction, veuillez
* vous reporter à la documentation de MLV_wait_keyboard().
*
* La fonction accepte des valeurs nulles pour les pointeurs sym, mod et
* unicode.
* Dans ce cas la fonction ignore les champs en questions.
*
* \bug Voir les bugs de la fonction MLV_get_event().
*
* \param sym Le code de la touche.
* \param mod Le mode dans lequel se trouve le clavier.
* \param unicode Le caractère codé en unicode de la lettre obtenue en combinant
* le code et le mode précédent.
* \param seconds Le nombre de secondes à attendre.
* \return Renvoie 1 si l'utilisateur a utilisé le calvier, 0 si le temps s'est
* écoulé.
*/
int MLV_wait_keyboard_or_seconds(
MLV_Keyboard_button* sym, MLV_Keyboard_modifier* mod, int* unicode, int seconds
);
/** \~french
* \brief Renvoie le code de la touche clavier correspondant au type clavier
* passé en paramètre.
*
* \param key_string La chaine de caractères codant le type de la touche.
*
* \return Le code de la touche clavier.
*/
MLV_Keyboard_button MLV_convert_string_to_keyboard_button( const char* key_string );
/** \~french
* \brief Renvoie la chaîne de caractères correspondant au code de la touche
* passé en paramètre.
*
* \param key_code Le code de la touche.
*
* \return La chaine de caractères codant le code de la touche.
*/
const char* MLV_convert_keyboard_button_to_string( MLV_Keyboard_button key_code );
/** \~french
* \brief Renvoie la chaîne de caractères correspondant au mode du clavier
* passé en paramètre.
*
* \param keymod_code Le code du mode.
*
* \return La chaine de caractères codant le mode du clavier.
*/
char* MLV_convert_keyboard_mod_to_string( MLV_Keyboard_modifier keymod_code );
/** \~french
*
* \brief Renvoie l'état (préssé ou relaché) d'une touche donnée d'un clavier.
*
* \param keyboard_code Le code de la touche dont il faut renvoyer l'état.
* \return L'état de la touche.
*/
MLV_Button_state MLV_get_keyboard_state( MLV_Keyboard_button keyboard_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison shift du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison shift a été appuyée.
*/
int MLV_shift_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison shift gauche du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison shift gauche a été appuyée.
*/
int MLV_left_shift_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison shift droit du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison shift droit a été appuyée.
*/
int MLV_right_shift_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison ctrl gauche du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison ctrl gauche a été appuyée.
*/
int MLV_left_ctrl_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison ctrl droit du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison ctrl droit a été appuyée.
*/
int MLV_right_ctrl_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison ctrl du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison ctrl a été appuyée.
*/
int MLV_ctrl_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison alt gauche du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison alt gauche a été appuyée.
*/
int MLV_left_alt_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison alt droit du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison alt droit a été appuyée.
*/
int MLV_right_alt_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison alt du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison alt a été appuyée.
*/
int MLV_alt_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison meta gauche du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison meta gauche a été appuyée.
*/
int MLV_left_meta_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison meta droit du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison meta droit a été appuyée.
*/
int MLV_right_meta_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison meta du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison meta a été appuyée.
*/
int MLV_meta_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison num du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison num a été appuyée.
*/
int MLV_num_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison cpas du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison caps a été appuyée.
*/
int MLV_caps_key_was_pressed( MLV_Keyboard_modifier modifier_code );
/** \~french
*
* \brief Renvoie vrai si le code, passé en paramètre, correspond à l'état appuyé de la touche de combinaison mode du clavier.
*
* \param modifier_code Le code de la touche de combinaison.
* \return Vrai, si la touche de cobinaison mode a été appuyée.
*/
int MLV_mode_key_was_pressed( MLV_Keyboard_modifier modifier_code );
#ifdef __cplusplus
}
#endif
#endif

127
MLV/MLV_mouse.h
View File

@@ -1,127 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_mouse.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions qui permettent
* d'utiliser la souris.
*
*/
#ifndef __MLV__MLV_MOUSE_H__
#define __MLV__MLV_MOUSE_H__
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
#include "MLV_device_with_buttons.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Énumère les différents bouttons de la souris
*
*/
typedef enum{
MLV_BUTTON_LEFT = SDL_BUTTON_LEFT, /**< \~french Bouton gauche de la souris */
MLV_BUTTON_MIDDLE = SDL_BUTTON_MIDDLE, /**< \~french Bouton du milieu de la souris */
MLV_BUTTON_RIGHT = SDL_BUTTON_RIGHT /**< \~french Bouton droit de la souris */
} MLV_Mouse_button;
/** \~french
*
* \brief Suspend l'exécution jusqu'à ce que l'utilisateur clique sur le bouton
* gauche de la souris.
*
* Au moment où l'utilisateur clique, la fonction retourne les
* coordonnées de la position de la souris dans la fenêtre.
*
* \param x Coordonnée en X de la position de la souris dans la fenêtre.
* \param y Coordonnée en Y de la position de la souris dans la fenêtre.
*/
void MLV_wait_mouse(int *x, int *y);
/** \~french
*
* \brief Suspend l'exécution jusqu'à ce que l'utilisateur clique sur le bouton
* gauche de la souris où jusqu'à ce qu'un nombre de secondes, passé en
* paramètres, se soient écoulées.
*
* Au moment où l'utilisateur clique, la fonction retourne les
* coordonnées de la position de la souris dans la fenêtre.
*
* \param x Coordonnée en X de la position de la souris dans la fenêtre.
* \param y Coordonnée en Y de la position de la souris dans la fenêtre.
* \param seconds Le nombre de second à attendre avant de quitter la fonction.
* \return Renvoie 1 si l'utilisateur a cliqué avec le bouton gauche de la souris,
* et 0 si le temps s'est écoulé.
*/
int MLV_wait_mouse_or_seconds(int *x, int *y, int seconds);
/** \~french
* \brief Convertit le code associé à un boutton de la souris (MLV_Mouse_button) en
* chaîne de caratères.
*
* \param button_code Le code du bouton.
* \return La chaîne de caratères correspondant au code du boutton de la
* souris passé en paramètre.
*/
const char* MLV_convert_mouse_button_to_string( MLV_Mouse_button button_code );
/** \~french
* \brief Convertit une chaîne de caractères en un code bouton.
*
* \param button_string La chaîne de caractères à convertir.
* \return Le code bouton associé à la chaîne de caractères.
*/
MLV_Mouse_button MLV_convert_string_to_mouse_button( const char* button_string );
/** \~french
*
* \brief Renvoie la position courante de la souris.
*
* \param x Coordonnée en X de la position de la souris dans la fenêtre.
* \param y Coordonnée en Y de la position de la souris dans la fenêtre.
*/
void MLV_get_mouse_position( int* x, int* y );
/** \~french
*
* \brief Renvoie l'état (préssé ou relaché) d'un bouton de la souris.
*
* \param mouse_button Le code du bouton de la souris
* \return L'état du bouton.
*/
MLV_Button_state MLV_get_mouse_button_state( MLV_Mouse_button mouse_button );
#ifdef __cplusplus
}
#endif
#endif

172
MLV/MLV_path.h
View File

@@ -1,172 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_path.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant de
* manipuler les chemins d'accès aux fichiers et répertoires.
*
*/
#ifndef __MLV__MLV_PATH_H__
#define __MLV__MLV_PATH_H__
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Renvoie la chaîne de caractères après le dernier séparteur / dans un
* chemin donné en paramètre.
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \param path Le chemin à analyser.
* \return Une chaîne de caractères.
*/
char* MLV_get_base_name( const char* path );
/** \~french
*
* \brief Renvoie la chaîne de caractères s'étendant jusqu'au dernier séparateur
* / du chemin donné en paramètre.
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \param path Le chemin à analyser.
* \return Une chaîne de caractères.
*/
char* MLV_get_directory_name( const char* path );
/** \~french
* \brief Teste si un chemin est absolu.
*
* \param path Le chemin
* \return Renvoie 1 si le chemin est absolue, 0 sinon.
*/
int MLV_path_is_absolute( const char* path );
/** \~french
* \brief Teste si un chemin est relatif.
*
* \param path Le chemin
* \return Renoie 1 si le chemin est relatif, 0 sinon.
*/
int MLV_path_is_relative( const char* path );
/** \~french
*
* \brief Teste si le chemin corespond au chemin d'un fichier ou dossier
* existant.
*
* \param path Le chemin
* \return Renvoie 1 si le chemin est associé à un dossier ou à un fichier
* existant, 0 sinon.
*/
int MLV_path_exists( const char* path );
/** \~french
* \brief Vérifie si un chemin est associé à un répertoire.
*
* \param path Le chemin
* \return Renvoie 1 si le chemin est associé à un dossier, 0 sinon.
*/
int MLV_path_is_a_directory( const char* path );
/** \~french
* \brief Vérifie si un chemin est associé à un fichier.
*
* \param path Le chemin
* \return Renvoie 1 si le chemin est associé à un fichier, 0 sinon.
*/
int MLV_path_is_a_file( const char* path );
/** \~french
* \brief Construit en concaténant différents textes, une chaîne de caractères
* représentant un chemin dont les séparateurs corespondent aux
* spécifications de la plateforme sur laquel s'exécute le programme.
*
* \bug Cette fonction ne fait que concaténer les differentes chaînes en
* mettant entre chaque chaîne un séparateur de répertoire compatible
* avec le système d'exploitation. Par contre, ce qui constitue le bug, il
* ne convertit pas chaque chaîne dans un format compatible avec celui du
* système d'exploitation.
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \param first_element La première chaîne à concaténer.
* \param ... Les autres éléments à concaténer.
* \return Le chemin vérifiant les normes de la plateforme hôte.
*/
char* MLV_build_path( const char* first_element, ... );
/** \~french
* \brief Même chose que MLV_build_path
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \param elements Les éléments à concaténer ensemble.
* \return Le chemin vérifiant les normes de la plateforme qui va exécuter
* le programme.
*/
char* MLV_build_path_v( char** elements );
/** \~french
* \brief Détermine le répertoire courant.
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \return Le chemin du répertoire courant.
*/
char * MLV_get_current_directory( );
/** \~french
* \brief Détermine le répertoire temporaire.
*
* Le répertoire temporaire est le répertoire dans lequel les applications
* ont le droit d'ajouter et de modifier des fichiers.
* Ce répertoire est génaralement vidé lorsque la machine est étteinte.
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \return Le chemin du répertoire temporaire.
*/
const char * MLV_get_temporary_directory( );
/** \~french
* \brief Détermine le répertoire personnel de l'utilisateur courant.
*
* La chaîne de caractères doit être désallouée après utilisation.
*
* \return Le chemin du répertoire personnel.
*/
const char * MLV_get_home_directory( );
#ifdef __cplusplus
}
#endif
#endif

58
MLV/MLV_playlist.h
View File

@@ -1,58 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__MLV_PLAYLIST_H__
#define __MLV__MLV_PLAYLIST_H__
#include "MLV_audio.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _MLV_Playlist MLV_Playlist;
void MLV_init_playlists();
void MLV_close_playlists();
MLV_Playlist* MLV_create_playlist( int loop );
void MLV_close_playlist( MLV_Playlist* playlist );
void MLV_playlist_add( MLV_Playlist* playlist, const char* file_music );
void MLV_playlist_add_sheet_music( MLV_Playlist* playlist, MLV_Music* );
void MLV_playlist_remove( MLV_Playlist* playlist, int index );
void MLV_playlist_clear( MLV_Playlist* playlist );
void MLV_playlist_volume( MLV_Playlist* playlist, double volume );
void MLV_playlist_play( MLV_Playlist* playlist );
void MLV_playlist_pause( MLV_Playlist* playlist );
void MLV_playlist_stop( MLV_Playlist* playlist );
void MLV_playlist_next( MLV_Playlist* playlist );
void MLV_playlist_previous( MLV_Playlist* playlist );
void MLV_playlist_first( MLV_Playlist* playlist );
void MLV_playlist_last( MLV_Playlist* playlist );
void MLV_playlist_index( MLV_Playlist* playlist, int index);
#ifdef __cplusplus
}
#endif
#endif

70
MLV/MLV_random.h
View File

@@ -1,70 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_random.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit tous les prototypes des fonctions concernant
* la manipulation des nombres aléatoires.
*
*/
#ifndef __MLV__MLV_RANDOM_H__
#define __MLV__MLV_RANDOM_H__
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Renvoie 0 ou 1 aléatoirement.
*
* \return 0 ou 1 aléatoirement.
*/
int MLV_get_random_boolean();
/** \~french
* \brief Renvoie un entier aléatoire choisi dans un intervalle donné en
* paramètre.
*
* \param begin Borne inférieur de l'intervalle ( inclusif )
* \param end Borne supérieur de l'intervalle ( inclusif )
* \return Un entier aléatoire choisi dans l'intervalle [begin, end].
*/
int MLV_get_random_integer(int begin, int end);
/** \~french
* \brief Renvoie un réel aléatoire choisi dans un intervalle donné en
* paramètre.
*
* \param begin Borne inférieur de l'intervalle ( inclusif )
* \param end Borne supérieur de l'intervalle ( inclusif )
* \return Un réel aléatoire choisi dans l'intervalle [begin, end].
*/
double MLV_get_random_double(double begin, double end);
#ifdef __cplusplus
}
#endif
#endif

414
MLV/MLV_shape.h
View File

@@ -1,414 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_shape.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit tout les prototypes des fonctions permettant de
* dessiner des figures.
*
*
*/
#ifndef __MLV__MLV_FIGURES_H__
#define __MLV__MLV_FIGURES_H__
#include "MLV_color.h"
#include "MLV_image.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Dessine un cercle à une position et un rayon spécifiés en paramètres.
**
* \param x La coordonnée en X du centre.
* \param y La coordonnée en Y du centre.
* \param radius Le rayon du cercle.
* \param color La couleur du tracé.
*/
void MLV_draw_circle(int x, int y, int radius, MLV_Color color);
/** \~french
* \brief Dessine un disque plein dont le centre et le rayon sont passés en
* paramètres.
*
* \param x La coordonnée en X du centre.
* \param y La coordonnée en Y du centre.
* \param radius Le rayon du cercle.
* \param color La couleur du tracé.
*/
void MLV_draw_filled_circle(int x, int y, int radius, MLV_Color color);
/** \~french
* \brief Dessine une ellipse.
*
* \param x La coordonnée en X du centre de l'ellipse.
* \param y La coordonnée en Y du centre de l'ellipse.
* \param radius_x Le rayon en X de l'ellipse.
* \param radius_y Le rayon en Y de l'ellipse.
* \param color La couleur du tracé.
*/
void MLV_draw_ellipse(
int x, int y, int radius_x, int radius_y, MLV_Color color
);
/** \~french
* \brief Dessine une ellipse pleine.
*
* \param x La coordonnée en X du centre de l'ellipse.
* \param y La coordonnée en Y du centre de l'ellipse.
* \param radius_x Le rayon en X de l'ellipse.
* \param radius_y Le rayon en Y de l'ellipse.
* \param color La couleur du tracé.
*/
void MLV_draw_filled_ellipse(
int x, int y, int radius_x, int radius_y, MLV_Color color
);
/** \~french
* \brief Dessine un polygone à partir d'une liste de sommets.
*
* \param vx La liste des coordonnées en X des différents sommets du polygone.
* \param vy La liste des coordonnées en Y des différents sommets du polygone.
* \param nb_points Le nombre de sommets du polygone.
* \param color La couleur du tracé.
*/
void MLV_draw_polygon(
const int* vx, const int* vy, int nb_points, MLV_Color color
);
/** \~french
* \brief Dessine un polygone plein à partir d'une liste de sommets.
*
* \param vx La liste des coordonnées en X des différents sommets du polygone.
* \param vy La liste des coordonnées en Y des différents sommets du polygone.
* \param nb_points Le nombre de sommets du polygone.
* \param color La couleur du tracé.
*/
void MLV_draw_filled_polygon(
const int* vx, const int* vy, int nb_points, MLV_Color color
);
/** \~french
* \brief Dessine une courbe de Bézier à partir d'une liste de sommets.
*
* \param vx La liste des coordonnées en X des différents sommets de la courbe.
* \param vy La liste des coordonnées en Y des différents sommets de la courbe.
* \param nb_points Le nombre de sommets disponibles pour dessiner la courbe de
* Bézier.
* \param color La couleur du tracé.
*/
void MLV_draw_bezier_curve(
const int* vx, const int* vy, int nb_points, MLV_Color color
);
/** \~french
* \brief Dessine un polygone plein à partir d'une liste de sommets.
*
* \param vx La liste des coordonnées en X des différents sommets du polygone.
* \param vy La liste des coordonnées en Y des différents sommets du polygone.
* \param nb_points Le nombre de sommets du polygone.
* \param color La couleur du tracé.
*/
void MLV_draw_filled_polygon(
const int* vx, const int* vy, int nb_points, MLV_Color color
);
/** \~french
* \brief Dessine un rectangle dont la taille, la couleur et la position du
* sommet Nord-Ouest sont données en paramètres.
*
* \param x La coordonnée en X du sommet Nord-Ouest du rectangle.
* \param y La coordonnée en Y du sommet Nord-Ouest du rectangle.
* \param width La largeur du rectangle.
* \param height La hauteur du rectangle.
* \param color La couleur du tracé.
*/
void MLV_draw_rectangle(int x, int y, int width, int height, MLV_Color color);
/** \~french
* \brief Dessine un rectangle dont la taille, la couleur et la position du
* sommet Nord-Ouest sont données en paramètres.
*
* \param x La coordonnée en X du sommet Nord-Ouest du rectangle.
* \param y La coordonnée en Y du sommet Nord-Ouest du rectangle.
* \param width La largeur du rectangle.
* \param height La hauteur du rectangle.
* \param color La couleur du tracé.
*/
void MLV_draw_rectangle(int x, int y, int width, int height, MLV_Color color);
/** \~french
* \brief Dessine un rectangle plein dont la taille, la couleur et la position
* du sommet Nord-Ouest sont données en paramètres.
*
* \param x La coordonnée en X du sommet Nord-Ouest du rectangle.
* \param y La coordonnée en Y du sommet Nord-Ouest du rectangle.
* \param width La largeur du rectangle.
* \param height La hauteur du rectangle.
* \param color La couleur du tracé.
*/
void MLV_draw_filled_rectangle(
int x, int y, int width, int height, MLV_Color color
);
/** \~french
* \brief Dessine une ligne.
*
* \param x1 La coordonnée en X de la première extrémité de la ligne.
* \param y1 La coordonnée en Y de la première extrémité de la ligne.
* \param x2 La coordonnée en X de la deuxième extrémité de la ligne.
* \param y2 La coordonnée en Y de la deuxième extrémité de la ligne.
* \param color La couleur du tracé.
*/
void MLV_draw_line(int x1, int y1, int x2, int y2, MLV_Color color);
/** \~french
* \brief Dessine un pixel dont les coordonnées sont passées en paramètres.
*
* \param x La coordonnée en X du pixel.
* \param y La coordonnée en Y du pixel.
* \param color La couleur du tracé.
*/
void MLV_draw_pixel(int x, int y, MLV_Color color);
/** \~french
* \brief Dessine un point dont les coordonnées sont passées en paramètres.
* Cette fonction est identique à MLV_draw_pixel.
*
* \param x La coordonnée en X du point.
* \param y La coordonnée en Y du point.
* \param color La couleur du tracé.
*/
void MLV_draw_point(int x, int y, MLV_Color color);
///////////////////////////////////////////////////////////////////////////////
// Drawing operation on images //
///////////////////////////////////////////////////////////////////////////////
/** \~french
* \brief Dessine un cercle à une position et un rayon spécifiés en paramètres
* dans une image.
*
* \param x La coordonnée en X du centre.
* \param y La coordonnée en Y du centre.
* \param radius Le rayon du cercle.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_circle_on_image(
int x, int y, int radius, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un disque plein dont le centre et le rayon sont passés en
* parametres dans une image.
*
* \param x La coordonnée en X du centre.
* \param y La coordonnée en Y du centre.
* \param radius Le rayon du cercle.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_filled_circle_on_image(
int x, int y, int radius, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine une ellipse dans une image.
*
* \param x La coordonnée en X du centre de l'ellipse.
* \param y La coordonnée en Y du centre de l'ellipse.
* \param radius_x Le rayon en X de l'ellipse.
* \param radius_y Le rayon en Y de l'ellipse.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_ellipse_on_image(
int x, int y, int radius_x, int radius_y, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine une ellipse pleine dans une image.
*
* \param x La coordonnée en X du centre de l'ellipse.
* \param y La coordonnée en Y du centre de l'ellipse.
* \param radius_x Le rayon en X de l'ellipse.
* \param radius_y Le rayon en Y de l'ellipse.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_filled_ellipse_on_image(
int x, int y, int radius_x, int radius_y, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un polygone à partir d'une liste de sommets dans une image.
*
* \param vx La liste des coordonnées en X des différents sommets du polygone.
* \param vy La liste des coordonnées en Y des différents sommets du polygone.
* \param nb_points Le nombre de sommets du polygone.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_polygon_on_image(
const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un polygone plein à partir d'une liste de sommets dans une
* image.
*
* \param vx La liste des coordonnées en X des différents sommets du polygone.
* \param vy La liste des coordonnées en Y des différents sommets du polygone.
* \param nb_points Le nombre de sommets du polygone.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_filled_polygon_on_image(
const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine une courbe de Bézier à partir d'une liste de sommets dans une
* image.
*
* \param vx La liste des coordonnées en X des différents sommets de la courbe.
* \param vy La liste des coordonnées en Y des différents sommets de la courbe.
* \param nb_points Le nombre de sommets disponibles pour dessiner la courbe de
* Bézier.
* \param color La couleur du tracé.
* \param image image dans laquelle la figure est dessinée
*/
void MLV_draw_bezier_curve_on_image(
const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un polygone plein à partir d'une liste de sommets dans une
* image.
*
* \param vx La liste des coordonnées en X des différents sommets du polygone.
* \param vy La liste des coordonnées en Y des différents sommets du polygone.
* \param nb_points Le nombre de sommets du polygone.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée
*/
void MLV_draw_filled_polygon_on_image(
const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un rectangle dont la taille, la couleur et la position du
* sommet Nord-Ouest sont données en paramètres dans une image.
*
* \param x La coordonnée en X du sommet Nord-Ouest du rectangle.
* \param y La coordonnée en Y du sommet Nord-Ouest du rectangle.
* \param width La largeur du rectangle.
* \param height La hauteur du rectangle.
* \param color La couleur du rectangle.
* \param image L'image dans laquelle la figure est dessinée .
*/
void MLV_draw_rectangle_on_image(
int x, int y, int width, int height, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un rectangle dont la taille, la couleur et la position du
* sommet Nord-Ouest sont données en paramètres dans une image.
*
* \param x La coordonnée en X du sommet Nord-Ouest du rectangle.
* \param y La coordonnée en Y du sommet Nord-Ouest du rectangle.
* \param width La largeur du rectangle.
* \param height La hauteur du rectangle.
* \param color La couleur du rectangle.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_rectangle_on_image(
int x, int y, int width, int height, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un rectangle plein dont la taille, la couleur et la position
* du sommet Nord-Ouest sont données en paramètres dans une image.
*
* \param x La coordonnée en X du sommet Nord-Ouest du rectangle.
* \param y La coordonnée en Y du sommet Nord-Ouest du rectangle.
* \param width La largeur du rectangle.
* \param height La hauteur du rectangle.
* \param color La couleur du rectangle.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_filled_rectangle_on_image(
int x, int y, int width, int height, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine une ligne dans une image.
*
* \param x1 La coordonnée en X de la première extrémité de la ligne.
* \param y1 La coordonnée en Y de la première extrémité de la ligne.
* \param x2 La coordonnée en X de la deuxième extrémité de la ligne.
* \param y2 La coordonnée en Y de la deuxième extrémité de la ligne.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_line_on_image(
int x1, int y1, int x2, int y2, MLV_Color color, MLV_Image* image
);
/** \~french
* \brief Dessine un pixel dont les coordonnées sont passées en paramètres dans
* une image.
*
* \param x Coordonnée en X du pixel
* \param y Coordonnée en Y du pixel
* \param color Couleur du tracé
* \param image image dans laquelle la figure est dessinée
*/
void MLV_draw_pixel_on_image(int x, int y, MLV_Color color, MLV_Image* image);
/** \~french
* \brief Dessine un point dont les coordonnées sont passées en paramètres.
* Cette fonction est identique à MLV_draw_pixel dans une image.
*
* \param x La coordonnée en X du point.
* \param y La coordonnée en Y du point.
* \param color La couleur du tracé.
* \param image L'image dans laquelle la figure est dessinée.
*/
void MLV_draw_point_on_image(int x, int y, MLV_Color color, MLV_Image* image);
#ifdef __cplusplus
}
#endif
#endif

489
MLV/MLV_text.h
View File

@@ -1,489 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_text.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les différents prototypes des fonctions permmettant
* d'afficher du texte et des boîtes de dialogues.
*/
#ifndef __MLV__MLV_TEXT_H__
#define __MLV__MLV_TEXT_H__
#include "MLV_color.h"
#include "MLV_image.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Énumère les différents types de justification du texte.
*/
typedef enum {
MLV_TEXT_CENTER, /**< \~french Le texte est justifié au centre. */
MLV_TEXT_LEFT, /**< \~french Le texte est justifié sur la gauche. */
MLV_TEXT_RIGHT /**< \~french Le texte est justifié sur la doite. */
} MLV_Text_justification;
/** \~french
* \brief Énumère les différents types de position horizontale du texte dans une boîte.
*/
typedef enum {
MLV_HORIZONTAL_CENTER, /**< \~french Le texte est centrée horizontalement
* dans la boîte. */
MLV_HORIZONTAL_LEFT, /**< \~french Le texte est positioné sur la droite de
* la boîte. */
MLV_HORIZONTAL_RIGHT /**< \~french Le texte est positioné sur la gauche de
* la boîte. */
} MLV_Horizontal_position;
/** \~french
* \brief Énumère les différents types de positions verticales du texte dans une boîte.
*/
typedef enum {
MLV_VERTICAL_CENTER, /**< \~french Le texte est centré horizonatalement
* dans la boîte. */
MLV_VERTICAL_TOP, /**< \~french Le texte est positionné en haut de la
* boîte. */
MLV_VERTICAL_BOTTOM /**< \~french Le texte est positionné en bas de la
* boîte. */
} MLV_Vertical_position;
/** \~french
* Ce type code une fonte de caractères.
*/
typedef struct _MLV_Font MLV_Font;
/** \~french
* \brief Cette fonction charge en mémoire une fonte de caractères de standard
* "TrueType" (fichiers ayant une extension .ttf).
*
* La fonte de caractères chargée est configurée avec une taille de fonte
* donnée en paramètre.
*
* \param file_font Le chemin d'accés où se trouve le fichier contenant la
* fonte de caractères.
* \param size La taille de la fonte de caractères.
* \return La structure de donnée MLV contenant la fonte de caractères.
*/
MLV_Font* MLV_load_font( const char* file_font, int size );
/** \~french
* \brief Cette fonction libère la mémoire d'une fonte de caractères
* précédement chargée.
*
* \param font L'adresse de la fonte de caractères à libérer.
*/
void MLV_free_font( MLV_Font* font );
/** \~french
* \brief Cette fonction calcule la taille du texte qui sera affiché sur
* l'écran à l'aide de la fonction MLV_draw_text().
*
* \param text Le texte qui doit être affiché.
* \param width La largeur du texte.
* \param height La hauteur du texte.
*/
void MLV_get_size_of_text( const char *text, int *width, int *height, ... );
/** \~french
* \brief Cette fonction calcule la taille du texte qui sera affiché sur
* l'écran à l'aide de la fonction MLV_draw_text_with_font().
*
* \param text Le texte qui doit être affiché.
* \param width La largeur du texte.
* \param height La hauteur du texte.
* \param font La fonte de caractères utilisée pour afficher le texte.
*/
void MLV_get_size_of_text_with_font(
const char *text, int *width, int *height, const MLV_Font* font, ...
);
/** \~french
* \brief Imprime un texte donné à une position et une couleur données.
*
* Le texte est imprimé à l'aide de la fonte de caractères par default de la
* bibliothèque MLV.
*
* \param x Coordonnée en X du coin Nord-Ouest du texte
* \param y Coordonnée en Y du coin Nord-Ouest du texte
* \param text texte à afficher
* \param color couleur du tracé
*/
void MLV_draw_text( int x, int y, const char *text, MLV_Color color, ... );
/** \~french
* \brief Écrit du texte sur l'écran en utilisant une couleur et une fonte de
* caractères données en paramètres.
*
* \param x La coordonnée en X du coin Nord-Ouest du texte.
* \param y La coordonnée en Y du coin Nord-Ouest du texte.
* \param text Le texte à afficher.
* \param color La couleur du tracé.
* \param font La fonte de caractères utilisée pour dessiner le texte.
*/
void MLV_draw_text_with_font(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color, ...
);
/** \~french
* \brief Écrit sur une image un texte donné à une position et une couleur
* données.
*
* Le texte est imprimé à l'aide de la fonte de caractères par default de la
* bibliothèque MLV.
*
* \param x La coordonnée en X du coin Nord-Ouest du texte.
* \param y La coordonnée en Y du coin Nord-Ouest du texte.
* \param text Le texte à afficher.
* \param color La couleur du tracé.
* \param image L'image sur laquel le texte doit être ecrit.
*/
void MLV_draw_text_on_image(
int x, int y, const char *text, MLV_Color color, MLV_Image* image, ...
);
/** \~french
* \brief Écrit du texte sur une image en utilisant une couleur et une fonte de
* caractères données en paramètres.
*
* \param x La coordonnée en X du coin Nord-Ouest du texte.
* \param y La coordonnée en Y du coin Nord-Ouest du texte.
* \param text Le texte à afficher.
* \param color La couleur du tracé.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param image L'image sur laquel le texte doit être ecrit.
*/
void MLV_draw_text_with_font_on_image(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color,
MLV_Image* image, ...
);
/** \~french
* \brief Dessine une boîte contenant du texte.
*
* La taille de la boîte dessinée s'adapte à la
* taille du texte.
* Les différentes couleurs de la boîte et du texte,
* ainsi que la taille de l'interligne du texte sont
* paramétrables.
*
* Il est possible de préciser la justification du texte à l'aide du
* paramètre "text_justification".
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param borderColor La couleur des bordures.
* \param sizeInterligne La taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
*/
void MLV_draw_adapted_text_box(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification, ...
);
/** \~french
* \brief Même chose que MLV_draw_adapted_text_box() mis à part que le texte est
* rendu avec une fonte de caractères donnée en paramètre.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param borderColor La couleur des bordures.
* \param sizeInterligne La taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param image L'image sur laquel le texte doit être ecrit.
*/
void MLV_draw_adapted_text_box_on_image(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, ...
);
/** \~french
* \brief Cette fonction calcule la taille de la boîte de texte qui serait
* obtenue si vous utilisez la fonction : MLV_draw_adapted_text_box().
*
* \param message Le texte qui sera affiché lorsque vous utiliserez
* MLV_draw_adapted_text_box().
* \param sizeInterligne La taille de l'interligne.
* \param result_width La largeur de la boîte que vous obtiendrez en
* utilisant MLV_draw_adapted_text_box().
* \param result_height La hauteur de la boîte que vous obtiendrez en
* utilisant MLV_draw_adapted_text_box().
*
* \return La fonction renvoie la taille de la boîte de texte.
*/
int MLV_get_size_of_adapted_text_box(
const char* message,
int sizeInterligne,
int *result_width, int *result_height,
...
);
/** \~french
* \brief Même chose que MLV_draw_adapted_text_box() mis à part que le texte est
* rendu avec une fonte de caractères donnée en paramètre.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param borderColor La couleur des bordures.
* \param sizeInterligne La taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
*/
void MLV_draw_adapted_text_box_with_font(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification, ...
);
/** \~french
* \brief Même chose que MLV_draw_adapted_text_box_with_font() mis à part que
* le texte est rendu sur une image et non directement à l'écran.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param borderColor La couleur des bordures.
* \param sizeInterligne Le taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param image L'image sur laquel le texte doit être ecrit.
*/
void MLV_draw_adapted_text_box_with_font_on_image(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, ...
);
/** \~french
* \brief Cette fonction calcule la taille de la boîte de texte qui serait
* obtenue si vous utilisez la fonction :
* MLV_draw_adapted_text_box_with_font().
*
* \param message Le texte qui sera affiché lorsque vous utiliserez
* MLV_draw_adapted_text_box_with_font().
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param sizeInterligne La taille de l'interligne.
* \param result_width La largeur de la boîte que vous obtiendrez en utilisant
* MLV_draw_adapted_text_box_with_font().
* \param result_height La hauteur de la boîte que vous obtiendrez en utilisant
* MLV_draw_adapted_text_box_with_font().
*
* \return La fonction renvoie la taille de la boîte de texte.
*/
int MLV_get_size_of_adapted_text_box_with_font(
const char* message,
const MLV_Font* font,
int sizeInterligne,
int *result_width, int *result_height,
...
);
/** \~french
* \brief Dessine une boîte de taille donnée par l'utilisateur et contenant un
* texte donné par l'utilisateur.
*
* Le texte est déssiné à l'interieur d'une boîte. Le texte est imprimé sur
* plusieurs lignes en respectant les retours à la ligne présents dans le texte.
*
* Les différentes couleurs de la boîte et du texte, ainsi que la taille de
* l'interligne du texte sont paramétrables.
*
* Il est possible de préciser la justification du texte contenu dans la boîte.
*
* De même , il est possible de préciser la position du texte à l'intérieur de
* la boîte.
*
* Cette fonction ne remet pas en forme le texte. Cela veux dire que si le texte
* est trop grand, alors il dépassera de la boîte et les parties qui depassent
* ne seront pas affichées.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
*/
void MLV_draw_text_box(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
...
);
/** \~french
* \brief Même chose que MLV_draw_text_box() mis à part que le texte n'est pas
* écrit directement sur l'écran, mais sur une image à la place.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
* \param image L'image sur laquel le texte doit être ecrit.
*/
void MLV_draw_text_box_on_image(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
...
);
/** \~french
* \brief Même chose que la fonction MLV_draw_text_box() mis à part que le texte
* est rendu avec une fonte de caractères donnée en paramètre par
* l'utilisateur.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
*/
void MLV_draw_text_box_with_font(
int x, int y,
int width, int height,
const char* message ,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
...
);
/** \~french
* \brief Même chose que la fonction MLV_draw_text_box_with_font() mis à part que
* le texte n'est pas dessinné directement sur l'ecran, mais sur une
* une image.
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param font La fonte caractères utilisée pour dessiner le texte.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
* \param image L'image sur laquel le texte doit être ecrit.
*/
void MLV_draw_text_box_with_font_on_image(
int x, int y,
int width, int height,
const char* message ,
MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
...
);
/** \~french
* \brief Transforme un caractère en format unicode en chaîne de caractères
* compatible avec le codage local (codage utilisé par la machine qui
* exécute le programme).
*
* Après utilisation, vous devez libérer l'espace mémoire de la chaîne de
* caractères renvoyée par la fonction.
*
* \param unicode Le caractère en format unicode.
* \return Un pointeur vers une nouvelle chaîne de caractères.
*/
char* MLV_convert_unicode_to_string( int unicode );
#ifdef __cplusplus
}
#endif
#endif

516
MLV/MLV_text_va.h
View File

@@ -1,516 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2013-2014 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_text_va.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit différents prototypes des fonctions permmettant
* d'afficher du texte et des boîtes de dialogues.
*/
#ifndef __MLV__MLV_TEXT_VA_H__
#define __MLV__MLV_TEXT_VA_H__
#include "MLV_color.h"
#include "MLV_image.h"
#include "MLV_text.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Imprime un texte donné à une position et une couleur données.
*
* Cette fonction est équivalente à la fonction MLV_draw_text() à l'exception
* qu'elle est apellée avec un paramètre de type va_list à la place d'une
* nombre variable d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text()
*
* \param x Coordonnée en X du coin Nord-Ouest du texte
* \param y Coordonnée en Y du coin Nord-Ouest du texte
* \param text texte à afficher
* \param color couleur du tracé
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_va(
int x, int y, const char *text, MLV_Color color, va_list pile
);
/** \~french
* \brief Écrit du texte sur l'écran en utilisant une couleur et une fonte de
* caractères données en paramètres.
*
* Cette fonction est équivalente à la fonction MLV_draw_text_wih_font() à
* l'exception qu'elle est apellée avec un paramètre de type va_list à la
* place d'une nombre variable d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text_with_font()
*
* \param x La coordonnée en X du coin Nord-Ouest du texte.
* \param y La coordonnée en Y du coin Nord-Ouest du texte.
* \param text Le texte à afficher.
* \param color La couleur du tracé.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_with_font_va(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color,
va_list pile
);
/** \~french
* \brief Écrit du texte sur une image en utilisant une couleur et une fonte de
* caractères données en paramètres.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_text_with_font_on_image() à l'exception qu'elle est apellée
* avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text_with_font_on_image()
*
* \param x La coordonnée en X du coin Nord-Ouest du texte.
* \param y La coordonnée en Y du coin Nord-Ouest du texte.
* \param text Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param color La couleur du tracé.
* \param image L'image sur laquel le texte doit être ecrit.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_with_font_on_image_va(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color,
MLV_Image* image, va_list pile
);
/** \~french
* \brief Cette fonction calcule la taille du texte qui sera affiché sur
* l'écran à l'aide de la fonction MLV_draw_text().
*
* Cette fonction est équivalente à la fonction
* MLV_get_size_of_text() à l'exception qu'elle est apellée
* avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_get_size_of_text()
*
* \param text Le texte qui doit être affiché.
* \param width La largeur du texte.
* \param height La hauteur du texte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_get_size_of_text_va(
const char *text, int *width, int *height, va_list pile
);
/** \~french
* \brief Cette fonction calcule la taille du texte qui sera affiché sur
* l'écran à l'aide de la fonction MLV_draw_text_with_font().
*
* Cette fonction est équivalente à la fonction
* MLV_get_size_of_text_with_font() à l'exception qu'elle est apellée
* avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_get_size_of_text_with_font()
*
* \param text Le texte qui doit être affiché.
* \param width La largeur du texte.
* \param height La hauteur du texte.
* \param font La fonte de caractères utilisée pour afficher le texte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_get_size_of_text_with_font_va(
const char *text, int *width, int *height, const MLV_Font* font,
va_list pile
);
/** \~french
* \brief Même chose que MLV_draw_adapted_text_box() mis à part que le texte est
* rendu avec une fonte de caractères donnée en paramètre.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_adapted_text_box_with_font() à l'exception qu'elle est apellée
* avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_adapted_text_box_with_font()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param borderColor La couleur des bordures.
* \param sizeInterligne La taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_adapted_text_box_with_font_va(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
va_list pile
);
/** \~french
* \brief Dessine une boîte contenant du texte.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_adapted_text_box() à l'exception qu'elle est apellée
* avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_adapted_text_box()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param borderColor La couleur des bordures.
* \param sizeInterligne La taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_adapted_text_box_va(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification, va_list pile
);
/** \~french
* \brief Même chose que MLV_draw_adapted_text_box() mis à part que le texte est
* rendu avec une fonte de caractères donnée en paramètre.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_adapted_text_box_on_image() à l'exception qu'elle est apellée
* avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_adapted_text_box_on_image()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param borderColor La couleur des bordures.
* \param sizeInterligne La taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param image L'image sur laquel le texte doit être ecrit.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_adapted_text_box_on_image_va(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, va_list pile
);
/** \~french
* \brief Même chose que MLV_draw_adapted_text_box_with_font() mis à part que
* le texte est rendu sur une image et non directement à l'écran.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_adapted_text_box_with_font_on_image() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_adapted_text_box_with_font_on_image()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param message Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param borderColor La couleur des bordures.
* \param sizeInterligne Le taille de l'interligne.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param image L'image sur laquel le texte doit être ecrit.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_adapted_text_box_with_font_on_image_va(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, va_list pile
);
/** \~french
* \brief Cette fonction calcule la taille de la boîte de texte qui serait
* obtenue si vous utilisez la fonction : MLV_draw_adapted_text_box().
*
* Cette fonction est équivalente à la fonction
* MLV_get_size_of_adapted_text_box() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_get_size_of_adapted_text_box()
*
* \param message Le texte qui sera affiché lorsque vous utiliserez
* MLV_draw_adapted_text_box().
* \param sizeInterligne La taille de l'interligne.
* \param result_width La largeur de la boîte que vous obtiendrez en
* utilisant MLV_draw_adapted_text_box().
* \param result_height La hauteur de la boîte que vous obtiendrez en
* utilisant MLV_draw_adapted_text_box().
* \param pile Une liste d'arguments supplémentaires
*
* \return La fonction renvoie la taille de la boîte de texte.
*/
int MLV_get_size_of_adapted_text_box_va(
const char* message,
int sizeInterligne,
int *result_width, int *result_height,
va_list pile
);
/** \~french
* \brief Cette fonction calcule la taille de la boîte de texte qui serait
* obtenue si vous utilisez la fonction :
* MLV_draw_adapted_text_box_with_font().
*
* Cette fonction est équivalente à la fonction
* MLV_get_size_of_adapted_text_box_with_font() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_get_size_of_adapted_text_box_with_font()
*
* \param message Le texte qui sera affiché lorsque vous utiliserez
* MLV_draw_adapted_text_box_with_font().
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param sizeInterligne La taille de l'interligne.
* \param result_width La largeur de la boîte que vous obtiendrez en utilisant
* MLV_draw_adapted_text_box_with_font().
* \param result_height La hauteur de la boîte que vous obtiendrez en utilisant
* MLV_draw_adapted_text_box_with_font().
* \param pile Une liste d'arguments supplémentaires
*
* \return La fonction renvoie la taille de la boîte de texte.
*/
int MLV_get_size_of_adapted_text_box_with_font_va(
const char* message,
const MLV_Font* font,
int sizeInterligne,
int *result_width, int *result_height,
va_list pile
);
/** \~french
* \brief Même chose que la fonction MLV_draw_text_box() mis à part que le texte
* est rendu avec une fonte de caractères donnée en paramètre par
* l'utilisateur.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_text_box_with_font() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text_box_with_font()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param font La fonte de caractères utilisée pour dessiner le texte.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_box_with_font_va(
int x, int y,
int width, int height,
const char* message ,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
va_list pile
);
/** \~french
* \brief Dessine une boîte de taille donnée par l'utilisateur et contenant un
* texte donné par l'utilisateur.
*
*
* Cette fonction est équivalente à la fonction
* MLV_draw_text_box() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text_box()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_box_va(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
va_list pile
);
/** \~french
* \brief Même chose que la fonction MLV_draw_text_box_with_font() mis à part que
* le texte n'est pas dessinné directement sur l'ecran, mais sur une
* une image.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_text_box_with_font_on_image() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text_box_with_font_on_image()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param font La fonte caractères utilisée pour dessiner le texte.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
* \param image L'image sur laquel le texte doit être ecrit.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_box_with_font_on_image_va(
int x, int y,
int width, int height,
const char* message ,
MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
va_list pile
);
/** \~french
* \brief Même chose que MLV_draw_text_box() mis à part que le texte n'est pas
* écrit directement sur l'écran, mais sur une image à la place.
*
* Cette fonction est équivalente à la fonction
* MLV_draw_text_box_on_image() à l'exception qu'elle est
* apellée avec un paramètre de type va_list à la place d'une nombre variable
* d'arguments.
*
* Pour plus de détail sur la fonction, aller voir la documentation de
* MLV_draw_text_box_on_image()
*
* \param x La coordonnée en X de la position du coin Nord-Ouest de la boîte.
* \param y La coordonnée en Y de la position du coin Nord-Ouest de la boîte.
* \param width La largeur de la boîte.
* \param height La hauteur de la boîte.
* \param message Le texte à afficher.
* \param sizeInterligne La taille de l'interligne.
* \param borderColor La couleur des bordures.
* \param textColor La couleur du texte.
* \param backgroundColor La couleur du fond de la boîte.
* \param text_justification La justification du texte.
* \param horizontal_position La position horizontale du texte dans la boîte.
* \param vertical_position La position verticale du texte dans la boîte.
* \param image L'image sur laquel le texte doit être ecrit.
* \param pile Une liste d'arguments supplémentaires
*/
void MLV_draw_text_box_on_image_va(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
va_list pile
);
#ifdef __cplusplus
}
#endif
#endif

119
MLV/MLV_time.h
View File

@@ -1,119 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_time.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit tous les prototypes des fonctions concernant la
* gestion du temps.
*
*/
#ifndef __MLV__MLV_TIME_H__
#define __MLV__MLV_TIME_H__
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Le programme s'intérompt pendant un nombre de milli-secondes donné
* en paramètre.
*
* \param milliseconds Le nombre de milli-secondes à attendre.
*/
void MLV_wait_milliseconds(int milliseconds);
/** \~french
* \brief Le programme s'intérompt pendant un nombre de secondes.
*
* \param seconds Le nombre de secondes à attendre.
*/
void MLV_wait_seconds(int seconds);
/** \~french
* \brief Renvoie le nombre de millisecondes écoulées depuis le début de
* l'initialisation de la bibliothèque MLV ( avec MLV_create_window ).
* \return Le temps écoulé depuis l'initialisation de la bibliothèque MLV.
*/
int MLV_get_time();
/** \~french
* \brief Donne la date du jour (seconde/heure/jour/mois/annee).
*
* L'année est donnée depuis l'an 0.
*
* Une valeur nulle peut être passée en paramètre de la fonction. Dans ce cas,
* le paramètre est ignoré par la fonction.
*
* \param seconds Le nombre de secondes écoulées depuis le dernier changement de
* minute.
* \param minutes Le nombre de minutes écoulées depuis le dernier changement
* d'heure
* \param hours Le nombre d'heures écoulées depuis minuit.
* \param day Le quantième du mois.
* \param month Le nombre de mois écoulés depuis le début de l'année.
* \param year Le nombre d'années depuis l'an 0.
* \param day_of_the_week Le jour de la semaine ( 0: Lundi, 1:Mardi, ...,
* 6:Dimanche).
* \return Renvoie 1 si le décalage heure d'hivers et heure d'été a été
* pris en compte, 0 si il ne l'a pas été et -1 si l'information
* n'est pas disponible.
*/
int MLV_get_date(
int* seconds, int* minutes, int* hours,
int* day, int* month, int* year,
int* day_of_the_week
);
/** \~french
* \brief Configure la fréquence de rafraichissement en Hz.
*
* La fréquence de rafraîchissement par defaut est de 100 Hz. Cela signifie
* que si l'on utilise MLV_delay_according_to_frame_rate() entre chaque
* rafraîchissement de la fenêtre graphique, on obtient un rafraichissement
* de 100 images par secondes.
*
* \param rate Fréquence de rafraîchissement.
*/
void MLV_change_frame_rate( int rate );
/** \~french
* \brief Donne la fréquence de rafraîchissement courante.
*
* \return La fréquence de rafraîchissement courante.
*/
int MLV_get_frame_rate( );
/** \~french
* \brief Suspend l'exécution du programme de façon à ce que le temps écoulé
* depuis le drenier appel à cette fonction, soit égale à la période de
* la fréquence de rafraîchissement configuré par MLV_change_frame_rate.
*/
void MLV_delay_according_to_frame_rate( );
#ifdef __cplusplus
}
#endif
#endif

306
MLV/MLV_window.h
View File

@@ -1,306 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_window.h
* \brief Ce fichier définit les prototypes des fonctions permettant de créer,
* initialiser et fermer des fenêtres.
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
*/
#ifndef __MLV__MLV_WINDOW_H__
#define __MLV__MLV_WINDOW_H__
#include "MLV_color.h"
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Créé une fenêtre dont la taille, et les différents noms sont passés en
* paramètres.
*
* Cette fonction initialise la bibliothèque MLV.
* Un programme donné ne peut pas ouvrir plus d'une fenêtre à la
* fois.
* Les paramètres largeur et hauteur peuvent éventuellement prendre des valeurs
* négatives. Dans ce cas, la fenêtre est dessinée en plein écran.
*
* \bug BOGUES WINDOWS ET MACOSX UNIQUEMENT\n\n
* Sous Windows uniquement, la fenêtre crée ne peut pas toujours être
* fermée à l'aide de la croix. En effet, la bibliothèque MLV implémente
* une fermeture automatique de la fenêtre lorsque l'utilisateur utilise
* la croix. Or, ce mécanisme utilise les threads SDL qui ne sont
* malheureusement pas bien supportés sous Windows et MacOSX.\n\n
* En fait, la bibliothèque MLV utilise un second thread pour
* récuperer en permanance tous les évènements SDL de la pile et pour les
* traiter au fur et à mesure de leurs apparitions. OR, sous Windos et
* Mac OS X, comme les threads ne fonctionnent pas, la bibliothèque ne peux
* pas lire les évènements systèmes comme ceux de la fermeture de la
* fenêtre.
* Elle n'est donc plus informée de ce qui ce passe.
* Pour permettre à la bibliothèque de récupérer ces informations, il vous
* suffit de demander un évènement à l'aide de la fonction :
* MLV_get_event().
* Cela obligera la bibliothèque MLV à dépiler et à traiter tous les
* évènements SDL de la pile. Cela aura pour conséquence de traiter
* l'évènement système de la fermeture de la fenêtre.
* Dans l'implémentation des fonctions : MLV_wait_keyboard(),
* MLV_wait_mouse(), etc ..., nous utilisons la fonction MLV_get_event().
* C'est pourquoi, la croix fonctionne correctement lorsque le programme
* est en attente d'une information provenant de l'utilisateur.
*
* \param window_name Le nom de la fenêtre.
* \param icone_name Le nom de l'icône de la fenêtre.
* \param width La largeur de la fenêtre.
* \param height La hauteur de la fenêtre.
*/
void MLV_create_window(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height
);
/** \~french
* \brief Même chose que MLV_create_window(), mais en utilisant une fonte
* de caractères particulière.
*
* \bug Même bogues que la fonction MLV_create_window().
*
* \param window_name Le nom de la fenêtre.
* \param icone_name Le nom de l'icône de la fenêtre.
* \param width La largeur de la fenêtre.
* \param height La hauteur de la fenêtre.
* \param path_to_font Le chemin d'accès vers une fonte de caratères au standard
* 'TrueType' (fichiers d'extension .ttf).
* \param size_font La taille de la fonte de caractères. la hauteur de la fenêtre.
*/
void MLV_create_window_with_default_font(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height,
const char* path_to_font, unsigned int size_font
);
/** \~french
* \brief Change la fonte de caractères par défault de la bibliothèque MLV.
*
* Cette fonction change la fonte de caractères par défault de la bibliothèque.
* Cette fonction ne peux s'exécuter qu'après avoir initialisé la bibliothèque
* MLV en créant une fenêtre à l'aide de la fonction MLV_create_window().
* Cette fonction n'a pas de sens si vous ne souhaitez pas changer de fontes
* plusieurs fois durant l'exécution de votre programme.
* Si vous n'utilisez qu'une seule fonte de caractères, il vaut mieux
* l'indiquer à la bibliothèque MLV lors de la création de la fenêtre en utilisant
* la fonction: MLV_create_window_with_default_font().
*
* \param path_to_font Le chemin d'accès vers une fonte de caratères au
* standard "TrueType" (fichiers d'extension .ttf).
* \param size_font La taille de la fonte de caractères.
*/
void MLV_change_default_font( const char* path_to_font, unsigned int size_font );
/** \~french
* \brief Même chose que MLV_create_window(), mais configure la fenêtre en
* mode plein écran.
*
* \bug Même bogues que MLV_create_window().
*
* \param window_name Le nom de la fenêtre.
* \param icone_name Le nom de l'icône de la fenêtre.
* \param width La largeur de la fenêtre ( en mode plein écran, cette valeur
* correspond à la coordonnée en X de la résolution de l'image ).
* \param height La hauteur de la fenêtre ( en mode plein écran, cela
* correspond à la coordonnée en Y de la résolution de l'image ).
*/
void MLV_create_full_screen_window(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height
);
/** \~french
* \brief Même chose que MLV_create_window(), mais configure la fenêtre en
* mode plein écran.
*
* \bug Même bogues que MLV_create_window().
*
* \param window_name Le nom de la fenêtre.
* \param icone_name Le nom de l'icône de la fenêtre.
* \param width La largeur de la fenêtre ( en mode plein écran, cette valeur
* correspond à la coordonnée en X de la résolution de l'image ).
* \param height La hauteur de la fenêtre ( en mode plein écran, cela
* correspond à la coordonnée en Y de la résolution de l'image ).
* \param path_to_font Le chemin d'accès vers une fonte de caratères au
* standard "TrueType" (fichiers d'extension .ttf).
* \param size_font La taille de la fonte de caractères.
*/
void MLV_create_full_screen_window_with_default_font(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height,
const char* path_to_font, unsigned int size_font
);
/** \~french
* \brief Affiche la fenêtre en plein ecran.
*
* La résolution de l'image est donnée alors par la taille de l'image.
* Pour que l'application soit en plein écran, il faut que la taille de la
* fenêtre soit compatible avec la résolution de l'écran.
*/
void MLV_enable_full_screen();
/** \~french
* \brief Désactve le mode plein écran de la fenêtre.
*/
void MLV_disable_full_screen();
/** \~french
* \brief Test si l'affichage est en mode plein écran ou en mode fenêtre.
*
* \return Renvoie 1 si l'affichage est en mode plein écran, 0 sinon.
*/
int MLV_is_full_screen();
/** \~french
* \brief Change la taille de la fenêtre.
*
* Si la fenêtre est configurée en mode plein ecran, l'application reste alors
* en mode plein écran.
* Pour que l'application soit en plein écran, il faut que la taille de la
* fenêtre soit compatible avec la résolution de l'écran.
* De plus, en mode plein écran, la taille de la fenêtre correspond à la
* résolution de l'image sur l'écran.
*
* \param width la largeur de la fenêtre
* \param height la hauteur de la fenêtre
*/
void MLV_change_window_size( unsigned int width, unsigned int height );
/** \~french
* \brief Change les intitulés de la fenêtre principale.
*
* \param window_name Intitulé apparaissaissant sur la barre de la fenêtre.
* \param icone_name Intitulé apparaissaissant dans la barre des tâches.
*/
void MLV_change_window_caption(
const char* window_name, const char* icone_name
);
/** \~french
* \brief Renvoie dans les paramètres, la hauteur et la largeur de la fentre.
*
* \param width La largeur de la fenêtre.
* \param height La hauteur de la fenêtre.
*/
void MLV_get_window_size( unsigned int* width, unsigned int* height );
/** \~french
* \brief Retourne la hauteur de la fenêtre.
*/
int MLV_get_window_height( );
/** \~french
* \brief Retourne la largeur de la fenêtre.
*/
int MLV_get_window_width( );
/** \~french
* \brief Éfface la fenêtre et la remplace par un monochrome de la couleur
* donnée en paramètre.
*
* \param color La couleur du fond de la fênetre.
*/
void MLV_clear_window( MLV_Color color );
/** \~french
* \brief Ferme la fenêtre de la bibliothèque MLV.
*
* Cette fonction libère correctement toutes les données qui ont été crées par la
* bibliothèque MLV
*
*/
void MLV_free_window();
/** \~french
* \brief Actualise l'affichage de la fenêtre.
*
* Vois La fonction MLV_update_window
*
* Lorsque vous utilisez des fonctions de dessins, les différents changements
* effectués ne sont pas visibles. Pour les afficher vous devez utiliser cette
* fonction.
*/
void MLV_actualise_window();
/** \~french
* \brief Met à jour l'affichage de la fenêtre.
*
* Lorsque vous utilisez des fonctions de dessins, les différents changements
* effectués ne sont pas visibles. Pour les afficher vous devez utiliser cette
* fonction.
*/
void MLV_update_window();
/** \~french
* \brief Exécute la fonction de call back donnée en paramètre lorsque le système
* envoie un signal d'arrêt, ou lorsque l'utilisateur clique sur la croix de la
* fenêtre.
*
* La fonction de call back est alors exécutée avec en
* paramêtre un pointeur vers une structure de donnée qui
* est aussi donné en paramètre à la fonction
* MLV_execute_at_exit().
*
* \param function Le pointeur de la fonction de call back qui doit être exécutée.
* \param data La Donnée à passer en paramètre à la fonction de call back lors de
* son exécution.
*/
void MLV_execute_at_exit( void (*function)(void*), void* data );
/** \~french
* \brief Renvoie dans les paramètres, la hauteur et la largeur de
* l'environement de bureau de l'ordinateur.
*
* \param width La largeur du bureau.
* \param height La hauteur du bureau.
*/
void MLV_get_desktop_size( unsigned int* width, unsigned int* height );
/** \~french
* \brief Renvoie la hauteur de l'environement de bureau de l'ordinateur.
*/
int MLV_get_desktop_height( );
/** \~french
* \brief Renvoie la largeur de l'environement de bureau de l'ordinateur.
*/
int MLV_get_desktop_width( );
#ifdef __cplusplus
}
#endif
#endif

217
MLV/MLV_xml.h
View File

@@ -1,217 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_xml.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les prototypes des fonctions permettant de lire des
* fichiers xml.
*
* Les fichiers xml sont utilisés pour stocker les données nécessaires au
* fonctionnement d'un programme. Ils permettent de modifier facilement
* l'exécution du programme sans avoir à le modifier. En effet, ils sont
* lisibles par l'homme et par la machine en même temps.
* Ils constituent donc une interface pratique entre l'ordinateur et
* l'utilisateur.
*
*/
#ifndef __MLV__MLV_XML_H__
#define __MLV__MLV_XML_H__
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Définit le type de donnée stockée au format xml dans la bibliothèque MLV.
*/
typedef struct _MLV_Xml MLV_Xml;
/** \~french
* \brief Charge en mémoire un fichier au format xml.
*
* Cette fonction renvoi NULL, lorsque le fichier n'a pas pu être correctement
* chargé.
*
* \param xml_file_path Chemin d'accès du fichier xml.
* \return Le fichier xml lu, analysé et chargé.
*/
MLV_Xml* MLV_load_xml( const char* xml_file_path );
/** \~french
* \brief Libère la mémoire utilisée par les données du fichier xml.
*
* \param xml_data Les données xml a supprimer.
*/
void MLV_free_xml( MLV_Xml* xml_data );
/** \~french
* \brief Énumère les différents codes d'erreurs que l'on peut rencontrer
* lorsque l'ordinateur lit un document xml.
*/
typedef enum {
MLV_XML_NONE, /**< \~french Aucune erreur detectée. */
MLV_XML_THE_FIELD_DOESNT_EXIST, /**< \~french Le champs n'existe pas dans le document xml. */
MLV_XML_THE_FIELD_IS_NOT_A_REAL, /**< \~french Le champs ne contient pas une chaîne de caractères codant un reel. */
MLV_XML_THE_FIELD_IS_NOT_AN_INTEGER, /**< \~french Le champs ne contient pas un chaîne de caractères codant un entier. */
MLV_XML_THE_FIELD_IS_TOO_BIG /**< \~french La chaîne code un réel/entier trop long pour être stocké dans la variable. */
} MLV_Xml_error;
/** \~french
* \brief Permet d'accéder à l'interieur d'un champs donné du fichier xml.
*
* Cette fonction peut contenir un nombre variable de paramètres.
* Comme avec la fonction printf les paramètres suplémentaires,
* situées après le paramètre xpath, permettent de construire des
* requêtes xpath évolué.
*
* Par exemple,
* \code
* int id_batiment = 2;
* char * type_salle = "informatique"
* int id_salle = 4;
* char* nom_salle;
* MLV_get_string_value_from_xml(
* xml_data, &(nom_salle),
* "/batiment[%d]/salle[type=%s][%d]/nom",
* id_batiment, type_salle, id_salle
* )
* free( nom_salle ); // on oublie pas de libérer la mémoire après avoir
* // utilisé nom_salle
* \endcode
*
* permet de recupérer le contenu du champs "nom" situé dans la 4eme salle
* informatique du 2eme batiment.
*
* Attention: Il ne faut pas oublier de libérer la mémoire associée au champs
* result.
*
* \param xml_data Les données xml.
* \param result Un pointeur vers une addresse vide qui contiendra l'addresse de la chaîne de caractères correspondant au résultat de la fonction.
* \param xpath Le chemin d'accès.
* \return renvoie un code d'erreur si la fonction n'a pa reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_string_value_from_xml(
const MLV_Xml* xml_data, char** result , const char* xpath, ...
);
/** \~french
* \brief Permet de récupérer l'entier d'un champs donné du fichier xml.
*
* Tout comme la fonction MLV_get_string_value_from_xml(), cette fonction peut
* contenir un nombre variable de paramètres.
* Pour plus d'informations, veuillez lire la documentation de la fonction
* MLV_get_string_value_from_xml().
*
* \param xml_data Les données xml.
* \param result Un pointeur vers un entier dans lequel le résultat de la fonction sera enregistré.
* \param xpath Le chemin d'accès.
* \return renvoie un code d'erreur si la fonction n'a pa reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_integer_value_from_xml(
const MLV_Xml* xml_data, int* result, const char* xpath, ...
);
/** \~french
* \brief Permet de récupérer le reel d'un champs donné du fichier xml.
*
* Tout comme la fonction MLV_get_string_value_from_xml(), cette fonction peut
* contenir un nombre variable de paramètres.
* Pour plus d'informations, veuillez lire la documentation de la fonction
* MLV_get_string_value_from_xml().
*
* \param xml_data Les données xml.
* \param result Un pointeur vers un réel dans lequel le résultat de la fonction sera enregistré.
* \param xpath Le chemin d'accès.
* \return renvoie un code d'erreur (voir MLV_Xml_error) si la fonction n'a pas reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_double_value_from_xml(
const MLV_Xml* xml_data, double* result, const char* xpath, ...
);
/** \~french
* \brief Permet de récupérer le réel d'un champs donné du fichier xml.
*
* Tout comme la fonction MLV_get_string_value_from_xml(), cette fonction peut
* contenir un nombre variable de paramètres.
* Pour plus d'informations, veuillez lire la documentation de la fonction
* MLV_get_string_value_from_xml().
*
* \param xml_data Les données xml.
* \param result Un pointeur vers un réel dans lequel le résultat de la fonction sera enregistré.
* \param xpath Le chemin d'accès.
* \return renvoie un code d'erreur (voir MLV_Xml_error) si la fonction n'a pas reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_float_value_from_xml(
const MLV_Xml* xml_data, float* result, const char* xpath, ...
);
/** \~french
* \brief Compte le nombre d'objets présents dans le fichier xml verifiant
* un certain nombre de critères passés en paramètre de la fonction.
*
* \param xml_data Les données xml.
* \param xpath Le chemin d'accès.
* \param ... Les paramètres de la fonction.
*
* \return Cette fonction renvoie le nombre d'objet ayant pour chemin d'accès
* "xpath".
*/
int MLV_get_number_of_objects_from_xml(
const MLV_Xml* xml_data, const char* xpath, ...
);
/** \~french
* \brief Permet de récupérer un noeud interne de l'arbre représentant le
* fichier XML.
*
* Cette fonction n'est pas encore implémentée.
*
* \param xml_data Les données xml.
* \param xpath Le chemin d'accès.
* \param ... Les paramètres de la fonction.
*
* \return Un noeud interne de l'arbre XML.
*/
MLV_Xml* MLV_get_xml_object_of( const MLV_Xml* xml_data, const char* xpath, ... );
/** \~french
* \brief Écrit sur le terminal le contenu d'un fichier xml.
*
* Cette fonction n'est pas encore implémentée.
*
* \param xml_data Les données xml.
* \param ... Les paramètres de la fonction.
*/
void MLV_print_xml( const MLV_Xml* xml_data );
#ifdef __cplusplus
}
#endif
#endif

155
MLV/MLV_xml_va.h
View File

@@ -1,155 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2013-2014 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
/** \~french
* \file MLV_xml_va.h
*
* \author Adrien Boussicault
* \author Marc Zipstein
*
* \brief Ce fichier définit les même prototypes des fonctions que MLV_xml.h
* mais en utilisant en argument sulémentaire une liste de type va_list.
*
* Les fichiers xml sont utilisés pour stocker les données nécessaires au
* fonctionnement d'un programme. Ils permettent de modifier facilement
* l'exécution du programme sans avoir à le modifier. En effet, ils sont
* lisibles par l'homme et par la machine en même temps.
* Ils constituent donc une interface pratique entre l'ordinateur et
* l'utilisateur.
*
*/
#ifndef __MLV__MLV_XML_VA_H__
#define __MLV__MLV_XML_VA_H__
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
/** \~french
* \brief Permet d'accéder à l'interieur d'un champs donné du fichier xml.
*
* Attention: Il ne faut pas oublier de libérer la mémoire associée au
* champs result.
*
* \param xml_data Les données xml.
* \param result Un pointeur vers une addresse vide qui contiendra l'addresse de la chaîne de caractères correspondant au résultat de la fonction.
* \param xpath Le chemin d'accès.
* \param pile La pile des complements de paramètres comme dans vaprintf.
* \return renvoie un code d'erreur si la fonction n'a pa reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_string_value_from_xml_va(
const MLV_Xml* xml_data, char** result, const char* xpath, va_list pile
);
/** \~french
* \brief Permet de récupérer l'entier d'un champs donné du fichier xml.
*
* Tout comme la fonction MLV_get_string_value_from_xml(), cette fonction peut
* contenir un nombre variable de paramètres.
* Pour plus d'informations, veuillez lire la documentation de la fonction
* MLV_get_string_value_from_xml().
*
* \param xml_data Les données xml.
* \param result Un pointeur vers un entier dans lequel le résultat de la fonction sera enregistré.
* \param xpath Le chemin d'accès.
* \param pile La pile des complements de paramètres comme dans vaprintf.
* \return renvoie un code d'erreur si la fonction n'a pa reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_integer_value_from_xml_va(
const MLV_Xml* xml_data, int* result, const char* xpath, va_list pile
);
/** \~french
* \brief Permet de récupérer le reel d'un champs donné du fichier xml.
*
* Tout comme la fonction MLV_get_string_value_from_xml(), cette fonction peut
* contenir un nombre variable de paramètres.
* Pour plus d'informations, veuillez lire la documentation de la fonction
* MLV_get_string_value_from_xml().
*
* \param xml_data Les données xml.
* \param result Un pointeur vers un réel dans lequel le résultat de la fonction sera enregistré.
* \param xpath Le chemin d'accès.
* \param pile La pile des complements de paramètres comme dans vaprintf.
* \return renvoie un code d'erreur (voir MLV_Xml_error) si la fonction n'a pas reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_double_value_from_xml_va(
const MLV_Xml* xml_data, double* result, const char* xpath, va_list pile
);
/** \~french
* \brief Permet de récupérer le réel d'un champs donné du fichier xml.
*
* Tout comme la fonction MLV_get_string_value_from_xml(), cette fonction peut
* contenir un nombre variable de paramètres.
* Pour plus d'informations, veuillez lire la documentation de la fonction
* MLV_get_string_value_from_xml().
*
* \param xml_data Les données xml.
* \param result Un pointeur vers un réel dans lequel le résultat de la fonction sera enregistré.
* \param xpath Le chemin d'accès.
* \param pile La pile des complements de paramètres comme dans vaprintf.
* \return renvoie un code d'erreur (voir MLV_Xml_error) si la fonction n'a pas reussie à extraire la donnée souhaitée du document xml.
*/
MLV_Xml_error MLV_get_float_value_from_xml_va(
const MLV_Xml* xml_data, float* result, const char* xpath, va_list pile
);
/** \~french
* \brief Compte le nombre d'objets présents dans le fichier xml verifiant
* un certain nombre de critères passés en paramètre de la fonction.
*
* \param xml_data Les données xml.
* \param xpath Le chemin d'accès.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*
* \return Cette fonction renvoie le nombre d'objet ayant pour chemin d'accès
* "xpath".
*/
int MLV_get_number_of_objects_from_xml_va(
const MLV_Xml* xml_data, const char* xpath, va_list pile
);
/** \~french
* \brief Permet de récupérer un noeud interne de l'arbre représentant le
* fichier XML.
*
* Cette fonction n'est pas encore implémentée.
*
* \param xml_data Les données xml.
* \param xpath Le chemin d'accès.
* \param pile La pile des complements de paramètres comme dans vaprintf.
*
* \return Un noeud interne de l'arbre XML.
*/
MLV_Xml* MLV_get_xml_object_of_va(
const MLV_Xml* xml_data, const char* xpath, va_list pile
);
#ifdef __cplusplus
}
#endif
#endif

118
MLV/Makefile.am
View File

@@ -1,118 +0,0 @@
#
# This file is part of the MLV Library.
#
# Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
#
#
# This library 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, either version 3 of the License, or
# (at your option) any later version.
#
# This library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
#
mlv_includedir=${includedir}/MLV
if OS_IS_APPLE
lib_LTLIBRARIES = libMLV.la libMLVMain.la
else
lib_LTLIBRARIES = libMLV.la
endif
libMLV_la_SOURCES = \
animation.c \
audio.c \
color.c \
event.c \
shapes.c \
image.c \
informations.c \
keyboard.c \
mouse.c \
path.c \
playlist.c \
input_box.c \
input_box_wait.c \
random.c \
sdlkeyboardtochar.c \
text.c \
time.c \
xml.c \
list.c \
mathematics.c \
key.c \
tree_set.c \
tree_map.c \
window.c
if OS_IS_APPLE
libMLVMain_la_SOURCES = \
SDLMain.m
endif
if MEMORY_DEBUG
libMLV_la_SOURCES += memory_debug.c
endif
if MEMORY_DEBUG
libMLV_la_CFLAGS = ${libxml_CFLAGS} ${glib_CFLAGS} -DDATA_PATH=\"${DATA_PATH}\"
libMLV_la_LIBADD = ${libxml_LIBS} ${glib_LIBS}
else
libMLV_la_CFLAGS = ${sdl_CFLAGS} ${sdlttf_CFLAGS} ${sdlimage_CFLAGS} ${sdlmixer_CFLAGS} ${libxml_CFLAGS} ${glib_CFLAGS} -DDATA_PATH=\"${DATA_PATH}\"
libMLV_la_LIBADD = ${sdl_LIBS} ${libxml_LIBS} ${glib_LIBS} ${sdlttf_LIBS} ${sdlgfx_LIBS} ${sdlimage_LIBS} ${sdlmixer_LIBS}
endif
libMLV_la_LDFLAGS = -version-info $(MLV_CURRENT):$(MLV_REVISION):$(MLV_AGE)
# To Compile .DLL
if RELATIVEPATH
libMLV_la_LDFLAGS += -no-undefined
endif
mlv_include_HEADERS = \
MLV_audio.h \
MLV_all.h \
MLV_animation.h \
MLV_color.h \
MLV_device_with_buttons.h \
MLV_event.h \
MLV_shape.h \
MLV_image.h \
MLV_information.h \
MLV_input_box_va.h \
MLV_keyboard.h \
MLV_mouse.h \
MLV_path.h \
MLV_playlist.h \
MLV_input_box.h \
MLV_random.h \
MLV_text.h \
MLV_text_va.h \
MLV_time.h \
MLV_xml.h \
MLV_xml_va.h \
MLV_window.h
noinst_HEADERS = \
image.h \
data_structure.h \
memory_debug.h \
memory_management.h \
platform.h \
input_box.h \
sdlkeyboardtochar.h \
text.h \
warning_error.h \
mathematics.h \
list.h \
key.h \
tree_set.h \
tree_map.h \
SDLMain.h

1138
MLV/Makefile.in
View File

File diff suppressed because it is too large Load Diff

33
MLV/SDLMain.h
View File

@@ -1,33 +0,0 @@
/* SDLMain.m - main entry point for our Cocoa-ized SDL app
*
* Copyright (C)
* Initial Version: Darrell Walisser <dwaliss1@purdue.edu>
* Non-NIB-Code & other changes: Max Horn <max@quendi.de>
* Change "Feel free to customize this file to suit your needs" to a
* GPL licence for the MLV Library : Adrien Boussicault (2013)
*
* This file is part of the MLV Library.
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _SDLMain_h_
#define _SDLMain_h_
#import <Cocoa/Cocoa.h>
@interface SDLMain : NSObject
@end
#endif /* _SDLMain_h_ */

398
MLV/SDLMain.m
View File

@@ -1,398 +0,0 @@
/* SDLMain.m - main entry point for our Cocoa-ized SDL app
*
* Copyright (C)
* Initial Version: Darrell Walisser <dwaliss1@purdue.edu>
* Non-NIB-Code & other changes: Max Horn <max@quendi.de>
* Change "Feel free to customize this file to suit your needs" to a
* GPL licence for the MLV Library : Adrien Boussicault (2013)
*
* This file is part of the MLV Library.
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "SDL/SDL.h"
#include "SDLMain.h"
#include <sys/param.h> /* for MAXPATHLEN */
#include <unistd.h>
/* For some reaon, Apple removed setAppleMenu from the headers in 10.4,
but the method still is there and works. To avoid warnings, we declare
it ourselves here. */
@interface NSApplication(SDL_Missing_Methods)
- (void)setAppleMenu:(NSMenu *)menu;
@end
/* Use this flag to determine whether we use SDLMain.nib or not */
#define SDL_USE_NIB_FILE 0
/* Use this flag to determine whether we use CPS (docking) or not */
#define SDL_USE_CPS 1
#ifdef SDL_USE_CPS
/* Portions of CPS.h */
typedef struct CPSProcessSerNum
{
UInt32 lo;
UInt32 hi;
} CPSProcessSerNum;
extern OSErr CPSGetCurrentProcess( CPSProcessSerNum *psn);
extern OSErr CPSEnableForegroundOperation( CPSProcessSerNum *psn, UInt32 _arg2, UInt32 _arg3, UInt32 _arg4, UInt32 _arg5);
extern OSErr CPSSetFrontProcess( CPSProcessSerNum *psn);
#endif /* SDL_USE_CPS */
static int gArgc;
static char **gArgv;
static BOOL gFinderLaunch;
static BOOL gCalledAppMainline = FALSE;
static NSString *getApplicationName(void)
{
const NSDictionary *dict;
NSString *appName = 0;
/* Determine the application name */
dict = (const NSDictionary *)CFBundleGetInfoDictionary(CFBundleGetMainBundle());
if (dict)
appName = [dict objectForKey: @"CFBundleName"];
if (![appName length])
appName = [[NSProcessInfo processInfo] processName];
return appName;
}
#if SDL_USE_NIB_FILE
/* A helper category for NSString */
@interface NSString (ReplaceSubString)
- (NSString *)stringByReplacingRange:(NSRange)aRange with:(NSString *)aString;
@end
#endif
@interface NSApplication (SDLApplication)
@end
@implementation NSApplication (SDLApplication)
/* Invoked from the Quit menu item */
- (void)terminate:(id)sender
{
/* Post a SDL_QUIT event */
SDL_Event event;
event.type = SDL_QUIT;
SDL_PushEvent(&event);
}
@end
/* The main class of the application, the application's delegate */
@implementation SDLMain
/* Set the working directory to the .app's parent directory */
- (void) setupWorkingDirectory:(BOOL)shouldChdir
{
if (shouldChdir)
{
char parentdir[MAXPATHLEN];
CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle());
CFURLRef url2 = CFURLCreateCopyDeletingLastPathComponent(0, url);
if (CFURLGetFileSystemRepresentation(url2, 1, (UInt8 *)parentdir, MAXPATHLEN)) {
chdir(parentdir); /* chdir to the binary app's parent */
}
CFRelease(url);
CFRelease(url2);
}
}
#if SDL_USE_NIB_FILE
/* Fix menu to contain the real app name instead of "SDL App" */
- (void)fixMenu:(NSMenu *)aMenu withAppName:(NSString *)appName
{
NSRange aRange;
NSEnumerator *enumerator;
NSMenuItem *menuItem;
aRange = [[aMenu title] rangeOfString:@"SDL App"];
if (aRange.length != 0)
[aMenu setTitle: [[aMenu title] stringByReplacingRange:aRange with:appName]];
enumerator = [[aMenu itemArray] objectEnumerator];
while ((menuItem = [enumerator nextObject]))
{
aRange = [[menuItem title] rangeOfString:@"SDL App"];
if (aRange.length != 0)
[menuItem setTitle: [[menuItem title] stringByReplacingRange:aRange with:appName]];
if ([menuItem hasSubmenu])
[self fixMenu:[menuItem submenu] withAppName:appName];
}
}
#else
static void setApplicationMenu(void)
{
/* warning: this code is very odd */
NSMenu *appleMenu;
NSMenuItem *menuItem;
NSString *title;
NSString *appName;
appName = getApplicationName();
appleMenu = [[NSMenu alloc] initWithTitle:@""];
/* Add menu items */
title = [@"About " stringByAppendingString:appName];
[appleMenu addItemWithTitle:title action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""];
[appleMenu addItem:[NSMenuItem separatorItem]];
title = [@"Hide " stringByAppendingString:appName];
[appleMenu addItemWithTitle:title action:@selector(hide:) keyEquivalent:@"h"];
menuItem = (NSMenuItem *)[appleMenu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
[menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask|NSCommandKeyMask)];
[appleMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];
[appleMenu addItem:[NSMenuItem separatorItem]];
title = [@"Quit " stringByAppendingString:appName];
[appleMenu addItemWithTitle:title action:@selector(terminate:) keyEquivalent:@"q"];
/* Put menu into the menubar */
menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
[menuItem setSubmenu:appleMenu];
[[NSApp mainMenu] addItem:menuItem];
/* Tell the application object that this is now the application menu */
[NSApp setAppleMenu:appleMenu];
/* Finally give up our references to the objects */
[appleMenu release];
[menuItem release];
}
/* Create a window menu */
static void setupWindowMenu(void)
{
NSMenu *windowMenu;
NSMenuItem *windowMenuItem;
NSMenuItem *menuItem;
windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
/* "Minimize" item */
menuItem = [[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];
[windowMenu addItem:menuItem];
[menuItem release];
/* Put menu into the menubar */
windowMenuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""];
[windowMenuItem setSubmenu:windowMenu];
[[NSApp mainMenu] addItem:windowMenuItem];
/* Tell the application object that this is now the window menu */
[NSApp setWindowsMenu:windowMenu];
/* Finally give up our references to the objects */
[windowMenu release];
[windowMenuItem release];
}
/* Replacement for NSApplicationMain */
static void CustomApplicationMain (int argc, char **argv)
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
SDLMain *sdlMain;
/* Ensure the application object is initialised */
[NSApplication sharedApplication];
#ifdef SDL_USE_CPS
{
CPSProcessSerNum PSN;
/* Tell the dock about us */
if (!CPSGetCurrentProcess(&PSN))
if (!CPSEnableForegroundOperation(&PSN,0x03,0x3C,0x2C,0x1103))
if (!CPSSetFrontProcess(&PSN))
[NSApplication sharedApplication];
}
#endif /* SDL_USE_CPS */
/* Set up the menubar */
[NSApp setMainMenu:[[NSMenu alloc] init]];
setApplicationMenu();
setupWindowMenu();
/* Create SDLMain and make it the app delegate */
sdlMain = [[SDLMain alloc] init];
[NSApp setDelegate:sdlMain];
/* Start the main event loop */
[NSApp run];
[sdlMain release];
[pool release];
}
#endif
/*
* Catch document open requests...this lets us notice files when the app
* was launched by double-clicking a document, or when a document was
* dragged/dropped on the app's icon. You need to have a
* CFBundleDocumentsType section in your Info.plist to get this message,
* apparently.
*
* Files are added to gArgv, so to the app, they'll look like command line
* arguments. Previously, apps launched from the finder had nothing but
* an argv[0].
*
* This message may be received multiple times to open several docs on launch.
*
* This message is ignored once the app's mainline has been called.
*/
- (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename
{
const char *temparg;
size_t arglen;
char *arg;
char **newargv;
if (!gFinderLaunch) /* MacOS is passing command line args. */
return FALSE;
if (gCalledAppMainline) /* app has started, ignore this document. */
return FALSE;
temparg = [filename UTF8String];
arglen = SDL_strlen(temparg) + 1;
arg = (char *) SDL_malloc(arglen);
if (arg == NULL)
return FALSE;
newargv = (char **) realloc(gArgv, sizeof (char *) * (gArgc + 2));
if (newargv == NULL)
{
SDL_free(arg);
return FALSE;
}
gArgv = newargv;
SDL_strlcpy(arg, temparg, arglen);
gArgv[gArgc++] = arg;
gArgv[gArgc] = NULL;
return TRUE;
}
/* Called when the internal event loop has just started running */
- (void) applicationDidFinishLaunching: (NSNotification *) note
{
int status;
/* Set the working directory to the .app's parent directory */
[self setupWorkingDirectory:gFinderLaunch];
#if SDL_USE_NIB_FILE
/* Set the main menu to contain the real app name instead of "SDL App" */
[self fixMenu:[NSApp mainMenu] withAppName:getApplicationName()];
#endif
/* Hand off to main application code */
gCalledAppMainline = TRUE;
status = SDL_main (gArgc, gArgv);
/* We're done, thank you for playing */
exit(status);
}
@end
@implementation NSString (ReplaceSubString)
- (NSString *)stringByReplacingRange:(NSRange)aRange with:(NSString *)aString
{
unsigned int bufferSize;
unsigned int selfLen = [self length];
unsigned int aStringLen = [aString length];
unichar *buffer;
NSRange localRange;
NSString *result;
bufferSize = selfLen + aStringLen - aRange.length;
buffer = (unichar *)NSAllocateMemoryPages(bufferSize*sizeof(unichar));
/* Get first part into buffer */
localRange.location = 0;
localRange.length = aRange.location;
[self getCharacters:buffer range:localRange];
/* Get middle part into buffer */
localRange.location = 0;
localRange.length = aStringLen;
[aString getCharacters:(buffer+aRange.location) range:localRange];
/* Get last part into buffer */
localRange.location = aRange.location + aRange.length;
localRange.length = selfLen - localRange.location;
[self getCharacters:(buffer+aRange.location+aStringLen) range:localRange];
/* Build output string */
result = [NSString stringWithCharacters:buffer length:bufferSize];
NSDeallocateMemoryPages(buffer, bufferSize);
return result;
}
@end
#ifdef main
# undef main
#endif
/* Main entry point to executable - should *not* be SDL_main! */
int main (int argc, char **argv)
{
/* Copy the arguments into a global variable */
/* This is passed if we are launched by double-clicking */
if ( argc >= 2 && strncmp (argv[1], "-psn", 4) == 0 ) {
gArgv = (char **) SDL_malloc(sizeof (char *) * 2);
gArgv[0] = argv[0];
gArgv[1] = NULL;
gArgc = 1;
gFinderLaunch = YES;
} else {
int i;
gArgc = argc;
gArgv = (char **) SDL_malloc(sizeof (char *) * (argc+1));
for (i = 0; i <= argc; i++)
gArgv[i] = argv[i];
gFinderLaunch = NO;
}
#if SDL_USE_NIB_FILE
NSApplicationMain (argc, argv);
#else
CustomApplicationMain (argc, argv);
#endif
return 0;
}

1116
MLV/animation.c
View File

File diff suppressed because it is too large Load Diff

149
MLV/audio.c
View File

@@ -1,149 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_audio.h"
#include "warning_error.h"
#include "memory_management.h"
#include "data_structure.h"
#include "platform.h"
#if defined( OS_WINDOWS )
# include <SDL/SDL_mixer.h>
#elif defined( OS_APPLE )
# include <SDL_mixer/SDL_mixer.h>
#else
# include <SDL/SDL_mixer.h>
#endif
#include <glib.h>
extern DataMLV* MLV_data;
struct _MLV_Music {
Mix_Music* music;
};
struct _MLV_Sound {
Mix_Chunk* sample;
};
struct _MLV_Playlist {
GList* list_music;
};
#define MLV_AUDIO_BUFFER_SIZE 1024
#define MLV_AUDIO_STEREO 2
#define MLV_AUDIO_NUMBER_OF_MIXING_CHANEL 16
int init_audio( int buffer_size ){
int result = Mix_OpenAudio(
MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, MLV_AUDIO_STEREO, buffer_size
);
if( !result ){
Mix_AllocateChannels(MLV_AUDIO_NUMBER_OF_MIXING_CHANEL);
}
return result;
}
void MLV_change_number_of_parallel_sounds( unsigned int n ){
if( ! n ){
fprintf( stderr, "Incorrect parameter for MLV_change_number_playing_parallel_sounds. The number of parrallel sound can't be null." );
exit(1);
}
Mix_AllocateChannels( n );
}
int MLV_init_audio(){
return init_audio( MLV_AUDIO_BUFFER_SIZE ); // If the sound are not well
// former, increse this value.
// If the sound have some lags, the you have
// to decrease this value.
}
int MLV_change_audio_buffer_size( int buffer_size ){
MLV_free_audio();
return init_audio( buffer_size );
}
void MLV_free_audio(){
Mix_HaltChannel(-1);
Mix_HaltMusic();
Mix_CloseAudio();
}
MLV_Music* MLV_load_music( const char* file_music ){
MLV_Music* result = MLV_MALLOC( 1, MLV_Music );
result->music= Mix_LoadMUS( file_music );
if(! result->music) {
MLV_FREE( result, MLV_Music );
result = NULL;
}
return result;
}
void MLV_free_music( MLV_Music* music ){
if( music ){
Mix_FreeMusic( music->music );
MLV_FREE( music, MLV_Music );
}
}
void MLV_play_music( const MLV_Music* music, float volume, int loop ){
Mix_VolumeMusic( volume * MIX_MAX_VOLUME );
MLV_stop_music();
if( loop ) Mix_PlayMusic( music->music, loop-1 );
}
void MLV_stop_music(){
Mix_HaltMusic();
}
MLV_Sound* MLV_load_sound( const char* file_sound ){
MLV_Sound* result = MLV_MALLOC( 1, MLV_Sound );
result->sample = Mix_LoadWAV( file_sound );
if(! result->sample ){
MLV_FREE( result, MLV_Sound );
result = NULL;
}else{
Mix_VolumeChunk( result->sample, MIX_MAX_VOLUME );
}
return result;
}
void MLV_free_sound( MLV_Sound* sound ){
if( sound ){
Mix_FreeChunk( sound->sample );
MLV_FREE( sound, MLV_Sound );
}
}
void MLV_play_sound( const MLV_Sound* sound, float volume ){
int channel = Mix_PlayChannel( -1, sound->sample, 0 );
Mix_Volume(channel, volume * MIX_MAX_VOLUME);
}
void MLV_stop_all_sounds(){
Mix_HaltChannel(-1);
}

4589
MLV/color.c
View File

File diff suppressed because it is too large Load Diff

77
MLV/config.h.in
View File

@@ -1,77 +0,0 @@
/* MLV/config.h.in. Generated from configure.ac by autoheader. */
/* Define to 1 if you have the <dlfcn.h> header file. */
#undef HAVE_DLFCN_H
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the `m' library (-lm). */
#undef HAVE_LIBM
/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#undef LT_OBJDIR
/* Define the revision in the source repository */
#undef MLV_RCS_REVISION
/* Define the revision control software */
#undef MLV_REPOSITORY
/* Define the address of the MLV repository */
#undef MLV_SOURCE_REPOSITORY
/* Name of package */
#undef PACKAGE
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the home page for this package. */
#undef PACKAGE_URL
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
/* Version number of package */
#undef VERSION
/* Define to empty if `const' does not conform to ANSI C. */
#undef const

72
MLV/data_structure.h
View File

@@ -1,72 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__DATA_STRUCTURE_H_
#define __MLV__DATA_STRUCTURE_H_
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#endif
#else
#include "memory_management.h"
#endif
#include <glib.h>
#include "MLV_playlist.h"
#include "MLV_text.h"
#include "list.h"
typedef struct _DataMLV {
SDL_Surface *screen;
Uint32 width;
Uint32 height;
int full_screen_is_enable;
SDL_Rect rectangle;
SDL_Surface *save_screen;
SDL_sem* audio_semaphore;
SDL_AudioSpec audio_device_spec;
MLV_List* playing_streaming;
MLV_List* playlists;
MLV_List* active_playlists;
MLV_Font* defaultFont;
FPSmanager frame_rate_manager;
FPSmanager frame_rate_manager_for_MLV_wait_event;
} DataMLV;
struct _MLV_Image {
SDL_Surface * surface;
};
#endif

425
MLV/event.c
View File

@@ -1,425 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_event.h"
#include "MLV_mouse.h"
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#endif
#else
#include "memory_debug.h"
#endif
#include <string.h>
#include "warning_error.h"
#include "memory_management.h"
#include "MLV_time.h"
#include "data_structure.h"
extern DataMLV* MLV_data;
MLV_Event MLV_get_event(
MLV_Keyboard_button* key_sym, MLV_Keyboard_modifier* key_mod, int* unicode,
char** texte, MLV_Input_box** input_box,
int* mouse_x, int* mouse_y, MLV_Mouse_button* mouse_button,
MLV_Button_state* state
){
SDL_Event event;
int invalidEvent = 1;
while( invalidEvent ){
if( SDL_PollEvent( &event ) ){
switch( event.type ){
case SDL_KEYDOWN: {
if( key_sym || key_mod || state ){
if( key_sym ){
(*key_sym) = (MLV_Keyboard_button)
event.key.keysym.sym;
}
if( key_mod ){
(*key_mod) = (MLV_Keyboard_modifier)
event.key.keysym.mod;
}
if( unicode ){
(*unicode) = event.key.keysym.unicode;
}
if( state ){
(*state) = MLV_PRESSED;
}
return MLV_KEY;
}
};
break;
case SDL_KEYUP:{
if( key_sym || key_mod || state ){
if( key_sym ){
(*key_sym) = (MLV_Keyboard_button)
event.key.keysym.sym;
}
if( key_mod ){
(*key_mod) = (MLV_Keyboard_modifier)
event.key.keysym.mod;
}
if( unicode ){
(*unicode) = event.key.keysym.unicode;
}
if( state ){
(*state) = MLV_RELEASED;
}
return MLV_KEY;
}
};
break;
case SDL_MOUSEMOTION:{
if( mouse_x || mouse_y ){
if( mouse_x ){
(*mouse_x) = event.motion.x;
}
if( mouse_y ){
(*mouse_y) = event.motion.y;
}
return MLV_MOUSE_MOTION;
}
}
break;
case SDL_MOUSEBUTTONUP: {
if( mouse_x || mouse_y || mouse_button || state ){
if( mouse_x ){
(*mouse_x) = event.button.x;
}
if( mouse_y ){
(*mouse_y) = event.button.y;
}
if( mouse_button ){
(*mouse_button) = (MLV_Mouse_button)
event.button.button;
}
if( state ){
(*state) = MLV_RELEASED;
}
return MLV_MOUSE_BUTTON;
}
}
break;
case SDL_MOUSEBUTTONDOWN: {
if( mouse_x || mouse_y || mouse_button || state ){
if( mouse_x ){
(*mouse_x) = event.button.x;
}
if( mouse_y ){
(*mouse_y) = event.button.y;
}
if( mouse_button ){
(*mouse_button) = (MLV_Mouse_button)
event.button.button;
}
if( state ){
(*state) = MLV_PRESSED;
}
return MLV_MOUSE_BUTTON;
}
}
break;
case SDL_QUIT:{
}
break;
case SDL_USEREVENT: {
if( event.user.code == MLV_INPUT_BOX ){
if( texte || input_box ){
if( input_box ){
(*input_box) = event.user.data1;
}
if( texte ){
int size = strlen(event.user.data2)+1;
(*texte) = MLV_MALLOC( size, char );
memcpy(
(*texte),
event.user.data2,
size
);
}
return MLV_INPUT_BOX;
}
}
}
break;
default:;
}
}else{
invalidEvent = 0;
}
}
return MLV_NONE;
}
MLV_Event MLV_wait_event(
MLV_Keyboard_button* key_sym, MLV_Keyboard_modifier* key_mod, int* unicode,
char** texte, MLV_Input_box** input_box,
int* mouse_x, int* mouse_y, MLV_Mouse_button* mouse_button,
MLV_Button_state* state
){
MLV_Event resultat;
while(
(
resultat = MLV_get_event(
key_sym, key_mod, unicode,
texte, input_box,
mouse_x, mouse_y, mouse_button,
state
)
) == MLV_NONE
) SDL_framerateDelay( &(MLV_data->frame_rate_manager_for_MLV_wait_event) );
return resultat;
}
MLV_Event MLV_wait_event_or_seconds(
MLV_Keyboard_button* key_sym, MLV_Keyboard_modifier* key_mod, int* unicode,
char** texte, MLV_Input_box** input_box,
int* mouse_x, int* mouse_y, MLV_Mouse_button* mouse_button,
MLV_Button_state* state, int seconds
){
MLV_Event resultat;
int time = MLV_get_time();
while(
(
(
resultat = MLV_get_event(
key_sym, key_mod, unicode,
texte, input_box,
mouse_x, mouse_y, mouse_button,
state
)
) == MLV_NONE
) && (
MLV_get_time() - time < seconds*1000
)
) SDL_framerateDelay( &(MLV_data->frame_rate_manager_for_MLV_wait_event) );
return resultat;
}
void MLV_flush_event_queue(){
MLV_get_event(
NULL, NULL, NULL,
NULL, NULL,
NULL, NULL, NULL,
NULL
);
}
MLV_Event MLV_wait_keyboard_or_mouse(
MLV_Keyboard_button* sym, MLV_Keyboard_modifier* mod, int* unicode,
int* mouse_x, int* mouse_y
){
MLV_Event resultat;
MLV_Button_state state;
MLV_Mouse_button mouse_button;
// We remove all existing event from the queue
MLV_flush_event_queue();
MLV_Keyboard_button tmp_sym;
MLV_Keyboard_modifier tmp_mod;
int tmp_unicode;
int tmp_mouse_x;
int tmp_mouse_y;
//We wait for a new keyboard or mouse event
while(
(
(
(
resultat = MLV_wait_event(
&tmp_sym, &tmp_mod, &tmp_unicode,
NULL, NULL,
&tmp_mouse_x, &tmp_mouse_y, &mouse_button,
&state
)
) != MLV_KEY
) && (
( resultat != MLV_MOUSE_BUTTON ) ||
( mouse_button != MLV_BUTTON_LEFT )
)
) || (
state != MLV_PRESSED
)
);
switch( resultat ){
case MLV_KEY:
if( sym ) *sym = tmp_sym;
if( mod ) *mod = tmp_mod;
if( unicode ) *unicode = tmp_unicode;
break;
case MLV_MOUSE_BUTTON:
if( mouse_x ) *mouse_x = tmp_mouse_x;
if( mouse_y ) *mouse_y = tmp_mouse_y;
break;
default:
ERROR("Valeur d'evenements innatendu.");
}
return resultat;
}
MLV_Event MLV_wait_keyboard_or_mouse_or_seconds(
MLV_Keyboard_button* sym, MLV_Keyboard_modifier* mod, int* unicode,
int* mouse_x, int* mouse_y,
int seconds
){
MLV_Event resultat;
MLV_Button_state state;
MLV_Mouse_button mouse_button;
// We remove all existing event from the queue
MLV_flush_event_queue();
int time = MLV_get_time();
MLV_Keyboard_button tmp_sym;
MLV_Keyboard_modifier tmp_mod;
int tmp_unicode;
int tmp_mouse_x;
int tmp_mouse_y;
int event_is_not_valid = 0;
//We wait for a new keyboard or mouse event
while(
(
event_is_not_valid = (
(
(
resultat = MLV_wait_event_or_seconds(
&tmp_sym, &tmp_mod, &tmp_unicode,
NULL, NULL,
&tmp_mouse_x, &tmp_mouse_y, &mouse_button,
&state,
seconds - (MLV_get_time() - time)/1000
)
) != MLV_KEY
) && (
( resultat != MLV_MOUSE_BUTTON ) ||
( mouse_button != MLV_BUTTON_LEFT )
)
) || (
state != MLV_PRESSED
)
) && (
(MLV_get_time() - time) < seconds*1000
)
);
if(event_is_not_valid) return MLV_NONE;
switch( resultat ){
case MLV_KEY:
if( sym ) *sym = tmp_sym;
if( mod ) *mod = tmp_mod;
if( unicode ) *unicode = tmp_unicode;
break;
case MLV_MOUSE_BUTTON:
if( mouse_x ) *mouse_x = tmp_mouse_x;
if( mouse_y ) *mouse_y = tmp_mouse_y;
break;
default:
ERROR("Valeur d'evenements innatendu.");
}
return resultat;
}
const char* MLV_convert_event_to_string( MLV_Event event_code ){
switch( event_code ){
case MLV_NONE:
return "MLV_NONE";
case MLV_KEY:
return "MLV_KEY";
case MLV_INPUT_BOX:
return "MLV_INPUT_BOX";
case MLV_MOUSE_BUTTON:
return "MLV_MOUSE_BUTTON";
case MLV_MOUSE_MOTION:
return "MLV_MOUSE_MOTION";
default:
ERROR( "Event code unexpected." );
}
return NULL;
}
MLV_Event MLV_convert_string_to_event( const char* event_string ){
if( strcmp( event_string, "MLV_NONE" )==0 ){
return MLV_NONE;
}
if( strcmp( event_string, "MLV_KEY" )==0 ){
return MLV_KEY;
}
if( strcmp( event_string, "MLV_INPUT_BOX" )==0 ){
return MLV_INPUT_BOX;
}
if( strcmp( event_string, "MLV_MOUSE_BUTTON" )==0 ){
return MLV_MOUSE_BUTTON;
}
if( strcmp( event_string, "MLV_MOUSE_MOTION" )==0 ){
return MLV_MOUSE_MOTION;
}
ERROR( "Event name unknown." );
return -1;
}
const char* MLV_convert_button_state_to_string( MLV_Button_state state_code ){
switch( state_code ){
case MLV_PRESSED :
return "MLV_PRESSED";
case MLV_RELEASED :
return "MLV_RELEASED";
default:
ERROR( "Unexpected state code." );
}
return NULL;
}
MLV_Button_state MLV_convert_string_to_button_state( const char* state_string ){
if( strcmp( state_string, "MLV_PRESSED" ) ){
return MLV_PRESSED;
}
if( strcmp( state_string, "MLV_RELEASED" ) ){
return MLV_RELEASED;
}
ERROR( "Unexpected state name." );
return -1;
}

521
MLV/image.c
View File

@@ -1,521 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_image.h"
#include "data_structure.h"
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_image.h>
# include <SDL/SDL_rotozoom.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL_image/SDL_image.h>
# include <SDL/SDL_rotozoom.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_image.h>
# include <SDL/SDL_rotozoom.h>
#endif
#else
#include "memory_debug.h"
#endif
#include "warning_error.h"
#include "memory_management.h"
#include "data_structure.h"
#include "image.h"
extern DataMLV* MLV_data;
SDL_Surface* create_surface( int width, int height ){
Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
#if defined( OS_ANDROID )
return SDL_CreateRGBSurface(
SDL_SWSURFACE|SDL_SRCALPHA,
width, height,
MLV_BPP, rmask, gmask, bmask, amask
);
#else
return SDL_CreateRGBSurface(
SDL_HWSURFACE|SDL_SRCALPHA,
width, height,
MLV_BPP, rmask, gmask, bmask, amask
);
#endif
}
MLV_Image* MLV_load_image( const char* file_image ){
if( MLV_data==NULL ){
ERROR("Before using MLV_load_image, you have to initialise the MLV library by calling MLV_create_windows.");
}
SDL_Surface* surface = IMG_Load( file_image );
if( surface==NULL ){
return NULL;
}
MLV_Image* image = MLV_MALLOC( 1, MLV_Image );
image->surface = SDL_DisplayFormatAlpha(
surface
);
SDL_FreeSurface( surface );
return image;
}
int MLV_save_image_as_bmp( const MLV_Image* image, const char* file_image ){
return SDL_SaveBMP( image->surface, file_image );
}
void MLV_resize_image( MLV_Image* image, int width, int height ){
double scalar_x = ((double) width) / ((double) image->surface->w);
double scalar_y = ((double) height) / ((double) image->surface->h);
MLV_scale_xy_image( image, scalar_x, scalar_y );
}
void MLV_vertical_image_mirror( MLV_Image* image ){
int width, height;
MLV_get_image_size( image, &width, &height );
Uint32 *pixel_src, *pixel_dst, tmp;
int i=0; int j=0;
for( i=0; i< width/2; i++ ){
for( j=0; j<height; j++ ){
pixel_src = ((Uint32*) image->surface->pixels) +
j*image->surface->pitch/4 + i;
pixel_dst = ((Uint32*) image->surface->pixels) +
j*image->surface->pitch/4 + width-1-i;
tmp = *pixel_dst;
*pixel_dst = *pixel_src;
*pixel_src = tmp;
}
}
}
void MLV_horizontal_image_mirror( MLV_Image* image ){
int width, height;
MLV_get_image_size( image, &width, &height );
Uint32 *pixel_src, *pixel_dst, tmp;
int i=0; int j=0;
for( i=0; i< width; i++ ){
for( j=0; j<height/2; j++ ){
pixel_src = ((Uint32*) image->surface->pixels) +
j*image->surface->pitch/4 + i;
pixel_dst = ((Uint32*) image->surface->pixels) +
(height-1-j)*image->surface->pitch/4 + i;
tmp = *pixel_dst;
*pixel_dst = *pixel_src;
*pixel_src = tmp;
}
}
}
void MLV_resize_image_with_proportions( MLV_Image* image, int width, int height ){
double scalar_x = -1.0;
double scalar_y = -1.0;
if( width<=0 && height<=0 ) return;
if( width > 0){
scalar_x = ((double) width) / ((double) image->surface->w);
}
if( height > 0){
scalar_y = ((double) height) / ((double) image->surface->h);
}
if( scalar_x < 0 ){
scalar_x = scalar_y;
}
if( scalar_y < 0 ){
scalar_y = scalar_x;
}
MLV_scale_image( image, ( scalar_x < scalar_y )? scalar_x : scalar_y );
}
void MLV_get_image_size( const MLV_Image* image, int* width, int* height ){
if( width ){
*width = image->surface->w;
}
if( height ){
*height = image->surface->h;
}
}
int MLV_get_image_width( const MLV_Image* image ){
return image->surface->w;
}
int MLV_get_image_height( const MLV_Image* image ){
return image->surface->h;
}
void MLV_scale_xy_image( MLV_Image* image, double scalar_x, double scalar_y ){
MLV_rotate_and_scale_xy_image( image, 0.0, scalar_x, scalar_y );
}
void MLV_rotate_and_scale_xy_image(
MLV_Image* image, double rotation, double scalar_x, double scalar_y
){
SDL_Surface* dst;
dst = rotozoomSurfaceXY( image->surface, rotation, scalar_x, scalar_y, 0);
SDL_FreeSurface( image->surface );
image->surface = dst;
}
void MLV_scale_image( MLV_Image* image, double scalar ){
MLV_rotate_and_scale_image( image, 0.0, scalar );
}
void MLV_rotate_image( MLV_Image* image, double rotation ){
MLV_rotate_and_scale_image( image, rotation, 1.0 );
}
void MLV_rotate_and_scale_image( MLV_Image* image, double rotation, double scalar ){
SDL_Surface* dst;
dst = rotozoomSurface( image->surface, rotation, scalar, 0);
SDL_FreeSurface( image->surface );
image->surface = dst;
}
MLV_Image* MLV_create_image( int width, int height ){
MLV_Image* result = MLV_MALLOC( 1, MLV_Image );
result->surface = create_surface( width, height );
int i,j;
for( i=0; i<width; i++ ){
for( j=0; j<height; j++ ){
MLV_set_pixel_on_image( i, j, MLV_rgba( 0,0,0,255 ), result );
}
}
return result;
}
void MLV_free_image( MLV_Image* image ){
if( image ){
SDL_FreeSurface( image->surface );
MLV_FREE( image, MLV_Image );
}
}
MLV_Image* MLV_copy_image( const MLV_Image* image ){
MLV_Image* result = MLV_MALLOC( 1, MLV_Image );
result->surface = SDL_ConvertSurface(
image->surface, image->surface->format, image->surface->flags
);
return result;
}
MLV_Image* MLV_copy_partial_image( const MLV_Image* image, int x, int y, int width, int height ){
MLV_Image* result = MLV_MALLOC( 1, MLV_Image );
SDL_Surface* tmp = create_surface( width, height );
result->surface = SDL_DisplayFormatAlpha( tmp );
SDL_FreeSurface( tmp );
SDL_LockSurface( image->surface );
SDL_LockSurface( result->surface );
Uint32 *pixel_src, *pixel_dst;
int i=0; int j=0;
for( i=0; i< width; i++ ){
for( j=0; j<height; j++ ){
pixel_src = ((Uint32*) image->surface->pixels) +
(y+j)*image->surface->pitch/4 + x+i;
pixel_dst = ((Uint32*) result->surface->pixels) +
j*result->surface->pitch/4 + i;
*pixel_dst = * pixel_src;
}
}
SDL_UnlockSurface( result->surface );
SDL_UnlockSurface( image->surface );
return result;
}
void MLV_draw_image( const MLV_Image* image, int x, int y ){
SDL_Rect rectangle;
rectangle.x = x;
rectangle.y = y;
rectangle.h = image->surface->h;
rectangle.w = image->surface->w;
SDL_BlitSurface( image->surface, NULL, MLV_data->screen, &rectangle);
}
void MLV_draw_partial_image(
const MLV_Image* image, int x_source, int y_source,
int width_source, int height_source,
int x, int y
){
SDL_Rect rectangle_source;
rectangle_source.x = x_source;
rectangle_source.y = y_source;
rectangle_source.h = height_source;
rectangle_source.w = width_source;
SDL_Rect rectangle_dest;
rectangle_dest.x = x;
rectangle_dest.y = y;
rectangle_dest.h = height_source;
rectangle_dest.w = width_source;
SDL_BlitSurface( image->surface, &rectangle_source, MLV_data->screen, &rectangle_dest);
}
void MLV_draw_scaled_rotated_image( MLV_Image* image, int centre_x, int centre_y, double rotation, double scalar ){
SDL_Surface* dst;
dst = rotozoomSurface( image->surface, rotation, scalar, 0);
SDL_Rect rectangle_dest;
rectangle_dest.x = centre_x;
rectangle_dest.y = centre_y;
rectangle_dest.h = dst->h;
rectangle_dest.w = dst->w;
SDL_BlitSurface( dst, NULL, MLV_data->screen, &rectangle_dest);
SDL_FreeSurface( dst );
}
void MLV_draw_rotated_image( MLV_Image* image, int centre_x, int centre_y, double roation ){
MLV_draw_scaled_rotated_image( image, centre_x, centre_y, roation, 1.0 );
}
void MLV_draw_scaled_image( MLV_Image* image, int centre_x, int centre_y, double scalar ){
MLV_draw_scaled_rotated_image( image, centre_x, centre_y, 0.0, scalar );
}
void MLV_set_alpha_on_image( MLV_Alpha alpha, MLV_Image *image ){
SDL_Surface* surface = image->surface;
SDL_LockSurface(surface);
SDL_PixelFormat *fmt;
Uint32 *pixel;
Uint32 alpha32;
fmt = surface->format;
int x,y;
int width, height;
MLV_get_image_size( image, &width, &height );
for( x=0; x<width; x++){
for( y=0; y<height; y++ ){
pixel = ((Uint32*) surface->pixels)+ y*surface->pitch/4 + x;
/* set the Alpha component */
alpha32 = alpha;
alpha32 = alpha32 >> fmt->Aloss;
alpha32 = alpha32 << fmt->Ashift;
*pixel = (
*pixel & ( fmt->Rmask | fmt->Gmask | fmt->Bmask )
) | alpha32;
}
}
SDL_UnlockSurface(surface);
}
void MLV_set_pixel_on_image(
int x, int y,
MLV_Color color,
MLV_Image *image
){
SDL_Surface* surface = image->surface;
SDL_LockSurface(surface);
SDL_PixelFormat *fmt;
Uint32 *pixel;
fmt = surface->format;
pixel = ((Uint32*) surface->pixels)+ y*surface->pitch/4 + x;
Uint8 red, blue, green, alpha;
MLV_convert_color_to_rgba( color, &red, &green, &blue, &alpha );
Uint32 red32 = red, blue32 = blue, green32 = green, alpha32 = alpha;
/* set the Red component */
red32 = red32 >> fmt->Rloss;
red32 = red32 << fmt->Rshift;
/* set the Green component */
green32 = green32 >> fmt->Gloss;
green32 = green32 << fmt->Gshift;
/* set the Blue component */
blue32 = blue32 >> fmt->Bloss;
blue32 = blue32 << fmt->Bshift;
/* set the Alpha component */
alpha32 = alpha32 >> fmt->Aloss;
alpha32 = alpha32 << fmt->Ashift;
*pixel = red32 | green32 | blue32 | alpha32;
SDL_UnlockSurface(surface);
}
SDL_Surface* MLV_get_image_data( MLV_Image* image ){
return image->surface;
}
void get_pixel_on_image_unsafe(
SDL_Surface* surface,
int x, int y,
int* red, int* green, int* blue, int* alpha
){
/* Extracting color components from a 32-bit color value */
SDL_PixelFormat *fmt;
Uint32 temp, pixel;
fmt = surface->format;
pixel = *(((Uint32*) surface->pixels)+ y*surface->pitch/4 + x );
/* Get Red component */
if( red ){
temp = pixel & fmt->Rmask; /* Isolate red component */
temp = temp >> fmt->Rshift; /* Shift it down to 8-bit */
temp = temp << fmt->Rloss; /* Expand to a full 8-bit number */
*red = temp;
}
/* Get Green component */
if( green ){
temp = pixel & fmt->Gmask; /* Isolate green component */
temp = temp >> fmt->Gshift; /* Shift it down to 8-bit */
temp = temp << fmt->Gloss; /* Expand to a full 8-bit number */
*green = temp;
}
/* Get Blue component */
if( blue ){
temp = pixel & fmt->Bmask; /* Isolate blue component */
temp = temp >> fmt->Bshift; /* Shift it down to 8-bit */
temp = temp << fmt->Bloss; /* Expand to a full 8-bit number */
*blue = temp;
}
/* Get Alpha component */
if( alpha ){
temp = pixel & fmt->Amask; /* Isolate alpha component */
temp = temp >> fmt->Ashift; /* Shift it down to 8-bit */
temp = temp << fmt->Aloss; /* Expand to a full 8-bit number */
*alpha = temp;
}
}
void get_pixel_on_image(
SDL_Surface* surface,
int x, int y,
int* red, int* green, int* blue, int* alpha
){
SDL_LockSurface(surface);
get_pixel_on_image_unsafe(
surface,
x, y,
red, green, blue, alpha
);
SDL_UnlockSurface(surface);
}
void MLV_get_pixel(
int x, int y, int* red, int* green, int* blue, int* alpha
){
get_pixel_on_image( MLV_data->screen, x, y, red, green, blue, alpha );
}
void MLV_get_pixel_on_image(
const MLV_Image* image, int x, int y,
int* red, int* green, int* blue, int* alpha
){
get_pixel_on_image( image->surface, x, y, red, green, blue, alpha );
}
void MLV_draw_image_on_image(
const MLV_Image* source_image,
MLV_Image* destination_image,
int destination_x, int destination_y
){
SDL_Rect rectangle;
rectangle.x = destination_x;
rectangle.y = destination_y;
rectangle.h = source_image->surface->h;
rectangle.w = source_image->surface->w;
SDL_BlitSurface( source_image->surface, NULL, destination_image->surface , &rectangle);
}
void MLV_draw_partial_image_on_image(
const MLV_Image* source_image,
int source_x, int source_y,
int width, int height,
MLV_Image* destination_image,
int destination_x, int destination_y
){
SDL_Rect rectangle_source,rectangle_destination;
rectangle_destination.x = destination_x;
rectangle_destination.y = destination_y;
rectangle_destination.w = destination_image->surface->w;
rectangle_destination.h = destination_image->surface->h;
rectangle_source.x = source_x;
rectangle_source.y = source_y;
rectangle_source.w = width;
rectangle_source.h = height;
SDL_BlitSurface(
source_image->surface, &rectangle_source,
destination_image->surface , &rectangle_destination
);
}
///////////////////////////////////////////////////////////////////////////////
// Save screen //
///////////////////////////////////////////////////////////////////////////////
void MLV_save_screen(){
SDL_BlitSurface( MLV_data->screen, NULL, MLV_data->save_screen, &(MLV_data->rectangle));
}
void MLV_load_screen(){
SDL_BlitSurface( MLV_data->save_screen, NULL, MLV_data->screen, &(MLV_data->rectangle));
}

55
MLV/image.h
View File

@@ -1,55 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__IMAGE_H__
#define __MLV__IMAGE_H__
#include "platform.h"
#if defined( __MLV_ANDROID__ )
# define MLV_16_BPP 16
#else
# define MLV_32_BPP 32
#endif
#if defined( MLV_32_BPP )
# define MLV_BPP 32
#elif defined( MLV_16_BPP )
# define MLV_BPP 16
#endif
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
#else
# include <SDL/SDL.h>
#endif
#else
#include "memory_debug.h"
#endif
SDL_Surface* create_surface( int width, int height );
void get_pixel_on_image_unsafe( SDL_Surface* surface, int x, int y,
int* red, int* green, int* blue, int* alpha
);
#endif

50
MLV/informations.c
View File

@@ -1,50 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_information.h"
#include "config.h"
const char* MLV_get_package_name( ){
return PACKAGE_NAME;
}
const char* MLV_get_version( ){
return VERSION;
}
const char* MLV_get_revision_of_revision_control_software( ){
return MLV_RCS_REVISION;
}
const char* MLV_get_repository( ){
return MLV_REPOSITORY;
}
const char* MLV_get_bug_report_address( ){
return PACKAGE_BUGREPORT;
}
const char* MLV_get_web_distribution( ){
return PACKAGE_URL;
}
const char* MLV_get_licence( ){
return "GPL V3";
}

935
MLV/input_box.c
View File

@@ -1,935 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "platform.h"
#ifdef OS_WINDOWS
/* Get va_list. */
#if __STDC__ || defined __cplusplus || defined _MSC_VER
# include <stdarg.h>
#else
# include <varargs.h>
#endif
extern int vasprintf (char **, const char *, va_list);
#endif
#include "MLV_input_box.h"
#include "MLV_event.h"
#include "MLV_text.h"
#include "platform.h"
#include "image.h"
#include "input_box.h"
#include "text.h"
#include "list.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
#endif
#else
#include "memory_debug.h"
#endif
#include "sdlkeyboardtochar.h"
#include "glib.h"
#include <string.h>
#include "warning_error.h"
#include "memory_management.h"
#define SIZE_FONT 8
#define SIZE_BORD 1
#define TIME_CURSOR 1000 //Periode d'oscillation du curseur (ms)
//
// Les fonction avec le suffixe _NST veux dire : No Safe Thread.
// Cela veux dire qu'anvant d'utiliser de telle fonctions, il faut
// s'assurer la propriété entiere des objet qu'il va modifier.
//
#include "data_structure.h"
extern DataMLV* MLV_data;
struct _MLV_Input_box {
//Géométrie de la boîte de saisie
int sommetHautGauche[2];
int sommetBasDroit[2];
int width;
int height;
SDL_Rect rectangle;
//Taille de la font du texte
const MLV_Font* font;
//Positiononnement du texte
int bord[2];
int widthMessage;
int widthAnswer;
int heightMessAns;
//Couleurs de la boîtes de saisie
MLV_Color borderColor;
MLV_Color textColor;
MLV_Color backgroundColor;
//Rendu de la boîte de saisie
SDL_Surface* apparence;
SDL_Surface* answer;
SDL_Rect answerRectangle;
//Message d'information
char* informativeMessage;
//position du curseur dans la réponse courante
int positionCursor;
int lastTime;
int cursorIsVisible; //le curseur (qui clignote ) est dans son etat visible
//La boîte de saisie est active
int isListenning;
//Histroique - le premier élément de l'historique correspond à la
//reponse courante de la boîte de saisie
MLV_List* history;
MLV_List* positionHistory;
//Gestion concurentiel de l'accès à la boîte de saisie.
SDL_sem* semaphore;
};
/*
* bord[0] withMessage withAnswer bord[0]
* <---><-------------><---------------------------><-->
* _ ____________________________________________________
* bord[1] | | |
* |_ | _____________________________________________ |
* | | | | | |
* heightMessAns | | | I. Message | An|swer | |
* |_ | |_______________|___________________________| |
* | | |
* bord[1] |_ |___________________________________________________|
*
*
* */
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void recalculateTextPositions_NTS( MLV_Input_box* input_box ){
int width_message, height_message;
MLV_get_size_of_text_with_font(
input_box->informativeMessage,
&width_message, &height_message,
input_box->font
);
input_box->widthMessage = width_message;
input_box->widthAnswer = input_box->width - input_box->widthMessage - 2 * input_box->bord[0];
input_box->heightMessAns = ( input_box->font->size > height_message )?
input_box->font->size : height_message ;
// input_box->heightMessAns = height_message ;
input_box->bord[1] = (input_box->height - ( input_box->heightMessAns ) )/2;
if(input_box->answer){
// DEBUG("Free answer");
SDL_FreeSurface( input_box->answer );
}
if( input_box->widthAnswer > 0 ){
// DEBUG("Create answer");
input_box->answer = create_surface( input_box->widthAnswer, input_box->heightMessAns );
input_box->answerRectangle.x = input_box->bord[0] + input_box->widthMessage;
input_box->answerRectangle.y = input_box->bord[1];
input_box->answerRectangle.w = input_box->widthAnswer;
input_box->answerRectangle.h = input_box->heightMessAns;
}else{
input_box->answer = NULL;
}
}
void lock_input_box( MLV_Input_box* input_box ){
if( SDL_SemWait( input_box->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
void unlock_input_box( MLV_Input_box* input_box ){
if( SDL_SemPost( input_box->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
typedef struct _Input_box_information {
MLV_List* input_box_list;
MLV_Input_box* input_box_activated;
SDL_sem* semaphore;
} Input_box_information;
Input_box_information input_box_information;
void lock_input_box_information( ){
if( SDL_SemWait( input_box_information.semaphore ) ){
ERROR_FULL( "Probleme de semaphore" );
}
}
void unlock_input_box_information( ){
if( SDL_SemPost( input_box_information.semaphore ) ){
ERROR_FULL( "Probleme de semaphore" );
}
}
/*
input_box->history->data
0 m l-1
---------------------------------------------------------
| | | | | X | Y | | | | | | | | \0 |
---------------------------------------------------------
|
curseur
new
0 m l-1 l
---------------------------------------------------------
| | | | | X | c | Y | | | | | | | \0 |
---------------------------------------------------------
|
curseur
*/
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void add_carac_input_box_NTS( MLV_Input_box* input_box, char c ){
int l = strlen(input_box->history->data);
int m = input_box->positionCursor ;
// DEBUG("Add History Entry");
char* new = MLV_MALLOC( ( l + 2 ), char );
strncpy( new, input_box->history->data , m );
new[input_box->positionCursor] = c;
strncpy( new + m + 1 , input_box->history->data + m , l - m );
new[l + 1] = '\0';
// DEBUG("Free History Entry");
MLV_FREE( input_box->history->data, char );
input_box->history->data = new;
input_box->positionCursor++;
}
/*
input_box->history->data
0 m l-1
---------------------------------------------------------
| | | | | X | Y | Z | | | | | | | \0 |
---------------------------------------------------------
|
curseur
resultat
0 m l-1
------------------------------------------------------
| | | | | X | Z | | | | | | | \0 |
------------------------------------------------------
|
curseur
*/
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void suppress_carac_input_box_NTS( MLV_Input_box* input_box ){
int l = strlen(input_box->history->data);
int m = input_box->positionCursor ;
if( l == m ) return;
memmove( input_box->history->data + m, input_box->history->data + m + 1, l - m );
}
/*
input_box->history->data
0 m l-1
---------------------------------------------------------
| | | | X | Y | Z | | | | | | | | \0 |
---------------------------------------------------------
|
curseur
resulat
0 m-1 m l-1
------------------------------------------------------
| | | | X | Z | | | | | | | | \0 |
------------------------------------------------------
|
curseur
*/
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void return_deletion_carac_input_box_NTS( MLV_Input_box* input_box ){
int l = strlen(input_box->history->data);
int m = input_box->positionCursor ;
if( m != 0 ){
memmove( input_box->history->data + m-1, input_box->history->data + m , l - m + 1 );
input_box->positionCursor--;
}
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void recalculateSommetBas_NTS( MLV_Input_box* input_box ){
input_box->sommetBasDroit[0] = input_box->sommetHautGauche[0] + input_box->width;
input_box->sommetBasDroit[1] = input_box->sommetHautGauche[1] + input_box->height;
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void change_position_input_box_NTS(MLV_Input_box* input_box, int sommetHautGaucheX, int sommetHautGaucheY){
input_box->sommetHautGauche[0] = sommetHautGaucheX;
input_box->sommetHautGauche[1] = sommetHautGaucheY;
input_box->rectangle.x = sommetHautGaucheX;
input_box->rectangle.y = sommetHautGaucheY;
recalculateSommetBas_NTS( input_box );
recalculateTextPositions_NTS( input_box );
}
void MLV_change_position_input_box(MLV_Input_box* input_box, int sommetHautGaucheX, int sommetHautGaucheY){
lock_input_box( input_box );
change_position_input_box_NTS( input_box, sommetHautGaucheX, sommetHautGaucheY );
unlock_input_box( input_box );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void change_size_input_box_NTS(MLV_Input_box* input_box, int width, int height){
if( (width < 0) || (height < 0)){
ERROR_FULL( "Les tailles ne sont pas correctes." );
}
input_box->width = width;
input_box->height = height;
input_box->rectangle.w = width;
input_box->rectangle.h = height;
if( input_box->apparence ){
// DEBUG("Free apparence");
SDL_FreeSurface(input_box->apparence);
}
// DEBUG("Create apparence");
input_box->apparence = create_surface( input_box->width, input_box->height );
recalculateSommetBas_NTS( input_box );
recalculateTextPositions_NTS( input_box );
}
void MLV_change_input_box_size(MLV_Input_box* input_box, int width, int height){
lock_input_box( input_box );
change_size_input_box_NTS( input_box, width, height);
unlock_input_box( input_box );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void change_geometry_input_box_NTS(MLV_Input_box* input_box, int sommetHautGaucheX, int sommetHautGaucheY, int width, int height){
change_size_input_box_NTS( input_box, width, height );
change_position_input_box_NTS( input_box, sommetHautGaucheX, sommetHautGaucheY);
};
void MLV_change_input_box_geometry(MLV_Input_box* input_box, int sommetHautGaucheX, int sommetHautGaucheY, int width, int height){
lock_input_box( input_box );
change_geometry_input_box_NTS( input_box, sommetHautGaucheX, sommetHautGaucheY, width, height);
unlock_input_box( input_box );
};
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void change_colors_input_box_NTS( MLV_Input_box* input_box, MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor ){
input_box->borderColor = borderColor;
input_box->textColor = textColor;
input_box->backgroundColor = backgroundColor;
};
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void MLV_change_input_box_colors( MLV_Input_box* input_box, MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor ){
lock_input_box( input_box );
change_colors_input_box_NTS( input_box, borderColor, textColor, backgroundColor );
unlock_input_box( input_box );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void desactivate_input_box_NTS( ){
if( input_box_information.input_box_activated ){
input_box_information.input_box_activated->isListenning = 0;
input_box_information.input_box_activated = NULL;
}
}
void MLV_desactivate_input_box( ){
lock_input_box_information();
desactivate_input_box_NTS( );
unlock_input_box_information();
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void activate_imput_box_NTS( MLV_Input_box* input_box ){
desactivate_input_box_NTS( );
input_box->isListenning = 1;
input_box_information.input_box_activated = input_box;
}
void MLV_activate_input_box( MLV_Input_box* input_box ){
lock_input_box_information();
lock_input_box( input_box );
activate_imput_box_NTS( input_box );
unlock_input_box( input_box );
unlock_input_box_information();
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
int is_in_input_box_NTS( MLV_Input_box* input_box, int x, int y ){
int result = 0;
if( (x >= input_box->sommetHautGauche[0]) &&
(x <= input_box->sommetBasDroit[0]) &&
(y >= input_box->sommetHautGauche[1]) &&
(y <= input_box->sommetBasDroit[1])
) result = 1;
return result;
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
MLV_Input_box* is_in_an_input_box_NTS( int x, int y ){
MLV_Input_box* result = NULL;
MLV_List* list = input_box_information.input_box_list;
while( list ){
MLV_Input_box* input_box = (MLV_Input_box*) list->data;
if( is_in_input_box_NTS( input_box, x, y ) ){
result = input_box;
break;
}
list = list->next;
}
return result;
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void construct_input_box_NTS( MLV_Input_box* input_box ){
int width_message_before_input_box, height_message_before_input_box;
boxColor(
input_box->apparence,
0, 0, input_box->width-1, input_box->height-1,
input_box->backgroundColor
);
drawString(
input_box->apparence,
input_box->bord[0] , input_box->bord[1],
input_box->informativeMessage,
input_box->textColor, input_box->font->font
);
if( input_box->widthAnswer > 0 ){
boxColor(
input_box->answer,
0, 0, input_box->widthAnswer-1, input_box->heightMessAns -1,
input_box->backgroundColor
);
char * message = (char*) input_box->history->data ;
int decalage = 0;
char* message_before_input_box = MLV_MALLOC( input_box->positionCursor+1, char );
strncpy( message_before_input_box, message, input_box->positionCursor );
message_before_input_box[input_box->positionCursor] = '\0';
MLV_get_size_of_text_with_font(
message_before_input_box,
&width_message_before_input_box, &height_message_before_input_box,
input_box->font
);
if( width_message_before_input_box > (input_box->widthAnswer) ){
decalage = input_box->widthAnswer - width_message_before_input_box -1;
}
MLV_FREE( message_before_input_box, char );
drawString(
input_box->answer,
decalage , 0,
message,
input_box->textColor, input_box->font->font
);
SDL_BlitSurface(
input_box->answer, NULL,
input_box->apparence, &(input_box->answerRectangle)
);
}
int time = SDL_GetTicks();
if( ( time - input_box->lastTime > TIME_CURSOR ) ){
input_box->lastTime = time;
input_box->cursorIsVisible = ! input_box->cursorIsVisible;
};
if( (! input_box->isListenning) || input_box->cursorIsVisible ){
int abscisse;
if( width_message_before_input_box > input_box->widthAnswer ){
abscisse = input_box->bord[0] +
input_box->widthMessage +
input_box->widthAnswer -2;
}else{
abscisse = input_box->bord[0] +
input_box->widthMessage +
width_message_before_input_box;
}
lineColor(
input_box->apparence,
abscisse , input_box->bord[1],
abscisse, input_box->bord[1] + input_box->heightMessAns -1,
input_box->textColor
);
}
rectangleColor(
input_box->apparence,
0, 0,
input_box->width-1, input_box->height-1,
input_box->borderColor
);
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void input_box_register_NTS(MLV_Input_box* input_box){
input_box_information.input_box_list = MLV_prepend_list( input_box_information.input_box_list , input_box );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void input_box_unregister_NTS(MLV_Input_box* input_box){
if( input_box_information.input_box_activated == input_box ) desactivate_input_box_NTS();
input_box_information.input_box_list = MLV_remove_list( input_box_information.input_box_list, input_box );
}
MLV_Input_box* create_input_box_with_font(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
const MLV_Font* font
){
// DEBUG("Add input_box");
MLV_Input_box* input_box = MLV_MALLOC( 1, MLV_Input_box );
// DEBUG("Create semaphore");
input_box->semaphore = SDL_CreateSemaphore(1);
input_box->font = font;
input_box->bord[0] = SIZE_BORD;
// DEBUG("Add Informative message");
input_box->informativeMessage = MLV_MALLOC( (strlen(informativeMessage)+1), char );
strcpy( input_box->informativeMessage, informativeMessage );
input_box->apparence = NULL;
input_box->answer = NULL;
change_geometry_input_box_NTS(input_box, sommetHautGaucheX, sommetHautGaucheY, width, height);
MLV_change_input_box_colors(input_box, borderColor, textColor, backgroundColor );
// DEBUG("Add History Entry");
input_box->history = MLV_prepend_list( NULL, MLV_MALLOC( 1, char ) );
((char*) input_box->history->data)[0] = '\0';
input_box->positionHistory = input_box->history;
input_box->positionCursor = 0;
input_box->lastTime = SDL_GetTicks();
input_box->cursorIsVisible = 1;
input_box->isListenning = 0;
lock_input_box_information();
input_box_register_NTS( input_box );
unlock_input_box_information();
return input_box;
}
MLV_Input_box* MLV_create_input_box_with_font_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
const MLV_Font* font, va_list pile
){
char* complete_informative_message;
if(
vasprintf(
&complete_informative_message, informativeMessage, pile
)==-1
){
ERROR("Unexpected Error.");
}
MLV_Input_box* result = create_input_box_with_font(
sommetHautGaucheX, sommetHautGaucheY, width, height, borderColor,
textColor, backgroundColor, complete_informative_message, font
);
free( complete_informative_message );
return result;
}
MLV_Input_box* MLV_create_input_box_with_font(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
const MLV_Font* font, ...
){
va_list pile;
va_start( pile, font );
MLV_Input_box* result = MLV_create_input_box_with_font_va(
sommetHautGaucheX, sommetHautGaucheY,
width, height,
borderColor, textColor,
backgroundColor,
informativeMessage,
font, pile
);
va_end( pile );
return result;
}
MLV_Input_box* MLV_create_input_box_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
va_list pile
){
return MLV_create_input_box_with_font_va(
sommetHautGaucheX, sommetHautGaucheY,
width, height,
borderColor, textColor,
backgroundColor,
informativeMessage,
MLV_data->defaultFont, pile
);
}
MLV_Input_box* MLV_create_input_box(
int sommetHautGaucheX, int sommetHautGaucheY,
int width, int height,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage, ...
){
va_list pile;
va_start( pile, informativeMessage );
MLV_Input_box* result = MLV_create_input_box_va(
sommetHautGaucheX, sommetHautGaucheY,
width, height,
borderColor, textColor,
backgroundColor,
informativeMessage, pile
);
va_end( pile );
return result;
}
void free_NTS( void* data, void* useless ){
// DEBUG("Free Entry Hystory");
MLV_FREE( data, char );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void suppressHistory_NTS( MLV_Input_box* input_box ){
MLV_foreach_list( input_box->history, free_NTS, NULL );
// DEBUG("Free history");
MLV_free_list( input_box->history );
}
void MLV_suppress_history( MLV_Input_box* input_box ){
lock_input_box( input_box );
suppressHistory_NTS( input_box );
unlock_input_box( input_box );
}
void MLV_free_input_box( MLV_Input_box* input_box ){
lock_input_box_information( );
lock_input_box( input_box );
input_box_unregister_NTS( input_box );
// DEBUG("Free apparence");
SDL_FreeSurface(input_box->apparence);
// DEBUG("Free answer");
SDL_FreeSurface( input_box->answer );
// DEBUG("Free Informative message");
MLV_FREE( input_box->informativeMessage, char );
// MLV_FREE( input_box->history->data, char );
suppressHistory_NTS( input_box );
// DEBUG("Free semaphore");
SDL_DestroySemaphore( input_box->semaphore );
unlock_input_box_information( );
// DEBUG("Free input_box");
MLV_FREE( input_box, MLV_Input_box );
}
void change_informative_message_of_input_box(
MLV_Input_box* input_box, const char* message
){
lock_input_box(input_box);
if( input_box->informativeMessage ){
// DEBUG("Free Informative message");
MLV_FREE( input_box->informativeMessage, char );
}
// DEBUG("Add Informative message");
input_box->informativeMessage = MLV_MALLOC( (strlen(message)+1), char );
strcpy( input_box->informativeMessage, message );
recalculateTextPositions_NTS( input_box );
unlock_input_box(input_box);
}
void MLV_change_informative_message_of_input_box_va(
MLV_Input_box* input_box, const char* message, va_list pile
){
char* complete_message;
if( vasprintf( &complete_message, message, pile )==-1 ){
ERROR("Unexpected Error.");
}
change_informative_message_of_input_box(
input_box, complete_message
);
free( complete_message );
}
void MLV_change_informative_message_of_input_box(
MLV_Input_box* input_box, const char* message, ...
){
va_list pile;
va_start( pile, message );
MLV_change_informative_message_of_input_box_va(
input_box, message, pile
);
va_end( pile );
}
void MLV_draw_input_box( MLV_Input_box* input_box ){
lock_input_box( input_box );
construct_input_box_NTS( input_box );
SDL_BlitSurface( input_box->apparence, NULL, MLV_data->screen, &(input_box->rectangle));
unlock_input_box( input_box );
}
void MLV_draw_all_input_boxes(){
lock_input_box_information( );
MLV_foreach_list( input_box_information.input_box_list, (void (*)(void*,void*)) MLV_draw_input_box , MLV_data->screen);
unlock_input_box_information( );
}
void init_input_box_mechanism(){
SDL_EnableUNICODE(SDL_ENABLE);
input_box_information.semaphore = SDL_CreateSemaphore(1);
lock_input_box_information();
input_box_information.input_box_list = NULL;
input_box_information.input_box_activated=NULL;
unlock_input_box_information();
}
void quit_input_box_mechanism(){
SDL_DestroySemaphore(input_box_information.semaphore);
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void replaceEntreeByHistory_NTS( MLV_Input_box* input_box ){
char* dst = input_box->history->data;
if( input_box->positionHistory != input_box->history ){
char* src = (char*) input_box->positionHistory->data;
if( strlen(dst) >= strlen(src) ){
strcpy( dst, src );
}else{
// DEBUG("Add Hystory Entry");
input_box->history->data = MLV_MALLOC( (strlen(src) + 1), char );
strcpy( input_box->history->data, src );
// DEBUG("Suppress Hystory Entry");
MLV_FREE( dst, char );
}
}else{
if(dst){
dst[0] = '\0';
}
}
input_box->positionCursor = strlen(input_box->history->data);
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void goDownInHistory_NTS( MLV_Input_box* input_box ){
if( input_box->positionHistory->previous ){
input_box->positionHistory = input_box->positionHistory->previous;
}else{
return;
}
replaceEntreeByHistory_NTS( input_box );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void goUpInHistory_NTS( MLV_Input_box* input_box ){
if( input_box->positionHistory->next ){
input_box->positionHistory = input_box->positionHistory->next;
}else{
return;
}
replaceEntreeByHistory_NTS( input_box );
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void make_the_input_box_visible_NTS( MLV_Input_box* input_box ){
input_box->lastTime = SDL_GetTicks();
input_box->cursorIsVisible = 1;
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void input_box_move_left_answer_NTS( MLV_Input_box* input_box ){
if( input_box->positionCursor > 0 ){
input_box->positionCursor--;
}
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void input_box_move_right_answer_NTS( MLV_Input_box* input_box ){
if( input_box->positionCursor < strlen( input_box->history->data ) ){
input_box->positionCursor++;
}
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void validate_input_box_NTS( MLV_Input_box* input_box ){
SDL_Event event;
event.type = SDL_USEREVENT;
event.user.code = MLV_INPUT_BOX;
event.user.data1 = input_box;
event.user.data2 = input_box->history->data;
SDL_PushEvent(&event);
input_box->history = MLV_prepend_list( input_box->history, input_box->history->data );
input_box->positionHistory = input_box->history;
// DEBUG("Add Hystory Entry");
input_box->history->data = MLV_MALLOC( 1, char );
((char*)input_box->history->data)[0] = '\0';
input_box->positionCursor = 0;
}
int input_box_events_filter(const SDL_Event *event) {
int result = 1;
lock_input_box_information();
switch(event->type){
case SDL_KEYUP :
{ //Une touche a ete appuyee
if( input_box_information.input_box_activated ) result = 0;
}
break;
case SDL_KEYDOWN :
{ //Une touche a ete appuyee
// Si la touche echap a ete appuye, on laisse passe l'evenement
if ( event->key.keysym.sym == SDLK_ESCAPE ) break;
if( input_box_information.input_box_activated ){
lock_input_box( input_box_information.input_box_activated );
make_the_input_box_visible_NTS( input_box_information.input_box_activated);
//Si la touche est une fleche gauche ou droite on deplace le curseu
if( event->key.keysym.sym == SDLK_LEFT ){
input_box_move_left_answer_NTS( input_box_information.input_box_activated );
}else if( event->key.keysym.sym == SDLK_RIGHT ){
input_box_move_right_answer_NTS( input_box_information.input_box_activated );
}else if( event->key.keysym.sym == SDLK_UP ){//Si la touche est une fleche bas ou haut on se deplace dans l'historique
goUpInHistory_NTS( input_box_information.input_box_activated );
}else if( event->key.keysym.sym == SDLK_DOWN ){
goDownInHistory_NTS( input_box_information.input_box_activated );
}else if( event->key.keysym.sym == SDLK_DELETE ){//Si la touche est une suppession on supprime une lettre
suppress_carac_input_box_NTS( input_box_information.input_box_activated );
}else if( event->key.keysym.sym == SDLK_BACKSPACE ){
return_deletion_carac_input_box_NTS( input_box_information.input_box_activated );
}else if( (event->key.keysym.sym == SDLK_RETURN) || (event->key.keysym.sym == SDLK_KP_ENTER) ){
validate_input_box_NTS(input_box_information.input_box_activated);
}else if( event->key.keysym.unicode != 0 ){
//Si la lettre n'est pas \n On ajoute la lettre au mot courant
//Sinon on vide le mot et on cree un evenement du mot qui
//a ete attrappee par la boite de saisie
char* character = MLV_convert_unicode_to_string(
event->key.keysym.unicode
);
int i=0;
while( character[i] != '\0' ){
add_carac_input_box_NTS(
input_box_information.input_box_activated,
character[i]
);
i++;
}
MLV_FREE( character, char );
}
unlock_input_box( input_box_information.input_box_activated );
result = 0;
}
}
break;
case SDL_MOUSEBUTTONDOWN :
{ //Si on est dans une zone de boîte de saisie on active
// l'enregistrement des données.
MLV_Input_box* tmp = is_in_an_input_box_NTS(
event->button.x, event->button.y
);
if( tmp ){
lock_input_box( tmp );
activate_imput_box_NTS( tmp );
unlock_input_box( tmp );
result=0;
}else{
desactivate_input_box_NTS( );
}
}
break;
default :;
}
unlock_input_box_information();
return result;
}

34
MLV/input_box.h
View File

@@ -1,34 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__INPUT_BOX_H__
#define __MLV__INPUT_BOX_H__
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
void init_input_box_mechanism();
void quit_input_box_mechanism();
int input_box_events_filter(const SDL_Event *event);
#endif

187
MLV/input_box_wait.c
View File

@@ -1,187 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "platform.h"
#ifdef OS_WINDOWS
/* Get va_list. */
#if __STDC__ || defined __cplusplus || defined _MSC_VER
# include <stdarg.h>
#else
# include <varargs.h>
#endif
extern int vasprintf (char **, const char *, va_list);
#endif
#include "MLV_input_box.h"
#include "MLV_shape.h"
#include "MLV_color.h"
#include "MLV_window.h"
#include "MLV_event.h"
#include "data_structure.h"
#include "warning_error.h"
#include <stdlib.h>
#include "memory_management.h"
#include "image.h"
extern DataMLV* MLV_data;
void MLV_wait_particular_input_box( MLV_Input_box* input_box, char** text){
MLV_Input_box* tmp_input_box = NULL;
(*text) = NULL;
//We activate the input_box
MLV_activate_input_box( input_box );
// We first flush the event queue
MLV_flush_event_queue();
// We wait for a input_box event
while( ! (*text) ){
MLV_Event event_type = MLV_get_event(
NULL, NULL, NULL,
text, &tmp_input_box,
NULL, NULL, NULL,
NULL
);
if( (event_type==MLV_INPUT_BOX ) && input_box != tmp_input_box ){
MLV_FREE( (*text), char );
(*text) = NULL;
}
MLV_draw_all_input_boxes();
MLV_actualise_window();
}
}
void wait_input_box_with_font(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text,
const MLV_Font* font
){
MLV_Input_box* input_box = MLV_create_input_box_with_font(
sommetHautGaucheX, sommetHautGaucheY,
sommetBasDroitX, sommetBasDroitY,
borderColor, textColor,
backgroundColor,
informativeMessage,
font
);
SDL_Surface *save_screen = create_surface( MLV_data->width, MLV_data->height );
SDL_BlitSurface( MLV_data->screen, NULL, save_screen, &(MLV_data->rectangle));
MLV_wait_particular_input_box( input_box, text);
MLV_free_input_box( input_box );
SDL_BlitSurface( save_screen, NULL, MLV_data->screen, &(MLV_data->rectangle));
SDL_FreeSurface( save_screen );
MLV_actualise_window();
}
void MLV_wait_input_box_with_font_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text,
const MLV_Font* font, va_list pile
){
char* complete_informative_message;
if(
vasprintf(
&complete_informative_message, informativeMessage, pile
)==-1
){
ERROR("Unexpected Error.");
}
wait_input_box_with_font(
sommetHautGaucheX, sommetHautGaucheY, sommetBasDroitX, sommetBasDroitY,
borderColor, textColor, backgroundColor, complete_informative_message,
text, font
);
free( complete_informative_message );
}
void MLV_wait_input_box_with_font(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text,
const MLV_Font* font, ...
){
va_list pile;
va_start( pile, font );
MLV_wait_input_box_with_font_va(
sommetHautGaucheX, sommetHautGaucheY, sommetBasDroitX, sommetBasDroitY,
borderColor, textColor, backgroundColor, informativeMessage,
text, font, pile
);
va_end( pile );
}
void MLV_wait_input_box_va(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text, va_list pile
){
MLV_wait_input_box_with_font_va(
sommetHautGaucheX, sommetHautGaucheY,
sommetBasDroitX, sommetBasDroitY,
borderColor, textColor,
backgroundColor,
informativeMessage,
text, MLV_data->defaultFont, pile
);
}
void MLV_wait_input_box(
int sommetHautGaucheX, int sommetHautGaucheY,
int sommetBasDroitX, int sommetBasDroitY,
MLV_Color borderColor, MLV_Color textColor,
MLV_Color backgroundColor,
const char* informativeMessage,
char** text, ...
){
va_list pile;
va_start( pile, text );
MLV_wait_input_box_va(
sommetHautGaucheX, sommetHautGaucheY, sommetBasDroitX, sommetBasDroitY,
borderColor, textColor, backgroundColor, informativeMessage, text, pile
);
va_end( pile );
}

97
MLV/key.c
View File

@@ -1,97 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "key.h"
#include "warning_error.h"
#include "memory_management.h"
#include <string.h>
struct _MLV_Key {
void* value;
void (* value_destroying_function )( void* value );
int (* compare_values )( void* value1, void* value2 );
};
MLV_Key* MLV_create_key(
void* value,
void (* value_destroying_function )( void* data ),
int (* compare_values )( void* value1, void* value2 )
){
MLV_Key* key = MLV_MALLOC( 1, MLV_Key );
key->value = value;
key->value_destroying_function = value_destroying_function;
key->compare_values = compare_values;
return key;
}
void MLV_free_key( MLV_Key* key ){
if( key ){
if( key->value_destroying_function ){
key->value_destroying_function( key->value );
}
MLV_FREE( key, MLV_Key );
}
}
int MLV_compare_keys( MLV_Key* key1, MLV_Key* key2 ){
return key1->compare_values( key1->value, key2->value );
}
void free_string( char* text ){
MLV_FREE( text, char );
}
int compare_strings( char* text1, char* text2 ){
return strcmp( text1, text2 );
}
MLV_Key* MLV_string_to_key( const char* text ){
size_t l = strlen( text );
char* text_copy = MLV_MALLOC( ( l + 1 ), char );
strncpy( text_copy, text, l+1);
return MLV_create_key(
text_copy,
( void (*)( void* ) ) free_string,
( int (*)( void*, void* ) ) compare_strings
);
}
void free_integer( int* integer ){
MLV_FREE( integer, int );
}
int compare_integers( int* int1, int* int2 ){
return (*int1) - (*int2);
}
MLV_Key* MLV_integer_to_key( int integer ){
int* value = MLV_MALLOC( 1, int );
*value = integer;
return MLV_create_key(
value,
( void (*)( void* ) ) free_integer,
(int (*)( void*, void* )) compare_integers
);
}
void* MLV_get_value_from_key( MLV_Key* key ){
return key->value;
}

42
MLV/key.h
View File

@@ -1,42 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__KEY_H__
#define __MLV__KEY_H__
typedef struct _MLV_Key MLV_Key;
MLV_Key* MLV_create_key(
void* value,
void (* value_destroying_function )( void* value ),
int (* compare_values )( void* value1, void* value2 )
);
void MLV_free_key( MLV_Key* key );
int MLV_compare_keys( MLV_Key* key1, MLV_Key* key2 );
MLV_Key* MLV_string_to_key( const char* text );
MLV_Key* MLV_integer_to_key( int integer );
void* MLV_get_value_from_key( MLV_Key* key );
#endif

1678
MLV/keyboard.c
View File

File diff suppressed because it is too large Load Diff

79
MLV/list.c
View File

@@ -1,79 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "list.h"
#include "memory_management.h"
MLV_List* MLV_prepend_list( MLV_List* list, void* data ){
MLV_List* result = MLV_MALLOC( 1, MLV_List );
if( list ){
list->previous = result;
}
result->previous = NULL;
result->next = list;
result->data = data;
return result;
}
void MLV_free_list( MLV_List* list ){
if( list ){
MLV_free_list( list->next );
MLV_FREE( list, MLV_List );
}
}
void MLV_foreach_list(
MLV_List* list,
void (* function )( void* data, void* user_data ),
void* user_data
){
while( list ){
function( list->data, user_data );
list = list->next;
}
}
MLV_List* MLV_find_list( MLV_List* list, void* data ){
while( list ){
if( list->data == data ){
break;
}
list = list->next;
}
return list;
}
MLV_List* MLV_remove_list( MLV_List* list, void* data ){
MLV_List* result;
MLV_List* elem = MLV_find_list( list, data );
if( elem->previous ){
elem->previous->next = elem->next;
}
if( elem->next ){
elem->next->previous = elem->previous;
}
if( elem==list ){
result = elem->next;
}else{
result = list;
}
return result;
}

46
MLV/list.h
View File

@@ -1,46 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__LIST_H__
#define __MLV__LIST_H__
typedef struct _MLV_List MLV_List;
struct _MLV_List {
MLV_List* previous;
MLV_List* next;
void* data;
};
MLV_List* MLV_prepend_list( MLV_List* list, void* data );
void MLV_free_list( MLV_List* list );
void MLV_foreach_list(
MLV_List* list,
void (* function )( void* data, void* user_data ),
void* user_data
);
MLV_List* MLV_find_list( MLV_List* list, void* data );
MLV_List* MLV_remove_list( MLV_List* list, void* data );
#endif

26
MLV/mathematics.c
View File

@@ -1,26 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mathematics.h"
int max( int a, int b ){
return (a>b)?a:b;
}

27
MLV/mathematics.h
View File

@@ -1,27 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__MATHEMATICS_H__
#define __MLV__MATHEMATICS_H__
int max( int a, int b );
#endif

575
MLV/memory_debug.c
View File

@@ -1,575 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "memory_debug.h"
#include <stdlib.h>
#include <stdio.h>
#define DEBUG_MEMORY_MSG(x) { fprintf(stderr,"Memory Debug : %s \n",(x)); }
#include "memory_management.h"
int memory_debug_n;
SDL_EventFilter memory_debug_filter;
SDL_Event memory_debug_event;
Memory_debug_statistics memory_debug_statistics;
void init_memory_debug(){
memory_debug_statistics.nb_create_surface = 0;
memory_debug_statistics.nb_free_surface = 0;
memory_debug_statistics.nb_init_sdl = 0;
memory_debug_statistics.nb_close_sdl = 0;
memory_debug_statistics.nb_create_semaphore = 0;
memory_debug_statistics.nb_free_semaphore = 0;
memory_debug_statistics.nb_malloc = 0;
memory_debug_statistics.nb_free = 0;
memory_debug_statistics.nb_free_wave = 0;
memory_debug_statistics.nb_load_wave = 0;
memory_debug_statistics.nb_open_font = 0;
memory_debug_statistics.nb_close_font = 0;
memory_debug_statistics.nb_init_ttf = 0;
memory_debug_statistics.nb_quit_ttf = 0;
}
void print_memory_statistics(){
fprintf(stderr,"--------------------------STATISTICS---------------------\n");
fprintf(stderr,"Memory Debug : nb_create_surface : %i \n", memory_debug_statistics.nb_create_surface);
fprintf(stderr,"Memory Debug : nb_free_surface : %i \n", memory_debug_statistics.nb_free_surface);
fprintf(stderr,"Memory Debug : nb_init_sdl : %i \n", memory_debug_statistics.nb_init_sdl);
fprintf(stderr,"Memory Debug : nb_close_sdl : %i \n", memory_debug_statistics.nb_close_sdl);
fprintf(stderr,"Memory Debug : nb_create_semaphore : %i \n", memory_debug_statistics.nb_create_semaphore);
fprintf(stderr,"Memory Debug : nb_free_semaphore : %i \n", memory_debug_statistics.nb_free_semaphore);
fprintf(stderr,"Memory Debug : nb_malloc : %i \n", memory_debug_statistics.nb_malloc);
fprintf(stderr,"Memory Debug : nb_calloc : %i \n", memory_debug_statistics.nb_calloc);
fprintf(stderr,"Memory Debug : nb_free : %i \n", memory_debug_statistics.nb_free);
fprintf(stderr,"Memory Debug : nb_free_wave : %i \n", memory_debug_statistics.nb_free_wave);
fprintf(stderr,"Memory Debug : nb_load_wave : %i \n", memory_debug_statistics.nb_load_wave);
fprintf(stderr,"Memory Debug : nb_open_font : %i \n", memory_debug_statistics.nb_open_font);
fprintf(stderr,"Memory Debug : nb_close_font : %i \n", memory_debug_statistics.nb_close_font);
fprintf(stderr,"Memory Debug : nb_init_ttf : %i \n", memory_debug_statistics.nb_init_ttf);
fprintf(stderr,"Memory Debug : nb_quit_ttf : %i \n", memory_debug_statistics.nb_quit_ttf);
fprintf(stderr,"----------------------END-STATISTICS---------------------\n");
}
typedef enum {
MEMORY_DEBUG_CREATE_SURFACE,
MEMORY_DEBUG_FREE_SURFACE,
MEMORY_DEBUG_INIT_SDL,
MEMORY_DEBUG_CLOSE_SDL,
MEMORY_DEBUG_CREATE_SEMAPHORE,
MEMORY_DEBUG_FREE_SEMAPHORE,
MEMORY_DEBUG_MALLOC,
MEMORY_DEBUG_CALLOC,
MEMORY_DEBUG_FREE,
MEMORY_DEBUG_FREE_WAVE,
MEMORY_DEBUG_LOAD_WAVE,
MEMORY_DEBUG_OPEN_FONT,
MEMORY_DEBUG_CLOSE_FONT,
MEMORY_DEBUG_QUIT_TTF,
MEMORY_DEBUG_INIT_TTF
} Memory_debug_statistics_type;
void update_memory_statistics( Memory_debug_statistics_type type ){
switch( type ){
case MEMORY_DEBUG_CREATE_SURFACE :
{
memory_debug_statistics.nb_create_surface++;
}
break;
case MEMORY_DEBUG_FREE_SURFACE :
{
memory_debug_statistics.nb_free_surface++;
}
break;
case MEMORY_DEBUG_INIT_SDL :
{
memory_debug_statistics.nb_init_sdl++;
}
break;
case MEMORY_DEBUG_CLOSE_SDL :
{
memory_debug_statistics.nb_close_sdl++;
}
break;
case MEMORY_DEBUG_CREATE_SEMAPHORE :
{
memory_debug_statistics.nb_create_semaphore++;
}
break;
case MEMORY_DEBUG_FREE_SEMAPHORE :
{
memory_debug_statistics.nb_free_semaphore ++;
}
break;
case MEMORY_DEBUG_MALLOC :
{
memory_debug_statistics.nb_malloc ++;
}
break;
case MEMORY_DEBUG_CALLOC :
{
memory_debug_statistics.nb_calloc ++;
}
break;
case MEMORY_DEBUG_FREE :
{
memory_debug_statistics.nb_free ++;
}
break;
case MEMORY_DEBUG_FREE_WAVE :
{
memory_debug_statistics.nb_free_wave ++;
}
break;
case MEMORY_DEBUG_LOAD_WAVE :
{
memory_debug_statistics.nb_load_wave ++;
}
break;
case MEMORY_DEBUG_OPEN_FONT :
{
memory_debug_statistics.nb_open_font ++;
}
break;
case MEMORY_DEBUG_CLOSE_FONT :
{
memory_debug_statistics.nb_close_font ++;
}
break;
case MEMORY_DEBUG_QUIT_TTF :
{
memory_debug_statistics.nb_quit_ttf ++;
}
break;
case MEMORY_DEBUG_INIT_TTF :
{
memory_debug_statistics.nb_init_ttf ++;
}
break;
default:;
}
}
void close_memory_debug(){
}
void filledCircleColor( SDL_Surface* screen, int x, int y, int radius, Uint32 color){
}
void circleColor( SDL_Surface* screen, int x, int y, int radius, Uint32 color){
}
void ellipseColor( SDL_Surface* screen, int x, int y, int radius_x, int radius_y, Uint32 color ){
}
void filledEllipseColor( SDL_Surface* screen, int x, int y, int radius_x, int radius_y, Uint32 color){
}
void polygonColor( SDL_Surface* screen, Sint16* vx, Sint16* vy, int npoints, Uint32 color){
}
void filledPolygonColor( SDL_Surface* screen, Sint16* vx, Sint16* vy, int npoints, Uint32 color){
}
void rectangleColor( SDL_Surface* screen, int x, int y, int width, int height, Uint32 color){
}
void boxColor( SDL_Surface* screen, int x, int y, int width, int height, Uint32 color){
}
void lineColor( SDL_Surface* screen, int x1, int y1, int x2, int y2, Uint32 color){
}
void pixelColor( SDL_Surface* screen, int x, int y, Uint32 color){
}
void stringColor( SDL_Surface* screen, int x, int y, const char *text, Uint32 color){
}
int SDL_BlitSurface( SDL_Surface* src, SDL_Rect* rectangle_src, SDL_Surface* dst, SDL_Rect* rectangle_dest){
return 0;
}
int memory_debug_modulo;
int SDL_PollEvent( SDL_Event* event ){
memory_debug_n = (memory_debug_n+1)%memory_debug_modulo;
switch( memory_debug_n ){
case 0:
{
DEBUG_MEMORY_MSG("Pas d'evenement")
return 0;
}
case 1: ;
{
DEBUG_MEMORY_MSG("souris deplace 10 10")
event->type=SDL_MOUSEMOTION;
event->motion.which = 0;
event->motion.state = SDL_RELEASED;
event->motion.x = 10;
event->motion.y = 10;
event->motion.xrel = -90;
event->motion.yrel = -90;
};
break;
case 2: ;
{
DEBUG_MEMORY_MSG("bouton gauche souris tape")
event->type=SDL_MOUSEBUTTONDOWN;
event->button.which = 0;
event->button.button = SDL_BUTTON_LEFT;
event->button.state = SDL_PRESSED;
event->button.x = 10;
event->button.y = 10;
};
break;
case 3: ;
{
DEBUG_MEMORY_MSG("bouton gauche souris relache")
event->type=SDL_MOUSEBUTTONUP;
event->button.which = 0;
event->button.button = SDL_BUTTON_LEFT;
event->button.state = SDL_RELEASED;
event->button.x = 10;
event->button.y = 10;
};
break;
case 4: ;
{
DEBUG_MEMORY_MSG("souris deplace 100")
event->type=SDL_MOUSEMOTION;
event->motion.which = 0;
event->motion.state = SDL_RELEASED;
event->motion.x = 100;
event->motion.y = 100;
event->motion.xrel = 90;
event->motion.yrel = 90;
};
break;
case 5: ;
{
DEBUG_MEMORY_MSG("bouton gauche souris tape")
event->type=SDL_MOUSEBUTTONDOWN;
event->button.which = 0;
event->button.button = SDL_BUTTON_LEFT;
event->button.state = SDL_PRESSED;
event->button.x = 100;
event->button.y = 100;
};
break;
case 6: ;
{
DEBUG_MEMORY_MSG("bouton gausche souris relache")
event->type=SDL_MOUSEBUTTONUP;
event->button.which = 0;
event->button.button = SDL_BUTTON_LEFT;
event->button.state = SDL_RELEASED;
event->button.x = 100;
event->button.y = 100;
};
break;
case 7:
{
DEBUG_MEMORY_MSG("a tape")
event->type=SDL_KEYDOWN;
event->key.type=SDL_KEYDOWN;
event->key.which=0;
event->key.state=SDL_PRESSED;
event->key.keysym.scancode = 0;
event->key.keysym.sym=SDLK_a;
event->key.keysym.mod=KMOD_NONE;
event->key.keysym.unicode=97;
};
break;
case 8: ;
{
DEBUG_MEMORY_MSG("a relache")
event->type=SDL_KEYUP;
event->key.type=SDL_KEYUP;
event->key.which=0;
event->key.state=SDL_RELEASED;
event->key.keysym.scancode = 0;
event->key.keysym.sym=SDLK_a;
event->key.keysym.mod=KMOD_NONE;
event->key.keysym.unicode=97;
};
break;
case 9: ;
{
DEBUG_MEMORY_MSG("b tape")
event->type=SDL_KEYDOWN;
event->key.type=SDL_KEYDOWN;
event->key.which=0;
event->key.state=SDL_PRESSED;
event->key.keysym.scancode = 0;
event->key.keysym.sym=SDLK_b;
event->key.keysym.mod=KMOD_NONE;
event->key.keysym.unicode=98;
};
break;
case 10: ;
{
DEBUG_MEMORY_MSG("b relache")
event->type=SDL_KEYUP;
event->key.type=SDL_KEYUP;
event->key.which=0;
event->key.state=SDL_RELEASED;
event->key.keysym.scancode = 0;
event->key.keysym.sym=SDLK_b;
event->key.keysym.mod=KMOD_NONE;
event->key.keysym.unicode=98;
};
break;
case 11: ;
{
DEBUG_MEMORY_MSG("return tape")
event->type=SDL_KEYDOWN;
event->key.type=SDL_KEYDOWN;
event->key.which=0;
event->key.state=SDL_PRESSED;
event->key.keysym.scancode = 0;
event->key.keysym.sym=SDLK_RETURN;
event->key.keysym.mod=KMOD_NONE;
event->key.keysym.unicode=13;
};
break;
case 12: ;
{
DEBUG_MEMORY_MSG("Return relache")
event->type=SDL_KEYUP;
event->key.type=SDL_KEYUP;
event->key.which=0;
event->key.state=SDL_RELEASED;
event->key.keysym.scancode = 0;
event->key.keysym.sym=SDLK_RETURN;
event->key.keysym.mod=KMOD_NONE;
event->key.keysym.unicode=13;
};
break;
case 13:
{
DEBUG_MEMORY_MSG("Evenement User")
(*event)=memory_debug_event;
};
break;
default: ;
}
return memory_debug_filter( event );
}
void SDL_SetAlpha(SDL_Surface* surface, int prop1, int prop2){
}
SDL_Surface* SDL_LoadBMP( const char* path ){
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
}
SDL_Surface* SDL_CreateRGBSurface( int prop1, int w, int h, int resol, int r, int g, int b, int prop2 ){
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
}
void SDL_FreeSurface( SDL_Surface* surface ){
update_memory_statistics( MEMORY_DEBUG_FREE_SURFACE );
free( surface );
}
SDL_Surface* rotozoomSurface( SDL_Surface* surface, double rotation, double zoom, int antialias){
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
}
SDL_Surface* rotozoomSurfaceXY( SDL_Surface* surface, double rotation, double zoomx, double zoomy, int antialias){
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
}
char* memory_debug_sdl_init;
int SDL_Init( int flags ){
memory_debug_n = 0;
memory_debug_modulo = 14;
update_memory_statistics( MEMORY_DEBUG_INIT_SDL );
memory_debug_sdl_init = (char*) malloc( sizeof(char) );
return 0;
}
void SDL_Quit(){
update_memory_statistics( MEMORY_DEBUG_CLOSE_SDL );
free(memory_debug_sdl_init);
}
char* SDL_GetError(){
return "TOTO";
}
SDL_Surface* SDL_SetVideoMode( int w, int h, int bits, int flags ){
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
return (SDL_Surface*) malloc( sizeof( SDL_Surface ) );
}
void SDL_WM_SetCaption( const char* wind, const char* icon ){
}
void SDL_SetEventFilter( SDL_EventFilter filter ){
memory_debug_filter = filter;
}
void SDL_Flip( SDL_Surface* surface ){
}
int SDL_SemWait( SDL_sem* semaphore ){
return 0;
}
int SDL_SemPost( SDL_sem* semaphore ){
return 0;
}
SDL_sem* SDL_CreateSemaphore( int valeur ){
update_memory_statistics( MEMORY_DEBUG_CREATE_SEMAPHORE );
return (SDL_sem*) malloc( sizeof( SDL_sem ) );
}
void SDL_DestroySemaphore( SDL_sem* semaphore ){
update_memory_statistics( MEMORY_DEBUG_FREE_SEMAPHORE );
free(semaphore);
}
void SDL_EnableUNICODE( int flags ){
}
int SDL_PushEvent( SDL_Event* event ){
memory_debug_event = (*event);
memory_debug_n = memory_debug_modulo - 2 ;
return 0;
}
int SDL_GetTicks(){
return 1;
}
void SDL_Delay( int milliseconds ){
}
void* memory_debug_malloc(size_t size, int line, char* file ){
update_memory_statistics( MEMORY_DEBUG_MALLOC );
fprintf(stderr, "Memory Debug : malloc ligne : %i, fichier : %s \n", line, file );
return malloc( size );
}
void* memory_debug_calloc( size_t nmemb, size_t size, int line, char* file ){
update_memory_statistics( MEMORY_DEBUG_CALLOC );
fprintf(stderr, "Memory Debug : calloc ligne : %i, fichier : %s \n", line, file );
return calloc( nmemb, size );
}
void memory_debug_free( void* ptr, int line, char* file ){
update_memory_statistics( MEMORY_DEBUG_FREE );
fprintf(stderr, "Memory Debug : free ligne : %i, fichier : %s \n", line, file );
free( ptr );
}
void SDL_LockAudio(){
}
void SDL_UnlockAudio(){
}
void SDL_MixAudio(Uint8 *dst, Uint8 *src, Uint32 len, int volume){
}
SDL_AudioSpec* SDL_LoadWAV(const char *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len){
update_memory_statistics( MEMORY_DEBUG_LOAD_WAVE );
(*audio_buf) = (Uint8*) malloc( 10000 * sizeof( Uint8 ) );
(*audio_len) = 10000 * sizeof(Uint8);
return spec;
}
void SDL_FreeWAV(Uint8 *audio_buf){
update_memory_statistics( MEMORY_DEBUG_FREE_WAVE );
free( audio_buf );
}
void SDL_PauseAudio(int pause_on){
}
int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained){
return 0;
}
void SDL_CloseAudio(){
}
int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key){
return 0;
}
int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h){
return 0;
}
char* memory_debug_ttf_init;
int TTF_Init(void){
update_memory_statistics( MEMORY_DEBUG_INIT_TTF );
memory_debug_ttf_init = (char*) malloc( sizeof(char) );
return 0;
}
void TTF_Quit(void){
update_memory_statistics( MEMORY_DEBUG_QUIT_TTF );
free( memory_debug_ttf_init );
}
TTF_Font * TTF_OpenFont(const char *file, int ptsize){
update_memory_statistics( MEMORY_DEBUG_OPEN_FONT );
return (TTF_Font*) malloc( sizeof(TTF_Font) );
}
void TTF_SetFontStyle(TTF_Font *font, int style){
}
void TTF_CloseFont(TTF_Font *font){
update_memory_statistics( MEMORY_DEBUG_CLOSE_FONT );
free( font );
}
SDL_Surface * TTF_RenderUTF8_Solid(TTF_Font *font, const char *text, SDL_Color fg){
update_memory_statistics( MEMORY_DEBUG_CREATE_SURFACE );
return (SDL_Surface*) malloc( sizeof(SDL_Surface) );
}

556
MLV/memory_debug.h
View File

@@ -1,556 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__MEMMORY_DEBUG_H__
#define __MLV__MEMMORY_DEBUG_H__
#include <stdlib.h>
void init_memory_debug();
void print_memory_statistics();
void close_memory_debug();
typedef struct _Memory_debug_statistics {
int nb_create_surface;
int nb_free_surface;
int nb_init_sdl;
int nb_close_sdl;
int nb_create_semaphore;
int nb_free_semaphore;
int nb_malloc;
int nb_calloc;
int nb_free;
int nb_free_wave;
int nb_load_wave;
int nb_open_font;
int nb_close_font;
int nb_init_ttf;
int nb_quit_ttf;
} Memory_debug_statistics;
typedef int Uint32;
typedef int Uint16;
typedef int Uint8;
typedef int Sint32;
typedef int Sint16;
typedef struct SDL_Rect {
Sint16 x, y;
Uint16 w, h;
} SDL_Rect;
typedef struct _SDL_Screen {
int h;
int w;
} SDL_Surface;
typedef enum {
SDLK_UNKNOWN,
SDLK_FIRST,
SDLK_BACKSPACE,
SDLK_TAB,
SDLK_CLEAR,
SDLK_RETURN,
SDLK_PAUSE,
SDLK_ESCAPE,
SDLK_SPACE,
SDLK_EXCLAIM,
SDLK_QUOTEDBL,
SDLK_HASH,
SDLK_DOLLAR,
SDLK_AMPERSAND,
SDLK_QUOTE,
SDLK_LEFTPAREN,
SDLK_RIGHTPAREN,
SDLK_ASTERISK,
SDLK_PLUS,
SDLK_COMMA,
SDLK_MINUS,
SDLK_PERIOD,
SDLK_SLASH,
SDLK_0,
SDLK_1,
SDLK_2,
SDLK_3,
SDLK_4,
SDLK_5,
SDLK_6,
SDLK_7,
SDLK_8,
SDLK_9,
SDLK_COLON,
SDLK_SEMICOLON,
SDLK_LESS,
SDLK_EQUALS,
SDLK_GREATER,
SDLK_QUESTION,
SDLK_AT,
SDLK_LEFTBRACKET,
SDLK_BACKSLASH,
SDLK_RIGHTBRACKET,
SDLK_CARET,
SDLK_UNDERSCORE,
SDLK_BACKQUOTE,
SDLK_a,
SDLK_b,
SDLK_c,
SDLK_d,
SDLK_e,
SDLK_f,
SDLK_g,
SDLK_h,
SDLK_i,
SDLK_j,
SDLK_k,
SDLK_l,
SDLK_m,
SDLK_n,
SDLK_o,
SDLK_p,
SDLK_q,
SDLK_r,
SDLK_s,
SDLK_t,
SDLK_u,
SDLK_v,
SDLK_w,
SDLK_x,
SDLK_y,
SDLK_z,
SDLK_DELETE,
SDLK_KP0,
SDLK_KP1,
SDLK_KP2,
SDLK_KP3,
SDLK_KP4,
SDLK_KP5,
SDLK_KP6,
SDLK_KP7,
SDLK_KP8,
SDLK_KP9,
SDLK_KP_PERIOD,
SDLK_KP_DIVIDE,
SDLK_KP_MULTIPLY,
SDLK_KP_MINUS,
SDLK_KP_PLUS,
SDLK_KP_ENTER,
SDLK_KP_EQUALS,
SDLK_UP,
SDLK_DOWN,
SDLK_RIGHT,
SDLK_LEFT,
SDLK_INSERT,
SDLK_HOME,
SDLK_END,
SDLK_PAGEUP,
SDLK_PAGEDOWN,
SDLK_F1,
SDLK_F2,
SDLK_F3,
SDLK_F4,
SDLK_F5,
SDLK_F6,
SDLK_F7,
SDLK_F8,
SDLK_F9,
SDLK_F10,
SDLK_F11,
SDLK_F12,
SDLK_F13,
SDLK_F14,
SDLK_F15,
SDLK_NUMLOCK,
SDLK_CAPSLOCK,
SDLK_SCROLLOCK,
SDLK_RSHIFT,
SDLK_LSHIFT,
SDLK_RCTRL,
SDLK_LCTRL,
SDLK_RALT,
SDLK_LALT,
SDLK_RMETA,
SDLK_LMETA,
SDLK_LSUPER,
SDLK_RSUPER,
SDLK_MODE,
SDLK_COMPOSE,
SDLK_HELP,
SDLK_PRINT,
SDLK_SYSREQ,
SDLK_BREAK,
SDLK_MENU,
SDLK_POWER,
SDLK_EURO,
SDLK_UNDO,
SDLK_LAST
} SDLKey;
typedef enum {
KMOD_NONE,
KMOD_LSHIFT,
KMOD_RSHIFT,
KMOD_LCTRL,
KMOD_RCTRL,
KMOD_LALT,
KMOD_RALT,
KMOD_LMETA,
KMOD_RMETA,
KMOD_NUM,
KMOD_CAPS,
KMOD_MODE,
KMOD_RESERVED
} SDLMod;
typedef struct SDL_keysym {
Uint8 scancode; /* hardware specific scancode */
SDLKey sym; /* SDL virtual keysym */
SDLMod mod; /* current key modifiers */
Uint16 unicode; /* translated character */
} SDL_keysym;
/* Event enumerations */
typedef enum SDL_Events {
SDL_NOEVENT = 0, /* Unused (do not remove) */
SDL_ACTIVEEVENT, /* Application loses/gains visibility */
SDL_KEYDOWN, /* Keys pressed */
SDL_KEYUP, /* Keys released */
SDL_MOUSEMOTION, /* Mouse moved */
SDL_MOUSEBUTTONDOWN, /* Mouse button pressed */
SDL_MOUSEBUTTONUP, /* Mouse button released */
SDL_JOYAXISMOTION, /* Joystick axis motion */
SDL_JOYBALLMOTION, /* Joystick trackball motion */
SDL_JOYHATMOTION, /* Joystick hat position change */
SDL_JOYBUTTONDOWN, /* Joystick button pressed */
SDL_JOYBUTTONUP, /* Joystick button released */
SDL_QUIT, /* User-requested quit */
SDL_SYSWMEVENT, /* System specific event */
SDL_EVENT_RESERVEDA, /* Reserved for future use.. */
SDL_EVENT_RESERVEDB, /* Reserved for future use.. */
SDL_VIDEORESIZE, /* User resized video mode */
SDL_VIDEOEXPOSE, /* Screen needs to be redrawn */
SDL_EVENT_RESERVED2, /* Reserved for future use.. */
SDL_EVENT_RESERVED3, /* Reserved for future use.. */
SDL_EVENT_RESERVED4, /* Reserved for future use.. */
SDL_EVENT_RESERVED5, /* Reserved for future use.. */
SDL_EVENT_RESERVED6, /* Reserved for future use.. */
SDL_EVENT_RESERVED7, /* Reserved for future use.. */
/* Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use */
SDL_USEREVENT = 24,
/* This last event is only for bounding internal arrays
It is the number of bits in the event mask datatype -- Uint32
*/
SDL_NUMEVENTS = 32
} SDL_EventType;
/* Application visibility event structure */
typedef struct SDL_ActiveEvent {
Uint8 type; /* SDL_ACTIVEEVENT */
Uint8 gain; /* Whether given states were gained or lost (1/0) */
Uint8 state; /* A mask of the focus states */
} SDL_ActiveEvent;
/* Keyboard event structure */
typedef struct SDL_KeyboardEvent {
Uint8 type; /* SDL_KEYDOWN or SDL_KEYUP */
Uint8 which; /* The keyboard device index */
Uint8 state; /* SDL_PRESSED or SDL_RELEASED */
SDL_keysym keysym;
} SDL_KeyboardEvent;
/* Mouse motion event structure */
typedef struct SDL_MouseMotionEvent {
Uint8 type; /* SDL_MOUSEMOTION */
Uint8 which; /* The mouse device index */
Uint8 state; /* The current button state */
Uint16 x, y; /* The X/Y coordinates of the mouse */
Sint16 xrel; /* The relative motion in the X direction */
Sint16 yrel; /* The relative motion in the Y direction */
} SDL_MouseMotionEvent;
/* Mouse button event structure */
typedef struct SDL_MouseButtonEvent {
Uint8 type; /* SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP */
Uint8 which; /* The mouse device index */
Uint8 button; /* The mouse button index */
Uint8 state; /* SDL_PRESSED or SDL_RELEASED */
Uint16 x, y; /* The X/Y coordinates of the mouse at press time */
} SDL_MouseButtonEvent;
/* Joystick axis motion event structure */
typedef struct SDL_JoyAxisEvent {
Uint8 type; /* SDL_JOYAXISMOTION */
Uint8 which; /* The joystick device index */
Uint8 axis; /* The joystick axis index */
Sint16 value; /* The axis value (range: -32768 to 32767) */
} SDL_JoyAxisEvent;
/* Joystick trackball motion event structure */
typedef struct SDL_JoyBallEvent {
Uint8 type; /* SDL_JOYBALLMOTION */
Uint8 which; /* The joystick device index */
Uint8 ball; /* The joystick trackball index */
Sint16 xrel; /* The relative motion in the X direction */
Sint16 yrel; /* The relative motion in the Y direction */
} SDL_JoyBallEvent;
/* Joystick hat position change event structure */
typedef struct SDL_JoyHatEvent {
Uint8 type; /* SDL_JOYHATMOTION */
Uint8 which; /* The joystick device index */
Uint8 hat; /* The joystick hat index */
Uint8 value; /* The hat position value:
SDL_HAT_LEFTUP SDL_HAT_UP SDL_HAT_RIGHTUP
SDL_HAT_LEFT SDL_HAT_CENTERED SDL_HAT_RIGHT
SDL_HAT_LEFTDOWN SDL_HAT_DOWN SDL_HAT_RIGHTDOWN
Note that zero means the POV is centered.
*/
} SDL_JoyHatEvent;
/* Joystick button event structure */
typedef struct SDL_JoyButtonEvent {
Uint8 type; /* SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP */
Uint8 which; /* The joystick device index */
Uint8 button; /* The joystick button index */
Uint8 state; /* SDL_PRESSED or SDL_RELEASED */
} SDL_JoyButtonEvent;
/* The "window resized" event
When you get this event, you are responsible for setting a new video
mode with the new width and height.
*/
typedef struct SDL_ResizeEvent {
Uint8 type; /* SDL_VIDEORESIZE */
int w; /* New width */
int h; /* New height */
} SDL_ResizeEvent;
/* The "screen redraw" event */
typedef struct SDL_ExposeEvent {
Uint8 type; /* SDL_VIDEOEXPOSE */
} SDL_ExposeEvent;
/* The "quit requested" event */
typedef struct SDL_QuitEvent {
Uint8 type; /* SDL_QUIT */
} SDL_QuitEvent;
/* A user-defined event type */
typedef struct SDL_UserEvent {
Uint8 type; /* SDL_USEREVENT through SDL_NUMEVENTS-1 */
int code; /* User defined event code */
void *data1; /* User defined data pointer */
void *data2; /* User defined data pointer */
} SDL_UserEvent;
/* If you want to use this event, you should include SDL_syswm.h */
struct SDL_SysWMmsg;
typedef struct SDL_SysWMmsg SDL_SysWMmsg;
typedef struct SDL_SysWMEvent {
Uint8 type;
SDL_SysWMmsg *msg;
} SDL_SysWMEvent;
/* General event structure */
typedef union SDL_Event {
Uint8 type;
SDL_ActiveEvent active;
SDL_KeyboardEvent key;
SDL_MouseMotionEvent motion;
SDL_MouseButtonEvent button;
SDL_JoyAxisEvent jaxis;
SDL_JoyBallEvent jball;
SDL_JoyHatEvent jhat;
SDL_JoyButtonEvent jbutton;
SDL_ResizeEvent resize;
SDL_ExposeEvent expose;
SDL_QuitEvent quit;
SDL_UserEvent user;
SDL_SysWMEvent syswm;
} SDL_Event;
#define SDL_BUTTON_LEFT 1
#define SDL_BUTTON_MIDDLE 2
#define SDL_BUTTON_RIGHT 3
void filledCircleColor( SDL_Surface* screen, int x, int y, int radius, Uint32 color);
void circleColor( SDL_Surface* screen, int x, int y, int radius, Uint32 color);
void ellipseColor( SDL_Surface* screen, int x, int y, int radius_x, int radius_y, Uint32 color );
void filledEllipseColor( SDL_Surface* screen, int x, int y, int radius_x, int radius_y, Uint32 color);
void polygonColor( SDL_Surface* screen, Sint16* vx, Sint16* vy, int npoints, Uint32 color);
void filledPolygonColor( SDL_Surface* screen, Sint16* vx, Sint16* vy, int npoints, Uint32 color);
void rectangleColor( SDL_Surface* screen, int x, int y, int width, int height, Uint32 color);
void boxColor( SDL_Surface* screen, int x, int y, int width, int height, Uint32 color);
void lineColor( SDL_Surface* screen, int x1, int y1, int x2, int y2, Uint32 color);
void pixelColor( SDL_Surface* screen, int x, int y, Uint32 color);
void stringColor( SDL_Surface* screen, int x, int y, const char *text, Uint32 color);
int SDL_BlitSurface( SDL_Surface* src, SDL_Rect* rectangle_src, SDL_Surface* dst, SDL_Rect* rectangle_dest);
int SDL_PollEvent( SDL_Event* event );
#define SDL_HWSURFACE 1
#define SDL_SRCALPHA 1
#define SDL_ALPHA_TRANSPARENT 1
#define SDL_RLEACCEL 1
#define SDL_ALPHA_OPAQUE 1
void SDL_SetAlpha(SDL_Surface* surface, int prop1, int prop2);
SDL_Surface* SDL_LoadBMP( const char* path );
SDL_Surface* SDL_CreateRGBSurface( int prop1, int w, int h, int resol, int r, int g, int b, int prop2 );
void SDL_FreeSurface( SDL_Surface* surface );
SDL_Surface* rotozoomSurface( SDL_Surface* surface, double rotation, double zoom, int antialias);
SDL_Surface* rotozoomSurfaceXY( SDL_Surface* surface, double rotation, double zoomx, double zoomy, int antialias);
#define SDL_INIT_VIDEO 1
#define SDL_INIT_TIMER 1
#define SDL_INIT_AUDIO 1
#define SDL_DOUBLEBUF 1
#define SDL_INIT_EVENTTHREAD 1
typedef int (*SDL_EventFilter)(const SDL_Event *event);
int SDL_Init( int flags );
void SDL_Quit();
char* SDL_GetError();
SDL_Surface* SDL_SetVideoMode( int w, int h, int bits, int flags );
void SDL_WM_SetCaption( const char* wind, const char* icon );
void SDL_SetEventFilter( SDL_EventFilter filter );
void SDL_Flip( SDL_Surface* surface );
#define SDL_PRESSED 0
#define SDL_RELEASED 1
#define SDL_ENABLE 1
typedef struct _SDL_sem {
} SDL_sem;
int SDL_SemWait( SDL_sem* semaphore );
int SDL_SemPost( SDL_sem* semaphore );
SDL_sem* SDL_CreateSemaphore( int );
void SDL_DestroySemaphore( SDL_sem* semaphore );
void SDL_EnableUNICODE( int flags );
int SDL_PushEvent( SDL_Event* event );
int SDL_GetTicks();
void SDL_Delay( int milliseconds );
void* memory_debug_malloc( size_t size, int line, char* file );
void* memory_debug_calloc( size_t nmemb, size_t size, int line, char* file );
void memory_debug_free( void* ptr, int line, char* file );
typedef struct{
int freq;
Uint16 format;
Uint8 channels;
Uint8 silence;
Uint16 samples;
Uint32 size;
void (*callback)(void *userdata, Uint8 *stream, int len);
void *userdata;
} SDL_AudioSpec;
void SDL_LockAudio();
void SDL_UnlockAudio();
void SDL_MixAudio(Uint8 *dst, Uint8 *src, Uint32 len, int volume);
SDL_AudioSpec* SDL_LoadWAV(const char *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len);
void SDL_FreeWAV(Uint8 *audio_buf);
void SDL_PauseAudio(int pause_on);
int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained);
void SDL_CloseAudio();
/* Audio format flags (defaults to LSB byte order) */
#define AUDIO_U8 0x0008 /* Unsigned 8-bit samples */
#define AUDIO_S8 0x8008 /* Signed 8-bit samples */
#define AUDIO_U16LSB 0x0010 /* Unsigned 16-bit samples */
#define AUDIO_S16LSB 0x8010 /* Signed 16-bit samples */
#define AUDIO_U16MSB 0x1010 /* As above, but big-endian byte order */
#define AUDIO_S16MSB 0x9010 /* As above, but big-endian byte order */
#define AUDIO_U16 AUDIO_U16LSB
#define AUDIO_S16 AUDIO_S16LSB
#define SDL_MIX_MAXVOLUME 128
typedef struct {
Uint8 r;
Uint8 g;
Uint8 b;
Uint8 unused;
} SDL_Color;
#define SDL_SRCCOLORKEY 0x00001000 /* Blit uses a source color key */
int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
/*
typedef struct {
} GList;
*/
typedef struct {
} TTF_Font;
int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h);
int TTF_Init(void);
void TTF_Quit(void);
TTF_Font * TTF_OpenFont(const char *file, int ptsize);
#define TTF_GetError SDL_GetError
void TTF_SetFontStyle(TTF_Font *font, int style);
#define TTF_STYLE_NORMAL 0x00
void TTF_CloseFont(TTF_Font *font);
SDL_Surface * TTF_RenderUTF8_Solid(TTF_Font *font, const char *text, SDL_Color fg);
#endif

38
MLV/memory_management.h
View File

@@ -1,38 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__MEMORY_MANAGEMENT_H__
#define __MLV__MEMORY_MANAGEMENT_H__
#include <stdlib.h>
#ifndef MEMORY_DEBUG
#define MLV_MALLOC( size, type ) (type *) malloc( (size) * sizeof( type ) )
#define MLV_CALLOC( nmemb, size, type ) (type *) calloc( nmemb, (size) * sizeof( type ) )
#define MLV_FREE( ptr, type ) free( (ptr) )
#else
#include "memory_debug.h"
#define MLV_MALLOC( size, type ) (type *) memory_debug_malloc( (size) * sizeof( type ), __LINE__, __FILE__ )
#define MLV_CALLOC( size, type ) (type *) memory_debug_calloc( (size) * sizeof( type ), __LINE__ , __FILE__ )
#define MLV_FREE( ptr, type ) memory_debug_free( (ptr), __LINE__, __FILE__ )
#endif
#endif

139
MLV/mouse.c
View File

@@ -1,139 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_mouse.h"
#include "MLV_event.h"
#include "MLV_time.h"
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
#include "warning_error.h"
#include "memory_management.h"
void MLV_wait_mouse(int *x, int *y){
MLV_Button_state state;
MLV_Mouse_button mouse_button;
// We remove all existing event from the queue
MLV_flush_event_queue();
//We wait for a new mouse event
while(
(
MLV_wait_event(
NULL, NULL, NULL,
NULL, NULL,
x, y, &mouse_button,
&state
) != MLV_MOUSE_BUTTON
) ||
( mouse_button != MLV_BUTTON_LEFT ) ||
( state != MLV_PRESSED )
);
};
int MLV_wait_mouse_or_seconds(int *x, int *y, int seconds){
MLV_Button_state state;
MLV_Mouse_button mouse_button;
// We remove all existing event from the queue
MLV_flush_event_queue();
int time = MLV_get_time();
//We wait for a new mouse event
int resultat = 0;
int tmp_x, tmp_y;
while(
(
resultat =
(
MLV_wait_event_or_seconds(
NULL, NULL, NULL,
NULL, NULL,
&tmp_x, &tmp_y, &mouse_button,
&state,
seconds - ( MLV_get_time() - time )/1000
) != MLV_MOUSE_BUTTON
) ||
( mouse_button != MLV_BUTTON_LEFT ) ||
( state != MLV_PRESSED )
) && (
(MLV_get_time() - time) < seconds*1000
)
);
if(
! resultat &&
mouse_button == MLV_BUTTON_LEFT &&
state == MLV_PRESSED
){
if( x ) *x = tmp_x;
if( y ) *y = tmp_y;
}
return !resultat;
}
const char* MLV_convert_mouse_button_to_string( MLV_Mouse_button button_code ){
switch( button_code ){
case MLV_BUTTON_LEFT:
return "MLV_BUTTON_LEFT";
case MLV_BUTTON_MIDDLE:
return "MLV_BUTTON_MIDDLE";
case MLV_BUTTON_RIGHT:
return "MLV_BUTTON_RIGHT";
default:
ERROR("Button code unexpected");
}
return NULL;
}
MLV_Mouse_button MLV_convert_string_to_mouse_button( const char* button_string ){
if( strcmp( button_string, "MLV_BUTTON_LEFT" )==0 ){
return MLV_BUTTON_LEFT;
}
if( strcmp( button_string, "MLV_BUTTON_MIDDLE" )==0 ){
return MLV_BUTTON_MIDDLE;
}
if( strcmp( button_string, "MLV_BUTTON_RIGHT" )==0 ){
return MLV_BUTTON_RIGHT;
}
ERROR("Button name unexpected");
return -1;
}
void MLV_get_mouse_position( int* x, int* y ){
SDL_PumpEvents();
SDL_GetMouseState(x,y);
}
MLV_Button_state MLV_get_mouse_button_state( MLV_Mouse_button mouse_button ){
SDL_PumpEvents();
if( SDL_GetMouseState(NULL,NULL) & SDL_BUTTON( mouse_button ) ){
return MLV_PRESSED;
}
return MLV_RELEASED;
}

122
MLV/path.c
View File

@@ -1,122 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_path.h"
#include "warning_error.h"
#include "memory_management.h"
#include "data_structure.h"
#include <glib.h>
#include <stdarg.h>
char* MLV_get_base_name( const char* path ){
return g_path_get_basename( path );
}
char* MLV_get_directory_name( const char* path ){
return g_path_get_dirname( path );
}
int MLV_path_is_absolute( const char* path ){
return g_path_is_absolute( path );
}
int MLV_path_is_relative( const char* path ){
return ! MLV_path_is_absolute( path );
}
char* MLV_build_path_v( char** elements ){
gchar* tmp_res = g_build_filenamev( elements );
char* result = strdup( tmp_res );
g_free( tmp_res ); // tmp_res have to be freed with g_free (
// see glib documentation
// )
return result;
}
char* MLV_build_path( const char* first_element, ...){
char *result;
if( !first_element ) return NULL;
va_list pile;
const char* type;
int compteur;
va_start( pile, first_element );
compteur = 2;
while(
(
type = va_arg( pile, char* )
) != NULL
){
compteur ++;
}
va_end( pile );
char** elements = MLV_MALLOC( compteur, char* );
elements[0] = strdup( first_element );
va_start( pile, first_element );
int i;
for( i=1; i<compteur; i++ ){
type = va_arg( pile, const char*);
if( type ){
elements[i] = strdup( (const char*) type );
}else{
elements[i] = NULL;
}
}
va_end( pile );
result = MLV_build_path_v( elements );
for( i=0; i<compteur-1; i++ ){
MLV_FREE( elements[i], char );
}
MLV_FREE( elements, char* );
return result;
}
int MLV_path_is_a_directory( const char* path ){
return g_file_test( path, G_FILE_TEST_IS_DIR );
}
int MLV_path_is_a_file( const char* path ){
return g_file_test( path, G_FILE_TEST_IS_REGULAR );
}
int MLV_path_exists( const char* path ){
return g_file_test( path, G_FILE_TEST_EXISTS );
}
char * MLV_get_current_directory( ){
return g_get_current_dir();
}
const char * MLV_get_temporary_directory( ){
return g_get_tmp_dir();
}
const char * MLV_get_home_directory( ){
return g_get_home_dir();
}

34
MLV/platform.h
View File

@@ -1,34 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__PLATFORM_H__
#define __MLV__PLATFORM_H__
#if defined( __WIN32__ ) || defined( _WIN32 ) || defined( __CYGWIN__ )
# define OS_WINDOWS
#elif defined( __APPLE_CC__)
# define OS_APPLE
#elif defined( __MLV_ANDROID__ )
# define OS_ANDROID
#else
# define OS_LINUX
#endif
#endif

205
MLV/playlist.c
View File

@@ -1,205 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_playlist.h"
#include "MLV_audio.h"
#include "data_structure.h"
#include "list.h"
#include "memory_management.h"
#include "warning_error.h"
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
extern DataMLV* MLV_data;
typedef struct _Music_item {
int interne;
MLV_Music* music;
} Music_item;
struct _MLV_Playlist {
MLV_List* music_items;
int playing;
int current;
int size;
SDL_sem* semaphore;
double volume;
int loop;
};
void MLV_init_playlists(){
MLV_data->playlists = NULL;
MLV_data->active_playlists = NULL;
}
void MLV_close_playlists(){
MLV_List* playlists = NULL;
MLV_List* tmp = MLV_data->playlists;
while(tmp){
playlists = MLV_prepend_list(
playlists,
tmp->data
);
tmp = tmp->next;
}
MLV_foreach_list(
playlists,
(void (*)(void*,void*)) MLV_close_playlist
, NULL
);
MLV_free_list( MLV_data->playlists );
MLV_free_list( MLV_data->active_playlists );
}
MLV_Playlist* MLV_create_playlist( int loop ){
MLV_Playlist* playlist = MLV_MALLOC( 1, MLV_Playlist );
playlist->music_items = NULL;
playlist->semaphore = SDL_CreateSemaphore(1);
playlist->volume = 1.0;
playlist->size = 0;
playlist->loop = loop;
if( SDL_SemWait( MLV_data->audio_semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
MLV_data->playlists = MLV_prepend_list(
MLV_data->playlists,
playlist
);
if( SDL_SemPost( MLV_data->audio_semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
return playlist;
}
void MLV_close_playlist( MLV_Playlist* playlist ){
if( SDL_SemWait( MLV_data->audio_semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
MLV_data->playlists = MLV_remove_list( MLV_data->playlists, playlist );
if( SDL_SemPost( MLV_data->audio_semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
MLV_playlist_clear( playlist );
MLV_free_list( playlist->music_items );
SDL_DestroySemaphore( playlist->semaphore );
}
void MLV_playlist_add( MLV_Playlist* playlist, const char* file_music ){
Music_item* item = MLV_MALLOC(1, Music_item);
item->interne = 1;
item->music = MLV_load_music( file_music );
if( SDL_SemWait( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
playlist->music_items = MLV_prepend_list(
playlist->music_items,
item
);
playlist->size ++;
if( SDL_SemPost( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
void MLV_playlist_add_sheet_music( MLV_Playlist* playlist, MLV_Music* music ){
Music_item* item = MLV_MALLOC(1, Music_item);
item->interne = 0;
item->music = music;
if( SDL_SemWait( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
playlist->music_items = MLV_prepend_list(
playlist->music_items,
item
);
if( SDL_SemPost( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
void MLV_playlist_remove( MLV_Playlist* playlist, int index ){
TODO
}
void MLV_playlist_clear( MLV_Playlist* playlist ){
TODO
}
void MLV_playlist_volume( MLV_Playlist* playlist, double volume ){
if( SDL_SemWait( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
playlist->volume = volume;
if( SDL_SemPost( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
void MLV_playlist_play( MLV_Playlist* playlist ){
if( SDL_SemWait( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
playlist->playing = 1;
if( SDL_SemPost( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
void MLV_playlist_pause( MLV_Playlist* playlist ){
if( SDL_SemWait( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
playlist->playing = 0;
if( SDL_SemPost( playlist->semaphore ) ){
ERROR_FULL("Probleme de semaphore");
}
}
void MLV_playlist_stop( MLV_Playlist* playlist ){
TODO
}
void MLV_playlist_next( MLV_Playlist* playlist ){
TODO
}
void MLV_playlist_previous( MLV_Playlist* playlist ){
TODO
}
void MLV_playlist_first( MLV_Playlist* playlist ){
TODO
}
void MLV_playlist_last( MLV_Playlist* playlist ){
TODO
}
void MLV_playlist_index( MLV_Playlist* playlist, int index){
TODO
}

44
MLV/random.c
View File

@@ -1,44 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_random.h"
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
#include <glib.h>
#include "warning_error.h"
#include "memory_management.h"
int MLV_get_random_boolean(int begin, int end){
return g_random_boolean( );
}
int MLV_get_random_integer(int begin, int end){
return g_random_int_range( begin, end );
}
double MLV_get_random_double(double begin, double end){
return g_random_double_range( begin, end );
}

198
MLV/sdlkeyboardtochar.c
View File

@@ -1,198 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "sdlkeyboardtochar.h"
#include "memory_management.h"
int sldKeyIsACharacter( SDLKey key){
int result = 1;
switch( key ) {
case SDLK_TAB : result = 1; break;
case SDLK_SPACE : result = 1; break;
case SDLK_EXCLAIM : result = 1; break;
case SDLK_QUOTEDBL : result = 1; break;
case SDLK_HASH : result = 1; break;
case SDLK_DOLLAR : result = 1; break;
case SDLK_AMPERSAND : result = 1; break;
case SDLK_QUOTE : result = 1; break;
case SDLK_LEFTPAREN : result = 1; break;
case SDLK_RIGHTPAREN : result = 1; break;
case SDLK_ASTERISK : result = 1; break;
case SDLK_PLUS : result = 1; break;
case SDLK_COMMA : result = 1; break;
case SDLK_MINUS : result = 1; break;
case SDLK_PERIOD : result = 1; break;
case SDLK_SLASH : result = 1; break;
case SDLK_0 : result = 1; break;
case SDLK_1 : result = 1; break;
case SDLK_2 : result = 1; break;
case SDLK_3 : result = 1; break;
case SDLK_4 : result = 1; break;
case SDLK_5 : result = 1; break;
case SDLK_6 : result = 1; break;
case SDLK_7 : result = 1; break;
case SDLK_8 : result = 1; break;
case SDLK_9 : result = 1; break;
case SDLK_COLON : result = 1; break;
case SDLK_SEMICOLON : result = 1; break;
case SDLK_LESS : result = 1; break;
case SDLK_EQUALS : result = 1; break;
case SDLK_GREATER : result = 1; break;
case SDLK_QUESTION : result = 1; break;
case SDLK_AT : result = 1; break;
case SDLK_LEFTBRACKET : result = 1; break;
case SDLK_BACKSLASH : result = 1; break;
case SDLK_RIGHTBRACKET : result = 1; break;
case SDLK_CARET : result = 1; break;
case SDLK_UNDERSCORE : result = 1; break;
case SDLK_BACKQUOTE : result = 1; break;
case SDLK_a : result = 1; break;
case SDLK_b : result = 1; break;
case SDLK_c : result = 1; break;
case SDLK_d : result = 1; break;
case SDLK_e : result = 1; break;
case SDLK_f : result = 1; break;
case SDLK_g : result = 1; break;
case SDLK_h : result = 1; break;
case SDLK_i : result = 1; break;
case SDLK_j : result = 1; break;
case SDLK_k : result = 1; break;
case SDLK_l : result = 1; break;
case SDLK_m : result = 1; break;
case SDLK_n : result = 1; break;
case SDLK_o : result = 1; break;
case SDLK_p : result = 1; break;
case SDLK_q : result = 1; break;
case SDLK_r : result = 1; break;
case SDLK_s : result = 1; break;
case SDLK_t : result = 1; break;
case SDLK_u : result = 1; break;
case SDLK_v : result = 1; break;
case SDLK_w : result = 1; break;
case SDLK_x : result = 1; break;
case SDLK_y : result = 1; break;
case SDLK_z : result = 1; break;
case SDLK_KP_PERIOD : result = 1; break;
case SDLK_KP_DIVIDE : result = 1; break;
case SDLK_KP_MULTIPLY : result = 1; break;
case SDLK_KP_MINUS : result = 1; break;
case SDLK_KP_PLUS : result = 1; break;
case SDLK_KP_EQUALS : result = 1; break;
default: result = 0;
}
return result;
}
int converSdlKeyToChar( SDLKey key, SDLMod mod, char* character ){
int result = 0;
/*
* if( mod & KMOD_NUM ) printf( "NUMLOCK " );
* if( mod & KMOD_CAPS ) printf( "CAPSLOCK " );
* if( mod & KMOD_LCTRL ) printf( "LCTRL " );
* if( mod & KMOD_RCTRL ) printf( "RCTRL " );
* if( mod & KMOD_RSHIFT ) printf( "RSHIFT " );
* if( mod & KMOD_LSHIFT ) printf( "LSHIFT " );
* if( mod & KMOD_RALT ) printf( "RALT " );
* if( mod & KMOD_LALT ) printf( "LALT " );
* if( mod & KMOD_CTRL ) printf( "CTRL " );
* if( mod & KMOD_SHIFT ) printf( "SHIFT " );
* if( mod & KMOD_ALT ) printf( "ALT " );
* */
switch( key ) {
case SDLK_TAB : (*character) = '\t'; break;
case SDLK_SPACE : (*character) = ' '; break;
case SDLK_EXCLAIM : (*character) = '!'; break;
case SDLK_QUOTEDBL : (*character) = '"'; break;
case SDLK_HASH : (*character) = '#'; break;
case SDLK_DOLLAR : (*character) = '$'; break;
case SDLK_AMPERSAND : (*character) = '&'; break;
case SDLK_QUOTE : (*character) = '\''; break;
case SDLK_LEFTPAREN : (*character) = '('; break;
case SDLK_RIGHTPAREN : (*character) = ')'; break;
case SDLK_ASTERISK : (*character) = '*'; break;
case SDLK_PLUS : (*character) = '+'; break;
case SDLK_COMMA : (*character) = ','; break;
case SDLK_MINUS : (*character) = '-'; break;
case SDLK_PERIOD : (*character) = '.'; break;
case SDLK_SLASH : (*character) = '/'; break;
case SDLK_0 : (*character) = '0'; break;
case SDLK_1 : (*character) = '1'; break;
case SDLK_2 : (*character) = '2'; break;
case SDLK_3 : (*character) = '3'; break;
case SDLK_4 : (*character) = '4'; break;
case SDLK_5 : (*character) = '5'; break;
case SDLK_6 : (*character) = '6'; break;
case SDLK_7 : (*character) = '7'; break;
case SDLK_8 : (*character) = '8'; break;
case SDLK_9 : (*character) = '9'; break;
case SDLK_COLON : (*character) = ':'; break;
case SDLK_SEMICOLON : (*character) = ';'; break;
case SDLK_LESS : (*character) = '<'; break;
case SDLK_EQUALS : (*character) = '='; break;
case SDLK_GREATER : (*character) = '>'; break;
case SDLK_QUESTION : (*character) = '?'; break;
case SDLK_AT : (*character) = '@'; break;
case SDLK_LEFTBRACKET : (*character) = '['; break;
case SDLK_BACKSLASH : (*character) = '\\'; break;
case SDLK_RIGHTBRACKET : (*character) = ']'; break;
case SDLK_CARET : (*character) = '^'; break;
case SDLK_UNDERSCORE : (*character) = '_'; break;
case SDLK_BACKQUOTE : (*character) = '`'; break;
case SDLK_a : (*character) = 'a'; break;
case SDLK_b : (*character) = 'b'; break;
case SDLK_c : (*character) = 'c'; break;
case SDLK_d : (*character) = 'd'; break;
case SDLK_e : (*character) = 'e'; break;
case SDLK_f : (*character) = 'f'; break;
case SDLK_g : (*character) = 'g'; break;
case SDLK_h : (*character) = 'h'; break;
case SDLK_i : (*character) = 'i'; break;
case SDLK_j : (*character) = 'j'; break;
case SDLK_k : (*character) = 'k'; break;
case SDLK_l : (*character) = 'l'; break;
case SDLK_m : (*character) = 'm'; break;
case SDLK_n : (*character) = 'n'; break;
case SDLK_o : (*character) = 'o'; break;
case SDLK_p : (*character) = 'p'; break;
case SDLK_q : (*character) = 'q'; break;
case SDLK_r : (*character) = 'r'; break;
case SDLK_s : (*character) = 's'; break;
case SDLK_t : (*character) = 't'; break;
case SDLK_u : (*character) = 'u'; break;
case SDLK_v : (*character) = 'v'; break;
case SDLK_w : (*character) = 'w'; break;
case SDLK_x : (*character) = 'x'; break;
case SDLK_y : (*character) = 'y'; break;
case SDLK_z : (*character) = 'z'; break;
case SDLK_KP_PERIOD : (*character) = '.'; break;
case SDLK_KP_DIVIDE : (*character) = '/'; break;
case SDLK_KP_MULTIPLY : (*character) = '*'; break;
case SDLK_KP_MINUS : (*character) = '-'; break;
case SDLK_KP_PLUS : (*character) = '+'; break;
case SDLK_KP_EQUALS : (*character) = '='; break;
default: result = 1;
}
return result;
}

34
MLV/sdlkeyboardtochar.h
View File

@@ -1,34 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__SDLKEYBOARDTOCHAR_H__
#define __MLV__SDLKEYBOARDTOCHAR_H__
#ifndef MEMORY_DEBUG
#include <SDL/SDL.h>
#else
#include "memory_debug.h"
#endif
int converSdlKeyToChar( SDLKey key, SDLMod mod, char* character );
int sldKeyIsACharacter( SDLKey key );
#endif

267
MLV/shapes.c
View File

@@ -1,267 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_shape.h"
#include "platform.h"
#include "image.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL_gfxPrimitives.h>
#elif defined( OS_APPLE )
# include <SDL/SDL_gfxPrimitives.h>
#else
# include <SDL/SDL_gfxPrimitives.h>
#endif
#else
#include "memory_debug.h"
#endif
#include "data_structure.h"
#include "warning_error.h"
#include "memory_management.h"
#include <stdarg.h>
#include "data_structure.h"
extern DataMLV *MLV_data;
///////////////////////////////////////////////////////////////////////////////
// Drawing operation on images //
///////////////////////////////////////////////////////////////////////////////
void MLV_draw_circle_on_image(int x, int y, int radius, MLV_Color color, MLV_Image* image){
circleColor( image->surface, x, y, radius, color );
}
void MLV_draw_filled_circle_on_image(int x, int y, int radius, MLV_Color color, MLV_Image* image){
filledCircleColor( image->surface, x, y, radius, color);
}
void MLV_draw_ellipse_on_image(int x, int y, int radius_x, int radius_y, MLV_Color color, MLV_Image* image){
ellipseColor(image->surface,x,y,radius_x,radius_y,color);
}
void MLV_draw_filled_ellipse_on_image(int x, int y, int radius_x, int radius_y, MLV_Color color, MLV_Image* image){
filledEllipseColor(image->surface,x,y,radius_x,radius_y,color);
}
void MLV_draw_polygon_on_image( const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image){
Sint16* tmp_vx = MLV_MALLOC( nb_points, Sint16 );
Sint16* tmp_vy = MLV_MALLOC( nb_points, Sint16 );
int i;
for( i=0; i< nb_points; i++){
tmp_vx[i] = vx[i];
tmp_vy[i] = vy[i];
}
polygonColor( image->surface, tmp_vx, tmp_vy, nb_points, color);
MLV_FREE( tmp_vx, Sint16 );
MLV_FREE( tmp_vy, Sint16 );
}
void MLV_draw_filled_polygon_on_image( const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image){
Sint16* tmp_vx = MLV_MALLOC( nb_points, Sint16 );
Sint16* tmp_vy = MLV_MALLOC( nb_points, Sint16 );
int i;
for( i=0; i< nb_points; i++){
tmp_vx[i] = vx[i];
tmp_vy[i] = vy[i];
}
filledPolygonColor( image->surface, tmp_vx, tmp_vy, nb_points, color);
MLV_FREE( tmp_vx, Sint16 );
MLV_FREE( tmp_vy, Sint16 );
}
void MLV_draw_bezier_curve_on_image( const int* vx, const int* vy, int nb_points, MLV_Color color, MLV_Image* image){
Sint16* tmp_vx = MLV_MALLOC( nb_points, Sint16 );
Sint16* tmp_vy = MLV_MALLOC( nb_points, Sint16 );
int i;
for( i=0; i< nb_points; i++){
tmp_vx[i] = vx[i];
tmp_vy[i] = vy[i];
}
bezierColor( image->surface, tmp_vx, tmp_vy, nb_points, 6 , color);
MLV_FREE( tmp_vx, Sint16 );
MLV_FREE( tmp_vy, Sint16 );
}
void MLV_draw_rectangle_on_image(int x, int y, int width, int height, MLV_Color color, MLV_Image* image){
rectangleColor(image->surface, x, y, x+width-1, y+height-1, color);
}
void MLV_draw_filled_rectangle_on_image(int x, int y, int width, int height, MLV_Color color, MLV_Image* image){
boxColor(image->surface, x, y, x+width-1, y+height-1, color);
}
void MLV_draw_line_on_image(int x1, int y1, int x2, int y2, MLV_Color color, MLV_Image* image){
lineColor( image->surface, x1, y1, x2, y2, color);
}
void draw_pixel_on_sdl_surface( SDL_Surface* surface, int x, int y, MLV_Color color ){
#if 0 // Je ne me souvient plus pourquoi pexelColor ne fonctionnait pas. Je crois que c'est la composante alpha qui pose problème.
pixelColor(MLV_data->screen, x, y, color);
#else
SDL_LockSurface(surface);
SDL_PixelFormat *fmt;
Uint32 *pixel;
fmt = surface->format;
pixel = ((Uint32*) surface->pixels)+ y*surface->pitch/4 + x;
Uint8 red, blue, green, alpha;
MLV_convert_color_to_rgba( color, &red, &green, &blue, &alpha );
int red_image, green_image, blue_image, alpha_image;
get_pixel_on_image_unsafe(
surface, x, y,
&red_image, &green_image, &blue_image, &alpha_image
);
int inv_alpha = 255 - alpha;
Uint32 red32 = ( alpha * red + inv_alpha * red_image )/255;
Uint32 blue32 = ( alpha * blue + inv_alpha * blue_image )/255;
Uint32 green32 = ( alpha * green + inv_alpha * green_image )/255;
Uint32 alpha32 = alpha_image;
/* set the Red component */
red32 = red32 >> fmt->Rloss;
red32 = red32 << fmt->Rshift;
/* set the Green component */
green32 = green32 >> fmt->Gloss;
green32 = green32 << fmt->Gshift;
/* set the Blue component */
blue32 = blue32 >> fmt->Bloss;
blue32 = blue32 << fmt->Bshift;
/* set the Alpha component */
alpha32 = alpha32 >> fmt->Aloss;
alpha32 = alpha32 << fmt->Ashift;
*pixel = red32 | green32 | blue32 | alpha32;
SDL_UnlockSurface(surface);
#endif
}
void draw_pixel( MLV_Image* image, int x, int y, MLV_Color color ){
SDL_Surface* surface = image->surface;
draw_pixel_on_sdl_surface( surface, x, y, color );
}
void MLV_draw_pixel_on_image(int x, int y, MLV_Color color, MLV_Image* image){
draw_pixel( image, x, y, color);
}
void MLV_draw_point_on_image(int x, int y, MLV_Color color, MLV_Image* image){
MLV_draw_pixel_on_image( x, y, color, image);
}
///////////////////////////////////////////////////////////////////////////////
// Drawing operation on iscreen //
///////////////////////////////////////////////////////////////////////////////
void MLV_draw_circle(int x, int y, int radius, MLV_Color color){
circleColor( MLV_data->screen, x, y, radius, color );
}
void MLV_draw_filled_circle(int x, int y, int radius, MLV_Color color){
filledCircleColor( MLV_data->screen, x, y, radius, color);
}
void MLV_draw_ellipse(int x, int y, int radius_x, int radius_y, MLV_Color color){
ellipseColor(MLV_data->screen,x,y,radius_x,radius_y,color);
}
void MLV_draw_filled_ellipse(int x, int y, int radius_x, int radius_y, MLV_Color color){
filledEllipseColor(MLV_data->screen,x,y,radius_x,radius_y,color);
}
void MLV_draw_polygon( const int* vx, const int* vy, int nb_points, MLV_Color color){
Sint16* tmp_vx = MLV_MALLOC( nb_points, Sint16 );
Sint16* tmp_vy = MLV_MALLOC( nb_points, Sint16 );
int i;
for( i=0; i< nb_points; i++){
tmp_vx[i] = vx[i];
tmp_vy[i] = vy[i];
}
polygonColor( MLV_data->screen, tmp_vx, tmp_vy, nb_points, color);
MLV_FREE( tmp_vx, Sint16 );
MLV_FREE( tmp_vy, Sint16 );
}
void MLV_draw_filled_polygon( const int* vx, const int* vy, int nb_points, MLV_Color color){
Sint16* tmp_vx = MLV_MALLOC( nb_points, Sint16 );
Sint16* tmp_vy = MLV_MALLOC( nb_points, Sint16 );
int i;
for( i=0; i< nb_points; i++){
tmp_vx[i] = vx[i];
tmp_vy[i] = vy[i];
}
filledPolygonColor( MLV_data->screen, tmp_vx, tmp_vy, nb_points, color);
MLV_FREE( tmp_vx, Sint16 );
MLV_FREE( tmp_vy, Sint16 );
}
void MLV_draw_bezier_curve( const int* vx, const int* vy, int nb_points, MLV_Color color){
Sint16* tmp_vx = MLV_MALLOC( nb_points, Sint16 );
Sint16* tmp_vy = MLV_MALLOC( nb_points, Sint16 );
int i;
for( i=0; i< nb_points; i++){
tmp_vx[i] = vx[i];
tmp_vy[i] = vy[i];
}
bezierColor( MLV_data->screen, tmp_vx, tmp_vy, nb_points, 6 , color);
MLV_FREE( tmp_vx, Sint16 );
MLV_FREE( tmp_vy, Sint16 );
}
void MLV_draw_rectangle(int x, int y, int width, int height, MLV_Color color){
rectangleColor(MLV_data->screen, x, y, x+width-1, y+height-1, color);
}
void MLV_draw_filled_rectangle(int x, int y, int width, int height, MLV_Color color){
boxColor(MLV_data->screen, x, y, x+width-1, y+height-1, color);
}
void MLV_draw_line(int x1, int y1, int x2, int y2, MLV_Color color){
lineColor( MLV_data->screen, x1, y1, x2, y2, color);
}
void MLV_draw_pixel(int x, int y, MLV_Color color){
draw_pixel_on_sdl_surface( MLV_data->screen, x, y, color );
}
void MLV_draw_point(int x, int y, MLV_Color color){
MLV_draw_pixel( x, y, color);
}

940
MLV/text.c
View File

@@ -1,940 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "platform.h"
#ifdef OS_WINDOWS
/* Get va_list. */
#if __STDC__ || defined __cplusplus || defined _MSC_VER
# include <stdarg.h>
#else
# include <varargs.h>
#endif
extern int vasprintf (char **, const char *, va_list);
#endif
#include "MLV_text.h"
#include "MLV_text_va.h"
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
# include <SDL/SDL_ttf.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
# include <SDL_ttf/SDL_ttf.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
# include <SDL/SDL_ttf.h>
#endif
#else
#include "memory_debug.h"
#endif
#include <string.h>
#include "text.h"
#include "MLV_shape.h"
#include "data_structure.h"
#include "image.h"
#include "memory_management.h"
#include "warning_error.h"
#define SIZE_FONT 8
extern DataMLV* MLV_data;
void MLV_get_size_of_text_va(
const char *text, int *width, int *height, va_list pile
){
MLV_get_size_of_text_with_font_va(
text, width, height, MLV_data->defaultFont, pile
);
}
void MLV_get_size_of_text( const char *text, int *width, int *height, ... ){
va_list pile;
va_start( pile, height );
MLV_get_size_of_text_va( text, width, height, pile );
va_end( pile );
}
void MLV_get_size_of_text_with_font_va(
const char *text, int *width, int *height, const MLV_Font* font,
va_list pile
){
char* complete_text;
if( vasprintf( &complete_text, text, pile )==-1 ){
ERROR("Unexpected Error.");
}
if( strlen( complete_text ) ){
TTF_SizeUTF8(font->font, complete_text, width, height);
}else{
TTF_SizeUTF8(font->font, " ", width, height);
}
free( complete_text );
}
void MLV_get_size_of_text_with_font(
const char *text, int *width, int *height, const MLV_Font* font, ...
){
va_list pile;
va_start( pile, font );
MLV_get_size_of_text_with_font_va( text, width, height, font, pile );
va_end( pile );
}
void init_font(){
if ( TTF_Init() < 0 ) {
fprintf(
stderr, "Couldn't initialize TTF: %s - file : %s, ligne : %i\n",
SDL_GetError(), __FILE__, __LINE__
);
exit(1);
}
}
void quit_font(){
TTF_Quit();
}
MLV_Font* MLV_load_font( const char* file_font, int size ){
if( !MLV_data ){
ERROR("To use MLV_load_font, please initialise first the MLV_Library by calling MLV_create_window before MLV_load_font.")
}
MLV_Font* font = MLV_MALLOC( 1, MLV_Font );
font->size = size;
font->font = TTF_OpenFont( file_font, size );
if(!font->font) {
printf(
"TTF_OpenFont: %s - file : %s, ligne : %i\n",
TTF_GetError(), __FILE__, __LINE__
);
exit(1);
}
TTF_SetFontStyle( font->font , TTF_STYLE_NORMAL );
return font;
}
void MLV_free_font( MLV_Font* font ){
TTF_CloseFont( font->font );
MLV_FREE( font, MLV_Font );
}
void convertionColor( MLV_Color src, SDL_Color* dst ){
src = src >> 8;
dst->b = (Uint8) src;
src = src >> 8;
dst->g = (Uint8) src;
src = src >> 8;
dst->r = (Uint8) src;
}
void getDefaultFont( MLV_Font** const font ){
if( *font ) return;
*font = MLV_data->defaultFont;
}
void drawString(
SDL_Surface* textBox, int x, int y,
const char* message, MLV_Color color, TTF_Font* font
){
SDL_Color sdl_color;
convertionColor( color, &sdl_color);
SDL_Surface* text;
if( strlen( message ) ){
text = TTF_RenderUTF8_Solid(
font,
message,
sdl_color
);
}else{
text = TTF_RenderUTF8_Solid(
font,
" ",
sdl_color
);
}
SDL_Rect rectangle;
rectangle.x = x;
rectangle.y = y;
rectangle.w = text->w;
rectangle.h = text->h;
SDL_BlitSurface( text, NULL, textBox, &rectangle);
SDL_FreeSurface( text );
}
void MLV_draw_text_on_image_va(
int x, int y, const char *text, MLV_Color color, MLV_Image* image,
va_list pile
){
MLV_draw_text_with_font_on_image_va(
x, y, text, MLV_data->defaultFont, color, image, pile
);
}
void MLV_draw_text_on_image(
int x, int y, const char *text, MLV_Color color, MLV_Image* image, ...
){
va_list pile;
va_start( pile, image );
MLV_draw_text_on_image_va( x, y, text, color, image, pile );
va_end( pile );
}
void MLV_draw_text_with_font_on_image_va(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color,
MLV_Image* image, va_list pile
){
char* complete_text;
if( vasprintf( &complete_text, text, pile )==-1 ){
ERROR("Unexpected Error.");
}
drawString( image->surface, x, y, complete_text, color, font->font );
free( complete_text );
}
void MLV_draw_text_with_font_on_image(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color,
MLV_Image* image, ...
){
va_list pile;
va_start( pile, image );
MLV_draw_text_with_font_on_image_va( x, y, text, font, color, image, pile );
va_end( pile );
}
void MLV_draw_text_va(
int x, int y, const char *text, MLV_Color color, va_list pile
){
MLV_draw_text_with_font_va(
x, y, text, MLV_data->defaultFont, color, pile
);
}
void MLV_draw_text(int x, int y, const char *text, MLV_Color color, ... ){
va_list pile;
va_start( pile, color );
MLV_draw_text_va( x, y, text, color, pile );
va_end( pile );
}
void MLV_draw_text_with_font_va(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color,
va_list pile
){
char* complete_text;
if( vasprintf( &complete_text, text, pile )==-1 ){
ERROR("Unexpected Error.");
}
drawString( MLV_data->screen, x, y, complete_text, color, font->font );
free( complete_text );
}
void MLV_draw_text_with_font(
int x, int y, const char *text, const MLV_Font* font, MLV_Color color, ...
){
va_list pile;
va_start( pile, color );
MLV_draw_text_with_font_va( x, y, text, font, color, pile );
va_end( pile );
}
int internal_draw_adapted_text_box_size_with_font(
char* copy,
const MLV_Font* font,
int sizeInterligne,
int *width, int *height,
int * width_text
){
int nb_line=1;
*width = 0;
*height = 0;
if( copy[0] != '\0' ){
int width_line,height_line;
char * new = copy;
char* old = new;
while( ( new = strchr( new ,'\n') ) ){
(*new) = '\0';
++nb_line;
MLV_get_size_of_text_with_font(
old, &width_line, &height_line, font
);
if( width_line > *width ){
*width = width_line;
}
*height += height_line + sizeInterligne;
new ++;
old=new;
}
MLV_get_size_of_text_with_font( old, &width_line, &height_line, font );
if( width_line > *width ){
*width = width_line;
}
*height += height_line + sizeInterligne;
}
if( width_text ){
*width_text = *width;
}
//Ajout des bords
*width += 2*sizeInterligne;
*height += sizeInterligne;
return nb_line;
}
void internal_draw_text_box_with_font(
char* copy ,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
int corner_position_x,
int corner_position_y,
int width_text,
int nb_line,
SDL_Surface* textBox
){
char * new = copy;
char* old = new;
int position = corner_position_y + sizeInterligne;
int horizontal_offset = corner_position_x + sizeInterligne;
int i;
for( i=0; i<nb_line; i++){
new = strchr( new ,'\0');
int width_line,height_line;
MLV_get_size_of_text_with_font( old, &width_line, &height_line, font );
switch( text_justification ){
case MLV_TEXT_CENTER:
drawString(
textBox,
horizontal_offset + (width_text-width_line)/2, position ,
old, textColor, font->font
);
break;
case MLV_TEXT_LEFT:
drawString(
textBox,
horizontal_offset , position ,
old, textColor, font->font
);
break;
case MLV_TEXT_RIGHT:
drawString(
textBox,
horizontal_offset+width_text-width_line+sizeInterligne,
position,
old, textColor, font->font
);
break;
default:
ERROR("Valeur impossible pour horizontal_position.");
}
position += height_line + sizeInterligne;
new ++;
old=new;
}
}
void internal_draw_adapted_text_box_with_font_on_image(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
SDL_Surface *screen
){
char* copy = (char*) MLV_MALLOC( (strlen(message)+1), char );
snprintf(copy, strlen(message)+1, "%s", message);
int width,height,width_text;
int nb_line = internal_draw_adapted_text_box_size_with_font(
copy, font, sizeInterligne, &width, &height, &width_text
);
SDL_Rect rectangle;
rectangle.x = x;
rectangle.y = y;
rectangle.w = width;
rectangle.h = height;
SDL_Surface* textBox= create_surface(
width, height
);
SDL_SetAlpha(textBox, SDL_SRCALPHA, SDL_ALPHA_OPAQUE);
SDL_SetColorKey(textBox, SDL_SRCCOLORKEY, backgroundColor);
boxColor( textBox , 0, 0, width-1, height-1, backgroundColor);
internal_draw_text_box_with_font(
copy ,
font,
sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
0,
0,
width_text,
nb_line,
textBox
);
rectangleColor( textBox , 0, 0, width-1, height-1, borderColor);
SDL_BlitSurface( textBox, NULL, screen, &rectangle);
SDL_FreeSurface( textBox );
MLV_FREE(copy, char);
}
void MLV_draw_adapted_text_box_with_font_va(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
va_list pile
){
char* complete_message;
if( vasprintf( &complete_message, message, pile )==-1 ){
ERROR("Unexpected Error.");
}
internal_draw_adapted_text_box_with_font_on_image(
x, y,
complete_message,
font,
sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
MLV_data->screen
);
free( complete_message );
}
void MLV_draw_adapted_text_box_va(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification, va_list pile
){
MLV_draw_adapted_text_box_with_font_va(
x, y, message, MLV_data->defaultFont, sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification, pile
);
}
void MLV_draw_adapted_text_box(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification, ...
){
va_list pile;
va_start( pile, text_justification );
MLV_draw_adapted_text_box_va(
x, y, message, sizeInterligne, borderColor, textColor, backgroundColor,
text_justification, pile
);
va_end( pile );
}
void MLV_draw_adapted_text_box_with_font_on_image_va(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, va_list pile
){
char* complete_message;
if( vasprintf( &complete_message, message, pile )==-1 ){
ERROR("Unexpected Error.");
}
internal_draw_adapted_text_box_with_font_on_image(
x, y,
complete_message,
font,
sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
image->surface
);
free( complete_message );
}
void MLV_draw_adapted_text_box_on_image_va(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, va_list pile
){
MLV_draw_adapted_text_box_with_font_on_image_va(
x, y, message, MLV_data->defaultFont, sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
image, pile
);
}
void MLV_draw_adapted_text_box_on_image(
int x, int y,
const char* message,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, ...
){
va_list pile;
va_start( pile, image );
MLV_draw_adapted_text_box_on_image_va(
x, y, message, sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
image, pile
);
va_end( pile );
}
int MLV_get_size_of_adapted_text_box_with_font_va(
const char* message,
const MLV_Font* font,
int sizeInterligne,
int *result_width, int *result_height,
va_list pile
){
char* complete_message;
if( vasprintf( &complete_message, message, pile )==-1 ){
ERROR("Unexpected Error.");
}
char* copy = (char*) MLV_MALLOC( (strlen(complete_message)+1), char );
snprintf(copy, strlen(complete_message)+1, "%s", complete_message);
int result = internal_draw_adapted_text_box_size_with_font(
copy,
font,
sizeInterligne,
result_width, result_height,
NULL
);
MLV_FREE(copy, char);
free( complete_message );
return result;
}
int MLV_get_size_of_adapted_text_box_va(
const char* message,
int sizeInterligne,
int *result_width, int *result_height,
va_list pile
){
return MLV_get_size_of_adapted_text_box_with_font_va(
message,
MLV_data->defaultFont,
sizeInterligne,
result_width, result_height,
pile
);
}
int MLV_get_size_of_adapted_text_box(
const char* message,
int sizeInterligne,
int *result_width, int *result_height,
...
){
int result;
va_list pile;
va_start( pile, result_height );
result = MLV_get_size_of_adapted_text_box_va(
message, sizeInterligne, result_width, result_height, pile
);
va_end( pile );
return result;
}
void MLV_draw_adapted_text_box_with_font(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification, ...
){
va_list pile;
va_start( pile, text_justification );
MLV_draw_adapted_text_box_with_font_va(
x, y, message, font, sizeInterligne, borderColor, textColor,
backgroundColor, text_justification, pile
);
va_end( pile );
}
void MLV_draw_adapted_text_box_with_font_on_image(
int x, int y,
const char* message,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Image* image, ...
){
va_list pile;
va_start( pile, image );
MLV_draw_adapted_text_box_with_font_on_image_va(
x, y, message, font, sizeInterligne, borderColor, textColor,
backgroundColor, text_justification, image, pile
);
va_end( pile );
}
int MLV_get_size_of_adapted_text_box_with_font(
const char* message,
const MLV_Font* font,
int sizeInterligne,
int *result_width, int *result_height, ...
){
int result;
va_list pile;
va_start( pile, result_height );
result = MLV_get_size_of_adapted_text_box_with_font_va(
message, font, sizeInterligne, result_width, result_height, pile
);
va_end( pile );
return result;
}
void internal_draw_text_box_with_font_on_image(
int x, int y,
int width, int height,
const char* message ,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
SDL_Surface* image
){
SDL_Rect rectangle;
rectangle.x = x;
rectangle.y = y;
rectangle.w = width;
rectangle.h = height;
SDL_Surface* textBox= create_surface(
width, height
);
SDL_SetAlpha(textBox, SDL_SRCALPHA, SDL_ALPHA_OPAQUE);
SDL_SetColorKey(textBox, SDL_SRCCOLORKEY, backgroundColor);
boxColor( textBox , 0, 0, width-1, height-1, backgroundColor);
char* copy = (char*) MLV_MALLOC( (strlen(message)+1), char );
snprintf(copy, strlen(message)+1, "%s", message);
int real_width,real_height,width_text;
int nb_line = internal_draw_adapted_text_box_size_with_font(
copy, font, sizeInterligne, &real_width, &real_height, &width_text
);
int position_corner_x;
switch( horizontal_position ){
case MLV_HORIZONTAL_LEFT:
position_corner_x = 0;
break;
case MLV_HORIZONTAL_RIGHT:
position_corner_x = width - real_width;
break;
case MLV_HORIZONTAL_CENTER:
position_corner_x = (width - real_width)/2;
break;
default:
ERROR("MLV_Vertical_position ne contient pas de bonnes valeurs.");
}
int position_corner_y;
switch( vertical_position ){
case MLV_VERTICAL_TOP:
position_corner_y = 0;
break;
case MLV_VERTICAL_BOTTOM:
position_corner_y = height - real_height;
break;
case MLV_VERTICAL_CENTER:
position_corner_y = (height - real_height)/2;
break;
default:
ERROR("MLV_Vertical_position ne contient pas de bonnes valeurs.");
}
internal_draw_text_box_with_font(
copy ,
font,
sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
position_corner_x,
position_corner_y,
width_text,
nb_line,
textBox
);
rectangleColor( textBox , 0, 0, width-1, height-1, borderColor);
SDL_BlitSurface( textBox, NULL, image, &rectangle);
SDL_FreeSurface( textBox );
MLV_FREE(copy, char);
}
void MLV_draw_text_box_with_font_va(
int x, int y,
int width, int height,
const char* message ,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
va_list pile
){
char* complete_message;
if( vasprintf( &complete_message, message, pile )==-1 ){
ERROR("Unexpected Error.");
}
internal_draw_text_box_with_font_on_image(
x, y,
width, height,
complete_message,
font,
sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
horizontal_position,
vertical_position,
MLV_data->screen
);
free( complete_message );
}
void MLV_draw_text_box_va(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
va_list pile
){
MLV_draw_text_box_with_font_va(
x, y, width, height, message , MLV_data->defaultFont, sizeInterligne,
borderColor, textColor, backgroundColor, text_justification,
horizontal_position, vertical_position, pile
);
}
void MLV_draw_text_box(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
...
){
va_list pile;
va_start( pile, vertical_position );
MLV_draw_text_box_va(
x, y, width, height, message , sizeInterligne, borderColor, textColor,
backgroundColor, text_justification, horizontal_position,
vertical_position, pile
);
va_end( pile );
}
void MLV_draw_text_box_with_font(
int x, int y,
int width, int height,
const char* message ,
const MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
...
){
va_list pile;
va_start( pile, vertical_position );
MLV_draw_text_box_with_font_va(
x, y, width, height, message, font, sizeInterligne,
borderColor, textColor, backgroundColor, text_justification,
horizontal_position, vertical_position, pile
);
va_end( pile );
}
void MLV_draw_text_box_with_font_on_image_va(
int x, int y,
int width, int height,
const char* message ,
MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
va_list pile
){
char* complete_message;
if( vasprintf( &complete_message, message, pile )==-1 ){
ERROR("Unexpected Error.");
}
internal_draw_text_box_with_font_on_image(
x, y,
width, height,
complete_message,
font,
sizeInterligne,
borderColor, textColor, backgroundColor,
text_justification,
horizontal_position,
vertical_position,
image->surface
);
free( complete_message );
}
void MLV_draw_text_box_with_font_on_image(
int x, int y,
int width, int height,
const char* message ,
MLV_Font* font,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
...
){
va_list pile;
va_start( pile, image );
MLV_draw_text_box_with_font_on_image_va(
x, y, width, height, message, font, sizeInterligne, borderColor,
textColor, backgroundColor, text_justification, horizontal_position,
vertical_position, image, pile
);
va_end( pile );
}
void MLV_draw_text_box_on_image_va(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
va_list pile
){
MLV_draw_text_box_with_font_on_image_va(
x, y, width, height, message, MLV_data->defaultFont, sizeInterligne,
borderColor, textColor, backgroundColor, text_justification,
horizontal_position, vertical_position, image, pile
);
}
void MLV_draw_text_box_on_image(
int x, int y,
int width, int height,
const char* message ,
int sizeInterligne,
MLV_Color borderColor, MLV_Color textColor, MLV_Color backgroundColor,
MLV_Text_justification text_justification,
MLV_Horizontal_position horizontal_position,
MLV_Vertical_position vertical_position,
MLV_Image* image,
...
){
va_list pile;
va_start( pile, image );
MLV_draw_text_box_on_image_va(
x, y, width, height, message, sizeInterligne, borderColor, textColor,
backgroundColor, text_justification, horizontal_position,
vertical_position, image, pile
);
va_end( pile );
}
char* MLV_convert_unicode_to_string( int unicode ){
gunichar v = unicode;
gchar* message;
int size = g_unichar_to_utf8(v,NULL);
message = (char*) MLV_MALLOC( size + 1, gchar );
message[ size ] = '\0';
g_unichar_to_utf8(v, message);
// const char* encodage;
// g_get_charset( &encodage );
// printf("encodage : %s\n",encodage);
// GError* error;
//
// gchar* result = g_locale_from_utf8(
// message,
// -1,
// NULL,
// NULL,
// &error // pas d'erreur
// );
//
//
// MLV_FREE( message, gchar* );
// return result;
return message;
}

52
MLV/text.h
View File

@@ -1,52 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__TEXT_H__
#define __MLV__TEXT_H__
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL_ttf.h>
#elif defined( OS_APPLE )
# include <SDL_ttf/SDL_ttf.h>
#else
# include <SDL/SDL_ttf.h>
#endif
#else
#include "memory_debug.h"
#endif
struct _MLV_Font {
int size;
TTF_Font* font;
};
void init_font();
void quit_font();
void drawString(
SDL_Surface* textBox, int x, int y,
const char* message, MLV_Color color, TTF_Font* font
);
#endif

107
MLV/time.c
View File

@@ -1,107 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_time.h"
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_framerate.h>
#endif
#else
#include "memory_debug.h"
#endif
#include <time.h>
#include "warning_error.h"
#include "memory_management.h"
#include "data_structure.h"
extern DataMLV* MLV_data;
void MLV_wait_milliseconds(int milliseconds){
SDL_Delay( milliseconds );
}
void MLV_wait_seconds(int seconds){
SDL_Delay( seconds * 1000 );
}
int MLV_get_time(){
return SDL_GetTicks();
}
int MLV_get_date(
int* seconds, int* minutes, int* hours,
int* day, int* month, int* year,
int* day_of_the_week
){
time_t current_time;
time(&current_time);
struct tm * timeinfo = localtime (&current_time);
if( seconds ){
*seconds = timeinfo->tm_sec;
}
if( minutes ){
*minutes = timeinfo->tm_min;
}
if( hours ){
*hours = timeinfo->tm_hour;
}
if( day ){
*day = timeinfo->tm_mday;
}
if( month ){
*month = timeinfo->tm_mon;
}
if( year ){
*year = timeinfo->tm_year+1900;
}
if( day_of_the_week ){
*day_of_the_week = timeinfo->tm_wday;
}
return timeinfo->tm_isdst;
}
void MLV_change_frame_rate( int rate ){
SDL_setFramerate( &(MLV_data->frame_rate_manager), rate );
}
int MLV_get_frame_rate( ){
return( SDL_getFramerate( &(MLV_data->frame_rate_manager) ) );
}
void MLV_delay_according_to_frame_rate( ){
SDL_framerateDelay( &(MLV_data->frame_rate_manager) );
}

182
MLV/tree_map.c
View File

@@ -1,182 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "tree_map.h"
#include "tree_set.h"
#include "warning_error.h"
#include "memory_management.h"
struct _MLV_TreeMap {
MLV_TreeSet* set;
};
typedef struct {
MLV_Key* key;
void* data;
void (* data_destroying_function )( void* data );
} PairKeyData;
PairKeyData* create_pair_key_data(
MLV_Key* key,
void* data,
void (* data_destroying_function )( void* data )
){
PairKeyData* result = MLV_MALLOC( 1, PairKeyData );
result->key = key;
result->data = data;
result->data_destroying_function = data_destroying_function;
return result;
}
void free_pair_key_data( PairKeyData* pair ){
if( pair ){
MLV_free_key( pair->key );
if( pair->data_destroying_function ){
pair->data_destroying_function( pair->data );
}
}
MLV_FREE( pair, PairKeyData );
}
void free_pair_key_data_without_key( PairKeyData* pair ){
if( pair ){
if( pair->data_destroying_function ){
pair->data_destroying_function( pair->data );
}
}
MLV_FREE( pair, PairKeyData );
}
int compare_pairs_key_data( PairKeyData* pair1, PairKeyData* pair2 ){
return MLV_compare_keys( pair1->key, pair2->key );
}
MLV_TreeMap* MLV_create_tree_map(){
MLV_TreeMap* result = MLV_MALLOC( 1, MLV_TreeMap );
result->set = NULL;
return result;
}
void MLV_add_data_in_tree_map(
MLV_Key* key, void* data,
void (* data_destroying_function)( void* data ),
MLV_TreeMap* tree_map
){
tree_map->set = MLV_add_data_in_tree_set(
create_pair_key_data(
key, data, data_destroying_function
),
( void (*)( void* ) ) free_pair_key_data,
( int (*)( void*, void* ) ) compare_pairs_key_data,
tree_map->set
);
}
void* MLV_get_data_from_tree_map( MLV_Key* key, MLV_TreeMap* tree_map ){
PairKeyData* key_data = create_pair_key_data( key, NULL, NULL );
MLV_TreeSet* elem = MLV_find_tree_set( key_data, tree_map->set );
PairKeyData* founded_key_data = (PairKeyData*) elem->data;
free_pair_key_data_without_key( key_data );
return founded_key_data->data;
}
void free_key_of_pair_key_data( PairKeyData* pair ){
MLV_free_key( pair->key );
}
void wrapper_free_key_of_pair_key_data( void* pair, void* useless_data ){
free_key_of_pair_key_data( ( PairKeyData* ) pair );
}
void MLV_init_tree_map( MLV_TreeMap* tree_map ){
// On supprime les clés
MLV_foreach_data_tree_set(
wrapper_free_key_of_pair_key_data,
NULL,
tree_map->set
);
// On réinitialise la table
MLV_init_tree_set( tree_map->set );
}
typedef struct {
void* data_user;
void (* key_data_function )( MLV_Key* key, void* data, void* data_user );
} Wrapper_data_user;
Wrapper_data_user* create_wrapper_data_user(
void* data_user,
void (* key_data_function )( MLV_Key* key, void* data, void* data_user )
){
Wrapper_data_user* result = MLV_MALLOC( 1, Wrapper_data_user );
result->data_user = data_user;
result->key_data_function = key_data_function;
return result;
}
void free_wrapper_data_user( Wrapper_data_user* data ){
MLV_FREE( data, Wrapper_data_user );
}
void wrapper_key_data_function(
void* data,
void* data_user
){
PairKeyData* pair = ( PairKeyData* ) data;
Wrapper_data_user* wrapper_data_user = (Wrapper_data_user*) data_user;
if( wrapper_data_user->key_data_function ){
wrapper_data_user->key_data_function(
pair->key, pair->data, wrapper_data_user->data_user
);
}
}
void MLV_foreach_key_data_tree_map(
void (* key_data_function )( MLV_Key* key, void* data, void* data_user ),
void* data_user,
MLV_TreeMap* tree_map
){
Wrapper_data_user* wrapper_data = create_wrapper_data_user(
data_user, key_data_function
);
MLV_foreach_data_tree_set(
wrapper_key_data_function,
wrapper_data,
tree_map->set
);
free_wrapper_data_user( wrapper_data );
}
void MLV_clear_tree_map( MLV_TreeMap* tree_map ){
MLV_clear_tree_set( tree_map->set );
}
void MLV_free_tree_map( MLV_TreeMap* tree_map ){
MLV_clear_tree_map( tree_map );
MLV_FREE( tree_map, MLV_TreeMap );
}
void MLV_superficial_free_tree_map( MLV_TreeMap* tree_map ){
MLV_init_tree_map( tree_map );
MLV_FREE( tree_map, MLV_TreeMap );
}

52
MLV/tree_map.h
View File

@@ -1,52 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__TREE_MAP_H__
#define __MLV__TREE_MAP_H__
#include "key.h"
typedef struct _MLV_TreeMap MLV_TreeMap;
MLV_TreeMap* MLV_create_tree_map();
void MLV_free_tree_map( MLV_TreeMap* tree_map );
void MLV_superficial_free_tree_map( MLV_TreeMap* tree_map );
void MLV_add_data_in_tree_map(
MLV_Key* key, void* data,
void (* data_destroying_function)( void* data ),
MLV_TreeMap* tree_map
);
void MLV_init_tree_map( MLV_TreeMap* tree_map );
void MLV_clear_tree_map( MLV_TreeMap* tree_map );
void* MLV_get_data_from_tree_map( MLV_Key* key, MLV_TreeMap* tree_map );
void MLV_foreach_key_data_tree_map(
void (* key_data_function )( MLV_Key* key, void* data, void* data_user ),
void* data_user,
MLV_TreeMap* tree_map
);
#endif

527
MLV/tree_set.c
View File

@@ -1,527 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "tree_set.h"
#include "warning_error.h"
#include "memory_management.h"
#include "mathematics.h"
/*
* Renvoie la hauteur d'un arbre
*/
int MLV_get_height_tree_set( MLV_TreeSet* tree_set ){
if( tree_set==NULL ){
return 0;
}
return tree_set->height;
}
/*
* Cette fonction substitue node par new_node
* dans le père de node.
*
* Avant :
* + <-- father
* / \
* + <-- node
*
* Après :
* + <-- father
* / \
* + <-- new_node
*
* Cette fonction ne modifie pas le contenu de new_node.
* Cette fonction renvoie un pointeur vers le père.
* Cette fonction n'accepte pas de node NULL.
*
*/
MLV_TreeSet* substitute_in_father_tree_Set(
MLV_TreeSet* node, MLV_TreeSet* new_node
){
if( node ){
ERROR_FULL("Node can't be NULL !");
}
MLV_TreeSet* father = node->father;
if( father ){
if( father->left_son == node ){
father->left_son = new_node;
}else{
father->right_son = new_node;
}
}
new_node->father = father;
return father;
}
/*
* Renvoie le noeud de l'arbre de valeur de clé maximale.
*/
MLV_TreeSet* MLV_get_maximal_node_of_tree_set( MLV_TreeSet* tree_set ){
MLV_TreeSet* result = NULL;
while( tree_set ){
result = tree_set;
tree_set = tree_set->right_son;
}
return result;
}
/*
* TODO
*
* Cette fonction retire un noeud de l'arbre.
* Cette focntion renvoi un pointeur vers le nouvel arbre
* obtenu.
*
*/
MLV_TreeSet* remove_node_of_tree_set( MLV_TreeSet* tree_set ){
NOT_IMPLEMENTED;
return NULL;
}
/*
* Cette fonction détruit les données contenues dans un noeud de l'arbre.
*
*/
void destroy_node_data_of_tree_set( MLV_TreeSet* tree_set ){
if( tree_set && tree_set->data_destroying_function ){
tree_set->data_destroying_function( tree_set->data );
}
}
/*
* Cette fonction suprime le noeud (en libérant la mémoire), mais
* ne suprrime pas la donnée qu'elle contient.
*
* Cette fonction renvoie un pointeur vers le nouvel arbre obtenu.
*/
MLV_TreeSet* destroy_node_of_tree_set( MLV_TreeSet* tree_set ){
MLV_TreeSet* new_tree;
new_tree = remove_node_of_tree_set( tree_set );
MLV_FREE( tree_set, MLV_TreeSet );
return new_tree;
}
/*
* Cette fonction détruit les données contenues dans un noeud, puis suprime le noeud
* de l'arbre et libère la mémoire associée à tree_set.
*
* Cette fonction renvoie un pointeur vers le nouvel arbre obtenu.
*
*/
MLV_TreeSet* destroy_node_and_his_data_of_tree_set( MLV_TreeSet* tree_set ){
MLV_TreeSet* new_tree;
destroy_node_data_of_tree_set( tree_set );
new_tree = remove_node_of_tree_set( tree_set );
MLV_FREE( tree_set, MLV_TreeSet );
return new_tree;
}
/*
* Cette fonction cherche un noeud ayant une donnée particulière.
* Cette fonction rencoie le noeud associé à cette donnée.
*/
MLV_TreeSet* MLV_find_tree_set( void* data, MLV_TreeSet* tree_set ){
if( tree_set == NULL ){
return NULL;
}
int comparaison = tree_set->sorting_function( data, tree_set->data );
if( comparaison == 0 ){
return tree_set;
}else if( comparaison < 0 ){
return MLV_find_tree_set( data, tree_set->left_son );
}else{
return MLV_find_tree_set( data, tree_set->right_son );
}
}
/*
* Supprime les données conetenu dans un tree_set et
* les remplaces par une autre donnée.
* La mémoire de l'ancienne donnée est suprimée.
*
*/
void change_data_of_node_tree_set(
void* data,
void (* data_destroying_function )( void* data ),
MLV_TreeSet * tree_set
){
destroy_node_data_of_tree_set( tree_set );
tree_set->data = data;
tree_set->data_destroying_function = data_destroying_function;
}
/*
* Créer un nouveau noeud.
*/
MLV_TreeSet* create_node_tree_set(
MLV_TreeSet* father, MLV_TreeSet* left_son, MLV_TreeSet* right_son,
void* data,
void (* data_destroying_function )( void* data ),
int (* sorting_function )( void* data1, void* data2 ),
int height
){
MLV_TreeSet* result = MLV_MALLOC( 1, MLV_TreeSet );
result->father = father;
result->left_son = left_son;
result->right_son = right_son;
result->data = data;
result->data_destroying_function = data_destroying_function;
result->sorting_function = sorting_function;
result->height = height;
return result;
}
/*
* Cette fonction équilibre localement le sous-arbre tree_set en équilibrant
* que sa racine.
*
* A l'issue de l'équilibrage, elle met à jour les hauteurs de tous les noeuds
* du sous-arbre associée à tree_set.
* Si les fils à tree_set étaient équilibrés, alors, tree_set devient lui aussi
* équilibré.
*
*/
MLV_TreeSet* equilibrate_localy_the_tree_set( MLV_TreeSet* tree_set ){
if( ! tree_set ) return NULL;
MLV_TreeSet *A, *B, *C, *D, *E, *F, *G;
MLV_TreeSet* father = tree_set->father;
int height_left = MLV_get_height_tree_set( tree_set->left_son );
int height_right = MLV_get_height_tree_set( tree_set->right_son );
int comparaison = height_left-height_right;
// Si les fils ont des tailles qui diffèrent d'au plus 1, alors le sous-arbre
// est déjà équilibré et il y a rien à faire.
if( abs( comparaison ) <= 1 ) return tree_set;
// Le sous arbres n'est pas équilibré.
// 4 type d'arbres non équilibrés peuvent se présenter
if( comparaison < 0 ){
/* B
* / \
* A \
* +
*/
B = tree_set;
A = B->left_son;
int height_right_left = MLV_get_height_tree_set( B->right_son->left_son );
int height_right_right = MLV_get_height_tree_set( B->right_son->right_son );
if( height_right_left > height_right_right ){
/* 1er type :
*
* B
* / \
* A F
* / \
* D G
* / \
* C E
*/
F = B->right_son;
D = F->left_son;
G = F->right_son;
C = D->left_son;
E = D->right_son;
}else{
/* 2ème type :
*
* B
* / \
* A D
* / \
* C F
* / \
* E G
*/
D = B->right_son;
C = D->left_son;
F = D->right_son;
E = F->left_son;
G = F->right_son;
}
}else{
/* F
* / \
* / G
* +
*/
F = tree_set;
G = F->right_son;
int height_left_left = MLV_get_height_tree_set( F->left_son->left_son );
int height_left_right = MLV_get_height_tree_set( F->left_son->right_son );
if( height_left_right > height_left_left ){
/* 3ème type :
*
* F
* / \
* B G
* / \
* A D
* / \
* C E
*/
B = F->left_son;
A = B->left_son;
D = B->right_son;
C = D->left_son;
E = D->right_son;
}else{
/* 4ème type :
*
* F
* / \
* D G
* / \
* B E
* / \
* A C
*/
D = F->left_son;
B = D->left_son;
E = D->right_son;
A = B->left_son;
C = B->right_son;
}
}
/*
* On réordonne l'arbre de façon à obtenir
*
* D
* / \
* B F
* / \ / \
* A C E G
*/
A->father = B;
C->father = B;
E->father = F;
G->father = F;
B->left_son = A;
B->right_son = C;
B->father = D;
B->height = max( A->height, C->height ) + 1;
F->left_son = E;
F->right_son = G;
F->father = D;
F->height = max( E->height, G->height ) + 1;
D->left_son = B;
D->right_son = F;
D->father = father;
D->height = max( B->height, F->height ) + 1;
// On met à jour le père du sous-arbre d'origine
if( father ){
if( father->left_son == tree_set ){
father->left_son = D;
}else{
father->right_son = D;
}
}
return D;
}
/*
* Algorithme d'insertion d'une nouvelle (cle, data) dans un arbre.
*/
MLV_TreeSet* MLV_add_data_in_tree_set(
void* data,
void (* data_destroying_function )( void* data ),
int (* sorting_function )( void* data1, void* data2 ),
MLV_TreeSet * tree_set
){
if( tree_set==NULL ){
return create_node_tree_set(
NULL, NULL, NULL,
data,
data_destroying_function, sorting_function,
1
);
}
// On cherche l'endroit où il faut insérer le noeud dans l'arbre.
MLV_TreeSet* current = tree_set;
MLV_TreeSet* father_of_insertion_point = NULL;
int comparaison;
while( current ){
comparaison = current->sorting_function( data, current->data );
if( comparaison == 0 ){
change_data_of_node_tree_set(
data, data_destroying_function, current
);
return tree_set;
}else if( comparaison < 0 ){
father_of_insertion_point = current;
current = current->left_son;
}else{
father_of_insertion_point = current;
current = current->right_son;
}
}
// on créé un nouveau noeud
current = create_node_tree_set(
father_of_insertion_point, NULL, NULL,
data,
data_destroying_function, sorting_function,
1
);
// On insère le nouveau noeud dans l'arbre.
// Ici, comme tree_set ne peut pas valoir NULL,
// father_of_insertion_point ne peut pas être NULL et
// comparaison contient une valeur.
// Le point d'insertion à donc toujours un père.
if( comparaison<0 ){
father_of_insertion_point->left_son = current;
}else{
father_of_insertion_point->right_son = current;
}
// On équilibre l'arbre.
// Pour cela on remonte l'arbre en paratn du sommet ajouté jusqu'à la
// racine et on rééqulibre localement chaque noeud rencontré.
current = father_of_insertion_point; // On part du père car le nouveau
// noeud est toujours équilibré.
MLV_TreeSet* new_root; // La nouvelle racine issue du rééquilibrage local.
while( current ){
new_root = equilibrate_localy_the_tree_set( current );
current = new_root->father;
}
// Comme father_of_inserion_point n'est pas NULL (voir explication
// précédente), current n'est pas NULL. Donc, new_root contient un valeur.
// D'après equilibrate_localy_the_tree_set, new_root est un arbre équilibré.
return new_root;
}
/*
* Execute un fonction sur chaque clé et donné de l'arbre.
*/
void MLV_foreach_data_tree_set(
void (* data_function )( void* data, void* data_user ),
void* data_user,
MLV_TreeSet* tree_set
){
if( tree_set ){
if( tree_set->left_son ){
MLV_foreach_data_tree_set( data_function, data_user, tree_set->left_son );
}
if( tree_set->right_son ){
MLV_foreach_data_tree_set( data_function, data_user, tree_set->right_son );
}
data_function( tree_set->data, data_user );
}
}
/*
* Execute un fonction sur chaque noeud de l'arbre.
*/
void foreach_node_tree_set(
void (* node_function)(MLV_TreeSet* tree_set, void* data_user),
void* data_user,
MLV_TreeSet* tree_set
){
if( tree_set ){
if( tree_set->left_son ){
foreach_node_tree_set( node_function, data_user, tree_set->left_son );
}
if( tree_set->right_son ){
foreach_node_tree_set( node_function, data_user, tree_set->right_son );
}
node_function( tree_set, data_user );
}
}
/*
* Un wrapper à utiliser avec foreach_node_tree_set.
*/
void wrapper_destroy_node_data_of_tree_set( MLV_TreeSet* tree_set, void* useless_data ){
destroy_node_data_of_tree_set( tree_set );
}
/*
* Un wrapper à utiliser avec foreach_node_tree_set.
*/
void wrapper_remove_node_of_tree_set( MLV_TreeSet* tree_set, void* useless_data ){
remove_node_of_tree_set( tree_set );
}
/*
* Un wrapper à utiliser avec foreach_node_tree_set.
*/
void wrapper_destroy_node_and_his_data_of_tree_set( MLV_TreeSet* tree_set, void* useless_data ){
destroy_node_and_his_data_of_tree_set( tree_set );
}
/*
* Un wrapper à utiliser avec foreach_node_tree_set.
*/
void wrapper_destroy_node_of_tree_set( MLV_TreeSet* tree_set, void* useless_data ){
destroy_node_of_tree_set( tree_set );
}
void free_tree_set( MLV_TreeSet* tree_set, void* useless_data ){
MLV_FREE( tree_set, MLV_TreeSet );
}
/*
* Cette fonction supprime tous les noeuds de l'abre sans détruire les données.
*/
void MLV_init_tree_set( MLV_TreeSet* tree_set ){
foreach_node_tree_set( free_tree_set, NULL, tree_set );
}
void deep_free_tree_set( MLV_TreeSet* tree_set, void* useless_data ){
destroy_node_data_of_tree_set( tree_set );
free_tree_set( tree_set, useless_data );
}
/*
* Cette fonction supprime tous les noeuds de l'abre et détruit les données
* associé à l'arbre.
*/
void MLV_clear_tree_set( MLV_TreeSet* tree_set ){
foreach_node_tree_set( deep_free_tree_set, NULL, tree_set );
}
/*
* Enlève une donnée de l'esemble.
* La donnée n'est pas supprimée.
*/
MLV_TreeSet* MLV_remove_data_from_tree_set( void* data, MLV_TreeSet* tree_set ){
MLV_TreeSet* node = MLV_find_tree_set( data, tree_set );
return destroy_node_of_tree_set( node );
}
/*
* Supprime une donnée de l'ensemble.
* La donnée est supprimée.
*/
MLV_TreeSet* MLV_remove_data_and_data_from_tree_set( void* data, MLV_TreeSet* tree_set ){
MLV_TreeSet* node = MLV_find_tree_set( data, tree_set );
destroy_node_data_of_tree_set( node );
return destroy_node_and_his_data_of_tree_set( node );
}
/*
* Supprime une donnée de l'ensemble.
* La donnée est supprimée.
*/
int MLV_is_in_tree_set( void* data, MLV_TreeSet* tree_set ){
return MLV_find_tree_set( data, tree_set )!=NULL ;
}

57
MLV/tree_set.h
View File

@@ -1,57 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__TREE_SET_H__
#define __MLV__TREE_SET_H__
typedef struct _MLV_TreeSet MLV_TreeSet;
struct _MLV_TreeSet {
MLV_TreeSet* father;
MLV_TreeSet* left_son;
MLV_TreeSet* right_son;
void* data;
void (* data_destroying_function )( void* data );
int (* sorting_function )( void* data1, void*data2 );
int height;
};
MLV_TreeSet* MLV_add_data_in_tree_set(
void* data,
void (* data_destroying_function)( void* data ),
int (* sorting_function)( void* data1, void* data2 ),
MLV_TreeSet * tree_set
);
void MLV_init_tree_set( MLV_TreeSet* tree_set );
void MLV_clear_tree_set( MLV_TreeSet* tree_set );
void* MLV_get_data_from_tree_set( void* data, MLV_TreeSet* tree_set );
MLV_TreeSet* MLV_find_tree_set( void* data, MLV_TreeSet* tree_set );
void MLV_foreach_data_tree_set(
void (* data_function )( void* data, void* data_user ),
void* data_user,
MLV_TreeSet* tree_set
);
#endif

43
MLV/warning_error.h
View File

@@ -1,43 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MLV__WARNING_ERROR_H__
#define __MLV__WARNING_ERROR_H__
#include <stdio.h>
#include <stdlib.h>
#define ERROR(x) { fprintf( stderr, "Error detected by the function %s() in LibMLV : %s \n", __FUNCTION__, (x) ); exit(1); }
#define WARNING(x) { fprintf( stderr, "Warning generated by the function %s() in LibMLV : %s \n", __FUNCTION__, (x) ); }
#define TODO { fprintf( stderr, "The function %s() in LibThis Library is not implemented. \n", __FUNCTION__ ); exit(1); }
#define DEPRECATED(x) { fprintf( stderr, "The function %s() is deprecated. In the future, this function will disapear. Please use the %s() function instead of.\n", __FUNCTION__, (x) ); }
#define ERROR_FULL(x) { fprintf( stderr, "Error detected by the function %s() in LibMLV : %s ( file : %s, line : %i) \n", __FUNCTION__, (x), __FILE__, __LINE__ ); exit(1); }
#define WARNING_FULL(x) { fprintf( stderr, "Warning generated by the function %s() in LibMLV : %s ( file : %s, line : %i) \n", __FUNCTION__, (x), __FILE__, __LINE__ ); }
#define DEBUG(x) { fprintf( stderr, "DEBUG : %s - line : %i, file : %s\n", (x), __LINE__, __FILE__ ); }
#define NOT_IMPLEMENTED { fprintf( stderr, "The function %s() in LibMLV ( file : %s, line : %i ) is not implemented.\n", __FUNCTION__, __FILE__, __LINE__ ); exit(1); }
#endif

387
MLV/window.c
View File

@@ -1,387 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "MLV_window.h"
#include "MLV_color.h"
#include "MLV_shape.h"
#include "config.h"
#include "text.h"
#include "input_box.h"
#include "MLV_color.h"
#include "MLV_audio.h"
#include <stdio.h>
#include <stdlib.h>
#include "platform.h"
#ifndef MEMORY_DEBUG
#if defined( OS_WINDOWS )
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
#elif defined( OS_APPLE )
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
#else
# include <SDL/SDL.h>
# include <SDL/SDL_gfxPrimitives.h>
#endif
#else
#include "memory_debug.h"
#endif
#include "warning_error.h"
#include "data_structure.h"
#include "image.h"
#include "memory_management.h"
#define SIZE_DEFAULT_FONT 12
int mlv_sdl_is_initialised = 0;
Uint32 mlv_width_of_desktop = 0;
Uint32 mlv_height_of_desktop = 0;
DataMLV *MLV_data = NULL;
void (*MLV_call_back_function_for_exit)(void*) = NULL;
void *MLV_call_back_data = NULL;
int events_filter(const SDL_Event *event){
if( event->type == SDL_QUIT ){
if( MLV_call_back_function_for_exit ){
(*(MLV_call_back_function_for_exit))(MLV_call_back_data);
return 1;
}else{
exit(0);
}
}
return input_box_events_filter(event);
}
/**************************************************************************/
/* Initialisation and closing functions for default font */
/**************************************************************************/
void initialize_default_font(
const char* path_to_font, unsigned int size_font
){
if( !MLV_data ){
ERROR("The MLV library has not been yet initialised. To initialise the \
MLV Library, create a new window with the MLV_create_window function."
);
}
MLV_data->defaultFont = MLV_load_font( path_to_font, size_font );
}
void free_default_font(){
if( !MLV_data ){
ERROR("The MLV library has not been yet initialised. To initialise the \
MLV Library, create a new window with the MLV_create_window function."
);
}
MLV_free_font( MLV_data->defaultFont );
}
/**************************************************************************/
/* Creation d'un fenetre graphique */
/**************************************************************************/
void initialise_graphic_window(
unsigned int width, unsigned int height, int full_screen_is_required
){
#if defined( OS_ANDROID )
Uint32 video_mode_flags = SDL_SWSURFACE | SDL_SRCALPHA;
#else
Uint32 video_mode_flags = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_SRCALPHA;
#endif
if( full_screen_is_required ){
video_mode_flags |= SDL_FULLSCREEN;
}
MLV_data->full_screen_is_enable = full_screen_is_required;
if( MLV_data->screen ){
SDL_FreeSurface( MLV_data->screen );
}
MLV_data->screen = SDL_SetVideoMode( width, height, MLV_BPP, video_mode_flags );
width = MLV_data->screen->w;
height = MLV_data->screen->h;
MLV_data->width = width;
MLV_data->height = height;
MLV_data->rectangle.x = 0;
MLV_data->rectangle.y = 0;
MLV_data->rectangle.w = width;
MLV_data->rectangle.h = height;
if( MLV_data->save_screen ){
SDL_FreeSurface( MLV_data->screen );
}
MLV_data->save_screen = create_surface( width, height ); // do we have to use SDL_ALPHA_OPAQUE here ?
if ( MLV_data->screen == NULL ){
fprintf(stderr,"Unable to set %dx%d video: %s\n", width, height, SDL_GetError());
exit(1);
}
/**************************************************************************/
/* Initialisation de la couleur du fond de la fenetre en noir. */
/**************************************************************************/
MLV_draw_filled_rectangle(0,0,width,height,MLV_COLOR_BLACK);
MLV_actualise_window();
}
void initialise_sdl(){
if( ! mlv_sdl_is_initialised ){
if(
SDL_Init(
SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO
#if defined( OS_LINUX ) // SDL thread is not supported on Windows and MacOSX
| SDL_INIT_EVENTTHREAD // Cette option est importante !
// Elle permet de faire en sorte
// que le filtrage des évenements soit fait dés
// réception d'un evenement de la part de l'OS
// Si cette option n'est pas activée, le filtre
// d'evenement est applique seulement après un
// appel à poll_event. Dans ce cas la gestion
// de l'arret automatique du programme après
// utilisation de la croix des fenetre ne
// fonctione plus correctement. En effet, si
// l'utilisateur n'utilise pas de fonction mettant
// en jeu des évènement, le filtre n'est jamais
// appelé et le mécanisme d'arret automatique
// non plus.
#endif
) <0
){
printf("Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
}
}
void initialise_size_of_desktop(){
initialise_sdl();
if( mlv_width_of_desktop==0 || mlv_height_of_desktop==0 ){
const SDL_VideoInfo* info = SDL_GetVideoInfo();
mlv_width_of_desktop = info->current_w;
mlv_height_of_desktop = info->current_h;
}
}
void MLV_create_window_with_default_font(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height,
const char* path_to_font, unsigned int size_font
){
if( MLV_data ){
ERROR("The MLV library has yet been initialised.");
}
/**************************************************************************/
/* Initialisation de la strcutre de MLV */
/**************************************************************************/
MLV_data = MLV_MALLOC( 1, DataMLV );
MLV_data->screen = NULL;
MLV_data->save_screen = NULL;
/**************************************************************************/
/* Initialisation de la libriaire SDL pour l'uilisation de la video et du */
/* temps */
/**************************************************************************/
initialise_sdl();
/**************************************************************************/
/* Save the size of the desktop */
/**************************************************************************/
initialise_size_of_desktop();
/**************************************************************************/
/* Creation d'un fenetre graphique */
/**************************************************************************/
initialise_graphic_window( width, height, 0 );
/**************************************************************************/
/* Configuration des noms de la fenetre */
/**************************************************************************/
SDL_WM_SetCaption(window_name, icone_name);
/**************************************************************************/
/* Configuration du mechanisme permettant d'utiliser les boîtes de saisie */
/**************************************************************************/
init_input_box_mechanism();
/**************************************************************************/
/* Configuration des fonts */
/**************************************************************************/
init_font();
/**************************************************************************/
/* Création d'une font par default */
/**************************************************************************/
initialize_default_font( path_to_font, size_font );
/**************************************************************************/
/* Initialise the Framerate Manager */
/**************************************************************************/
SDL_initFramerate( &(MLV_data->frame_rate_manager) );
SDL_setFramerate( &(MLV_data->frame_rate_manager), 100 );
/**************************************************************************/
/* Initialise the internal Framerate Manager for MLV_wait_event */
/**************************************************************************/
SDL_initFramerate( &(MLV_data->frame_rate_manager_for_MLV_wait_event) );
SDL_setFramerate( &(MLV_data->frame_rate_manager_for_MLV_wait_event), 24 );
SDL_SetEventFilter(events_filter);
}
void MLV_create_window(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height
){
MLV_create_window_with_default_font(
window_name, icone_name, width, height,
DATA_PATH "/font/DejaVuSerif-Bold.ttf" , SIZE_DEFAULT_FONT
);
}
void MLV_change_default_font(
const char* path_to_font, unsigned int size_font
){
free_default_font();
initialize_default_font( path_to_font, size_font );
}
void MLV_enable_full_screen(){
initialise_graphic_window( MLV_data->width, MLV_data->height, 1 );
}
void MLV_create_full_screen_window(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height
){
MLV_create_window( window_name, icone_name, width, height );
MLV_enable_full_screen();
}
void MLV_create_full_screen_window_with_default_font(
const char* window_name, const char* icone_name,
unsigned int width, unsigned int height,
const char* path_to_font, unsigned int size_font
){
MLV_create_window_with_default_font(
window_name, icone_name, width, height, path_to_font, size_font
);
MLV_enable_full_screen();
}
void MLV_disable_full_screen(){
initialise_graphic_window( MLV_data->width, MLV_data->height, 0 );
}
int MLV_is_full_screen(){
return MLV_data->full_screen_is_enable;
}
void MLV_change_window_size( unsigned int with, unsigned int height ){
initialise_graphic_window( with, height, MLV_data->full_screen_is_enable );
}
void MLV_change_window_caption(
const char* window_name, const char* icone_name
){
SDL_WM_SetCaption( window_name, icone_name );
}
void MLV_get_window_size( unsigned int* width, unsigned int* height ){
*width = MLV_data->width;
*height = MLV_data->height;
}
int MLV_get_window_height(){
return MLV_data->height;
}
int MLV_get_window_width(){
return MLV_data->width;
}
void MLV_clear_window( MLV_Color color ){
MLV_draw_filled_rectangle(
0, 0, MLV_get_window_width( ), MLV_get_window_height( ), color
);
}
void MLV_free_window(){
if( ! MLV_data ){
ERROR("No window has been created.");
}
SDL_FreeSurface(MLV_data->screen);
SDL_FreeSurface(MLV_data->save_screen);
free_default_font();
quit_font();
MLV_FREE( MLV_data, DataMLV );
MLV_data = NULL;
SDL_Quit();
quit_input_box_mechanism();
}
void MLV_update_window(){
if( (! MLV_data ) || (! MLV_data->screen) ){
ERROR("A window can't be displayed whitout being created.");
}
SDL_Flip(MLV_data->screen);
}
#ifndef OS_APPLE // Hack to compile with MAC OS 10.9 (maverick)
inline
#endif
void MLV_actualise_window(){
MLV_update_window();
}
void MLV_execute_at_exit( void (*function)(void*), void* data ){
if( MLV_data ){
ERROR("The mlv window is yet initialized. The function execute_at_exit() must be executed before the create_window() function.");
}
if( MLV_call_back_function_for_exit ){
ERROR("The call back function for exiting program is yet initialized.");
}
MLV_call_back_function_for_exit = function;
MLV_call_back_data = data;
}
void MLV_get_desktop_size( unsigned int* width, unsigned int* height ){
initialise_size_of_desktop();
*width = mlv_width_of_desktop;
*height = mlv_height_of_desktop;
}
int MLV_get_desktop_height( ){
initialise_size_of_desktop();
return mlv_height_of_desktop;
}
int MLV_get_desktop_width( ){
initialise_size_of_desktop();
return mlv_width_of_desktop;
}

376
MLV/xml.c
View File

@@ -1,376 +0,0 @@
/*
* This file is part of the MLV Library.
*
* Copyright (C) 2010,2011,2012 Adrien Boussicault, Marc Zipstein
*
*
* This Library 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, either version 3 of the License, or
* (at your option) any later version.
*
* This Library 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 this Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "platform.h"
#ifdef OS_WINDOWS
/* Get va_list. */
#if __STDC__ || defined __cplusplus || defined _MSC_VER
# include <stdarg.h>
#else
# include <varargs.h>
#endif
extern int vasprintf (char **, const char *, va_list);
extern int asprintf (char **, const char *, ...);
#endif
#include "MLV_xml.h"
#include "MLV_xml_va.h"
#include "warning_error.h"
#include "memory_management.h"
#include "data_structure.h"
#include <glib.h>
#include <stdio.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include <errno.h>
extern DataMLV* MLV_data;
struct _MLV_Xml {
xmlDocPtr doc;
// xmlNodePtr cur;
};
MLV_Xml* MLV_load_xml( const char* xml_file_path ){
MLV_Xml* result = MLV_MALLOC( 1, MLV_Xml );
result->doc = xmlParseFile( xml_file_path );
if (result->doc == NULL ) {
fprintf(stderr,"Document not parsed successfully. \n");
MLV_FREE( result, MLV_Xml );
return NULL;
}
// result->cur = xmlDocGetRootElement( result->doc );
//
// if ( result->cur == NULL) {
// fprintf(stderr,"empty document\n");
// xmlFreeDoc(result->doc);
// MLV_FREE( result, MLV_Xml );
// return NULL;
// }
return result;
}
void MLV_free_xml( MLV_Xml* xml_data ){
if( xml_data ){
if( xml_data->doc ){
xmlFreeDoc( xml_data->doc );
}
MLV_FREE( xml_data, MLV_Xml );
}
}
void test_if_text_is_valid( const char* text, const char* xpath ){
if( ! text ){
char* message;
if(
asprintf(
&message,
"The xml file is probably corupted. The following element is not present: \"%s\" in the xml file.",
xpath
) < 0
){
ERROR_FULL("The error message can be constructed.");
}
ERROR( message );
}
}
void internal_scan_xml(
const MLV_Xml* xml_data, const char* xpath, va_list pile,
xmlXPathObjectPtr *result_search
){
xmlXPathContextPtr context;
char* complete_xpath;
if( vasprintf( &complete_xpath, xpath, pile ) < 0 ){
ERROR_FULL("Unexpected error");
}
context = xmlXPathNewContext( xml_data->doc );
*result_search = xmlXPathEvalExpression( (xmlChar*) complete_xpath, context);
MLV_FREE( complete_xpath, char );
xmlXPathFreeContext( context );
if( xmlXPathNodeSetIsEmpty((*result_search)->nodesetval) ){
xmlXPathFreeObject((*result_search));
*result_search = NULL;
}
}
char* internal_get_string_value_from_xml(
const MLV_Xml* xml_data, int i, const char* xpath, va_list pile
){
char* result = NULL;
xmlXPathObjectPtr result_search;
internal_scan_xml( xml_data, xpath, pile, &result_search );
if( !result_search ) return NULL;
xmlNodeSetPtr nodeset;
nodeset = result_search->nodesetval;
if( i < nodeset->nodeNr ){
result = (char*) xmlNodeListGetString(
xml_data->doc, nodeset->nodeTab[i]->xmlChildrenNode, 1
);
}
xmlXPathFreeObject(result_search);
return result;
}
MLV_Xml_error MLV_get_string_value_from_xml_va(
const MLV_Xml* xml_data, char** result, const char* xpath, va_list pile
){
*result = internal_get_string_value_from_xml( xml_data, 0, xpath, pile );
if( *result == NULL ){
return MLV_XML_THE_FIELD_DOESNT_EXIST;
}
return MLV_XML_NONE;
}
MLV_Xml_error MLV_get_string_value_from_xml(
const MLV_Xml* xml_data, char** result, const char* xpath, ...
){
MLV_Xml_error error;
va_list pile;
va_start( pile, xpath );
error = MLV_get_string_value_from_xml_va( xml_data, result, xpath, pile );
va_end( pile );
return error;
}
MLV_Xml_error MLV_get_integer_value_from_xml_va(
const MLV_Xml* xml_data, int* result, const char* xpath, va_list pile
){
long int value;
char* text;
MLV_Xml_error error;
error = MLV_get_string_value_from_xml_va( xml_data, &text, xpath, pile );
if( error ){
return error;
}
char* final;
errno = 0;
value = strtol(text, &final, 10 );
int err_sys = errno;
if( (final==NULL) || (*text='\0') || (*final != '\0') ){
error = MLV_XML_THE_FIELD_IS_NOT_AN_INTEGER;
}else if( err_sys==ERANGE ){
error = MLV_XML_THE_FIELD_IS_TOO_BIG;
}else if( err_sys != 0 && value == 0 ){
ERROR_FULL("A anormal error occurs during string to int conversion in XML Parsing." );
}else{
error = MLV_XML_NONE;
}
MLV_FREE( text, char );
*result = value;
return error;
}
MLV_Xml_error MLV_get_integer_value_from_xml(
const MLV_Xml* xml_data, int* result, const char* xpath, ...
){
MLV_Xml_error error;
va_list pile;
va_start( pile, xpath );
error = MLV_get_integer_value_from_xml_va( xml_data, result, xpath, pile );
va_end( pile );
return error;
}
MLV_Xml_error MLV_get_double_value_from_xml_va(
const MLV_Xml* xml_data, double* result, const char* xpath, va_list pile
){
double value;
char* text;
MLV_Xml_error error;
error = MLV_get_string_value_from_xml_va( xml_data, &text, xpath, pile );
if( error ){
return error;
}
char* final;
errno = 0;
value = strtod(text, &final );
int err_sys = errno;
if( (final==NULL) || (*text='\0') || (*final != '\0') ){
error = MLV_XML_THE_FIELD_IS_NOT_A_REAL;
}else if( err_sys==ERANGE ){
error = MLV_XML_THE_FIELD_IS_TOO_BIG;
}else if( err_sys != 0 && value == 0 ){
ERROR_FULL("A anormal error occurs during string to double conversion in XML Parsing." );
}else{
error = MLV_XML_NONE;
}
MLV_FREE( text, char );
*result = value;
return error;
}
MLV_Xml_error MLV_get_double_value_from_xml(
const MLV_Xml* xml_data, double* result, const char* xpath, ...
){
MLV_Xml_error error;
va_list pile;
va_start( pile, xpath );
error = MLV_get_double_value_from_xml_va( xml_data, result, xpath, pile );
va_end( pile );
return error;
}
MLV_Xml_error MLV_get_float_value_from_xml_va(
const MLV_Xml* xml_data, float* result, const char* xpath, va_list pile
){
float value;
char* text;
MLV_Xml_error error;
error = MLV_get_string_value_from_xml_va( xml_data, &text, xpath, pile );
if( error ){
return error;
}
char* final;
errno = 0;
value = strtof(text, &final);
int err_sys = errno;
if( (final==NULL) || (*text='\0') || (*final != '\0') ){
error = MLV_XML_THE_FIELD_IS_NOT_A_REAL;
}else if( err_sys==ERANGE ){
error = MLV_XML_THE_FIELD_IS_TOO_BIG;
}else if( err_sys != 0 && value == 0 ){
ERROR_FULL("A anormal error occurs during string to double conversion in XML Parsing." );
}else{
error = MLV_XML_NONE;
}
MLV_FREE( text, char );
*result = value;
return error;
}
MLV_Xml_error MLV_get_float_value_from_xml(
const MLV_Xml* xml_data, float* result, const char* xpath, ...
){
MLV_Xml_error error;
va_list pile;
va_start( pile, xpath );
error = MLV_get_float_value_from_xml_va( xml_data, result, xpath, pile );
va_end( pile );
return error;
}
int MLV_get_number_of_objects_from_xml_va(
const MLV_Xml* xml_data, const char* xpath, va_list pile
){
int result;
xmlXPathObjectPtr result_search;
internal_scan_xml( xml_data, xpath, pile, &result_search );
if( !result_search ) return 0;
result = result_search->nodesetval->nodeNr;
xmlXPathFreeObject(result_search);
return result;
}
int MLV_get_number_of_objects_from_xml(
const MLV_Xml* xml_data, const char* xpath, ...
){
int result;
va_list pile;
va_start( pile, xpath );
result = MLV_get_number_of_objects_from_xml_va( xml_data, xpath, pile );
va_end( pile );
return result;
}
MLV_Xml* MLV_get_xml_object_of_va(
const MLV_Xml* xml_data, const char* xpath, va_list pile
){
MLV_Xml* result = NULL;
ERROR_FULL("Not implemented.");
return result;
}
MLV_Xml* MLV_get_xml_object_of(
const MLV_Xml* xml_data, const char* xpath, ...
){
MLV_Xml* result;
va_list pile;
va_start( pile, xpath );
result = MLV_get_xml_object_of_va( xml_data, xpath, pile );
va_end( pile );
return result;
}
void MLV_print_xml( const MLV_Xml* xml_data ){
ERROR_FULL("Not implemented.");
}

4
Makefile
View File

@@ -8,10 +8,10 @@ CFLAGS = -Wall -pedantic -ansi
LDFLAGS = -lMLV
# Target executable
TARGET = maison
TARGET = game
# Source files
SRCS = maison.c
SRCS = game.c grid.c
# Object files
OBJS = $(SRCS:.c=.o)

33
README-fr.md
View File

@@ -1,17 +1,21 @@
# Programme de Dessin de Maison
[![en](https://img.shields.io/badge/lang-en-red.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp1/README.md)
[![fr](https://img.shields.io/badge/lang-fr-green.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp1/README-fr.md)
# Jeu Snake 2025
[![en](https://img.shields.io/badge/lang-en-red.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp2/README.md)
[![fr](https://img.shields.io/badge/lang-fr-green.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp2/README-fr.md)
Ce programme dessine une maison simple avec un carré rouge pour le mur principal, un triangle bleu pour le toit, des rectangles colorés pour les fenêtres, et un cercle jaune pour le soleil en utilisant la bibliothèque graphique MLV.
Ce projet est une visualisation simple d'un jeu basé sur une grille utilisant la bibliothèque graphique MLV. La grille représente un plateau de jeu avec des murs, des espaces vides et des fruits. Le programme affiche la grille dans une fenêtre graphique et attend une interaction de l'utilisateur.
## Fonctionnalités
- Dessine un carré rouge comme mur principal de la maison.
- Dessine un triangle bleu comme toit de la maison.
- Dessine deux rectangles colorés comme fenêtres de la maison.
- Dessine un rectangle marron comme porte de la maison.
- Dessine un cercle jaune comme soleil.
- Affiche un message "Appuyez sur ESC pour quitter" et attend que l'utilisateur appuie sur la touche ESC pour fermer la fenêtre.
- Affiche une grille avec des murs, des espaces vides et des fruits.
- Utilise la bibliothèque graphique MLV pour le rendu graphique.
- Permet à l'utilisateur de quitter le programme en appuyant sur la touche ESC.
## Représentation de la Grille
- La grille est représentée comme un tableau 2D de caractères :
- `'w'` pour les murs.
- `' '` (espace) pour les espaces vides.
- `'f'` pour les fruits.
## Dépendances
@@ -31,22 +35,22 @@ Ce programme dessine une maison simple avec un carré rouge pour le mur principa
### Compiler le Programme
1. Clonez le dépôt ou téléchargez le code source.
2. Naviguez vers le répertoire contenant le `Makefile` et `maison.c`.
2. Naviguez vers le répertoire contenant le `Makefile`.
3. Exécutez la commande suivante pour compiler le programme :
```sh
make
```
Cela compilera `maison.c` et créera un exécutable nommé `maison`.
Cela compilera les fichiers sources et créera un exécutable nommé `game` dans le répertoire `build`.
## Utilisation
1. Après avoir compilé le programme, exécutez l'exécutable :
```sh
./maison
./build/game
```
2. Une fenêtre s'ouvrira affichant la maison et le soleil. Appuyez sur la touche ESC pour fermer la fenêtre.
2. Une fenêtre s'ouvrira affichant la grille. Appuyez sur la touche ESC pour fermer la fenêtre.
## Nettoyage
@@ -58,6 +62,7 @@ make clean
Cela supprimera les fichiers objets et l'exécutable.
## Licence
Ce projet est sous licence GPLv3. Pour plus de détails, voir [Licence GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html).
## Auteurs

33
README.md
View File

@@ -1,17 +1,21 @@
# House Drawing Program
[![en](https://img.shields.io/badge/lang-en-red.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp1/README.md)
[![fr](https://img.shields.io/badge/lang-fr-green.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp1/README-fr.md)
# Snake 2025 Game
[![en](https://img.shields.io/badge/lang-en-red.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp2/README.md)
[![fr](https://img.shields.io/badge/lang-fr-green.svg)](https://git.esiee.fr/frequela/snake2025/-/blob/tp2/README-fr.md)
This program draws a simple house with a red square for the main wall, a blue triangle for the roof, colored rectangles for the windows, and a yellow circle for the sun using the MLV graphics library.
This project is a simple grid-based game visualization using the MLV graphics library. The grid represents a game board with walls, empty spaces, and fruits. The program displays the grid in a graphical window and waits for user interaction.
## Features
- Draws a red square as the main wall of the house.
- Draws a blue triangle as the roof of the house.
- Draws two colored rectangles as the windows of the house.
- Draws a brown rectangle as the door of the house.
- Draws a yellow circle as the sun.
- Displays a message "Press ESC to quit" and waits for the user to press the ESC key to close the window.
- Displays a grid with walls, empty spaces, and fruits.
- Uses the MLV graphics library for graphical rendering.
- Allows the user to quit the program by pressing the ESC key.
## Grid Representation
- The grid is represented as a 2D array of characters:
- `'w'` for walls.
- `' '` (space) for empty spaces.
- `'f'` for fruits.
## Dependencies
@@ -31,22 +35,22 @@ This program draws a simple house with a red square for the main wall, a blue tr
### Building the Program
1. Clone the repository or download the source code.
2. Navigate to the directory containing the `Makefile` and `maison.c`.
2. Navigate to the directory containing the `Makefile`.
3. Run the following command to build the program:
```sh
make
```
This will compile `maison.c` and create an executable named `maison`.
This will compile the source files and create an executable named `game` in the `build` directory.
## Usage
1. After building the program, run the executable:
```sh
./maison
./game
```
2. A window will open displaying the house and the sun. Press the ESC key to close the window.
2. A window will open displaying the grid. Press the ESC key to close the window.
## Cleaning Up
@@ -58,6 +62,7 @@ make clean
This will remove the object files and the executable.
## License
This project is licensed under the GPLv3 License. For more details, see [GPLv3 License](https://www.gnu.org/licenses/gpl-3.0.en.html).
## Authors

80
maison.c → game.c
View File

@@ -155,50 +155,62 @@
*/
#include <MLV/MLV_all.h>
#include <stdio.h>
#include "grid.h"
int main(int argc, char *argv[])
int main()
{
/* Créé et affiche la fenêtre */
MLV_create_window("House Drawing", "House", 640, 480);
char grid[NBL][NBC+1] = {
"w w",
" ",
" f ",
" ",
" f f ",
" ",
" ",
" f ",
" ",
" ",
" wwwwwwwwww ",
" ",
" ",
" ",
" ",
" ",
" f ",
" ",
" f f ",
" ",
" f ",
"w w"
};
/* Dessine le ciel (rectangle bleu) */
MLV_draw_filled_rectangle(0, 0, 640, 480, MLV_COLOR_SKY_BLUE);
MLV_Keyboard_button touche = MLV_KEYBOARD_NONE;
int width = 640, height = 480;
/* Dessine l'herbe (rectangle vert) */
MLV_draw_filled_rectangle(0, 400, 640, 80, MLV_COLOR_GREEN);
/* Ouverture de la fenêtre graphique */
MLV_create_window("SNAKE", "3R-IN1B", width, height);
MLV_change_frame_rate(24);
/* Dessine le mur principal (carré rouge) */
MLV_draw_filled_rectangle(200, 200, 200, 200, MLV_COLOR_RED);
while (
MLV_get_event(
&touche, NULL, NULL,
NULL, NULL,
NULL, NULL, NULL,
NULL
) == MLV_NONE ||
touche != MLV_KEYBOARD_ESCAPE
) {
MLV_clear_window(MLV_COLOR_BROWN);
/* Dessine le toit (triangle bleu) */
int roof_x[3] = {200, 400, 300};
int roof_y[3] = {200, 200, 100};
MLV_draw_filled_polygon(roof_x, roof_y, 3, MLV_COLOR_BLUE);
draw_grid(grid);
/* Dessine les fenêtres (rectangles de couleur) */
MLV_draw_filled_rectangle(220, 220, 50, 50, MLV_COLOR_DODGER_BLUE);
MLV_draw_filled_rectangle(330, 220, 50, 50, MLV_COLOR_DODGER_BLUE);
/* Dessine la porte (rectangle de couleur) */
MLV_draw_filled_rectangle(275, 300, 50, 100, MLV_COLOR_BROWN);
/* Dessine le soleil (cercle jaune) */
MLV_draw_filled_circle(500, 100, 50, MLV_COLOR_YELLOW);
/* Text: press ESC to quit */
MLV_draw_text(10, 10, "Press ESC to quit", MLV_COLOR_BLACK);
/* Met à jour l'affichage */
MLV_actualise_window();
/* Attend que l'utilisateur appuie sur la touche Échap pour quitter */
MLV_Keyboard_button key;
do {
MLV_wait_keyboard(&key, NULL, NULL);
} while (key != MLV_KEYBOARD_ESCAPE);
touche = MLV_KEYBOARD_NONE;
MLV_delay_according_to_frame_rate();
}
/* Appelle la fonction quit pour fermer la fenêtre */
MLV_free_window();
return 0;
}

47
grid.c Normal file
View File

@@ -0,0 +1,47 @@
#include <stdio.h>
#include <MLV/MLV_all.h>
#include "grid.h"
void debug(char grid[NBL][NBC+1]) {
int i;
for (i = 0; i < NBL; i++) {
printf("%s\n", grid[i]);
}
}
int compute_size(int w, int h) {
int size_width = w / NBC;
int size_height = h / NBL;
return (size_width < size_height) ? size_width : size_height;
}
void draw_grid(char grid[NBL][NBC+1]) {
int i, j;
int window_width = MLV_get_window_width();
int window_height = MLV_get_window_height();
int cell_size = compute_size(window_width, window_height);
for (i = 0; i < NBL; i++) {
for (j = 0; j < NBC; j++) {
int x = j * cell_size;
int y = i * cell_size;
switch (grid[i][j]) {
case WALL:
MLV_draw_filled_rectangle(x, y, cell_size, cell_size, MLV_COLOR_BROWN);
break;
case EMPTY:
MLV_draw_filled_rectangle(x, y, cell_size, cell_size, MLV_COLOR_WHITE);
break;
case FRUIT:
MLV_draw_filled_rectangle(x, y, cell_size, cell_size, MLV_COLOR_YELLOW);
break;
default:
break;
}
}
}
}

19
grid.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef GRID_H
#define GRID_H
#include <MLV/MLV_all.h>
#define NBL 22
#define NBC 36
typedef enum {
WALL = 'w',
EMPTY = ' ',
FRUIT = 'f'
} Element;
void debug(char grid[NBL][NBC+1]);
int compute_size(int w, int h);
void draw_grid(char grid[NBL][NBC+1]);
#endif /* GRID_H */