Page principale | Liste des namespaces | Hiérarchie des classes | Liste par ordre alphabétique | Liste des composants | Liste des fichiers | Membres des namespaces | Composants | Déclarations

# Référence de la classe ExManagerWindow

`#include <ExManagerWindow.h>`

Graphe d'héritage de la classe ExManagerWindow

## Membres publics
void | CreateNewWindow (int SizeX, int SizeY, int PosX, int PosY, char *argv)
void | CreateNewWindow (int SizeX, int SizeY, char *argv)
void | Move (int Posx, int Posy)
void | SetResolution (int SizeX, int SizeY)
void | SetRate (int Rate)
void | SetBits (int Bits)
void | SetFullScreen (bool State)
void | SetWindowTitle (char *Title)
void | SetIconTitle (char *Title)
void | SetCursor (int Cursor)
void | Apply (void)
int | GetResolutionX (void)
int | GetResolutionY (void)
int | GetRate (void)
int | GetBits (void)
bool | GetFullScreen (void)
void | SetGrilleState (bool state)
bool | GetGrilleState (void)
void | SetFpsState (bool state)
bool | GetFpsState (void)
void | ShowFps (void)
void | ShowNetStat (void)
void | Reset (void)
ExCAction | InputCommand (ExCCommand Command)
ExCAction | InputAction (ExCAction Action)
void | SetFlux (std::ostrstream *consol, ExCFluxAction *action)
bool | GetStatus (void)
void | SetStatus (bool status)
void | SetAskForCommand (bool status)
void | SetAskForExclusifCommand (bool status)
bool | AskForCommand (void)
bool | AskForExclusifCommand (void)
virtual void | Init (void)
virtual void | Reload (void)
## Membres publics statiques
ExManagerWindow * | CreateSingleton (void)
## Attributs Publics
void(* | GlutCallBack )()
std::ostrstream * | Consol
ExCFluxAction * | FluxAction
## Attributs Protégés
bool | m_Status
bool | m_AskForCommand
bool | m_Exclusif
## Membres privés
| ExManagerWindow (void)
| ~ExManagerWindow (void)
## Attributs Privés
int | m_WindowHandler
int | m_WindowSizeX
int | m_WindowSizeY
int | m_WindowSizeXOld
int | m_WindowSizeYOld
int | m_WindowPosX
int | m_WindowPosY
int | m_Bits
int | m_Rate
bool | m_FullScreen
bool | m_OldMode
char * | m_Title
char * | m_IconTitle
int | m_Cursor
bool | m_ShowGrille
bool | m_ShowFps
int | frame
int | timeframe
int | timebase
char | s [30]
## Attributs Privés Statiques
bool | m_flag = false
ExManagerWindow * | m_instance = NULL

## Documentation des contructeurs et destructeurs

ExManagerWindow::ExManagerWindow | ( | void |  | ) | `[private]`

| Définition à la ligne 29 du fichier ExManagerWindow.cpp. Références ExManagerWindow(), Guard, m_Bits, m_Cursor, m_FullScreen, m_IconTitle, m_OldMode, m_Rate, m_ShowFps, m_ShowGrille, m_Title, m_WindowPosX, m_WindowPosY, m_WindowSizeX, m_WindowSizeXOld, m_WindowSizeY, m_WindowSizeYOld, UnGuard, et VERSION. Référencé par ExManagerWindow(), et ~ExManagerWindow().
    00029                                     {
    00030 Guard(ExManagerWindow::ExManagerWindow(void))
    00031         m_ShowGrille=false;
    00032
    00033 //      m_Antialliasing=true;
    00034
    00035         /*
    00036         options = new ExCOptions;
    00037
    00038         m_ShowFps = options->getWindowShowfps ();
    00039
    00040         m_WindowSizeX = options->getWindowResolutionX ();
    00041         m_WindowSizeY = options->getWindowResolutionY ();
    00042                 m_Bits = options->getWindowDepth ();
    00043         m_Rate = options->getWindowRate ();
    00044         m_FullScreen = options->getWindowFullscreen () ;
    00045         */
    00046         m_ShowFps = true;
    00047         m_WindowSizeX = 800;
    00048         m_WindowSizeY = 600;
    00049         m_WindowSizeXOld = m_WindowSizeX;
    00050         m_WindowSizeYOld = m_WindowSizeY;
    00051         m_WindowPosX=0;
    00052         m_WindowPosY=0;
    00053         m_Bits = 16;
    00054         m_Rate = 75;
    00055         m_FullScreen = true ;
    00056         m_OldMode=m_FullScreen;
    00057         m_Cursor=GLUT_CURSOR_CROSSHAIR;
    00058
    00059         m_Title=new char[strlen("ExNihilo Engine Version ")+20];
    00060         sprintf(m_Title,"ExNihilo Engine Version %s",VERSION);
    00061
    00062         m_IconTitle=new char[strlen("ExNihilo Engine Version ")+20];
    00063         sprintf(m_IconTitle,"ExNihilo Engine Version %s",VERSION);
    00064
    00065 UnGuard
    00066 }

