Exemplo n.º 1
0
void Fichier::genererFichierDot (string nomDot)
{
    
    ofstream fluxFichier(nomDot, ios::out);
    ostringstream fluxFichierTemp;
    ostringstream fluxFichierTemp2;
    
    int iDoc = 0;
    int jRef = 0;
    int debutBoucle = 0;
    
    
    if(fluxFichier && fluxFichierTemp){
        fluxFichier<<"digraph {"<<endl;
        
        for(map<string,Document*>::iterator iter=documents.begin();  iter!= documents.end(); ++iter){
            
            fluxFichier<<"node"<< iDoc <<" [label=\""<<iter->first<<"\"];"<<endl;
            
            
            for(map<string,int>::iterator iter2 =iter->second->referers.begin(); iter2 != iter->second->referers.end(); ++iter2){
                
                
                if(debutBoucle==0 ){
                    jRef=iDoc+1;
                }
                
                fluxFichier<<"node"<< jRef <<" [label="<<iter2->first<<"];"<<endl;
                
                fluxFichierTemp<<"node"<<iDoc<<
                " -> "<<"node"<<jRef <<" [label=\""<<iter2->second<<"\"];"<<endl;
                
                jRef++;
                debutBoucle++;
                
            }
            
            iDoc=jRef+1;
            debutBoucle = 0;
            
            
        }
        fluxFichier << fluxFichierTemp.str();
        fluxFichier<<"}";
        
        fluxFichier.close();
        
        cout<<"Le fichier "<<nomDot<<" a bien ete genere"<<endl;
        
    } else {
        cout<<"Impossible d'ecrire sur le fichier"<<nomDot<<endl;
    }
    
    
    
} //----- Fin de M?thode
Exemplo n.º 2
0
void CompteurDeLignes::selectionFichiers()
{
	setCursor(Qt::WaitCursor);

	QStringList fichiers = QFileDialog::getOpenFileNames(this, "Multiuso", Multiuso::lastPath() , "Tous les fichiers (*)");
	
	Multiuso::setLastPath(fichiers.value(0));

	if (!fichiers.isEmpty())
	{
		for (int i = 0; i <= fichiers.size(); i++)
		{
			QFile fichier(fichiers.value(i));

			if (fichier.exists())
			{
				if (fichier.open(QIODevice::ReadOnly | QIODevice::Text))
				{
					int nombreDeLignes = 0;

					QTextStream fluxFichier(&fichier);
						fluxFichier.setCodec("UTF-8");

					while (!fluxFichier.atEnd())
					{
						QCoreApplication::processEvents();

						QString nouvelleLigne = fluxFichier.readLine();
						nombreDeLignes++;
					}

					nombreDeLignes -= doNotCount->value();

					if (nombreDeLignes < 0)
						nombreDeLignes = 0;

					QFileInfo infosFichier(fichier);

					QStandardItem *n_nom = new QStandardItem(infosFichier.fileName());
						n_nom->setEditable(false);

					QStandardItem *n_taille = new QStandardItem(Multiuso::toSize(infosFichier.size()));
						n_taille->setEditable(false);

					QStandardItem *n_lignes = new QStandardItem(QString::number(nombreDeLignes));
						n_lignes->setEditable(false);

					QList<QStandardItem *> nouveauxItems;
						nouveauxItems << n_nom << n_taille << n_lignes;

					modele->appendRow(nouveauxItems);

					vue->resizeColumnsToContents();
					vue->horizontalHeader()->setStretchLastSection(true);

					totalDeLignes += nombreDeLignes;

					QString txtLignes = "lignes";

					if (totalDeLignes == 1)
						txtLignes = "ligne";

					QString txtFichiers = "fichiers";

					if (modele->rowCount() == 1)
						txtFichiers = "fichier";

					resultat->setText("<strong>" + QString::number(totalDeLignes) + "</strong> " + txtLignes + " "
						"pour <strong>" + QString::number(modele->rowCount()) + "</strong> " + txtFichiers + ".");
				}

				fichier.close();
			}
		}
	}

	setCursor(Qt::ArrowCursor);
}
Exemplo n.º 3
0
    int main(int argc, char *argv[])
    {
		// Initialisation du generateur de nombre aleatoire
		srand(clock());
	
		// Creation de l'application
        QApplication app(argc, argv);
		
		// Creation de la fenetre de log
		Log = new QTextEdit();
		Log->setWindowTitle("Log");
		Log->setReadOnly(true);
	//	Log->show();

		// Installation du handler de debugage
		qInstallMsgHandler(handlerAffichageMsg);

		// Chargement du traducteur de Qt
		QTranslator qtTranslator;
		qtTranslator.load("qt_" + QLocale::system().name());
		app.installTranslator(&qtTranslator);

		// On charge le fichier de ressources qui contient ttes les images
		QResource::registerResource(QString(NOM_APPLICATION) + ".rcc");

		#ifdef WIN32
			// M.a.j de l'icone de l'application
			app.setWindowIcon(QIcon(":/icones/" + QString(NOM_APPLICATION) + ".png"));
		#endif

  		// Initialisation de la librairie FMOD
		if (!FSOUND_Init(FREQUENCE_AUDIO, 32, 0))
			qWarning("Probleme d'initialisation de la librairie FMOD (main - main.cpp)");

		// Par defaut la variable d'initialisation n'est pas utilisable
		G_initialisation.initialisee = false;

		// Nom du fichier d'initialisation
		#ifdef WIN32
			QString fichierInitialisation = QString(NOM_APPLICATION) + ".ini";
		#elif defined (MACOS)
			// Creation du repertoire ou sont stockees les preferences, si celui-ci n'existe pas
			if (!(QDir(QDir::homePath() + "/." + QString(NOM_APPLICATION)).exists()))
				QDir::home().mkdir("." + QString(NOM_APPLICATION));
			QString fichierInitialisation = QDir::homePath() + "/." + QString(NOM_APPLICATION) + "/" + QString(NOM_APPLICATION) + ".ini";
		#endif
 
		// Si le fichier d'initialisation existe, on le charge
		if (QFile::exists(fichierInitialisation))
		{
			// Creation du descripteur de fichier
			QFile file(fichierInitialisation);
			// Ouverture du fichier en lecture seule
			if (!file.open(QIODevice::ReadOnly))
			{
				qWarning("Probleme a l'ouverture du fichier d'initialisation (main - main.cpp)");
			}
			
			// L'ouverture s'est correctement passee
			else
			{
				// On indique que la variable d'initilisation est utilisable
				G_initialisation.initialisee = true;
				// On cree un flux de donnees rattache au fichier
				QDataStream fluxFichier(&file);
				
				// On recupere la version de l'application
				fluxFichier >> G_initialisation.versionApplication;
				// ...le nom de l'utilisateur
				fluxFichier >> G_initialisation.nomUtilisateur;
				// ...la couleur de l'utilisateur
				fluxFichier >> G_initialisation.couleurUtilisateur;
				// ...la nature de l'utilisateur (joueur ou MJ)
				fluxFichier >> G_initialisation.joueur;
				// ...la nature de l'ordinateur local
				fluxFichier >> G_initialisation.client;
				// ...l'adresse IP du serveur
				fluxFichier >> G_initialisation.ipServeur;
				// ...le port du serveur
				fluxFichier >> G_initialisation.portServeur;
				// ...le port de connexion pour les clients
				fluxFichier >> G_initialisation.portClient;
				// ...le chemin pour les musiques
				fluxFichier >> G_initialisation.dossierMusiquesMj;
				// ...le chemin pour les musiques des joueurs
				fluxFichier >> G_initialisation.dossierMusiquesJoueur;
				// ...le chemin pour les images
				fluxFichier >> G_initialisation.dossierImages;
				// ...le chemin pour les plans
				fluxFichier >> G_initialisation.dossierPlans;
				// ...le chemin pour les scenarii
				fluxFichier >> G_initialisation.dossierScenarii;
				// ...le chemin pour les notes
				fluxFichier >> G_initialisation.dossierNotes;
				// ...le chemin pour les tchats
				fluxFichier >> G_initialisation.dossierTchats;
				// ...les couleurs personnelles
				for (int i=0; i<16; i++)
					fluxFichier >> G_initialisation.couleurPersonnelle[i];
				// ...le volume du lecteur audio
				fluxFichier >> G_initialisation.niveauVolume;
				// Fermeture du fichier
				file.close();
			}
		}

		// Creation du client/serveur : si la connexion reussie alors
		// le programme principal est lance
		ClientServeur *clientServeur = new ClientServeur();
		
		// Lancement de la boucle d'application
        return app.exec();
    } 
