SDL_Window.cpp

Aller à la documentation de ce fichier.

#include "SDL_Window.h"

using namespace std;

//retourne true si un problème à eu lieu, false sinon.
bool SDL_Window::Draw()
{
    // calcul des coordonées absolues de la fenêtre
    SDL_Rect coordAbs=coord;
    calcCoord(&coordAbs);

    if(ClearWindow())
    {
        fprintf(stderr,"SDL_Window::Draw(), 1: Echec de ClearWindow\n");
        return true;
    }
    if(PrepareWindow())//cette fonction devra vérifier si il est nécessaire de refaire tous les calculs
    {
        fprintf(stderr,"SDL_Window::Draw(), 2: Echec de PrepareWindow\n");
        return true;
    }
    if(SDL_BlitSurface(screen,&coordAbs,shadow,NULL))//sauvegarde de l'écran
    {
        fprintf(stderr,"SDL_Window::Draw(), 3: Echec de SDL_BlitSurface:%s\n",SDL_GetError());
        return true;
    }
    if(SDL_BlitSurface(window,NULL,screen,&coordAbs))//affichage
    {
        fprintf(stderr,"SDL_Window::Draw(), 4: Echec de SDL_BlitSurface:%s\n",SDL_GetError());
        return true;
    }

    SDL_Window *ptrMere=mere;
    while(ptrMere)
    {fputc('\t',stderr);ptrMere=ptrMere->mere;}
    fprintf(stderr,"%x coord:(%d,%d)/(%d,%d)\toldCoord:(%d,%d)/(%d,%d)\n",(int)this,coord.x,coord.y,coord.w,coord.h,oldCoord.x,oldCoord.y,oldCoord.w,oldCoord.h);
    oldCoord=coord;
    for_each(filles.begin(),filles.end(), mem_fun(&SDL_Window::Draw));

    drawed=true;
    return false;
}

//Redimensionne la fenêtre
//Si relative vaut:
//0: données brutes
//1: données relatives (agrandit ou rétrécit donc)
//true si échec
bool SDL_Window::Resize(short width, short height, unsigned char relative)
{
    needInit=true;
    if(!relative)
    {
        if(height<0 || width<0)
        {
            fprintf(stderr,"SDL_Window::Resize(short,short,uchar), 1:height(=%d) ou width(=%d) sont nuls\n",height,width);
            return true;
        }
        coord.h=height;
        coord.w=width;
    }
    else
    {
        coord.h+=height;
        coord.w+=width;
    }
    return false;
}

//Redimensionne la fenêtre avec un pourcentage.
//si target vaut 0: le pourcentage s'applique à la mère
//si target vaut 1: le pourcentage s'applique à elle-même
//true si échec
bool SDL_Window::Resize(float width, float height, bool target)
{

    if(!target)
    {
        if(!mere)
        {
            fprintf(stderr,"SDL_Window::Resize(float,float,uchar), 1:mere est nul\n");
            return true;
        }
        return Resize(mere->window->w*width,mere->window->h*height,0);
    }
    return Resize(window->w*width,window->h*height,1);
}

//Déplace la fenêtre.
//Si relative vaut 1 et que la fenêtre est une fille, les valeurs sont relatives à la fenêtre mère.
//Si relative vaut 2, les valeurs sont relatives à elle-même.
//true si échec
bool SDL_Window::Move(short x, short y, unsigned char relative)
{
    if(relative==1)//relatif à la mère
    {
        if(!mere)
        {
            fprintf(stderr,"SDL_Window::Move(short,short,uchar), 1:mere est nul\n");
            return true;
        }
        coord.x=x;
        coord.y=y;
    }
    else if(relative==2)//relatif à elle même
    {
        coord.x+=x;
        coord.y+=y;
    }
    else//absolu
    {
        //soustraire tour à tour les coordonées de chaque mère pour avoir les coordonnées relatives finales.
        SDL_Window *ptrMere=mere;
        if(ptrMere)
        {
            coord.x=0;
            coord.y=0;
            while(ptrMere)
            {
                coord.x+=ptrMere->coord.x;
                coord.y+=ptrMere->coord.y;
                ptrMere=ptrMere->mere;
            }//c contient les coordonnées du point 0,0 de la fenetre
            coord.x-=x;
            coord.y-=y;
        }
        else
        {
            coord.x=x;
            coord.y=y;
        }
    }
    return false;
}

//Déplace la fenêtre dans la fenêtre mère. Positions en % de la mère.
//true si échec.
bool SDL_Window::Move(float x, float y)
{

    if(!mere)
    {
        fprintf(stderr,"SDL_Window::Move(float,float), 1:mere est nul\n");
        return true;
    }
    return Move((short)(mere->coord.w*x),(short)(mere->coord.h*y),1);
}