ExManagerWindow::~ExManagerWindow | ( | void |  | ) | `[private]`

| Définition à la ligne 68 du fichier ExManagerWindow.cpp. Références ExManagerWindow(), Guard, m_flag, et UnGuard.
    00069 {
    00070 Guard(ExManagerWindow::~ExManagerWindow(void))
    00071         m_flag=false;
    00072 UnGuard
    00073 }

## Documentation des méthodes

void ExManagerWindow::Apply | ( | void |  | ) |

| Définition à la ligne 160 du fichier ExManagerWindow.cpp. Références Apply(), ExManager::FluxAction, GlutCallBack, Guard, m_Bits, m_FullScreen, m_OldMode, m_Rate, m_Title, m_WindowHandler, m_WindowPosX, m_WindowPosY, m_WindowSizeX, m_WindowSizeY, ExCFluxAction::Push(), RELOAD, et UnGuard. Référencé par Apply(), InputAction(), et PreInitManager().
    00160                                {
    00161 Guard(ExManagerWindow::Apply(void))
    00162         if(m_FullScreen)
    00163         {
    00164                 char *game;
    00165                 game=new char[15];
    00166                 sprintf(game,"%dx%d:%d@%d",m_WindowSizeX,m_WindowSizeY,m_Bits,m_Rate);
    00167                 if(m_OldMode)
    00168                 {
    00169                         glutDestroyWindow(m_WindowHandler);
    00170                 }
    00171
    00172                 glutGameModeString(game);
    00173
    00174                 if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
    00175                 {
    00176                         m_WindowHandler=glutEnterGameMode();
    00177                         GlutCallBack();
    00178                         glutSetWindow(m_WindowHandler);
    00179                         FluxAction->Push(ExCAction(RELOAD));
    00180                 }else
    00181                 {
    00182                         std::cout << "Can not switch to fullscreen  error with your graphic card or glut lib " << std::endl;
    00183                 }
    00184         }else
    00185         {
    00186                 if(m_OldMode)
    00187                 {
    00188                         glutLeaveGameMode();
    00189                         glutInitWindowPosition(m_WindowPosX,m_WindowPosY);
    00190                         glutInitWindowSize(m_WindowSizeX,m_WindowSizeY);
    00191                         m_WindowHandler=glutCreateWindow(m_Title);
    00192                 }else
    00193                 {
    00194                         glutReshapeWindow(m_WindowSizeX,m_WindowSizeY);
    00195                 }
    00196         }
    00197 UnGuard
    00198 }

bool ExManager::AskForCommand | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 89 du fichier ExManager.h. Références ExManager::m_AskForCommand. Référencé par ExManagerCommand::InputCommand().
    00089 {return m_AskForCommand;}

bool ExManager::AskForExclusifCommand | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 90 du fichier ExManager.h. Références ExManager::m_Exclusif. Référencé par ExManagerCommand::InputCommand().
    00090 {return m_Exclusif;}

void ExManagerWindow::CreateNewWindow | ( | int | SizeX,
|  | int | SizeY,
|  | char * | argv
| ) |

| Définition à la ligne 105 du fichier ExManagerWindow.cpp. Références CreateNewWindow(), Guard, m_Cursor, m_IconTitle, m_Title, m_WindowHandler, m_WindowPosX, m_WindowPosY, m_WindowSizeX, m_WindowSizeXOld, m_WindowSizeY, m_WindowSizeYOld, SetCursor(), et UnGuard.
    00105                                                                    {
    00106 Guard(ExManagerWindow::CreateNewWindow(int SizeX,int SizeY,char *argv))
    00107         m_WindowSizeX=SizeX;
    00108         m_WindowSizeY=SizeY;
    00109         m_WindowSizeXOld=SizeX;
    00110         m_WindowSizeYOld=SizeY;
    00111         glutInitWindowPosition(m_WindowPosX,m_WindowPosY);
    00112         glutInitWindowSize(m_WindowSizeX,m_WindowSizeY);
    00113         m_WindowHandler=glutCreateWindow(m_Title);
    00114         glutSetIconTitle(m_IconTitle);
    00115         SetCursor(m_Cursor);
    00116 UnGuard
    00117 }

