plein écran en mode console

Bonjour
Je programme sous visual c++ 6.
Je cherche un moyen d'obliger les application console a se lancer en plein écran.
Merci d'avance pour les réponses

Salut,
Voici un petit code pour windows NT/2000/XP:

#include <windows.h> void main() { typedef BOOL (WINAPI *PFONCTION) (HANDLE,DWORD,PCOORD); HMODULE hDLL=LoadLibrary("kernel32.dll"); PFONCTION SetDisplayMode = (PFONCTION) GetProcAddress(hDLL,"SetConsoleDisplayMode"); HANDLE hconsole = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord; SetDisplayMode (hconsole,1,&coord); //suite du code //.............. }

Ci-dessous le code d'une fonction (tres commente) qui permet de regler la taille
d'une fenetre en mode console.

En esperant que cela puisse te rendre service ...

Necessite l'include :
#include <windows.h>

//------------------------------------------------------------------------------------------
// Fonction TailleEcran(int x, int y) Définit la taille de la fenêtre DOS
//
//------------------------------------------------------------------------------------------
// Utilise la fonction : BOOL SetConsoleScreenBufferSize(HANDLE hConsoleOutput,COORD dwSize)
// déclarée dans : wincon.h **** librairie utilisée : kernel32.lib.
// Variable d'entrée : hConsoleOutput , dwSize
// Variable de sortie : si succès : TRUE
// si erreur : FALSE
//------------------------------------------------------------------------------------------
// Utilise la fonction : BOOL SetConsoleWindowInfo(HANDLE hConsoleOutput,BOOL bAbsolute,
// CONST SMALL_RECT *lpConsoleWindow )
// déclarée dans : wicon.h **** librairie utilisée : kernel32.lib.
// Variable d'entrée : hConsoleOutput, bAbsolute, *lpConsoleWindow
// Variable de sortie : si succès : TRUE
// si erreur : FALSE
//------------------------------------------------------------------------------------------

void TailleEcran(int x, int y)// Cette fonction définie la taille de l'écran en mode console
{

// *** instruction 1 ***

COORD MaTailleEcran = {x,y};

// déclare et défini un objet de structure COORD (défini dans wincon.h)
// possédant les membres MaTailleEcran.X et MaTailleEcran.Y

// Les membres de l'objet COORD sont :

// SHORT X : coordonnée sur l'axe des abscisses (ligne).
// SHORT Y : coordonnée sur l'axe des ordonnées (colonne).

// on peut aussi utiliser à la place de l'instruction 1 :

// COORD MaTailleEcran; // déclare l'objet COORD
// MaTailleEcran.X = x; // défini le membre .X
// MaTailleEcran.Y = y; // défini le membre .Y

// *** instruction 2 ***:

SMALL_RECT MonRectangle = {0,0,x-1,y-1};

// déclare et défini un objet de structure SMALL_RECT (définie dans wincon.h)
//possédant les membres .Bottom, .Left, .Right, .Top

//Membres de l'objet SMALL_RECT :

// SHORT Left : Specifie les coordonnée x du coin haut gauche du rectangle.
// SHORT Top : Specifie les coordonnées y du coin haut gauche du rectangle.
// SHORT Right : Specifie les coordonnée x du coin bas droit du rectangle.
// SHORT Bottom : Specifie les coordonnée x du coin bas droit du rectangle.

// on peut aussi utiliser à la place de l'instruction 2 :

// SMALL_RECT MonRectangle // déclare l'objet SMALL_RECT
// MonRectangle.Bottom = y - 1; // défini le membre .Bottom
// MonRectangle.Left = 0; // défini le membre .Left
// MonRectangle.Right = x - 1; // défini le membre .Right
// MonRectangle.Top = 0; // défini le membre .Top



// *** instruction 3 ***:

SetConsoleScreenBufferSize (MaConsoleEcran,MaTailleEcran);


//SetConsoleScreenBufferSize(handle du buffer de la console écran,
// nouvelle dimension du buffer de l'écran
// en nb de caractère lignes et colonne.)

// la fonction SetConsoleScreenBufferSize défini la dimension du buffer de la console
// écran qui est spécifié en 1er argument de la fonction (soit MaConsoleEcran).

// Cette dimension est indiquée sous forme d'un objet de structure COORD
// (en l'occurrence MaTailleEcran), en 2ème argument,
// contenant en donnée membre la nouvelle dimension (nb de caractère en ligne et en colonne).


// *** instruction 4 ***:

SetConsoleWindowInfo(MaConsoleEcran,TRUE,&MonRectangle);

//SetConsoleWindowsInfo(handle du buffer de la console écran,
//booléen : si TRUE accepte la modif si FALSE garde la valeur prédéfinie,
// adresse (&) de MonRectangle contenant les nouvelles coordonnées)

//la fonction SetConsoleWindowInfo mets la dimension de la fenêtre DOS dont le Handle est
//spécifié dans l'argument 1 aux dimensions fournies en argument 3 dans l'objet de
// de structure SMALL_RECT (MonRectangle), l'argument 3 est TRUE (prise en compte de la modif
// ou FALSE (on conserve les données d'origine prévues pour la taille de la fenêtre).

// A NOTER : LE RECTANGLE EST INFERIEURE EN DIMENSION AU BUFFER (-1)

// : Si l'on met FALSE en 2ème argument, la fenêtre est bien de la taille demandée mais
// s'affiche à l'écran selon les dimensions de la fenêtre par défaut, avec possibilité
// de l'agrandir avec la souris (flêche en bas à droite de la fenêtre)


} //********** Fin de la fonction

J'ai oublie de preciser qu'il fallait definir MaConsoleEcran comme suit ;


const HANDLE MaConsoleEcran = GetStdHandle(STD_OUTPUT_HANDLE);

// REMARQUE :
// La fonction GetStdHandle retourne le n° de handle pour (selon l'argument fourni) :

// la console standard de sortie (écran) : syntaxe : GetStdHandle(STD_OUTPUT_HANDLE);
// la console standart d'entrée (clavier) : syntaxe : GetStdHandle(STD_INPUT_HANDLE);
// la console standart d'erreur : syntaxe : GetStdHandle(STD_ERROR_HANDLE);

Autre solution :
tu simules l'appuie des touches ALT+ENTREE. C'est moins compliqué...