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 ExManagerObjectWindow

`#include <ExManagerObjectWindow.h>`

Graphe d'héritage de la classe ExManagerObjectWindow

## Membres publics
void | SetManagerTexture (ExManagerTexture *Texture)
void | SetManagerWindow (ExManagerWindow *Window)
void | Reset (void)
void | Init (void)
void | Draw (void)
ExCAction | InputAction (ExCAction Action)
ExCAction | InputCommand (ExCCommand Command)
bool | SetCurrentObject (ExNihilo::ExId id)
bool | Load (std::string FileName)
void | SetSizeWhenMinimized (float value)
float | GetSizeWhenMinimized (void)
void | SetManagerId (ExManagerId *Id)
void | Init (std::string FileName)
void | Reload (void)
void | List (void)
bool | Add (ExCWindowobject)
bool | Add (std::string FileName)
bool | Remove (ExNihilo::ExId id)
bool | Remove (std::string Name)
bool | RemoveCurrentObject (void)
ExCWindow * | GetObject (ExNihilo::ExId id)
ExCWindow * | GetObject (std::string Name)
ExCWindow * | GetCurrentObject (void)
ExCWindow * | GetFirstObject (void)
ExCWindow * | GetLastObject (void)
ExNihilo::ExId | GetFirstObjectId (void)
ExNihilo::ExId | GetLasstObjectId (void)
bool | SetCurrentObject (std::string Name)
ExNihilo::ExId | NextObject (void)
ExNihilo::ExId | PreviousObject (void)
unsigned int | GetNumberObject (void)
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)
## Membres publics statiques
ExManagerObjectWindow * | CreateSingleton (void)
## Attributs Publics
std::ostrstream * | Consol
ExCFluxAction * | FluxAction
## Attributs Protégés
std::map< ExNihilo::ExId, ExCWindow, std::less< ExNihilo::ExId > > * | m_Map
std::map< ExNihilo::ExId, ExCWindow, std::less< ExNihilo::ExId > >::iterator | m_ItMap
ExManagerId * | ManagerId
ExNihilo::ExId | m_CurrentObjectId
bool | m_Status
bool | m_AskForCommand
bool | m_Exclusif
## Membres privés
| ExManagerObjectWindow (void)
| ~ExManagerObjectWindow (void)
void | OrganizeMinimizedWindow (void)
void | ReadWindowObject (ExCWindowObject *win, std::ifstream *file)
std::string | ReadWindowObject (ExCWindowObject *win, std::string FileName)
std::string | ReadWindowObject (ExCWindowObject *win, std::string FileName, std::ifstream *fileReturn)
void | ReadWindowSubObject (ExCWindow *win, std::string FileName)
ExCWindowControl * | ReadWindowControlObject (ExCWindowObject *win, std::string FileName)
## Attributs Privés
bool | m_MoveWindow
ExCVec2D | m_MovePointerShift
ExCCommand | m_LastCommandReceived
float | m_SizeWhenMinimized
bool | m_DrawAllWindow
ExManagerTexture * | ManagerTexture
ExManagerWindow * | ManagerWindow
ExCWindow * | ModalWindow
## Attributs Privés Statiques
bool | m_flag = false
ExManagerObjectWindow * | m_instance = NULL

## Documentation des contructeurs et destructeurs

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

| Définition à la ligne 42 du fichier ExManagerObjectWindow.cpp. Références ExManagerObjectWindow(), Guard, et UnGuard. Référencé par ExManagerObjectWindow(), et ~ExManagerObjectWindow().
    00043 {
    00044 Guard(ExManagerObjectWindow::ExManagerObjectWindow(void))
    00045
    00046 UnGuard
    00047 }

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

| Définition à la ligne 50 du fichier ExManagerObjectWindow.cpp. Références ExManagerObjectWindow(), Guard, et UnGuard.
    00051 {
    00052 Guard(ExManagerObjectWindow::~ExManagerObjectWindow(void))
    00053 UnGuard
    00054 }

## Documentation des méthodes

bool ExManagerObject< ExCWindow >::Add | ( | std::string | FileName | ) | `[inherited]`

bool ExManagerObject< ExCWindow >::Add | ( | ExCWindow | object | ) | `[inherited]`

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;}

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

| Définition à la ligne 28 du fichier ExManagerObjectWindow.cpp. Références CreateSingleton(), Guard, m_flag, m_instance, et UnGuard. Référencé par CreateManager(), et CreateSingleton().
    00028                                                                  {
    00029 Guard(ExManagerObjectWindow* ExManagerObjectWindow::CreateSingleton(void))
    00030         if(!m_flag)
    00031         {
    00032                 m_flag = true; // We are creating the error log now, so set flag to true
    00033                 m_instance = new ExManagerObjectWindow; // Create the error log
    00034         }else
    00035         {
    00036                 std::cout<<"Error singleton already created"<<std::endl;
    00037         }
    00038         return m_instance;
    00039 UnGuard
    00040 }

void ExManagerObjectWindow::Draw | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCWindow >. Définition à la ligne 93 du fichier ExManagerObjectWindow.cpp. Références ExCWindow::Draw(), Draw(), ExManagerObject< ExCWindow >::GetCurrentObject(), Guard, ExCWindow::m_BeClosed, ExManagerObject< ExCWindow >::m_CurrentObjectId, m_DrawAllWindow, ExManagerObject< ExCWindow >::m_ItMap, ExManagerObject< ExCWindow >::m_Map, ModalWindow, et UnGuard. Référencé par Draw(), et ExManagerOutput::DrawScene().
    00094 {
    00095 Guard(void  ExManagerObjectWindow::Draw(void))
    00096 glPushAttrib(GL_ALL_ATTRIB_BITS);
    00097 glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
    00098         if(m_DrawAllWindow)
    00099         {
    00100                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00101                 {
    00102                         if(!m_ItMap->second.IsActive())
    00103                         {
    00104                                 m_ItMap->second.Draw();
    00105                         }
    00106                 }
    00107                 if(m_CurrentObjectId!=-1)GetCurrentObject()->Draw();
    00108         }
    00109         if(ModalWindow!=NULL)
    00110         {
    00111                 ModalWindow->Draw();
    00112                 if(ModalWindow->m_BeClosed)
    00113                 {
    00114                         delete ModalWindow;
    00115                         ModalWindow=NULL;
    00116                 }
    00117         }
    00118 glPopAttrib();
    00119
    00120 UnGuard
    00121 }

ExCWindow * ExManagerObject< ExCWindow >::GetCurrentObject | ( | void |  | ) | `[inherited]`

| Référencé par Draw(), InputAction(), InputCommand(), OrganizeMinimizedWindow(), et SetCurrentObject().

ExCWindow * ExManagerObject< ExCWindow >::GetFirstObject | ( | void |  | ) | `[inherited]`

ExNihilo::ExId ExManagerObject< ExCWindow >::GetFirstObjectId | ( | void |  | ) | `[inherited]`

ExNihilo::ExId ExManagerObject< ExCWindow >::GetLasstObjectId | ( | void |  | ) | `[inherited]`

ExCWindow * ExManagerObject< ExCWindow >::GetLastObject | ( | void |  | ) | `[inherited]`

unsigned int ExManagerObject< ExCWindow >::GetNumberObject | ( | void |  | ) | `[inline, inherited]`

| Définition à la ligne 124 du fichier ExManagerObject.h.
    00124 {return m_Map->size();}

ExCWindow * ExManagerObject< ExCWindow >::GetObject | ( | std::string | Name | ) | `[inherited]`

ExCWindow * ExManagerObject< ExCWindow >::GetObject | ( | ExNihilo::ExId | id | ) | `[inherited]`