void ExManagerWindow::CreateNewWindow | ( | int | SizeX,
|  | int | SizeY,
|  | int | PosX,
|  | int | PosY,
|  | char * | argv
| ) |

| Définition à la ligne 89 du fichier ExManagerWindow.cpp. Références CreateNewWindow(), Guard, m_Cursor, m_IconTitle, m_Title, m_WindowHandler, m_WindowPosX, m_WindowPosY, m_WindowSizeX, m_WindowSizeXOld, m_WindowSizeY, m_WindowSizeYOld, SetCursor(), et UnGuard. Référencé par CreateNewWindow(), et main().
    00089                                                                                      {
    00090 Guard(ExManagerWindow::CreateNewWindow(int SizeX,int SizeY,int PosX,int PosY,char *argv))
    00091         m_WindowSizeX=SizeX;
    00092         m_WindowSizeY=SizeY;
    00093         m_WindowSizeXOld=SizeX;
    00094         m_WindowSizeYOld=SizeY;
    00095         m_WindowPosX=PosX;
    00096         m_WindowPosY=PosY;
    00097         glutInitWindowPosition(m_WindowPosX,m_WindowPosY);
    00098         glutInitWindowSize(m_WindowSizeX,m_WindowSizeY);
    00099         m_WindowHandler=glutCreateWindow(m_Title);
    00100         glutSetIconTitle(m_IconTitle);
    00101         SetCursor(m_Cursor);
    00102 UnGuard
    00103 }

ExManagerWindow * ExManagerWindow::CreateSingleton | ( | void |  | ) | `[static]`

| Définition à la ligne 75 du fichier ExManagerWindow.cpp. Références CreateSingleton(), Guard, m_flag, m_instance, et UnGuard. Référencé par CreateManager(), et CreateSingleton().
    00075                                                      {
    00076 Guard(ExManagerWindow* ExManagerWindow::CreateSingleton(void))
    00077         if(!m_flag)
    00078         {
    00079                 m_flag = true; // We are creating the error log now, so set flag to true
    00080                 m_instance = new ExManagerWindow; // Create the error log
    00081         }else
    00082         {
    00083                 std::cout<<"Error singleton already created"<<std::endl;
    00084         }
    00085         return m_instance;
    00086 UnGuard
    00087 }

int ExManagerWindow::GetBits | ( | void |  | ) | `[inline]`

| Définition à la ligne 118 du fichier ExManagerWindow.h. Références m_Bits.
    00118 {return m_Bits;}

bool ExManagerWindow::GetFpsState | ( | void |  | ) | `[inline]`

| Définition à la ligne 124 du fichier ExManagerWindow.h. Références m_ShowFps. Référencé par ExManagerOutput::DrawScene().
    00124 {return m_ShowFps;}

bool ExManagerWindow::GetFullScreen | ( | void |  | ) | `[inline]`

| Définition à la ligne 119 du fichier ExManagerWindow.h. Références m_FullScreen.
    00119 {return m_FullScreen;}

bool ExManagerWindow::GetGrilleState | ( | void |  | ) | `[inline]`

| Définition à la ligne 122 du fichier ExManagerWindow.h. Références m_ShowGrille. Référencé par ExManagerOutput::DrawScene(), et InputAction().
    00122 {return m_ShowGrille;}

int ExManagerWindow::GetRate | ( | void |  | ) | `[inline]`

| Définition à la ligne 117 du fichier ExManagerWindow.h. Références m_Rate.
    00117 {return m_Rate;}

int ExManagerWindow::GetResolutionX | ( | void |  | ) | `[inline]`

| Définition à la ligne 115 du fichier ExManagerWindow.h. Références m_WindowSizeX. Référencé par ExManagerConsole::Draw(), ExManagerObjectWindow::InputAction(), ExCInterface::InputCommand(), ExManagerObjectWindow::OrganizeMinimizedWindow(), ExManagerOutput::Reshape(), et ExManagerConsole::UpdateConsolBuffer().
    00115 {return m_WindowSizeX;}

int ExManagerWindow::GetResolutionY | ( | void |  | ) | `[inline]`

| Définition à la ligne 116 du fichier ExManagerWindow.h. Références m_WindowSizeY. Référencé par ExManagerConsole::Draw(), ExManagerObjectWindow::InputAction(), ExCInterface::InputCommand(), ExManagerObjectWindow::OrganizeMinimizedWindow(), et ExManagerOutput::Reshape().
    00116 {return m_WindowSizeY;}