Exemplo n.º 4
0
    Carte::Carte(const std::string& fichier)
    {
        // Initialisation du tableau
        carte = new ENTITES*[16];
        for(int i=0; i<16; i++)
        {
            carte[i] = new ENTITES[16];
        }



        // Ouverture du fichier
        std::string cheminAbsolu = Constantes::DOSSIER_MEDIA+fichier;
        QFile fichierDesc(QString(cheminAbsolu.c_str()));
        if(fichierDesc.open(QIODevice::ReadOnly))
        {
            // Le fichier a su etre ouvert
            QTextStream fluxFichier(&fichierDesc);
            QString tampon;
            QStringList listeTmp;

            // Lecture du fichier
            tampon = fluxFichier.readAll();
            listeTmp = tampon.split(" ", QString::SkipEmptyParts);

            int k = 0;
            for(int i=0; i<16; i++)
            {
                for(int j=0; j<16; j++)
                {

                    switch(listeTmp.at(k).toInt())
                    {
                    case 0:
                        carte[i][j] = LIBRE;
                        break;
                    case 1:
                        carte[i][j] = CHEMIN_NORD;
                        break;
                    case 2:
                        carte[i][j] = CHEMIN_SUD;
                        break;
                    case 4:
                        carte[i][j] = CHEMIN_EST;
                        break;
                    case 8:
                        carte[i][j] = CHEMIN_OUEST;
                        break;
                    case 5:
                        carte[i][j] = CHEMIN_NE;
                        break;
                    case 6:
                        carte[i][j] = CHEMIN_SE;
                        break;
                    case 9:
                        carte[i][j] = CHEMIN_NO;
                        break;
                    case 10:
                        carte[i][j] = CHEMIN_SO;
                        break;
                    case 17:
                        carte[i][j] = DEPART_NORD;
                        depart = Position(j, i);
                        break;
                    case 18:
                        carte[i][j] = DEPART_SUD;
                        depart = Position(j, i);
                        break;
                    case 20:
                        carte[i][j] = DEPART_EST;
                        depart = Position(j, i);
                        break;
                    case 24:
                        carte[i][j] = DEPART_OUEST;
                        depart = Position(j, i);
                        break;
                    case 32:
                        carte[i][j] = BUT_ENNEMIS;
                        break;
                    case 64:
                        carte[i][j] = BOUE;
                        break;
                    default:
                        carte[i][j] = LIBRE;
                        break;
                    }


                    k++;
                }
                std::cout << "\n";
            }
            fichierDesc.close();
        }
        else
        {
            // Le fichier n'a su etre ouvert correctement
            for(int i=0; i<16; i++)
            {
                for(int j=0; j<16; j++)
                {
                    carte[i][j] = LIBRE;
                }
            }
        }
    }