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

ExManagerObject< ExCWindow > ExManager

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 :
Généré le Tue Oct 28 12:44:04 2003 pour ExNihilo par doxygen 1.3.4