bool ExManager::GetStatus | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 85 du fichier ExManager.h. Références ExManager::m_Status. Référencé par ExManagerInterface::Draw(), ExManagerConsole::Draw(), et ExManagerOutput::DrawScene().
    00085 {return m_Status;}

void ExManager::Init | ( | void |  | ) | `[virtual, inherited]`

| Redéfinie dans ExManagerCollision, ExManagerCommand, ExManagerConsole, ExManagerFog, ExManagerId, ExManagerInputGLUT, ExManagerMap, ExManagerNetwork, ExManagerOutput, ExManagerPVS, ExManagerSpecialEffect, ExManagerLoad, ExManagerAnimation, ExManagerCamera, ExManagerEntity, ExManagerFont, ExManagerGizmo, ExManagerInterface, ExManagerLight, ExManagerLoad, ExManagerMesh, ExManagerModel, ExManagerObject< TypeA >, ExManagerObjectWindow, ExManagerParticuleSystem, ExManagerSound, ExManagerSpirit, ExManagerTexture, ExManagerVertexArrays, ExManagerVertexProgram, ExManagerObject< ExCAnimation >, ExManagerObject< ExCModel * >, ExManagerObject< ExCWindow >, ExManagerObject< ExCVertexProgram >, ExManagerObject< ExCLight >, ExManagerObject< ExCLoadingAnimation >, ExManagerObject< ExCInterface >, ExManagerObject< ExCSound >, ExManagerObject< ExCCamera * >, ExManagerObject< ExCFont >, ExManagerObject< ExCGizmo >, ExManagerObject< ExCMesh * >, ExManagerObject< ExCTexture >, ExManagerObject< ExCEntity * >, ExManagerObject< ExCSystemeParticule >, et ExManagerObject< ExCSpirit >. Définition à la ligne 31 du fichier ExManager.cpp.
    00032 {}

