C++Talk.NET

Kubiak62 · Guest

Bonjour à tous,

Je me permets de vous écrire (encore !) car je rencontre un problème
plutôt bizarre avec un projet sous GTKMM 2.0.

Pour l'affichage de la grille, j'utilise les couleurs avec les objets
Gdk::Color et Colormap. Cela fonctionne mais la 1ère ligne de ma grille
ne s'affiche pas. Pourtant, lorsque je la dessine en noir (je remplace
gc_copeaux, gc_termites et gc_cases par gc et je mets les lignes
concernant les couleurs en commentaire), elle s'affiche correctement.

J'ai passé un long moment à chercher d'où vient le bug, mais en vain.

Pouvez-vous m'expliquer quelle en est la cause?

Merci d'avance.

Matthieu Crogiez

Voilà le code :

#include "interface.h"
#include <iostream>
#include <fstream>
#include <stdlib.h>
using namespace std;

char* NomFic; //nom du fichier où les données de la grille sont enregistrées
char* NomConfig="save.dat"; //nom du fichier où la configuration est
enregistrée
//En cas d'annulation, on rétablit les valeurs précédemment inscrites
dans les Entry
string NbTermitesTemp,NbCopeauxTemp,HautGrilleTemp,LargGrilleTemp;
bool AffichGrilleTemp;
Gdk::Color TerTemp,CopTemp,CasTemp;