float ExManagerObjectWindow::GetSizeWhenMinimized | ( | void |  | ) | `[inline]`

| Définition à la ligne 120 du fichier ExManagerObjectWindow.h. Références m_SizeWhenMinimized.
    00120 { return m_SizeWhenMinimized;}

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 ExManagerObject< ExCWindow >::Init | ( | std::string | FileName | ) | `[inherited]`

void ExManagerObjectWindow::Init | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCWindow >. Définition à la ligne 68 du fichier ExManagerObjectWindow.cpp. Références Guard, ExManagerObject< TypeA >::Init(), Init(), Load(), m_DrawAllWindow, m_MoveWindow, m_SizeWhenMinimized, ModalWindow, ExManager::SetAskForCommand(), ExManager::SetAskForExclusifCommand(), ExManager::SetStatus(), et UnGuard. Référencé par Init(), et PreInitManager().
    00069 {
    00070 Guard(void  ExManagerObjectWindow::Init(void))
    00071         SetStatus(true);
    00072         SetAskForCommand(true);
    00073         SetAskForExclusifCommand(false);
    00074         ExManagerObject<ExCWindow>::Init();
    00075
    00076 /*      ExCWindow Win2(ExCVec2D(600,300),ExCVec2D(200,350),"TEST2");
    00077         Win2.SetManagerTexture(ManagerTexture);
    00078         Win2.SetManagerWindow(ManagerWindow);
    00079         Win2.GetWindowContentPointer()->SetBackroundTexturing1(true,"earth.bmp");
    00080         Win2.GetWindowContentPointer()->SetBackroundTexturing2(true,"fog.bmp");
    00081         ExManagerObject<ExCWindow>::Add(Win2);
    00082         */
    00083         Load("WindowMainMenu.ExW");
    00084         //Load("wlotr.ExW");
    00085
    00086         m_MoveWindow=false;
    00087         ModalWindow=NULL;
    00088         m_SizeWhenMinimized=150;
    00089         m_DrawAllWindow=true;
    00090 UnGuard
    00091 }

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

| Redéfinie à partir de ExManager. Définition à la ligne 213 du fichier ExManagerObjectWindow.cpp. Références CLOSE_OBJECT_WINDOW, DISABLE_WINDOW, ENABLE_WINDOW, ExManagerObject< ExCWindow >::GetCurrentObject(), ExCAction::GetParamAsInt(), ExCObject2D::GetPosition(), ExManagerWindow::GetResolutionX(), ExManagerWindow::GetResolutionY(), Guard, InputAction(), ExCWindow::IsMaximized(), ExCWindow::IsReduced(), ExCWindow::IsShowWindowContent(), Load(), LOAD_OBJECT_WINDOW, ExCAction::m_Action, ExManagerObject< ExCWindow >::m_CurrentObjectId, m_DrawAllWindow, m_LastCommandReceived, ExManagerObject< ExCWindow >::m_Map, ExCCommand::m_MousePosx, ExCCommand::m_MousePosy, m_MovePointerShift, m_MoveWindow, ExCAction::m_NextAction, ExCAction::m_Param, ManagerTexture, ManagerWindow, MAXIMIZE_OBJECT_WINDOW, MESSAGE_BOX, MESSAGE_BOX_QUESTION, MINIMIZE_OBJECT_WINDOW, MINIMIZE_TO_BAR_OBJECT_WINDOW, ModalWindow, MOUVE_OBJECT_WINDOW, NOTHING, OrganizeMinimizedWindow(), ExManagerObject< ExCWindow >::RemoveCurrentObject(), ExCWindow::SetManagerTexture(), ExCWindowObject::SetManagerWindow(), ExCWindow::SetMaximized(), ExCWindow::SetOldPosition(), ExCWindow::SetOldWindowSize(), ExCWindow::SetReduced(), ExCWindow::SetShowWindowContent(), ExCWindow::SetWindowOldTitle(), ExCWindow::SetWindowPosition(), ExCWindow::SetWindowSize(), ExCWindow::SetWindowTitle(), TOGGLE_WINDOW, et UnGuard. Référencé par InputAction(), InputCommand(), et ExManagerCommand::ProcesExCAction().
    00214 {
    00215 Guard(ExCAction ExManagerObjectWindow::InputAction(ExCAction Action))
    00216         //std::cout<<"Receive action :"<<Action<<std::endl;
    00217         ExCVec2D TmpSize,TmpPos;
    00218         switch(Action.m_Action)
    00219     {
    00220         case CLOSE_OBJECT_WINDOW:
    00221                 if(ModalWindow!=NULL)
    00222                 {
    00223                         delete ModalWindow;
    00224                         ModalWindow=NULL;
    00225                         return NOTHING;
    00226                 }
    00227                 //check were we are are (button) bar window content
    00228                 if(m_CurrentObjectId==-1) return NOTHING;
    00229                 std::cout<<"Close window id:"<<m_CurrentObjectId<<std::endl;
    00230                 if(RemoveCurrentObject())
    00231                 {
    00232                         std::cout<<"Close window succes"<<std::endl;
    00233                 }else std::cout<<"Close window fail"<<std::endl;
    00234                 return NOTHING;
    00235
    00236         case MINIMIZE_OBJECT_WINDOW:
    00237                 //std::cout<<"Minimize window id:"<<m_CurrentObjectId<<std::endl;
    00238
    00239                 if(!GetCurrentObject()->IsReduced())
    00240                 {
    00241                         if(!GetCurrentObject()->IsMaximized())
    00242                         {
    00243                                 GetCurrentObject()->SetOldWindowSize(GetCurrentObject()->GetWindowSize());
    00244                                 GetCurrentObject()->SetOldPosition(GetCurrentObject()->GetPosition());
    00245                         }
    00246                         if(GetCurrentObject()->IsShowWindowContent())
    00247                         {
    00248                                 //GetCurrentObject()->SetShowWindowContent(false);
    00249                         }
    00250                         GetCurrentObject()->SetReduced(true);
    00251                         GetCurrentObject()->SetWindowOldTitle(GetCurrentObject()->GetWindowTitle());
    00252                         std::string ShortName(GetCurrentObject()->GetWindowTitle());
    00253                         ShortName.resize(10);
    00254                         ShortName.replace(6,4,"...");
    00255                         GetCurrentObject()->SetWindowTitle(ShortName);
    00256                         OrganizeMinimizedWindow();
    00257                 }else
    00258                 {
    00259                         GetCurrentObject()->SetWindowSize(ExCVec2D(GetCurrentObject()->GetOldWindowSize()));
    00260                         GetCurrentObject()->SetWindowPosition(ExCVec2D(GetCurrentObject()->GetOldPosition()));
    00261                         GetCurrentObject()->SetWindowTitle(GetCurrentObject()->GetWindowOldTitle());
    00262                         GetCurrentObject()->SetReduced(false);
    00263                         if(!GetCurrentObject()->IsShowWindowContent())
    00264                         {
    00265                                 GetCurrentObject()->SetShowWindowContent(true);
    00266                         }
    00267                 }
    00268
    00269                 return NOTHING;
    00270         case MAXIMIZE_OBJECT_WINDOW:
    00271                 //std::cout<<"MAximize window id:"<<m_CurrentObjectId<<std::endl;
    00272                 if(!GetCurrentObject()->IsMaximized())
    00273                 {
    00274                         if(!GetCurrentObject()->IsReduced())
    00275                         {
    00276                                 GetCurrentObject()->SetOldWindowSize(GetCurrentObject()->GetWindowSize());
    00277                                 GetCurrentObject()->SetOldPosition(GetCurrentObject()->GetPosition());
    00278                         }
    00279                         GetCurrentObject()->SetWindowSize(ExCVec2D(ManagerWindow->GetResolutionX(),ManagerWindow->GetResolutionY()));
    00280                         GetCurrentObject()->SetWindowPosition(ExCVec2D(0,0));
    00281                         GetCurrentObject()->SetMaximized(true);
    00282                         if(!GetCurrentObject()->IsShowWindowContent())
    00283                         {
    00284                                 GetCurrentObject()->SetShowWindowContent(true);
    00285                         }
    00286                         break;
    00287                 }else
    00288                 {
    00289                         GetCurrentObject()->SetWindowSize(ExCVec2D(GetCurrentObject()->GetOldWindowSize()));
    00290                         GetCurrentObject()->SetWindowPosition(ExCVec2D(GetCurrentObject()->GetOldPosition()));
    00291                         GetCurrentObject()->SetMaximized(false);
    00292                 }
    00293                 return NOTHING;
    00294         case MINIMIZE_TO_BAR_OBJECT_WINDOW:
    00295                 //std::cout<<"Minimize to bar window id:"<<m_CurrentObjectId<<std::endl;
    00296                 if(GetCurrentObject()->IsShowWindowContent())
    00297                 {
    00298                 //GetCurrentObject()->SetShowWindowContent(false);
    00299                 }else GetCurrentObject()->SetShowWindowContent(true);
    00300                 return NOTHING;
    00301         case MOUVE_OBJECT_WINDOW:
    00302                 std::cout<<"Move window:"<<m_CurrentObjectId<<std::endl;
    00303                 m_MovePointerShift=((ExCVec2D(m_LastCommandReceived.m_MousePosx,m_LastCommandReceived.m_MousePosy)-GetCurrentObject()->GetPosition()));
    00304                 m_MoveWindow=true;
    00305                 return NOTHING;
    00306         case MESSAGE_BOX:
    00307                 ModalWindow= new ExCWindowMessageBox(Action.m_Param);
    00308                 ModalWindow->SetManagerTexture(ManagerTexture);
    00309                 ModalWindow->SetManagerWindow(ManagerWindow);
    00310                 break;
    00311         case MESSAGE_BOX_QUESTION:
    00312                 ModalWindow= new ExCWindowMessageBoxQuestion(Action.m_Param,Action.GetParamAsInt(1),Action.GetParamAsInt(2));
    00313                 ModalWindow->SetManagerTexture(ManagerTexture);
    00314                 ModalWindow->SetManagerWindow(ManagerWindow);
    00315                 break;
    00316         case LOAD_OBJECT_WINDOW:
    00317                 Load(Action.m_Param);
    00318                 /*m_ItMap=m_Map->end();
    00319                 if(m_CurrentObjectId!=-1)
    00320                 GetCurrentObject()->SetActive(false);
    00321                 SetCurrentObject(m_ItMap->second.GetId());
    00322                 //GetCurrentObject()->SetActive(true);
    00323                 std::cout<<"plok"<<std::endl;*/
    00324                 break;
    00325         case ENABLE_WINDOW:
    00326                 m_DrawAllWindow=true;
    00327                 if(m_Map->size()==0)Load("WindowMainMenu.ExW");
    00328                 //if(m_Map->size()==0)Load("wlotr.ExW");
    00329                 break;
    00330         case DISABLE_WINDOW:
    00331                 m_DrawAllWindow=false;
    00332                 break;
    00333         case TOGGLE_WINDOW:
    00334                 m_DrawAllWindow ? m_DrawAllWindow=false :m_DrawAllWindow=true;
    00335                 break;
    00336         default:
    00337                 return Action;
    00338         }
    00339         if(Action.m_NextAction){return *Action.m_NextAction;}
    00340         else{return NOTHING;}
    00341 UnGuard
    00342 }

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