ExCAction ExManagerWindow::InputAction | ( | ExCAction | Action | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 228 du fichier ExManagerWindow.cpp. Références Apply(), DISABLE_GRIDE, ENABLE_GRIDE, GetGrilleState(), Guard, HIDE_FPS_STAT, InputAction(), ExCAction::m_Action, NOTHING, SET_POLYGONMODE_FILL, SET_POLYGONMODE_LINES, SET_POLYGONMODE_POINTS, SET_RESOLUTION_1024_768_16, SET_RESOLUTION_1024_768_24, SET_RESOLUTION_1024_768_32, SET_RESOLUTION_1600_1200_16, SET_RESOLUTION_1600_1200_24, SET_RESOLUTION_1600_1200_32, SET_RESOLUTION_800_600_16, SET_RESOLUTION_800_600_24, SET_RESOLUTION_800_600_32, SetBits(), SetFpsState(), SetFullScreen(), SetGrilleState(), SetResolution(), SHOW_FPS_STAT, SWITCH_GRIDE, et UnGuard. Référencé par InputAction(), et ExManagerCommand::ProcesExCAction().
    00229 {
    00230 Guard(ExManagerWindow::InputAction(ExCAction Action))
    00231         switch(Action.m_Action)
    00232         {
    00233         case SET_RESOLUTION_800_600_16:
    00234                 SetResolution(800,600);
    00235                 SetBits(16);
    00236                 SetFullScreen(true);
    00237                 Apply();
    00238                 break;
    00239
    00240         case SET_RESOLUTION_800_600_24:
    00241                 SetResolution(800,600);
    00242                 SetBits(24);
    00243                 SetFullScreen(true);
    00244                 Apply();
    00245                 break;
    00246
    00247         case SET_RESOLUTION_800_600_32:
    00248                 SetResolution(800,600);
    00249                 SetBits(32);
    00250                 SetFullScreen(true);
    00251                 Apply();
    00252                 break;
    00253
    00254         case SET_RESOLUTION_1024_768_16:
    00255                 SetResolution(1024,768);
    00256                 SetBits(16);
    00257                 SetFullScreen(true);
    00258                 Apply();
    00259                 break;
    00260
    00261         case SET_RESOLUTION_1024_768_24:
    00262                 SetResolution(1024,768);
    00263                 SetBits(24);
    00264                 SetFullScreen(true);
    00265                 Apply();
    00266                 break;
    00267
    00268         case SET_RESOLUTION_1024_768_32:
    00269                 SetResolution(1024,768);
    00270                 SetBits(32);
    00271                 SetFullScreen(true);
    00272                 Apply();
    00273                 break;
    00274
    00275         case SET_RESOLUTION_1600_1200_16:
    00276                 SetResolution(1600,1200);
    00277                 SetBits(16);
    00278                 SetFullScreen(true);
    00279                 Apply();
    00280                 break;
    00281
    00282         case SET_RESOLUTION_1600_1200_24:
    00283                 SetResolution(1600,1200);
    00284                 SetBits(24);
    00285                 SetFullScreen(true);
    00286                 Apply();
    00287                 break;
    00288
    00289         case SET_RESOLUTION_1600_1200_32:
    00290                 SetResolution(1600,1200);
    00291                 SetBits(32);
    00292                 SetFullScreen(true);
    00293                 Apply();
    00294                 break;
    00295
    00296         case SHOW_FPS_STAT:
    00297                 SetFpsState(true);
    00298                 break;
    00299
    00300         case HIDE_FPS_STAT:
    00301                 SetFpsState(false);
    00302                 break;
    00303
    00304         case ENABLE_GRIDE:
    00305                 SetGrilleState(true);
    00306                 break;
    00307
    00308         case DISABLE_GRIDE:
    00309                 SetGrilleState(false);
    00310                 break;
    00311
    00312         case SWITCH_GRIDE:
    00313                 if(GetGrilleState())
    00314                 {
    00315                         InputAction(DISABLE_GRIDE);
    00316                 }else
    00317                 {
    00318                         InputAction(ENABLE_GRIDE);
    00319                 }
    00320                 break;
    00321         case SET_POLYGONMODE_POINTS:
    00322                 glPolygonMode(GL_FRONT_AND_BACK,GL_POINT);
    00323                 break;
    00324
    00325         case SET_POLYGONMODE_LINES:
    00326                 glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
    00327                 break;
    00328
    00329         case SET_POLYGONMODE_FILL:
    00330                 glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    00331                 break;
    00332
    00333         default: return NOTHING;
    00334         }
    00335         return  NOTHING;
    00336 UnGuard
    00337 }

ExCAction ExManagerWindow::InputCommand | ( | ExCCommand | Command | ) | `[virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 221 du fichier ExManagerWindow.cpp. Références Guard, InputCommand(), NOTHING, et UnGuard. Référencé par InputCommand().
    00222 {
    00223 Guard(ExManagerWindow::InputCommand(ExCCommand Command))
    00224         return  NOTHING;
    00225 UnGuard
    00226 }

void ExManagerWindow::Move | ( | int | Posx,
|  | int | Posy
| ) |

| Définition à la ligne 119 du fichier ExManagerWindow.cpp. Références Guard, m_WindowPosX, m_WindowPosY, Move(), et UnGuard. Référencé par Move().
    00119                                            {
    00120 Guard(ExManagerWindow::Move(int Posx,int Posy))
    00121         m_WindowPosX=Posx;
    00122         m_WindowPosY=Posy;
    00123         glutPositionWindow(Posx,Posy);
    00124 UnGuard
    00125 }

void ExManager::Reload | ( | void |  | ) | `[virtual, inherited]`

| Redéfinie dans ExManagerCollision, ExManagerAnimation, ExManagerEntity, ExManagerModel, ExManagerObject< TypeA >, ExManagerTexture, ExManagerObject< ExCAnimation >, ExManagerObject< ExCModel * >, ExManagerObject< ExCWindow >, ExManagerObject< ExCVertexProgram >, ExManagerObject< ExCLight >, ExManagerObject< ExCLoadingAnimation >, ExManagerObject< ExCInterface >, ExManagerObject< ExCSound >, ExManagerObject< ExCCamera * >, ExManagerObject< ExCFont >, ExManagerObject< ExCGizmo >, ExManagerObject< ExCMesh * >, ExManagerObject< ExCTexture >, ExManagerObject< ExCEntity * >, ExManagerObject< ExCSystemeParticule >, et ExManagerObject< ExCSpirit >. Définition à la ligne 33 du fichier ExManager.cpp. Référencé par ExManagerCommand::ProcesExCAction().
    00034 {}

void ExManagerWindow::Reset | ( | void |  | ) | `[inline, virtual]`

| Redéfinie à partir de ExManager. Définition à la ligne 129 du fichier ExManagerWindow.h.
    00129 {return;}

void ExManager::SetAskForCommand | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 87 du fichier ExManager.h. Références ExManager::m_AskForCommand. Référencé par ExManagerConsole::ExManagerConsole(), ExManagerModel::ExManagerModel(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), ExManagerLoad::LoadSetOfFile(), et ExManagerNetwork::Say().
    00087 {m_AskForCommand=status;}

void ExManager::SetAskForExclusifCommand | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 88 du fichier ExManager.h. Références ExManager::m_Exclusif. Référencé par ExManagerConsole::ExManagerConsole(), ExManagerModel::ExManagerModel(), ExManagerObjectWindow::Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), et ExManagerNetwork::Say().
    00088 {m_Exclusif=status;}

void ExManagerWindow::SetBits | ( | int | Bits | ) | `[inline]`

| Définition à la ligne 108 du fichier ExManagerWindow.h. Références m_Bits. Référencé par InputAction().
    00108 {m_Bits=Bits;}

void ExManagerWindow::SetCursor | ( | int | Cursor | ) |

| Définition à la ligne 153 du fichier ExManagerWindow.cpp. Références Guard, SetCursor(), et UnGuard. Référencé par CreateNewWindow(), et SetCursor().
    00153                                          {
    00154 Guard(ExManagerWindow::SetCursor(int Cursor))
    00155         glutSetCursor(Cursor);
    00156 UnGuard
    00157 }

void ExManager::SetFlux | ( | std::ostrstream * | consol,
|  | ExCFluxAction * | action
| ) | `[inherited]`

| Définition à la ligne 35 du fichier ExManager.cpp. Références ExManager::Consol, et ExManager::FluxAction. Référencé par SetManagerLink().
    00036 {
    00037         Consol=consol;
    00038         FluxAction=action;
    00039 }

void ExManagerWindow::SetFpsState | ( | bool | state | ) | `[inline]`

| Définition à la ligne 123 du fichier ExManagerWindow.h. Références m_ShowFps. Référencé par InputAction().
    00123 {m_ShowFps=state;}

void ExManagerWindow::SetFullScreen | ( | bool | State | ) | `[inline]`

| Définition à la ligne 109 du fichier ExManagerWindow.h. Références m_FullScreen. Référencé par InputAction(), et main().
    00109 {m_FullScreen=State;}

void ExManagerWindow::SetGrilleState | ( | bool | state | ) | `[inline]`

| Définition à la ligne 121 du fichier ExManagerWindow.h. Références m_ShowGrille. Référencé par InputAction().
    00121 {m_ShowGrille=state;}

void ExManagerWindow::SetIconTitle | ( | char * | Title | ) |

| Définition à la ligne 145 du fichier ExManagerWindow.cpp. Références Guard, m_IconTitle, SetIconTitle(), et UnGuard. Référencé par SetIconTitle().
    00145                                              {
    00146 Guard(ExManagerWindow::SetIconTitle(char *Title))
    00147         m_IconTitle=new char[strlen(Title)];
    00148         sprintf(m_IconTitle,"%s",Title);
    00149         glutSetIconTitle(m_IconTitle);
    00150 UnGuard
    00151 }

void ExManagerWindow::SetRate | ( | int | Rate | ) | `[inline]`

| Définition à la ligne 107 du fichier ExManagerWindow.h. Références m_Rate.
    00107 {m_Rate=Rate;}

void ExManagerWindow::SetResolution | ( | int | SizeX,
|  | int | SizeY
| ) |

| Définition à la ligne 128 du fichier ExManagerWindow.cpp. Références Guard, m_WindowSizeX, m_WindowSizeXOld, m_WindowSizeY, m_WindowSizeYOld, SetResolution(), et UnGuard. Référencé par InputAction(), ExManagerOutput::Reshape(), et SetResolution().
    00128                                                       {
    00129 Guard(ExManagerWindow::SetResolution(int SizeX,int SizeY))
    00130         m_WindowSizeXOld=m_WindowSizeX;
    00131         m_WindowSizeYOld=m_WindowSizeY;
    00132         m_WindowSizeX=SizeX;
    00133         m_WindowSizeY=SizeY;
    00134 UnGuard
    00135 }

void ExManager::SetStatus | ( | bool | status | ) | `[inline, inherited]`

| Définition à la ligne 86 du fichier ExManager.h. Références ExManager::m_Status. Référencé par ExManagerConsole::Draw(), ExManagerConsole::ExManagerConsole(), ExManagerObjectWindow::Init(), ExManagerInterface::Init(), ExManagerConsole::InputAction(), ExManagerLoad::LoadSetOfFile(), et ExManagerConsole::SetConsoleState().
    00086 {m_Status=status;}

void ExManagerWindow::SetWindowTitle | ( | char * | Title | ) |

| Définition à la ligne 137 du fichier ExManagerWindow.cpp. Références Guard, m_Title, SetWindowTitle(), et UnGuard. Référencé par SetWindowTitle().
    00137                                                {
    00138 Guard(ExManagerWindow::SetWindowTitle(char *Title))
    00139         m_Title = new char[strlen(Title)];
    00140         sprintf(m_Title,"%s",Title);
    00141         glutSetWindowTitle(m_Title);
    00142 UnGuard
    00143 }

void ExManagerWindow::ShowFps | ( | void |  | ) |

| Définition à la ligne 200 du fichier ExManagerWindow.cpp. Références ExNihilo::DrawCadre(), frame, Guard, m_Title, s, ShowFps(), timebase, timeframe, UnGuard, et ExNihilo::WriteToScreen(). Référencé par ExManagerOutput::DrawScene(), et ShowFps().
    00201 {
    00202 Guard(void ExManagerWindow::ShowFps(void))
    00203         frame++;
    00204         timeframe=glutGet(GLUT_ELAPSED_TIME);
    00205         if (timeframe - timebase > 1000)
    00206         {
    00207                 sprintf(s,"FPS:%4.2f",frame*1000.0/(timeframe-timebase));
    00208                 timebase = timeframe;
    00209                 frame = 0;
    00210         }
    00211         char TimeSinceStart[30];
    00212         sprintf(TimeSinceStart,"Time since start:%f",(double)((double)glutGet(GLUT_ELAPSED_TIME)/1000));
    00213         ExNihilo::DrawCadre(15,10,165,50,0.2f,0.0f,0.6f,0.9f);
    00214         ExNihilo::WriteToScreen(18,25,1,1,1,m_Title);
    00215         ExNihilo::WriteToScreen(18,40,1,1,1,s);
    00216         ExNihilo::WriteToScreen(18,55,1,1,1,TimeSinceStart);
    00217
    00218 UnGuard
    00219 }

void ExManagerWindow::ShowNetStat | ( | void |  | ) |

## Documentation des données imbriquées

std::ostrstream* ExManager::Consol`[inherited]`

| Définition à la ligne 73 du fichier ExManager.h. Référencé par ExManagerObject< TypeA >::Add(), ExManagerConsole::AddStringAction(), ExManagerConsole::ApplyBuffCommand(), ExManagerInputGLUT::CheckInput(), ExManagerSound::DisplayAviableInput(), ExManagerInputGLUT::DisplayAviableInput(), ExManagerLoad::DisplayFileType(), ExManagerLoad::GetFileType(), ExManagerVertexArrays::Init(), ExManagerTexture::Init(), ExManagerSound::Init(), ExManagerFog::Init(), ExManagerSound::InputAction(), ExManagerPVS::InputAction(), ExManagerParticuleSystem::InputAction(), ExManagerModel::InputAction(), ExManagerMesh::InputAction(), ExManagerMap::InputAction(), ExManagerLoad::InputAction(), ExManagerInterface::InputAction(), ExManagerFog::InputAction(), ExManagerEntity::InputAction(), ExManagerConsole::InputAction(), ExManagerCommand::InputAction(), ExManagerCamera::InputAction(), ExManagerAnimation::InputAction(), ExManagerObject< TypeA >::List(), ExManagerModel::List(), ExManagerId::List(), ExManagerConsole::ListConsoleCommand(), ExManagerTexture::Load(), ExManagerParticuleSystem::Load(), ExManagerModel::Load(), ExManagerInterface::Load(), ExManagerTexture::LoadCubeMap(), ExManagerLoad::LoadSetOfFile(), ExManagerSound::LoadSound(), ExManagerSound::PauseSound(), ExManagerSound::PlaySound(), ExManagerCommand::ProcesExCAction(), ExManagerId::RecordObject(), ExManager::SetFlux(), ExManagerSound::SetRepeatSound(), ExManagerSound::StopSound(), ExManagerConsole::UpdateConsolBuffer(), et ExManagerConsole::Write().

ExCFluxAction* ExManager::FluxAction`[inherited]`

| Définition à la ligne 74 du fichier ExManager.h. Référencé par Apply(), ExManagerCommand::ApplyAction(), ExManagerCommand::LoadExecFile(), ExManagerId::RecordObject(), ExManager::SetFlux(), et ExManagerSpecialEffect::Specialeffect().

int ExManagerWindow::frame`[private]`

| Définition à la ligne 86 du fichier ExManagerWindow.h. Référencé par ShowFps().

void(* ExManagerWindow::GlutCallBack)()

| Référencé par Apply(), et PreInitManager().

bool ExManager::m_AskForCommand`[protected, inherited]`

| Définition à la ligne 70 du fichier ExManager.h. Référencé par ExManager::AskForCommand(), ExManagerConsole::ExManagerConsole(), et ExManager::SetAskForCommand().

int ExManagerWindow::m_Bits`[private]`

| Définition à la ligne 77 du fichier ExManagerWindow.h. Référencé par Apply(), ExManagerWindow(), GetBits(), et SetBits().

int ExManagerWindow::m_Cursor`[private]`

| Définition à la ligne 83 du fichier ExManagerWindow.h. Référencé par CreateNewWindow(), et ExManagerWindow().

bool ExManager::m_Exclusif`[protected, inherited]`

| Définition à la ligne 71 du fichier ExManager.h. Référencé par ExManager::AskForExclusifCommand(), et ExManager::SetAskForExclusifCommand().

bool ExManagerWindow::m_flag = false`[static, private]`

| Définition à la ligne 26 du fichier ExManagerWindow.cpp. Référencé par CreateSingleton(), et ~ExManagerWindow().

bool ExManagerWindow::m_FullScreen`[private]`

| Définition à la ligne 79 du fichier ExManagerWindow.h. Référencé par Apply(), ExManagerWindow(), GetFullScreen(), et SetFullScreen().

char* ExManagerWindow::m_IconTitle`[private]`

| Définition à la ligne 82 du fichier ExManagerWindow.h. Référencé par CreateNewWindow(), ExManagerWindow(), et SetIconTitle().

ExManagerWindow * ExManagerWindow::m_instance = NULL`[static, private]`

| Définition à la ligne 27 du fichier ExManagerWindow.cpp. Référencé par CreateSingleton().

bool ExManagerWindow::m_OldMode`[private]`

| Définition à la ligne 80 du fichier ExManagerWindow.h. Référencé par Apply(), et ExManagerWindow().

int ExManagerWindow::m_Rate`[private]`

| Définition à la ligne 78 du fichier ExManagerWindow.h. Référencé par Apply(), ExManagerWindow(), GetRate(), et SetRate().

bool ExManagerWindow::m_ShowFps`[private]`

| Définition à la ligne 85 du fichier ExManagerWindow.h. Référencé par ExManagerWindow(), GetFpsState(), et SetFpsState().

bool ExManagerWindow::m_ShowGrille`[private]`

| Définition à la ligne 84 du fichier ExManagerWindow.h. Référencé par ExManagerWindow(), GetGrilleState(), et SetGrilleState().

bool ExManager::m_Status`[protected, inherited]`

| Définition à la ligne 69 du fichier ExManager.h. Référencé par ExManager::GetStatus(), et ExManager::SetStatus().

char* ExManagerWindow::m_Title`[private]`

| Définition à la ligne 81 du fichier ExManagerWindow.h. Référencé par Apply(), CreateNewWindow(), ExManagerWindow(), SetWindowTitle(), et ShowFps().

int ExManagerWindow::m_WindowHandler`[private]`

| Définition à la ligne 70 du fichier ExManagerWindow.h. Référencé par Apply(), et CreateNewWindow().

int ExManagerWindow::m_WindowPosX`[private]`

| Définition à la ligne 75 du fichier ExManagerWindow.h. Référencé par Apply(), CreateNewWindow(), ExManagerWindow(), et Move().

int ExManagerWindow::m_WindowPosY`[private]`

| Définition à la ligne 76 du fichier ExManagerWindow.h. Référencé par Apply(), CreateNewWindow(), ExManagerWindow(), et Move().

int ExManagerWindow::m_WindowSizeX`[private]`

| Définition à la ligne 71 du fichier ExManagerWindow.h. Référencé par Apply(), CreateNewWindow(), ExManagerWindow(), GetResolutionX(), et SetResolution().

int ExManagerWindow::m_WindowSizeXOld`[private]`

| Définition à la ligne 73 du fichier ExManagerWindow.h. Référencé par CreateNewWindow(), ExManagerWindow(), et SetResolution().

int ExManagerWindow::m_WindowSizeY`[private]`

| Définition à la ligne 72 du fichier ExManagerWindow.h. Référencé par Apply(), CreateNewWindow(), ExManagerWindow(), GetResolutionY(), et SetResolution().

int ExManagerWindow::m_WindowSizeYOld`[private]`

| Définition à la ligne 74 du fichier ExManagerWindow.h. Référencé par CreateNewWindow(), ExManagerWindow(), et SetResolution().

char ExManagerWindow::s[30]`[private]`

| Définition à la ligne 89 du fichier ExManagerWindow.h. Référencé par ShowFps().

int ExManagerWindow::timebase`[private]`

| Définition à la ligne 88 du fichier ExManagerWindow.h. Référencé par ShowFps().

int ExManagerWindow::timeframe`[private]`

| Définition à la ligne 87 du fichier ExManagerWindow.h. Référencé par ShowFps().

La documentation associée à cette classe a été générée à partir des fichiers suivants :

- ExManagerWindow.h
- ExManagerWindow.cpp