void Interface::Quitter() {
hide();
}
/********************************************************************************/
void Interface::vSuivant() {
list<grille>::iterator temp=it;
temp++;
//Si on est sur le dernier élemt de la liste, on en créé un nouveau
if (temp==l.end()) {
grille G=(*it);
G.faire_un_pas();
l.push_back(G);
}
it++;//dans tous les cas, on incrémente l'itérateur
queue_draw();
}
/********************************************************************************/
void Interface::vPrecedent() {
if (it!=l.begin()) it--;
queue_draw();
}
/********************************************************************************/
void Interface::vApropos() {
static About *a=NULL;
if (a==NULL)
a=new About();
a->show_all();
}
/********************************************************************************/
void Interface::vNouveau() {
l.clear();
l.push_back(grille());
it=l.begin();
queue_draw();
}
/********************************************************************************/
void Interface::vPremier() {
it=l.begin();
queue_draw();
}
/********************************************************************************/
void Interface::vDernier() {
it=l.end();
it--;
queue_draw();
}
/********************************************************************************/
void Interface::vEnregistrer() {
if (NomFic==NULL) vEnregistrerSous();
ofstream fic(NomFic);
if (!fic) {cout<<"Erreur de creation du fichier !"< fic<<(*it).largeur< fic<<(*it).hauteur< fic<<(*it).nb_c< fic<<(*it).nb_t< for (int i=0;i<(*it).largeur;i++) {
for (int j=0;j<(*it).hauteur;j++) {
fic<<(*it).t[j][i];
}
fic< }
fic.close();
cout<<"simulation sauvegardee dans :"< }
/********************************************************************************/
void Interface::vEnregistrerSous() {
ChoixFichSave->show();
}
/********************************************************************************/
void Interface::vCharger() {
ChoixFichLoad->show();
}
/********************************************************************************/
void Interface::vSauverConfig() {
ofstream fic(NomConfig);
if (!fic) {cout<<"Erreur de creation du fichier !"< if (atoi(HautGrille->get_text().data())!=0)
fic< else
fic<<"10"< if (atoi(LargGrille->get_text().data())!=0)
fic< else
fic<<"10"< if (atoi(NbTermites->get_text().data())!=0)
fic< else
fic<<"1"< if (atoi(NbCopeaux->get_text().data())!=0)
fic< else
fic<<"5"< fic< //On enregistre la couleur des Copeaux selon le mode RVB
fic< fic< fic< fic< fic< fic< fic< fic< fic< fic.close();
cout<<"configuration sauvegardee"< }
/********************************************************************************/
void Interface::vChargerConfig() {
char* temp;
char coche;
ifstream fic(NomConfig);
if (!fic) {cout<<"Erreur d'ouverture du fichier !"< fic>>temp;
HautGrille->set_text(temp);
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
LargGrille->set_text(temp);
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
NbTermites->set_text(temp);
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
NbCopeaux->set_text(temp);
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>coche;
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
if (coche=='1')
AffichGrille->set_active(true);
else
AffichGrille->set_active(false);
fic>>temp;
CoCopeaux.set_red(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
CoCopeaux.set_green(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
CoCopeaux.set_blue(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
ColorSelCop->set_current_color(CoCopeaux);
fic>>temp;
CoTermites.set_red(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
CoTermites.set_green(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
CoTermites.set_blue(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
ColorSelTer->set_current_color(CoTermites);
fic>>temp;
CoCases.set_red(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
CoCases.set_green(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>temp;
CoCases.set_blue(atoi(temp));
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
ColorSelCas->set_current_color(CoCases);
fic.close();
cout<<"configuration chargee"< }
/********************************************************************************/
bool Interface::Dessiner(GdkEventExpose *event) {
Glib::RefPtrget_window();
//On instancie les différents objets nécessaires à la manipulation des
couleurs
Glib::RefPtr<Gdk::GC> gc = Dessin->get_style()->get_black_gc();
Glib::RefPtr<Gdk::GC> gc_copeaux = Gdk::GC::create(win);
Glib::RefPtr<Gdk::GC> gc_termites = Gdk::GC::create(win);
Glib::RefPtr<Gdk::GC> gc_cases = Gdk::GC::create(win);
Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
//On initialise les couleurs de dessin pour les copeaux, termites et
les cases vides
CoCopeaux=ColorSelCop->get_current_color();
CoCases=ColorSelCas->get_current_color();
CoTermites=ColorSelTer->get_current_color();
colormap->alloc_color(CoCopeaux);
colormap->alloc_color(CoCases);
colormap->alloc_color(CoTermites);
gc_copeaux->set_foreground(CoCopeaux);
gc_termites->set_foreground(CoTermites);
gc_cases->set_foreground(CoCases);
//On dessine les éléments de la simulation
int i,j,x,y=0;
int larg=640/(*it).largeur;
int haut=480/(*it).hauteur;
for (i=0;i<(*it).largeur;i++){
for (j=0;j<(*it).hauteur;j++){
switch((*it).t[j][i]) {
case 0 :
win->draw_rectangle(gc_cases,true,x,y,larg,haut); //Case vide
x+=larg;
break;
case 1 :
win->draw_line(gc_copeaux,x,y,x+larg,y+haut);
win->draw_line(gc_copeaux,x,y+haut,x+larg,y);
x+=larg;
break; //copeau
case 2 :
win->draw_rectangle(gc_termites,true,x,y,larg,haut);
x+=larg;
break; //termite
case 3 :
win->draw_rectangle(gc_copeaux,true,x,y,larg,haut);
x+=larg;
break; //termite avec copeau
default : x+=larg;break;
}
}
x=0;
y+=haut;
}
if (AffichGrille->get_active()==true) {
x=0;y=0;
for (i=0;i<=(*it).largeur;i++){
win->draw_line(gc,x,0,x,(*it).hauteur*haut);
x+=larg;
}
for (i=0;i<=(*it).hauteur;i++){
win->draw_line(gc,0,y,(*it).largeur*larg,y);
y+=haut;
}
}
return true;
}
/********************************************************************************/
void Interface::vParametrer() {
Param->show();
HautGrilleTemp=HautGrille->get_text();
LargGrilleTemp=LargGrille->get_text();
NbCopeauxTemp=NbCopeaux->get_text();
NbTermitesTemp=NbTermites->get_text();
AffichGrilleTemp=AffichGrille->get_active();
}
/********************************************************************************/
void Interface::vPQuitter() {
//On rétablit les valeurs précédentes dans les Gtk::Entry
HautGrille->set_text(HautGrilleTemp);
LargGrille->set_text(LargGrilleTemp);
NbCopeaux->set_text(NbCopeauxTemp);
NbTermites->set_text(NbTermitesTemp);
AffichGrille->set_active(AffichGrilleTemp);
Param->hide();
}
/********************************************************************************/
void Interface::vPValider() {
//On récupère les valeurs des zones de texte
int h=atoi(HautGrille->get_text().data());
int la=atoi(LargGrille->get_text().data());
int t=atoi(NbTermites->get_text().data());
int c=atoi(NbCopeaux->get_text().data());
//Si 1 ou plusieurs zones sont vides, on initialise avec une valeur par
défaut
if (h==0) h=10;
if (la==0) la=10;
if (t==0) t=1;
if (c==0) c=5;
//On créé une nouvelle simulation à l'aide des paramètres
l.clear();
l.push_back(grille(h,la,c,t));
it=l.begin();
Param->hide();
queue_draw();
}
/********************************************************************************/
void Interface::vPRafraichir() {
InitialiserParametres();
}
/********************************************************************************/
void Interface::vCCopeaux() {
CopTemp=CoCopeaux;
CoulCopeaux->show();
}
/********************************************************************************/
void Interface::vCTermites() {
TerTemp=CoTermites;
CoulTermites->show();
}
/********************************************************************************/
void Interface::vCCases() {
CasTemp=CoCases;
CoulCases->show();
}
/********************************************************************************/
void Interface::CasQuitter() {
CoCases=CasTemp;
ColorSelCas->set_current_color(CoCases); //rétablit la couleur précédente
CoulCases->hide();
}
/********************************************************************************/
void Interface::CopQuitter() {
CoCopeaux=CopTemp;
ColorSelCop->set_current_color(CoCopeaux); //rétablit la couleur précédente
CoulCopeaux->hide();
}
/********************************************************************************/
void Interface::TerQuitter() {
CoTermites=TerTemp;
ColorSelTer->set_current_color(CoTermites); //rétablit la couleur
précédente
CoulTermites->hide();
}
/********************************************************************************/
void Interface::CasesValider() {
CoulCases->hide();
}
/********************************************************************************/
void Interface::CopeauxValider() {
CoulCopeaux->hide();
}
/********************************************************************************/
void Interface::TermitesValider() {
CoulTermites->hide();
}
/********************************************************************************/
void Interface::FicSavQuitter() {
ChoixFichSave->hide();
}
/********************************************************************************/
void Interface::FicLoaQuitter() {
ChoixFichLoad->hide();
}
/********************************************************************************/
void Interface::FicEnregistrer() {
string s=ChoixFichSave->get_filename();//Récupère le chemin et le nom
du fichier
NomFic=new char[s.size()+1];
strcpy(NomFic,s.c_str());
ofstream fic(NomFic);
if (!fic) {cout<<"Erreur de creation du fichier !"< fic<<(*it).largeur< fic<<(*it).hauteur< fic<<(*it).nb_c< fic<<(*it).nb_t< for (int i=0;i<(*it).largeur;i++) {
for (int j=0;j<(*it).hauteur;j++) {
fic<<(*it).t[j][i];
}
fic< }
fic.close();
cout<<"simulation sauvegardee dans :"< ChoixFichSave->hide();
}
/********************************************************************************/
void Interface::FicCharger() {
int larg,haut,term,cop=0;
char *temp;
string s=ChoixFichLoad->get_filename();//Récupère le chemin et le nom
du fichier
NomFic=new char[s.size()+1];
strcpy(NomFic,s.c_str());
l.clear();
ifstream fic(NomFic);
if (!fic) {cout<<"Erreur d'ouverture du fichier !"< fic>>larg;
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>haut;
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>cop;
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
fic>>term;
fic.ignore(std::numeric_limits<int>::max(), 'n');//on passe à la ligne
suivante
l.push_back(grille(haut,larg,cop,term));
it=l.begin();
temp=new char[haut];
for (int i=0;i<(*it).largeur;i++) {
fic>>temp;
for (int j=0;j<(*it).hauteur;j++) {
(*it).t[j][i]=temp[j]-48;
}
fic.ignore(std::numeric_limits ligne suivante
}
delete[] temp;
fic.close();
ChoixFichLoad->hide();
cout<<"simulation chargee a partir de :"< queue_draw();
}
/********************************************************************************/
void Interface::InitialiserParametres() {
//On initialise les couleurs des boites de dialogue
CoCopeaux=Gdk::Color("red");
CoCases=Gdk::Color("yellow");
CoTermites=Gdk::Color("blue");
ColorSelTer = CoulTermites->get_colorsel();
ColorSelTer->set_current_color(CoTermites);
ColorSelCop = CoulCopeaux->get_colorsel();
ColorSelCop->set_current_color(CoCopeaux);
ColorSelCas = CoulCases->get_colorsel();
ColorSelCas->set_current_color(CoCases);
//On initialise le contenu des zones de texte
HautGrille->set_text("10");
LargGrille->set_text("10");
NbTermites->set_text("1");
NbCopeaux->set_text("5");
HautGrilleTemp="10";
LargGrilleTemp="10";
NbTermitesTemp="1";
NbCopeauxTemp="5";
CopTemp=CoCopeaux;
CasTemp=CoCases;
TerTemp=CoTermites;
}
/********************************************************************************
void Interface::vGuideFermer() {
Guide->hide();
}
/********************************************************************************
void Interface::vGuideOuvrir() {
Guide->show();
}
/********************************************************************************/
Interface::Interface() {
l.push_back(grille());
it=l.begin();
//Change le titre de la fenetre
set_title("Les termites attaquent...");
//redefinit la taille de la fenetre
set_size_request(800,600);
// on charge le fichier, on instancie les widgets
Glib::RefPtr<Gnome::Glade::Xml> xml;
//Créé l'interface graphique cout< xml = Gnome::Glade::Xml::create("fenetre.glade");
//On réaffecte le pointeur sur la Vbox à la fenêtre Interface
xml->reparent_widget("vbox1",*this);
// on récupère les composants de la fenêtre
xml->get_widget("quitter1",quitter);
xml->get_widget("prec",precedent);
xml->get_widget("prem",premier);
xml->get_widget("suiv",suivant);
xml->get_widget("relo",recharger);
xml->get_widget("stop",stop);
xml->get_widget("dern",dernier);
xml->get_widget("Apropos",Apropos);
xml->get_widget("guide",guide);
xml->get_widget("nouveau",nouveau);
xml->get_widget("charger",charger);
xml->get_widget("enregistrer",enregistrer);
xml->get_widget("enregistrer_sous",enregistrer_sous);
xml->get_widget("parametrer",parametrer);
xml->get_widget("chargerconfig",chargerconfig);
xml->get_widget("sauver_config",sauverconfig);
xml->get_widget("Dessin",Dessin);
xml->get_widget("window2",Param);
xml->get_widget("Choix_Fichier_Save",ChoixFichSave);
xml->get_widget("Choix_Fichier_Load",ChoixFichLoad);
xml->get_widget("Nb_termites",NbTermites);
xml->get_widget("Nb_copeaux",NbCopeaux);
xml->get_widget("Larg_grille",LargGrille);
xml->get_widget("Haut_grille",HautGrille);
xml->get_widget("Affich_grille",AffichGrille);
xml->get_widget("C_Copeaux",CCopeaux);
xml->get_widget("C_Termites",CTermites);
xml->get_widget("C_Cases",CCases);
xml->get_widget("Pannuler",Pannuler);
xml->get_widget("Pvalider",Pvalider);
xml->get_widget("Prafraichir",Prafraichir);
xml->get_widget("Couleur_Termites",CoulTermites);
xml->get_widget("Couleur_Copeaux",CoulCopeaux);
xml->get_widget("Couleur_Cases",CoulCases);
xml->get_widget("CasAnnuler",CasAnnuler);
xml->get_widget("CasValider",CasValider);
xml->get_widget("CopAnnuler",CopAnnuler);
xml->get_widget("CopValider",CopValider);
xml->get_widget("TerValider",TerValider);
xml->get_widget("TerAnnuler",TerAnnuler);
xml->get_widget("FicSavAnnuler",FicSavAnnuler);
xml->get_widget("FicSavValider",FicSavValider);
xml->get_widget("FicLoaAnnuler",FicLoaAnnuler);
xml->get_widget("FicLoaValider",FicLoaValider);
//xml->get_widget("window3",Guide);

//On connecte les widgets à des évènements par des slots
quitter->signal_activate().connect(SigC::slot(*this, &Interface::Quitter));
Apropos->signal_activate().connect(SigC::slot(*this,
&Interface::vApropos));
nouveau->signal_activate().connect(SigC::slot(*this,
&Interface::vNouveau));
enregistrer->signal_activate().connect(SigC::slot(*this,
&Interface::vEnregistrer));
enregistrer_sous->signal_activate().connect(SigC::slot(*this,
&Interface::vEnregistrerSous));
charger->signal_activate().connect(SigC::slot(*this,
&Interface::vCharger));
chargerconfig->signal_activate().connect(SigC::slot(*this,&Interface::vChargerConfig));
sauverconfig->signal_activate().connect(SigC::slot(*this,&Interface::vSauverConfig));
parametrer->signal_activate().connect(SigC::slot(*this,&Interface::vParametrer));
//guide->signal_activate().connect(SigC::slot(*this,
&Interface::vGuideOuvrir));
Dessin->signal_expose_event().connect(SigC::slot(*this,&Interface::Dessiner));
suivant->signal_clicked().connect(SigC::slot(*this,&Interface::vSuivant));
precedent->signal_clicked().connect(SigC::slot(*this,&Interface::vPrecedent));
premier->signal_clicked().connect(SigC::slot(*this,&Interface::vPremier));
dernier->signal_clicked().connect(SigC::slot(*this,&Interface::vDernier));
recharger->signal_clicked().connect(SigC::slot(*this,&Interface::vPValider));
Pannuler->signal_clicked().connect(SigC::slot(*this,&Interface::vPQuitter));
Pvalider->signal_clicked().connect(SigC::slot(*this,&Interface::vPValider));
Prafraichir->signal_clicked().connect(SigC::slot(*this,&Interface::vPRafraichir));
CCopeaux->signal_clicked().connect(SigC::slot(*this,&Interface::vCCopeaux));
CTermites->signal_clicked().connect(SigC::slot(*this,&Interface::vCTermites));
CCases->signal_clicked().connect(SigC::slot(*this,&Interface::vCCases));
CasAnnuler->signal_clicked().connect(SigC::slot(*this,&Interface::CasQuitter));
CopAnnuler->signal_clicked().connect(SigC::slot(*this,&Interface::CopQuitter));
TerAnnuler->signal_clicked().connect(SigC::slot(*this,&Interface::TerQuitter));
CasValider->signal_clicked().connect(SigC::slot(*this,&Interface::CasesValider));
CopValider->signal_clicked().connect(SigC::slot(*this,&Interface::CopeauxValider));
TerValider->signal_clicked().connect(SigC::slot(*this,&Interface::TermitesValider));
FicSavAnnuler->signal_clicked().connect(SigC::slot(*this,&Interface::FicSavQuitter));
FicSavValider->signal_clicked().connect(SigC::slot(*this,&Interface::FicEnregistrer));
FicLoaAnnuler->signal_clicked().connect(SigC::slot(*this,&Interface::FicLoaQuitter));
FicLoaValider->signal_clicked().connect(SigC::slot(*this,&Interface::FicCharger));
//GuideFermer->signal_clicked().connect(SigC::slot(*this,&Interface::vGuideFermer));

InitialiserParametres();
//On affiche le contenu de la Drawing Area
queue_draw();
}
/********************************************************************************/
int main(int argc, char ** argv)
{
Gtk::Main application(&argc, &argv); // initialise Gtk
Interface f; //créé une instance de la fenêtre Interface
Gtk::Main::run(f); // on lance la boucle événementielle
}