//Retourne true si un problème à eu lieu.
bool SDL_Window::ClearWindow()
{

    if(drawed)
    {
        // calcul des coordonées absolues de la fenêtre
        SDL_Rect coordAbs=oldCoord;
        SDL_Window *ptrMere=this;
        while(ptrMere->mere)
        {
            ptrMere=ptrMere->mere;
            coordAbs.x+=ptrMere->oldCoord.x;
            coordAbs.y+=ptrMere->oldCoord.y;
        }

        for_each(filles.rbegin(),filles.rend(),mem_fun(&SDL_Window::ClearWindow));
        if(SDL_BlitSurface(shadow,NULL,screen,&coordAbs))
        {
            fprintf(stderr,"SDL_Window::ClearWindow(), 1:Echec de BlitSurface:%s\n",SDL_GetError());
            return true;
        }
        drawed=false;
    }
    return false;
}

//retourne true si problème
bool SDL_Window::PrepareWindow()
{

    //NOTE regarder du côté de SDL_gfx pour gérer les zoom et agrandissements
    //NOTE pour éviter les problèmes: avoir des textures pour les traits de 1px de longueur OU calculer la dimension de la fenêtre précisément. Sinon, risque d'avoir un empiètement sur les coins.
    if(!needInit)
        return false;
    if(!border || !body)
    {
        fprintf(stderr,"SDL_Window::PrepareWindow(), 1: border(=%x) ou body(=%x) n'ont pas été initialisé\n",(unsigned int)border,(unsigned int)body);
        return true; //si border n'à pas été initialisée, retourner une erreur
    }
    SDL_Rect destRect= {0,0,0,0};
    Uint32 flags=(screen->flags)&(SDL_SWSURFACE|SDL_HWSURFACE|SDL_SRCCOLORKEY|SDL_SRCALPHA);
    int bpp=screen->format->BitsPerPixel;

    SDL_FreeSurface(shadow);
    SDL_FreeSurface(window);
    shadow=SDL_CreateRGBSurface(flags,coord.w, coord.h, bpp, 0, 0, 0, 0);
    if(!shadow)
    {
        fprintf(stderr,"SDL_Window::PrepareWindow(), 2: shadow non initialisé: %s\n",SDL_GetError());
        return true;
    }

    window=SDL_CreateRGBSurface(flags,coord.w, coord.h, bpp, Rmask, Gmask, Bmask, Amask);
    if(!window)
    {
        fprintf(stderr,"SDL_Window::PrepareWindow(), 3: window non initialisé: %s\n",SDL_GetError());
        return true;
    }

    destRect.x=border->width[HAUTDROITE];
    destRect.y=border->height[HAUTGAUCHE];
    if(SDL_BlitSurface(body,NULL,window, &destRect))
    {
        fprintf(stderr,"SDL_Window::PrepareWindow(), 4: Echec de BlitSurface: %s\n",SDL_GetError());
        return true;
    }

    destRect.x=0;
    destRect.y=0;
    destRect.w=coord.w;
    destRect.h=coord.h;
    border->Draw(window,&destRect);

    needInit=false;
    return false;
}

SDL_Window::SDL_Window(void)
    :Rmask(0)
    ,Gmask(0)
    ,Bmask(0)
    ,Amask(0)
    ,filles()
    ,coord()
    ,mere(0)
    ,shadow(0)
    ,window(0)
    ,body(0)
    ,border(0)
    ,gesEvent()
    ,screen(0)
    ,oldCoord()
    ,drawed(false)
    ,needInit(true)
{
    if(SDL_InitSubSystem(SDL_INIT_VIDEO))
        fprintf(stderr,"SDL_Window::SDL_Window(void), 1:Impossible d'initialiser le sous-système vidéo:%s\n",SDL_GetError()); //TODO (#9) Il faudrait aussi utiliser une exception pour empêcher la création d'une fenêtre si le sous-système vidéo à foiré
    if(!(screen=SDL_GetVideoSurface()))
        fprintf(stderr,"SDL_Window::SDL_Window(void), 2:Echec de SDL_GetVideoSurface(): %s\n",SDL_GetError());
    coord.h=0;
    coord.w=0;
    coord.x=0;
    coord.y=0;
}

SDL_Window::SDL_Window(SDL_Window *Mere)
    :Rmask(0)
    ,Gmask(0)
    ,Bmask(0)
    ,Amask(0)
    ,filles()
    ,coord()
    ,mere(Mere)
    ,shadow(0)
    ,window(0)
    ,body(0)
    ,border(0)
    ,gesEvent()
    ,screen(mere->screen)
    ,oldCoord()
    ,drawed(false)
    ,needInit(true)
{
}

void SDL_Window::SetMasks(unsigned long rmask, unsigned long gmask, unsigned long bmask, unsigned long amask)
{
    needInit=true;
    Rmask=rmask;
    Gmask=gmask;
    Bmask=bmask;
    Amask=amask;
}

list<SDL_Window*>::iterator SDL_Window::CreateSubWindow(void)
{
    filles.push_front(new SDL_Window(this));
    return filles.begin();
}