| Redéfinie à partir de ExManager. Définition à la ligne 123 du fichier ExManagerObjectWindow.cpp. Références ExManagerObject< ExCWindow >::GetCurrentObject(), Guard, InputAction(), ExCWindow::InputCommand(), InputCommand(), ExManagerObject< ExCWindow >::m_CurrentObjectId, m_DrawAllWindow, ExManagerObject< ExCWindow >::m_ItMap, m_LastCommandReceived, ExManagerObject< ExCWindow >::m_Map, m_MovePointerShift, m_MoveWindow, ModalWindow, MOUSE_LEFT_BUTTON_DOWN, MOUSE_LEFT_BUTTON_UP, MOUSE_MOTION, NOTHING, ExCWindow::PointInWindow(), ExCWindow::SetActive(), SetCurrentObject(), ExCWindow::SetWindowPosition(), et UnGuard. Référencé par InputCommand(), et ExManagerCommand::InputCommand().
    00124 {
    00125 Guard(ExCAction ExManagerObjectWindow::InputCommand(ExCCommand Command))
    00126         //std::cout<<"ExManagerObjectWindow::Input Command window:"<<Command.m_Command<<std::endl;
    00127         if(ModalWindow!=NULL)
    00128         {
    00129                 return InputAction(ModalWindow->InputCommand(Command));
    00130         }
    00131
    00132         m_LastCommandReceived=Command;
    00133         switch(Command.m_Command)
    00134         {
    00135         /*case MOUSE_RIGHT_BUTTON_DOWN:
    00136                 m_DrawAllWindow ? m_DrawAllWindow=false :m_DrawAllWindow=true;
    00137         break;*/
    00138         case MOUSE_LEFT_BUTTON_DOWN:
    00139         //Search for the good window to activate
    00140                 if(!m_DrawAllWindow) return NOTHING;
    00141                 if(m_CurrentObjectId!=-1)
    00142                 {
    00143                         if(GetCurrentObject()->PointInWindow(ExCVec2D(Command.m_MousePosx,Command.m_MousePosy)))break;
    00144                 }
    00145                 for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00146                 {
    00147                         if(m_ItMap->second.PointInWindow(ExCVec2D(Command.m_MousePosx,Command.m_MousePosy)))
    00148                         {
    00149
    00150                                 //if(!GetCurrentObject()->PointInWindow(ExCVec2D(Command.m_MousePosx,Command.m_MousePosy)))
    00151                                 //{
    00152                                         if(m_CurrentObjectId!=-1)GetCurrentObject()->SetActive(false);
    00153                                         SetCurrentObject(m_ItMap->second.GetId());
    00154                                         GetCurrentObject()->SetActive(true);
    00155                                 //}
    00156                         }
    00157                 }
    00158                 break;
    00159         case MOUSE_LEFT_BUTTON_UP:
    00160                 if(m_MoveWindow)
    00161                 {
    00162                         GetCurrentObject()->SetWindowPosition(ExCVec2D(Command.m_MousePosx,Command.m_MousePosy)-m_MovePointerShift);
    00163                         m_MoveWindow=false;
    00164                 }
    00165         case MOUSE_MOTION:
    00166                 if(m_MoveWindow)
    00167                 {
    00168                         GetCurrentObject()->SetWindowPosition(ExCVec2D(Command.m_MousePosx,Command.m_MousePosy)-m_MovePointerShift);
    00169
    00170                 }
    00171                 break;
    00172         }
    00173         //find the correct window to send the message
    00174         if(m_CurrentObjectId==-1)return NOTHING;//there is no active window
    00175         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00176         {
    00177                 if(m_ItMap->second.IsActive())
    00178                 {
    00179                         if(m_ItMap->second.PointInWindow(ExCVec2D(Command.m_MousePosx,Command.m_MousePosy)))
    00180                         {
    00181                                 return InputAction(m_ItMap->second.InputCommand(Command));
    00182                         }
    00183                 }
    00184         }
    00185
    00186
    00187         return NOTHING;
    00188 UnGuard
    00189 }

