PFen.cpp

Aller à la documentation de ce fichier.

#include "PFen.h"

using namespace std;

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

    if(ClearWindow())
    {
        logErr(__FILE__,__LINE__,"Echec de ClearWindow\n");
        return true;
    }
    if(PrepareWindow())//cette fonction devra vérifier si il est nécessaire de refaire tous les calculs
    {
        logErr(__FILE__,__LINE__,"Echec de PrepareWindow\n");
        return true;
    }
    if(SDL_BlitSurface(screen,&coordAbs,shadow,NULL))//sauvegarde de l'écran
    {
        logErr(__FILE__,__LINE__,SDL_GetError());
        return true;
    }
    if(SDL_BlitSurface(window,NULL,screen,&coordAbs))//affichage
    {
        logErr(__FILE__,__LINE__,SDL_GetError());
        return true;
    }

    PFen *ptrMere=mere;//bloc pour insérer une tabulation pour chaque mere dans stderr, pour indenter les erreurs
    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(&PFen::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 PFen::Resize(short width, short height, unsigned char relative)
{
    needInit=true;
    if(!relative)
    {
        if(height<0 || width<0)
        {
            logErr(__FILE__,__LINE__,"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 PFen::Resize(float width, float height, bool target)
{

    if(!target)
    {
        if(!mere)
        {
            logErr(__FILE__,__LINE__,"mere est nul");
            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 PFen::Move(short x, short y, unsigned char relative)
{
    if(relative==1)//relatif à la mère
    {
        if(!mere)
        {
            logErr(__FILE__,__LINE__,"mere est nul");
            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.
        PFen *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 PFen::Move(float x, float y)
{

    if(!mere)
    {
        logErr(__FILE__,__LINE__,"mere est nul");
        return true;
    }
    return Move((short)(mere->coord.w*x),(short)(mere->coord.h*y),1);
}

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

    if(drawed)
    {
        // calcul des coordonées absolues de la fenêtre
        SDL_Rect coordAbs=oldCoord;
        PFen *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(&PFen::ClearWindow));
        if(SDL_BlitSurface(shadow,NULL,screen,&coordAbs))
        {
            logErr(__FILE__,__LINE__,SDL_GetError());
            return true;
        }
        drawed=false;
    }
    return false;
}

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

    //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)
    {
        logErr(__FILE__,__LINE__,"border(=%x) ou body(=%x) n'ont pas été initialisés",(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)
    {
        logErr(__FILE__,__LINE__,SDL_GetError());
        return true;
    }

    window=SDL_CreateRGBSurface(flags,coord.w, coord.h, bpp, Rmask, Gmask, Bmask, Amask);
    if(!window)
    {
        logErr(__FILE__,__LINE__,SDL_GetError());
        return true;
    }

    destRect.x=border->width[HAUTDROITE];
    destRect.y=border->height[HAUTGAUCHE];
    if(SDL_BlitSurface(body,NULL,window, &destRect))
    {
        logErr(__FILE__,__LINE__,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;
}

PFen::PFen(void)
    :Rmask(0)
    ,Gmask(0)
    ,Bmask(0)
    ,Amask(0)
    ,filles()
    ,coord()
    ,mere(0)
    ,shadow(0)
    ,window(0)
    ,body(0)
    ,border(0)
    ,refEvent()
    ,screen(0)
    ,oldCoord()
    ,drawed(false)
    ,needInit(true)
{
    if(SDL_InitSubSystem(SDL_INIT_VIDEO))
        logErr(__FILE__,__LINE__,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()))
        logErr(__FILE__,__LINE__,SDL_GetError());
    coord.h=0;
    coord.w=0;
    coord.x=0;
    coord.y=0;
}

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

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

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

//si tout est ok, renvoie false.
bool PFen::InitTextures(BorderTexture *bordTex,char* filebody)
{
    needInit=true;
    border=bordTex;
    SDL_FreeSurface(body);
    if(!filebody)
    {
        logErr(__FILE__,__LINE__,"filebody vaut NULL\n");
        return false;
    }
    if(!border)
    {
        logErr(__FILE__,__LINE__,"bordTex vaut NULL\n");
        return false;
    }
    if(!(body=SDL_LoadBMP(filebody)))
    {
        logErr(__FILE__,__LINE__,SDL_GetError());
        return true;
    }

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

bool PFen::SetAlpha(unsigned char alpha,bool srcAlpha,bool rleAccel)
{
    Amask=alpha;
    if(SDL_SetAlpha(window,(srcAlpha*SDL_SRCALPHA)|(rleAccel*SDL_RLEACCEL),alpha))
    {
        logErr(__FILE__,__LINE__,SDL_GetError());
        return true;
    }
    return false;
}

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

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

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

PFen::PFen(PFen &source, PFen *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)
    ,refEvent()
    ,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<PFen*>::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 PFen(**it,this));
}

PFen &PFen::operator=(PFen &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<PFen*>::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 PFen(**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 timers:
Questions:
_ la gestion de timer pourrait-elle être intéressante?
    _si oui, s'inspirer de la classe d'empilage d'event de référence:

*/

bool PFen::testEvent(const SDL_Event *evnt)
{
    event=(SDL_Event*)evnt;
    pTestEvent();
    return evFired;
}

bool PFen::pTestEvent(void)
{
//TODO définir une exception
/*
    try
    {
        for_each(refEvent.begin(),refEvent.end(),testEvent); //ne marche pas car testEvent prend un argument
        for_each(filles.begin(),filles.end(),mem_fun(pTestEvent));
    }
    catch(MonException)
    {
        evFired=true;
        throw;
    }
    evFired=false;
*/
    return false;
}