//si tout est ok, renvoie false.
bool SDL_Window::InitTextures(BorderTexture *bordTex,char* filebody)
{
    needInit=true;
    border=bordTex;
    SDL_FreeSurface(body);
    if(!filebody)
    {
        fprintf(stderr,"SDL_Window::InitTextures(BorderTexture *,char*), 1:filebody vaut NULL\n");
        return false;
    }
    if(!border)
    {
        fprintf(stderr,"SDL_Window::InitTextures(BorderTexture *,char*), 2:bordTex vaut NULL\n");
        return false;
    }
    if(!(body=SDL_LoadBMP(filebody)))
    {
        fprintf(stderr,"SDL_Window::InitTextures(BorderTexture *,char*), 3:Echec de SDL_LoadBMP: %s\n",SDL_GetError());
        return true;
    }

    if(border->isInit())
        return false;
    return true;
}

bool SDL_Window::SetAlpha(unsigned char alpha,bool srcAlpha,bool rleAccel)
{
    Amask=alpha;
    if(SDL_SetAlpha(window,(srcAlpha*SDL_SRCALPHA)|(rleAccel*SDL_RLEACCEL),alpha))
    {
        fprintf(stderr,"SDL_Window::SetAlpha(uchar, bool, bool), 1:Echec de SDL_SetAlpha: %s\n",SDL_GetError());
        return true;
    }
    return false;
}

void SDL_Window::calcCoord(SDL_Rect *c)
{
    // calcul des coordonées absolues de la fenêtre
    SDL_Window *ptrMere=this;
    while(ptrMere->mere)
    {
        ptrMere=ptrMere->mere;
        c->x+=ptrMere->coord.x;
        c->y+=ptrMere->coord.y;
    }
}

SDL_Window::~SDL_Window()
{
    if(mere)
        mere->filles.remove(this);

    while (!filles.empty())
        delete filles.front();
    SDL_FreeSurface(shadow);
    SDL_FreeSurface(window);
    SDL_FreeSurface(body);
}

SDL_Window::SDL_Window(SDL_Window &source, SDL_Window *Mere)
    :Rmask(source.Rmask)
    ,Gmask(source.Gmask)
    ,Bmask(source.Bmask)
    ,Amask(source.Amask)
    ,filles()
    ,coord(source.coord)
    ,mere(source.mere)
    ,shadow(0)
    ,window(0)
    ,body(source.body)
    ,border(source.border)
    ,gesEvent()
    ,screen(source.screen)
    ,oldCoord()
    ,drawed(false)
    ,needInit(true) // window et shadow DOIVENT être réinitialisées (ou alors, il faut que je les duplique, ce qui pourrait économiser de la ressource de calcul)
{
    list<SDL_Window*>::iterator it;
    coord.h=source.coord.h;
    coord.w=source.coord.w;
    coord.x=source.coord.x;
    coord.y=source.coord.y;

    if(Mere)
        mere=Mere;

    if(mere)
        (mere->filles).push_back(this);

    if(body)
        body->refcount++;
    for(it=source.filles.begin();it!=source.filles.end();it++)
        filles.push_back(new SDL_Window(**it,this));
}

SDL_Window &SDL_Window::operator=(SDL_Window &source)
{
    Rmask=source.Rmask;
    Gmask=source.Gmask;
    Bmask=source.Bmask;
    Amask=source.Amask;
    coord.h=source.coord.h;
    coord.w=source.coord.w;
    coord.x=source.coord.x;
    coord.y=source.coord.y;
    mere=source.mere;
    shadow=0;
    window=0;
    body=source.body;
    border=source.border;
    screen=source.screen;
    drawed=false;
    needInit=true; // window et shadow DOIVENT être réinitialisées (ou alors, il faut que je les duplique, ce qui pourrait économiser de la ressource de calcul)

    list<SDL_Window*>::iterator it;

    if(mere)
        (mere->filles).push_back(this);

    if(body)
        body->refcount++;

    //trouver le moyen de remplacer par un for_each également
    for(it=source.filles.begin();it!=source.filles.end();it++)
        filles.push_back(new SDL_Window(**it,this));
    return *this;
    // TODO (Bérenger#9#): Méthode à tester. Devrait fonctionner, vu le peu de différences avec le constructeur de copie, mais prudence est mère de sûreté.
}
// TODO : vérifier que dans le cas ou 2 fenetres non affiliées dont l'ordre d'affichage ne suit aucun ordre prédéfini ne causent pas d'altération des graphismes lorsqu'elles se chevauchent

/* TODO ajouter la gestion des évènements:

algo:
créer un stack<SDL_Event> pile
while(!pollEvent(&event))
{
    envoyer l'event aux filles
    comparer l'event aux event traités par l'objet
    si il doit être traité
        traiter
    sinon
        ajouter à pile
}
remettre la pile dans le stack en utilisant un iterateur inversé

Questions:
_ pomper tous les event dans la mère ou traiter ça dans la boucle principale du programme?
_ la gestion de timer pourrait-elle être intéressante?
    _si oui, s'inspirer de la classe d'empilage d'event de référence:

*/