void ExManagerObject< ExCWindow >::List | ( | void |  | ) | `[inherited]`

bool ExManagerObjectWindow::Load | ( | std::string | FileName | ) |

| Redéfinie à partir de ExManagerObject< ExCWindow >. Définition à la ligne 353 du fichier ExManagerObjectWindow.cpp. Références ExManagerObject< TypeA >::Add(), ExNihilo::ExtracValueFromSring(), Guard, Load(), ManagerTexture, ManagerWindow, PREFIX, ReadWindowObject(), ReadWindowSubObject(), ExCWindow::RefreshPosotion(), ExCWindow::RefreshSize(), ExCWindow::SetManagerTexture(), ExCWindowObject::SetManagerWindow(), et UnGuard. Référencé par Init(), InputAction(), ExManagerLoad::InputAction(), Load(), ExManagerLoad::LoadSetOfFile(), et Reset().
    00354 {
    00355 Guard(bool ExManagerObjectWindow::Load(std::string FileName))
    00356         //std::cout<<"Load:"<<FileName<<std::endl;
    00357         char                    buffer[255],b[255];
    00358         std::string buffstring;
    00359         std::ifstream file,fileControl;
    00360         #ifdef UNIX_SRC
    00361                 sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", FileName.data());
    00362         #else
    00363                 sprintf(buffer, "../Data/Window/%s", FileName.data());
    00364         #endif
    00365
    00366         ExCWindow NewWindow;
    00367         file.open(buffer,std::ios::in);
    00368         if(file.is_open())
    00369         {
    00370                 //read header
    00371                 memset(b,0,255);file.getline(b,256,'\n');
    00372                 try
    00373                 {
    00374                         //READ MAIN WINDOW INFO
    00375                         ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00376                         ReadWindowObject(&NewWindow,&file);
    00377                         //READ CONTENT WINDOW INFO
    00378                         memset(b,0,255);file.getline(b,256,'\n');
    00379                         buffstring=ExNihilo::ExtracValueFromSring(b,"<FileForWindow>","<#FileForWindow>");
    00380                         ReadWindowSubObject(&NewWindow,buffstring);
    00381                         //READ BAR WINDOW INFO
    00382                         memset(b,0,255);file.getline(b,256,'\n');
    00383                         buffstring=ExNihilo::ExtracValueFromSring(b,"<FileForBar>","<#FileForBar>");
    00384                         ReadWindowSubObject(&NewWindow,buffstring);
    00385
    00386                 }catch(ExCExpStringNotFound){std::cout<<"Bad file type plok"<<buffer<<std::endl;}
    00387         }else
    00388         {
    00389                 std::cout<<"a pouet"<<buffer<<std::endl;
    00390                 throw   ExCExpFileNotFound();
    00391         }
    00392         file.close();
    00393     NewWindow.RefreshPosotion();
    00394         NewWindow.RefreshSize();
    00395         NewWindow.SetManagerTexture(ManagerTexture);
    00396         NewWindow.SetManagerWindow(ManagerWindow);
    00397         ExManagerObject<ExCWindow>::Add(NewWindow);
    00398         /*m_ItMap=m_Map->end();
    00399         m_ItMap--;
    00400         SetCurrentObject(m_ItMap->second.GetId());
    00401         GetCurrentObject()->SetActive(true);*/
    00402         /*ExCCommand Command;
    00403         Command.m_MousePosx=NewWindow.GetPosition().GetX()+5;
    00404         Command.m_MousePosy=NewWindow.GetPosition().GetY()+5;
    00405         Command.m_Command=MOUSE_LEFT_BUTTON_DOWN;
    00406         InputCommand(Command);*/
    00407         return true;
    00408 UnGuard
    00409 }

ExNihilo::ExId ExManagerObject< ExCWindow >::NextObject | ( | void |  | ) | `[inherited]`

void ExManagerObjectWindow::OrganizeMinimizedWindow | ( | void |  | ) | `[private]`

| Définition à la ligne 191 du fichier ExManagerObjectWindow.cpp. Références ExManagerObject< ExCWindow >::GetCurrentObject(), ExManagerWindow::GetResolutionX(), ExManagerWindow::GetResolutionY(), ExCWindowObject::GetTitleBarSize(), Guard, ExManagerObject< ExCWindow >::m_ItMap, ExManagerObject< ExCWindow >::m_Map, m_SizeWhenMinimized, ManagerWindow, OrganizeMinimizedWindow(), et UnGuard. Référencé par InputAction(), et OrganizeMinimizedWindow().
    00192 {
    00193 Guard(void ExManagerObjectWindow::OrganizeMinimizedWindow(void))
    00194         int couterx=0,coutery=1;
    00195         for(m_ItMap=m_Map->begin();m_ItMap!=m_Map->end();m_ItMap++)
    00196         {
    00197                 if(m_ItMap->second.IsReduced())
    00198                 {
    00199                         m_ItMap->second.SetWindowSize(ExCVec2D((ManagerWindow->GetResolutionX()/(ManagerWindow->GetResolutionX()/m_SizeWhenMinimized)),GetCurrentObject()->GetTitleBarSize()));
    00200                         m_ItMap->second.SetWindowPosition(ExCVec2D((ManagerWindow->GetResolutionX()/(ManagerWindow->GetResolutionX()/m_SizeWhenMinimized))*couterx-1,(ManagerWindow->GetResolutionY()-(GetCurrentObject()->GetTitleBarSize()*coutery-1))));
    00201                         couterx++;
    00202                 }
    00203                 if(couterx>=(ManagerWindow->GetResolutionX()/m_SizeWhenMinimized)-1)
    00204                 {
    00205                         couterx=0;
    00206                         coutery++;
    00207                 }
    00208         }
    00209 UnGuard
    00210 }

ExNihilo::ExId ExManagerObject< ExCWindow >::PreviousObject | ( | void |  | ) | `[inherited]`

ExCWindowControl * ExManagerObjectWindow::ReadWindowControlObject | ( | ExCWindowObject * | win,
|  | std::string | FileName
| ) | `[private]`

| Définition à la ligne 519 du fichier ExManagerObjectWindow.cpp. Références ExCWindowControl::AddActionCommand(), ExNihilo::ExtractIntValueFromSring(), ExNihilo::ExtracValueFromSring(), Guard, ExCWindowButtonSwitch::m_Butt1, ExCWindowButtonSwitch::m_Butt2, ExCAction::m_Param, PREFIX, ReadWindowControlObject(), ReadWindowObject(), ExCWindowButtonSwitchOnMouse::SwitchValue(), ExCWindowButtonSwitch::SwitchValue(), et UnGuard. Référencé par ReadWindowControlObject(), et ReadWindowSubObject().
    00520 {
    00521 Guard(ExCWindowControl *  ExManagerObjectWindow::ReadWindowControlObject(ExCWindowObject *win,std::string FileName))
    00522         char                    buffer[255],b[255];
    00523         std::string buffstring;
    00524         std::ifstream fileControl;
    00525         #ifdef UNIX_SRC
    00526                 sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", FileName.data());
    00527         #else
    00528                 sprintf(buffer, "../Data/Window/%s", FileName.data());
    00529         #endif
    00530         fileControl.open(buffer,std::ios::in);
    00531         if(fileControl.is_open())
    00532         {
    00533                 memset(b,0,255);fileControl.getline(b,256,'\n');
    00534                 buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00535                 // EXCWINDOWLABEL CONTROL
    00536                 if(strcmp(buffstring.data(),"ExCWindowLabel")==0)
    00537                 {
    00538                         ExCWindowLabel *NewLabel;
    00539                         NewLabel= new ExCWindowLabel;
    00540                         ReadWindowObject(NewLabel,&fileControl);
    00541                         win->AddObjectControl(NewLabel);
    00542                 }
    00543                 // EXCWINDOWBUTTON CONTROL
    00544                 if(strcmp(buffstring.data(),"ExCWindowButton")==0)
    00545                 {
    00546                         ExCWindowButton *NewButton;
    00547                         NewButton= new ExCWindowButton;
    00548                         ReadWindowObject(NewButton,&fileControl);
    00549                         //READ ACTION FOR BUTTON
    00550                         memset(b,0,255);fileControl.getline(b,256,'\n');
    00551                         buffstring=ExNihilo::ExtracValueFromSring(b,"<ActionCommand>","<#ActionCommand>");
    00552                         ExCAction Action=ExNihilo::ExtractIntValueFromSring(buffstring,"<Action>","<#Action>");
    00553                         ExCCommand Command=ExNihilo::ExtractIntValueFromSring(buffstring,"<Command>","<#Command>");
    00554                         Action.m_Param=ExNihilo::ExtracValueFromSring(buffstring,"<Param>","<#Param>");
    00555                         NewButton->AddActionCommand(Action,Command);
    00556                         win->AddObjectControl(NewButton);
    00557                 }
    00558                 //EXCWINDOWBUTTONSWITCH CONTROL
    00559                 if(strcmp(buffstring.data(),"ExCWindowButtonSwitch")==0)
    00560                 {
    00561                         std::ifstream fileB1,fileB2;
    00562                         ExCWindowButtonSwitch *NewButton;
    00563                         NewButton= new ExCWindowButtonSwitch;
    00564                         ReadWindowObject(NewButton,&fileControl);
    00565                         ExCWindowButton * Butt1,*Butt2;
    00566                         Butt1=new ExCWindowButton;
    00567                         Butt2=new ExCWindowButton;
    00568
    00569                         //Read Normal Button
    00570                         memset(b,0,255);fileControl.getline(b,256,'\n');
    00571                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Button1>","<#Button1>");
    00572                         ReadWindowObject(Butt1,buffstring,&fileB1);
    00573                         NewButton->m_Butt1=Butt1;
    00574
    00575
    00576                         //Read Alternate Button
    00577                         memset(b,0,255);fileControl.getline(b,256,'\n');
    00578                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Button2>","<#Button2>");
    00579                         ReadWindowObject(Butt2,buffstring,&fileB2);
    00580                         NewButton->m_Butt2=Butt2;
    00581
    00582                         //READ ACTION FOR BUTTON1
    00583                         memset(b,0,255);fileB1.getline(b,256,'\n');
    00584                         buffstring=ExNihilo::ExtracValueFromSring(b,"<ActionCommand>","<#ActionCommand>");
    00585                         ExCAction Action=ExNihilo::ExtractIntValueFromSring(buffstring,"<Action>","<#Action>");
    00586                         ExCCommand Command=ExNihilo::ExtractIntValueFromSring(buffstring,"<Command>","<#Command>");
    00587                         Action.m_Param=ExNihilo::ExtracValueFromSring(buffstring,"<Param>","<#Param>");
    00588                         Butt1->AddActionCommand(Action,Command);
    00589                         fileB1.close();
    00590
    00591                         //READ ACTION FOR BUTTON2
    00592                         memset(b,0,255);fileB2.getline(b,256,'\n');
    00593                         buffstring=ExNihilo::ExtracValueFromSring(b,"<ActionCommand>","<#ActionCommand>");
    00594                         Action=ExNihilo::ExtractIntValueFromSring(buffstring,"<Action>","<#Action>");
    00595                         Command=ExNihilo::ExtractIntValueFromSring(buffstring,"<Command>","<#Command>");
    00596                         Action.m_Param=ExNihilo::ExtracValueFromSring(buffstring,"<Param>","<#Param>");
    00597                         Butt2->AddActionCommand(Action,Command);
    00598                         fileB2.close();
    00599
    00600                         NewButton->SwitchValue();
    00601                         //NewButton->SwitchValue();
    00602                         win->AddObjectControl(NewButton);
    00603                 }
    00604                 //EXCWINDOWBUTTONSWITCHONMOUSE CONTROL
    00605                 if(strcmp(buffstring.data(),"ExCWindowButtonSwitchOnMouse")==0)
    00606                 {
    00607                         std::ifstream fileB1,fileB2;
    00608                         ExCWindowButtonSwitchOnMouse *NewButton;
    00609                         NewButton= new ExCWindowButtonSwitchOnMouse;
    00610                         ReadWindowObject(NewButton,&fileControl);
    00611                         ExCWindowButton * Butt1,*Butt2;
    00612                         Butt1=new ExCWindowButton;
    00613                         Butt2=new ExCWindowButton;
    00614
    00615                         //Read Normal Button
    00616                         memset(b,0,255);fileControl.getline(b,256,'\n');
    00617                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Button1>","<#Button1>");
    00618                         ReadWindowObject(Butt1,buffstring,&fileB1);
    00619                         NewButton->m_Butt1=Butt1;
    00620
    00621
    00622                         //Read Alternate Button
    00623                         memset(b,0,255);fileControl.getline(b,256,'\n');
    00624                         buffstring=ExNihilo::ExtracValueFromSring(b,"<Button2>","<#Button2>");
    00625                         ReadWindowObject(Butt2,buffstring,&fileB2);
    00626                         NewButton->m_Butt2=Butt2;
    00627
    00628                         //READ ACTION FOR BUTTON1
    00629                         memset(b,0,255);fileB1.getline(b,256,'\n');
    00630                         buffstring=ExNihilo::ExtracValueFromSring(b,"<ActionCommand>","<#ActionCommand>");
    00631                         ExCAction Action=ExNihilo::ExtractIntValueFromSring(buffstring,"<Action>","<#Action>");
    00632                         ExCCommand Command=ExNihilo::ExtractIntValueFromSring(buffstring,"<Command>","<#Command>");
    00633                         Action.m_Param=ExNihilo::ExtracValueFromSring(buffstring,"<Param>","<#Param>");
    00634                         Butt1->AddActionCommand(Action,Command);
    00635                         fileB1.close();
    00636
    00637                         //READ ACTION FOR BUTTON2
    00638                         memset(b,0,255);fileB2.getline(b,256,'\n');
    00639                         buffstring=ExNihilo::ExtracValueFromSring(b,"<ActionCommand>","<#ActionCommand>");
    00640                         Action=ExNihilo::ExtractIntValueFromSring(buffstring,"<Action>","<#Action>");
    00641                         Command=ExNihilo::ExtractIntValueFromSring(buffstring,"<Command>","<#Command>");
    00642                         Action.m_Param=ExNihilo::ExtracValueFromSring(buffstring,"<Param>","<#Param>");
    00643                         Butt2->AddActionCommand(Action,Command);
    00644                         fileB2.close();
    00645
    00646                         NewButton->SwitchValue();
    00647                         //NewButton->SwitchValue();
    00648                         win->AddObjectControl(NewButton);
    00649                 }
    00650         }
    00651         fileControl.close();
    00652         return NULL;
    00653 UnGuard
    00654 }

std::string ExManagerObjectWindow::ReadWindowObject | ( | ExCWindowObject * | win,
|  | std::string | FileName,
|  | std::ifstream * | fileReturn
| ) | `[private]`

| Définition à la ligne 679 du fichier ExManagerObjectWindow.cpp. Références ExNihilo::ExtracValueFromSring(), Guard, PREFIX, ReadWindowObject(), et UnGuard.
    00680 {
    00681 Guard(std::string ExManagerObjectWindow::ReadWindowObject(ExCWindowObject *win,std::string FileName,std::ifstream *fileReturn))
    00682         char                    buffer[255],b[255];
    00683         std::string buffstring;
    00684         #ifdef UNIX_SRC
    00685                 sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", FileName.data());
    00686         #else
    00687                 sprintf(buffer, "../Data/Window/%s", FileName.data());
    00688         #endif
    00689         fileReturn->open(buffer,std::ios::in);
    00690         if(fileReturn->is_open())
    00691         {
    00692                 memset(b,0,255);fileReturn->getline(b,256,'\n');
    00693                 buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00694                 ReadWindowObject(win,fileReturn);
    00695         }
    00696         return buffstring;//RETURN TYPE OF CONTROL
    00697 UnGuard
    00698 }

std::string ExManagerObjectWindow::ReadWindowObject | ( | ExCWindowObject * | win,
|  | std::string | FileName
| ) | `[private]`

| Définition à la ligne 656 du fichier ExManagerObjectWindow.cpp. Références ExNihilo::ExtracValueFromSring(), Guard, PREFIX, ReadWindowObject(), et UnGuard.
    00657 {
    00658 Guard(std::string ExManagerObjectWindow::ReadWindowObject(ExCWindowObject *win,std::string FileName))
    00659         char                    buffer[255],b[255];
    00660         std::string buffstring;
    00661         std::ifstream fileControl;
    00662         #ifdef UNIX_SRC
    00663                 sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", FileName.data());
    00664         #else
    00665                 sprintf(buffer, "../Data/Window/%s", FileName.data());
    00666         #endif
    00667         fileControl.open(buffer,std::ios::in);
    00668         if(fileControl.is_open())
    00669         {
    00670                 memset(b,0,255);fileControl.getline(b,256,'\n');
    00671                 buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00672                 ReadWindowObject(win,&fileControl);
    00673         }
    00674         fileControl.close();
    00675         return buffstring;//RETURN TYPE OF CONTROL
    00676 UnGuard
    00677 }

void ExManagerObjectWindow::ReadWindowObject | ( | ExCWindowObject * | win,
|  | std::ifstream * | file
| ) | `[private]`

| Définition à la ligne 699 du fichier ExManagerObjectWindow.cpp. Références ExNihilo::ExtractIntValueFromSring(), ExNihilo::ExtracValueFromSring(), Guard, ReadWindowObject(), et UnGuard. Référencé par Load(), ReadWindowControlObject(), ReadWindowObject(), et ReadWindowSubObject().
    00700 {
    00701 Guard(void ExManagerObjectWindow::ReadWindowObject(ExCWindowObject *win,std::ifstream *file))
    00702     char                        b[255];
    00703         std::string buffstring;
    00704         try
    00705         {
    00706                 //READ WINDOW POSITION
    00707                 memset(b,0,255);file->getline(b,256,'\n');
    00708                 try
    00709                 {
    00710                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowPosition>","<#WindowPosition>");
    00711                         win->SetPosition(ExCVec2D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00712                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>")));
    00713                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowPosition:"<<buffstring<<std::endl;}
    00714                 //READ WINDOW SIZE
    00715                 memset(b,0,255);file->getline(b,256,'\n');
    00716                 try
    00717                 {
    00718                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowSize>","<#WindowSize>");
    00719                         win->SetWindowSize(ExCVec2D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00720                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>")));
    00721                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowSize"<<std::endl;}
    00722                 //READ TITLE BAR SIZE
    00723                 memset(b,0,255);file->getline(b,256,'\n');
    00724                 try
    00725                 {
    00726                         win->SetTitleBarSize(ExNihilo::ExtractFloatValueFromSring(b,"<TitleBarSize>","<#TitleBarSize>"));
    00727                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading TitleBarSize"<<std::endl;}
    00728                 //READ WINDOW TITLE
    00729                 memset(b,0,255);file->getline(b,256,'\n');
    00730                 try
    00731                 {
    00732                         win->SetWindowTitle(ExNihilo::ExtracValueFromSring(b,"<WindowTitle>","<#WindowTitle>"));
    00733                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowTitle"<<std::endl;}
    00734                 //READ WINDOW TITLE COLOR
    00735                 memset(b,0,255);file->getline(b,256,'\n');
    00736                 try
    00737                 {
    00738                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowTitleColor>","<#WindowTitleColor>");
    00739                         win->SetWindowTitleColor(ExCVec3D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00740                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00741                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>")));
    00742                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowTitleColor"<<std::endl;}
    00743                 //READ IS BACRGROUND BLENDING AND VALUE
    00744                 memset(b,0,255);file->getline(b,256,'\n');
    00745                 try
    00746                 {
    00747                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<IsBackroundBlending>","<#IsBackroundBlending>"))
    00748                         {
    00749                                 memset(b,0,255);file->getline(b,256,'\n');
    00750                                 win->SetBackroundBlending(true,ExNihilo::ExtractFloatValueFromSring(b,"<BackroundBlendingValue>","<#BackroundBlendingValue>"));
    00751                         }else
    00752                         {
    00753                                 memset(b,0,255);file->getline(b,256,'\n');
    00754                                 win->SetBackroundBlending(false,ExNihilo::ExtractFloatValueFromSring(b,"<BackroundBlendingValue>","<#BackroundBlendingValue>"));
    00755                         }
    00756                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading IsBackroundBlending"<<std::endl;}
    00757                 //READ BACKGROUND COLOR
    00758                 memset(b,0,255);file->getline(b,256,'\n');
    00759                 try
    00760                 {
    00761                         buffstring=ExNihilo::ExtracValueFromSring(b,"<BackroundColor>","<#BackroundColor>");
    00762                         win->SetBackroundColor(ExCVec3D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00763                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00764                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>")));
    00765                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BackroundColor"<<std::endl;}
    00766                 //READ IS SHOW BORDER
    00767                 memset(b,0,255);file->getline(b,256,'\n');
    00768                 try
    00769                 {
    00770                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<ShowBorder>","<#ShowBorder>"))
    00771                         {
    00772                                 win->SetShowBorder(true);
    00773                         }else
    00774                         {
    00775                                 win->SetShowBorder(false);
    00776                         }
    00777                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading ShowBorder"<<std::endl;}
    00778                 //READ BACKGROUND COLOR
    00779                 memset(b,0,255);file->getline(b,256,'\n');
    00780                 try
    00781                 {
    00782                         buffstring=ExNihilo::ExtracValueFromSring(b,"<BorderColor>","<#BorderColor>");
    00783                         win->SetBorderColor(ExCVec3D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00784                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
    00785                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>")));
    00786                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BorderColor"<<std::endl;}
    00787                 //READ IS BACRGROUND TEXTURING AND TEXTURE 1
    00788                 memset(b,0,255);file->getline(b,256,'\n');
    00789                 try
    00790                 {
    00791                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<BackroundIsTexturing1>","<#BackroundIsTexturing1>"))
    00792                         {
    00793                                 memset(b,0,255);file->getline(b,256,'\n');
    00794                                 win->SetBackroundTexturing1(true,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture1>","<#BackroundTexture1>"));
    00795                         }else
    00796                         {
    00797                                 memset(b,0,255);file->getline(b,256,'\n');
    00798                                 win->SetBackroundTexturing1(false,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture1>","<#BackroundTexture1>"));
    00799                         }
    00800                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BackroundIsTexturing1 :"<<buffstring<<std::endl;}
    00801                 //READ IS BACRGROUND TEXTURING AND TEXTURE 2
    00802                 memset(b,0,255);file->getline(b,256,'\n');
    00803                 try
    00804                 {
    00805                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<BackroundIsTexturing2>","<#BackroundIsTexturing2>"))
    00806                         {
    00807                                 memset(b,0,255);file->getline(b,256,'\n');
    00808                                 win->SetBackroundTexturing2(true,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture2>","<#BackroundTexture2>"));
    00809                         }else
    00810                         {
    00811                                 memset(b,0,255);file->getline(b,256,'\n');
    00812                                 win->SetBackroundTexturing2(false,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture2>","<#BackroundTexture2>"));
    00813                         }
    00814                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BackroundIsTexturing2:"<<buffstring<<std::endl;}
    00815                 //READ TEXTURE IS MOUVING
    00816                 memset(b,0,255);file->getline(b,256,'\n');
    00817                 try
    00818                 {
    00819                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<TextureIsMouving>","<#TextureIsMouving>"))
    00820                         {
    00821                                 win->SetTextureIsMouving(true);
    00822                         }else
    00823                         {
    00824                                 win->SetTextureIsMouving(false);
    00825                         }
    00826                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading TextureIsMouving"<<std::endl;}
    00827                 //READ TEXTURE MOUVING VEC
    00828                 memset(b,0,255);file->getline(b,256,'\n');
    00829                 try
    00830                 {
    00831                         buffstring=ExNihilo::ExtracValueFromSring(b,"<TextureMouvingVec>","<#TextureMouvingVec>");
    00832                         win->SetTextureMouvingVec(ExCVec2D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
    00833                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>")));
    00834                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading TextureMouvingVec:"<<buffstring<<std::endl;}
    00835         }catch(...){throw ExCExpFileReadError();}
    00836 UnGuard
    00837 }

void ExManagerObjectWindow::ReadWindowSubObject | ( | ExCWindow * | win,
|  | std::string | FileName
| ) | `[private]`

| Définition à la ligne 411 du fichier ExManagerObjectWindow.cpp. Références ExNihilo::ExtractIntValueFromSring(), ExNihilo::ExtracValueFromSring(), Guard, PREFIX, ReadWindowControlObject(), ReadWindowObject(), ReadWindowSubObject(), et UnGuard. Référencé par Load(), et ReadWindowSubObject().
    00412 {
    00413 Guard(void ExManagerObjectWindow::ReadWindowSubObject(ExCWindow *win,std::string FileName))
    00414         char                    buffer[255],b[255];
    00415         std::string buffstring;
    00416         std::ifstream file,fileButton,fileControl;
    00417         #ifdef UNIX_SRC
    00418                 sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", FileName.data());
    00419         #else
    00420                 sprintf(buffer, "../Data/Window/%s", FileName.data());
    00421         #endif
    00422         //std::cout<<buffer<<std::endl;
    00423         file.open(buffer,std::ios::in);
    00424
    00425         if(file.is_open())
    00426         {
    00427                 //read header
    00428                 memset(b,0,255);file.getline(b,256,'\n');
    00429                 try
    00430                 {
    00431                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00432                         if(strcmp(buffstring.data(),"WindowContent")==0)
    00433                         {
    00434                                 ReadWindowObject(win->GetWindowContentPointer(),&file);
    00435                                 //Read all control
    00436                                 memset(b,0,255);file.getline(b,256,'\n');
    00437                                 int numberofcontrol=ExNihilo::ExtractIntValueFromSring(b,"<NumberOfControl>","<#NumberOfControl>");
    00438                                 for(int i=0;i<numberofcontrol;i++)
    00439                                 {
    00440                                         memset(b,0,255);file.getline(b,256,'\n');
    00441                                         ReadWindowControlObject(win->GetWindowContentPointer(),ExNihilo::ExtracValueFromSring(b,"<FileControl>","<#FileControl>"));
    00442                                 }
    00443                         }
    00444                         if(strcmp(buffstring.data(),"BarContent")==0)
    00445                         {
    00446                                 ReadWindowObject(win->GetWindowBarPointer(),&file);
    00447                                 //READ CLOSE BUTTON
    00448                                 memset(b,0,255);file.getline(b,256,'\n');
    00449                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<FileForButtonClose>","<#FileForButtonClose>");
    00450                                 #ifdef UNIX_SRC
    00451                                         sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", buffstring.data());
    00452                                 #else
    00453                                         sprintf(buffer, "../Data/Window/%s", buffstring.data());
    00454                                 #endif
    00455                                 fileButton.open(buffer,std::ios::in);
    00456                                 if(fileButton.is_open())
    00457                                 {
    00458                                         memset(b,0,255);fileButton.getline(b,256,'\n');
    00459                                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00460                     ReadWindowObject(win->GetButtonClose(),&fileButton);
    00461                                         win->GetButtonClose()->SetBackroundColor(ExCVec3D(1.0f,1.0f,1.0f));
    00462                                 }fileButton.close();
    00463                                 //READ Maximize BUTTON
    00464                                 memset(b,0,255);file.getline(b,256,'\n');
    00465                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<FileForButtonMaximize>","<#FileForButtonMaximize>");
    00466                                 #ifdef UNIX_SRC
    00467                                         sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", buffstring.data());
    00468                                 #else
    00469                                         sprintf(buffer, "../Data/Window/%s", buffstring.data());
    00470                                 #endif
    00471                                 fileButton.open(buffer,std::ios::in);
    00472                                 if(fileButton.is_open())
    00473                                 {
    00474                                         memset(b,0,255);fileButton.getline(b,256,'\n');
    00475                                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00476                     ReadWindowObject(win->GetButtonMaximize(),&fileButton);
    00477                                         win->GetButtonMaximize()->SetBackroundColor(ExCVec3D(1.0f,1.0f,1.0f));
    00478                                 }fileButton.close();
    00479                                 //READ Minimize BUTTON
    00480                                 memset(b,0,255);file.getline(b,256,'\n');
    00481                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<FileForButtonMinimize>","<#FileForButtonMinimize>");
    00482                                 #ifdef UNIX_SRC
    00483                                         sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", buffstring.data());
    00484                                 #else
    00485                                         sprintf(buffer, "../Data/Window/%s", buffstring.data());
    00486                                 #endif
    00487                                 fileButton.open(buffer,std::ios::in);
    00488                                 if(fileButton.is_open())
    00489                                 {
    00490                                         memset(b,0,255);fileButton.getline(b,256,'\n');
    00491                                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00492                                         ReadWindowObject(win->GetButtonMinimize(),&fileButton);
    00493                                         win->GetButtonMinimize()->SetBackroundColor(ExCVec3D(1.0f,1.0f,1.0f));
    00494                                 }fileButton.close();
    00495                                 //READ MinimizeToBar BUTTON
    00496                                 memset(b,0,255);file.getline(b,256,'\n');
    00497                                 buffstring=ExNihilo::ExtracValueFromSring(b,"<FileForButtonMinimizeToBar>","<#FileForButtonMinimizeToBar>");
    00498                                 #ifdef UNIX_SRC
    00499                                         sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", buffstring.data());
    00500                                 #else
    00501                                         sprintf(buffer, "../Data/Window/%s", buffstring.data());
    00502                                 #endif
    00503                                 fileButton.open(buffer,std::ios::in);
    00504                                 if(fileButton.is_open())
    00505                                 {
    00506                                         memset(b,0,255);fileButton.getline(b,256,'\n');
    00507                                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
    00508                     ReadWindowObject(win->GetButtonMinimizeToBar(),&fileButton);
    00509                                         win->GetButtonMinimizeToBar()->SetBackroundColor(ExCVec3D(1.0f,1.0f,1.0f));
    00510                                 }fileButton.close();
    00511
    00512                         }
    00513                 }catch(ExCExpStringNotFound){std::cout<<"ReadWindowSubObject::ExCExpStringNotFound";}
    00514         }else throw   ExCExpFileNotFound();
    00515         file.close();
    00516 UnGuard
    00517 }

void ExManagerObject< ExCWindow >::Reload | ( | void |  | ) | `[virtual, inherited]`

| Redéfinie à partir de ExManager. Référencé par ExManagerCommand::ProcesExCAction().

bool ExManagerObject< ExCWindow >::Remove | ( | std::string | Name | ) | `[inherited]`

bool ExManagerObject< ExCWindow >::Remove | ( | ExNihilo::ExId | id | ) | `[inherited]`

bool ExManagerObject< ExCWindow >::RemoveCurrentObject | ( | void |  | ) | `[inherited]`

| Référencé par InputAction().

void ExManagerObjectWindow::Reset | ( | void |  | ) | `[virtual]`

| Redéfinie à partir de ExManagerObject< ExCWindow >. Définition à la ligne 57 du fichier ExManagerObjectWindow.cpp. Références Guard, Load(), m_DrawAllWindow, ExManagerObject< TypeA >::Reset(), Reset(), et UnGuard. Référencé par ExManagerCommand::ProcesExCAction(), et Reset().
    00058 {
    00059 Guard(void  ExManagerObjectWindow::Reset(void))
    00060         ExManagerObject<ExCWindow>::Reset();
    00061         Load("WindowMainMenu.ExW");
    00062         //Load("wlotr.ExW");
    00063         m_DrawAllWindow=true;
    00064 UnGuard
    00065 }

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(), 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(), Init(), ExManagerNetwork::Init(), ExManagerConsole::InputAction(), ExManagerNetwork::InputCommand(), et ExManagerNetwork::Say().
    00088 {m_Exclusif=status;}

bool ExManagerObject< ExCWindow >::SetCurrentObject | ( | std::string | Name | ) | `[inherited]`

bool ExManagerObjectWindow::SetCurrentObject | ( | ExNihilo::ExId | id | ) |

| Redéfinie à partir de ExManagerObject< ExCWindow >. Définition à la ligne 344 du fichier ExManagerObjectWindow.cpp. Références ExNihilo::ExId, ExManagerObject< ExCWindow >::GetCurrentObject(), Guard, ExCWindow::SetActive(), ExManagerObject< TypeA >::SetCurrentObject(), SetCurrentObject(), et UnGuard. Référencé par InputCommand(), et SetCurrentObject().
    00345 {
    00346 Guard(bool ExManagerObjectWindow::SetCurrentObject(ExNihilo::ExId id))
    00347         ExManagerObject<ExCWindow>::SetCurrentObject(id);
    00348         GetCurrentObject()->SetActive(true);
    00349         return true;
    00350 UnGuard
    00351 }

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 ExManagerObject< ExCWindow >::SetManagerId | ( | ExManagerId * | Id | ) | `[inline, inherited]`

| Définition à la ligne 94 du fichier ExManagerObject.h. Référencé par SetManagerLink().
    00094 {ManagerId      = Id;}

void ExManagerObjectWindow::SetManagerTexture | ( | ExManagerTexture * | Texture | ) | `[inline]`

| Définition à la ligne 108 du fichier ExManagerObjectWindow.h. Références ManagerTexture. Référencé par SetManagerLink().
    00108 {ManagerTexture = Texture;}

void ExManagerObjectWindow::SetManagerWindow | ( | ExManagerWindow * | Window | ) | `[inline]`

| Définition à la ligne 109 du fichier ExManagerObjectWindow.h. Références ManagerWindow. Référencé par SetManagerLink().
    00109 {ManagerWindow = Window;}

void ExManagerObjectWindow::SetSizeWhenMinimized | ( | float | value | ) | `[inline]`

| Définition à la ligne 119 du fichier ExManagerObjectWindow.h. Références m_SizeWhenMinimized.
    00119 {m_SizeWhenMinimized=value;}

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(), Init(), ExManagerInterface::Init(), ExManagerConsole::InputAction(), ExManagerLoad::LoadSetOfFile(), et ExManagerConsole::SetConsoleState().
    00086 {m_Status=status;}

## 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 ExManagerWindow::Apply(), ExManagerCommand::ApplyAction(), ExManagerCommand::LoadExecFile(), ExManagerId::RecordObject(), ExManager::SetFlux(), et ExManagerSpecialEffect::Specialeffect().

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().

ExNihilo::ExId ExManagerObject< ExCWindow >::m_CurrentObjectId`[protected, inherited]`

| Définition à la ligne 79 du fichier ExManagerObject.h. Référencé par Draw(), InputAction(), et InputCommand().

bool ExManagerObjectWindow::m_DrawAllWindow`[private]`

| Définition à la ligne 92 du fichier ExManagerObjectWindow.h. Référencé par Draw(), Init(), InputAction(), InputCommand(), et Reset().

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 ExManagerObjectWindow::m_flag = false`[static, private]`

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

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

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

std::map< ExNihilo::ExId , ExCWindow , std::less <ExNihilo::ExId > >::iterator ExManagerObject< ExCWindow >::m_ItMap`[protected, inherited]`

| Définition à la ligne 76 du fichier ExManagerObject.h. Référencé par Draw(), InputCommand(), et OrganizeMinimizedWindow().

ExCCommand ExManagerObjectWindow::m_LastCommandReceived`[private]`

| Définition à la ligne 90 du fichier ExManagerObjectWindow.h. Référencé par InputAction(), et InputCommand().

std::map< ExNihilo::ExId , ExCWindow , std::less <ExNihilo::ExId > >* ExManagerObject< ExCWindow >::m_Map`[protected, inherited]`

| Définition à la ligne 75 du fichier ExManagerObject.h. Référencé par Draw(), InputAction(), InputCommand(), et OrganizeMinimizedWindow().

ExCVec2D ExManagerObjectWindow::m_MovePointerShift`[private]`

| Définition à la ligne 89 du fichier ExManagerObjectWindow.h. Référencé par InputAction(), et InputCommand().

bool ExManagerObjectWindow::m_MoveWindow`[private]`

| Définition à la ligne 88 du fichier ExManagerObjectWindow.h. Référencé par Init(), InputAction(), et InputCommand().

float ExManagerObjectWindow::m_SizeWhenMinimized`[private]`

| Définition à la ligne 91 du fichier ExManagerObjectWindow.h. Référencé par GetSizeWhenMinimized(), Init(), OrganizeMinimizedWindow(), et SetSizeWhenMinimized().

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

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

ExManagerId* ExManagerObject< ExCWindow >::ManagerId`[protected, inherited]`

| Définition à la ligne 78 du fichier ExManagerObject.h.

ExManagerTexture* ExManagerObjectWindow::ManagerTexture`[private]`

| Définition à la ligne 94 du fichier ExManagerObjectWindow.h. Référencé par InputAction(), Load(), et SetManagerTexture().

ExManagerWindow* ExManagerObjectWindow::ManagerWindow`[private]`

| Définition à la ligne 95 du fichier ExManagerObjectWindow.h. Référencé par InputAction(), Load(), OrganizeMinimizedWindow(), et SetManagerWindow().

ExCWindow* ExManagerObjectWindow::ModalWindow`[private]`

| Définition à la ligne 96 du fichier ExManagerObjectWindow.h. Référencé par Draw(), Init(), InputAction(), et InputCommand().

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

- ExManagerObjectWindow.h
- ExManagerObjectWindow.cpp