ExNihilo : ExCWindowControl class Reference

00028 {
00029 Guard(ExCWindowControl::ExCWindowControl(void))
00030         SetName("ExCWindowControl");
00031         SetType(typeid(this).name());
00032         m_TitleBarSize=20;
00033 UnGuard
00034 }

00063 {
00064 Guard(ExCAction ExCWindowControl::AddActionCommand(ExCAction Action,ExCCommand Command))
00065         m_VecCommandAction.push_back(CommandAction(Command,Action));
00066 UnGuard
00067 }

00237 {
00238 Guard(void ExCWindowObject::AddObjectControl(ExCWindowObject *object))
00239         object->SetParrent(this);
00240         object->SetManagerTexture(ManagerTexture);
00241         object->SetManagerWindow(ManagerWindow);
00242         object->SetPosition(m_Position+object->GetPosition());
00243         m_VecWindowObject.push_back(object);
00244 UnGuard
00245 }

00043 {
00044 Guard(void ExCWindowControl::Draw(void))
00045         //std::cout<<"Draw windows"<<std::endl;
00046 UnGuard
00047 }

00167 {return m_BackroundBlending;}

00189 {return m_BackroundBlending;}

00171 {return m_BackroundColor;}

00193 {return m_BackroundColor;}

00157 {return m_BackroundTexture1;}

00179 {return m_BackroundTexture1;}

00160 {return m_BackroundTexture2;}

00182 {return m_BackroundTexture2;}

00176 {return m_BorderColor;}

00198 {return m_BorderColor;}

00174 {return m_BorderSize;}

00196 {return m_BorderSize;}

00205 {return m_CanMouve;}

00094 {return m_ObjectFileName;}

00092 {return m_ObjectId;}

00093 {return m_ObjectName;}

00150 {return m_OldPosition;}

00169 {return m_OldPosition;}

00148 {return m_OldSize;}

00167 {return m_OldSize;}

00127 {return m_Parent;}

00145 {return m_Parent;}

00080 {return m_Position;}

00177 {return m_ShowBorder;}

00199 {return m_ShowBorder;}

00164 {return m_TextureMouvingVec;}

00186 {return m_TextureMouvingVec;}

00171 {return m_TitleBarSize;}

00095 {return m_ObjectType;}

00084 {return m_VecCommandAction;}

00086 {return m_VecCommandAction;}

00140 {return &m_VecWindowObject;}

00140 {return m_WindowOldTitle;}

00159 {return m_WindowOldTitle;}

00146 {return m_WindowSize;}

00165 {return m_WindowSize;}

00138 {return m_WindowTitle;}

00157 {return m_WindowTitle;}

00142 {return m_WindowTitleColor;}

00161 {return m_WindowTitleColor;}

00072 {
00073 Guard(void ExCWindowObject::Init(void))
00074         SetName("ExCWindowObject");
00075         SetType(typeid(this).name());
00076         m_ShowWindow=true;
00077         m_Blending=false;
00078         m_RequestFocus=false;
00079         m_CurrentObjectFocus=NULL;
00080         m_LastObjectFocus=NULL;
00081         //Manager Pointer
00082         ManagerTexture=NULL;
00083         ManagerWindow=NULL;
00084         //Parent
00085         m_Parent=NULL;
00086         //Title
00087         m_ShowWindowTitle=false;
00088         m_WindowTitle="ExCWindowObject";
00089         m_WindowOldTitle="ExCWindowObject";
00090         m_WindowTitleColor.SetValue(0.1f,0.1f,0.1f);
00091         //Size and position
00092         m_WindowSize.SetValue(240,320);
00093         m_OldSize.SetValue(240,320);
00094         m_TitleBarSize=20;
00095         m_OldPosition.SetValue(0.0f,0.0f);
00096         m_OldMousePosition.SetValue(0,0);
00097         m_Position.SetValue(0,0);
00098         //Color and blending
00099         m_Blending=false;
00100         m_BackroundBlending=0.5f;
00101         m_BackroundColor.SetValue(1.0f,1.0f,1.0f);
00102         //Border 
00103         m_BorderColor.SetValue(0.6f,0.6f,0.6f);
00104         m_BorderSize=1.0f;
00105         m_ShowBorder=true;
00106         //Texturing
00107         m_BackroundIsTexturing1=false;
00108         m_BackroundTexture1="NONE";
00109         m_BackroundIsTexturing2=false;
00110         m_BackroundTexture2="NONE";
00111         m_TextureIsMouving=false;
00112         m_TextureMouvingVec.SetValue(0.0f,0.0f);
00113         //Window state
00114         m_CanMouve=false;
00115         m_Mouving=false;
00116         m_Reduced=false;
00117         m_Maximized=false;
00118         m_ShowWindow=true;
00119         m_Active=false;                 //if windows is the active windows
00120 
00121         m_RequestFocus=false;
00122         m_LastObjectFocus=NULL;
00123         m_CurrentObjectFocus=NULL;
00124         m_ObjectRequestFocus=NULL;
00125         //std::cout<<"ExCWindowObject"<<std::endl;
00126 UnGuard
00127 }

00057 {
00058 Guard(ExCAction ExCWindowControl::InputAction(ExCAction Action))
00059         return NOTHING;
00060 UnGuard
00061 }

00050 {
00051 Guard(ExCAction ExCWindowControl::InputCommand(ExCCommand Command))
00052         return NOTHING;
00053 UnGuard
00054 }

00213 {return m_Active;}

00166 {return m_Blending;}

00188 {return m_Blending;}

00155 {return m_BackroundIsTexturing1;}

00177 {return m_BackroundIsTexturing1;}

00158 {return m_BackroundIsTexturing2;}

00180 {return m_BackroundIsTexturing2;}

00209 {return m_Maximized;}

00203 {return m_Mouving;}

00207 {return m_Reduced;}

00211 {return m_ShowWindow;}

00136 {return m_ShowWindowTitle;}

00155 {return m_ShowWindowTitle;}

00161 {return m_TextureIsMouving;}

00183 {return m_TextureIsMouving;}

00385 {
00386 Guard(std::string ExCWindowObject::Load(std::string FileName))
00387         char                    buffer[255],b[255];
00388         std::string buffstring,returncontrolstring;
00389         std::ifstream file;
00390         #ifdef UNIX_SRC
00391         sprintf(buffer, PREFIX "/ExNihilo/Data/Window/%s", FileName.data());
00392         #else
00393         sprintf(buffer, "../Data/Window/%s", FileName.data());
00394         #endif
00395         file.open(buffer,std::ios::in);
00396         if(file.is_open())
00397         {
00398                 memset(b,0,255);file.getline(b,256,'\n');
00399                 returncontrolstring=ExNihilo::ExtracValueFromSring(b,"<WindowHeader>","<#WindowHeader>");
00401                 Load(FileName);
00403         }
00404         file.close();
00405         return returncontrolstring;//RETURN TYPE OF CONTROL
00406 UnGuard
00407 }

00410 {
00411 Guard(void ExCWindowObject::Load(std::ifstream *file))
00412         char                    b[255];
00413         std::string buffstring;
00414         try
00415         {
00416                 //READ WINDOW POSITION
00417                 memset(b,0,255);file->getline(b,256,'\n');
00418                 try
00419                 {
00420                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowPosition>","<#WindowPosition>");
00421                         SetPosition(ExCVec2D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
00422                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>")));
00423                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowPosition:"<<buffstring<<std::endl;}
00424                 //READ WINDOW SIZE
00425                 memset(b,0,255);file->getline(b,256,'\n');
00426                 try
00427                 {
00428                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowSize>","<#WindowSize>");
00429                         SetWindowSize(ExCVec2D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
00430                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>")));
00431                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowSize"<<std::endl;}
00432                 //READ TITLE BAR SIZE
00433                 memset(b,0,255);file->getline(b,256,'\n');
00434                 try
00435                 {
00436                         SetTitleBarSize(ExNihilo::ExtractFloatValueFromSring(b,"<TitleBarSize>","<#TitleBarSize>"));
00437                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading TitleBarSize"<<std::endl;}
00438                 //READ WINDOW TITLE
00439                 memset(b,0,255);file->getline(b,256,'\n');
00440                 try
00441                 {
00442                         SetWindowTitle(ExNihilo::ExtracValueFromSring(b,"<WindowTitle>","<#WindowTitle>"));
00443                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowTitle"<<std::endl;}
00444                 //READ WINDOW TITLE COLOR
00445                 memset(b,0,255);file->getline(b,256,'\n');
00446                 try
00447                 {
00448                         buffstring=ExNihilo::ExtracValueFromSring(b,"<WindowTitleColor>","<#WindowTitleColor>");
00449                         SetWindowTitleColor(ExCVec3D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
00450                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
00451                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>")));
00452                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading WindowTitleColor"<<std::endl;}
00453                 //READ IS BACRGROUND BLENDING AND VALUE
00454                 memset(b,0,255);file->getline(b,256,'\n');
00455                 try
00456                 {
00457                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<IsBackroundBlending>","<#IsBackroundBlending>"))
00458                         {
00459                                 memset(b,0,255);file->getline(b,256,'\n');
00460                                 SetBackroundBlending(true,ExNihilo::ExtractFloatValueFromSring(b,"<BackroundBlendingValue>","<#BackroundBlendingValue>"));
00461                         }else 
00462                         {
00463                                 memset(b,0,255);file->getline(b,256,'\n');
00464                                 SetBackroundBlending(false,ExNihilo::ExtractFloatValueFromSring(b,"<BackroundBlendingValue>","<#BackroundBlendingValue>"));
00465                         }
00466                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading IsBackroundBlending"<<std::endl;}
00467                 //READ BACKGROUND COLOR
00468                 memset(b,0,255);file->getline(b,256,'\n');
00469                 try
00470                 {
00471                         buffstring=ExNihilo::ExtracValueFromSring(b,"<BackroundColor>","<#BackroundColor>");
00472                         SetBackroundColor(ExCVec3D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
00473                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
00474                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>")));
00475                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BackroundColor"<<std::endl;}
00476                 //READ IS SHOW BORDER
00477                 memset(b,0,255);file->getline(b,256,'\n');
00478                 try
00479                 {
00480                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<ShowBorder>","<#ShowBorder>"))
00481                         {
00482                                 SetShowBorder(true);
00483                         }else 
00484                         {
00485                                 SetShowBorder(false);
00486                         }
00487                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading ShowBorder"<<std::endl;}
00488                 //READ BACKGROUND COLOR
00489                 memset(b,0,255);file->getline(b,256,'\n');
00490                 try
00491                 {
00492                         buffstring=ExNihilo::ExtracValueFromSring(b,"<BorderColor>","<#BorderColor>");
00493                         SetBorderColor(ExCVec3D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
00494                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>"),
00495                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Z>","<#Z>")));
00496                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BorderColor"<<std::endl;}
00497                 //READ IS BACRGROUND TEXTURING AND TEXTURE 1
00498                 memset(b,0,255);file->getline(b,256,'\n');
00499                 try
00500                 {
00501                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<BackroundIsTexturing1>","<#BackroundIsTexturing1>"))
00502                         {
00503                                 memset(b,0,255);file->getline(b,256,'\n');
00504                                 SetBackroundTexturing1(true,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture1>","<#BackroundTexture1>"));
00505                         }else 
00506                         {
00507                                 memset(b,0,255);file->getline(b,256,'\n');
00508                                 SetBackroundTexturing1(false,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture1>","<#BackroundTexture1>"));
00509                         }
00510                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BackroundIsTexturing1 :"<<buffstring<<std::endl;}        
00511                 //READ IS BACRGROUND TEXTURING AND TEXTURE 2
00512                 memset(b,0,255);file->getline(b,256,'\n');
00513                 try
00514                 {
00515                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<BackroundIsTexturing2>","<#BackroundIsTexturing2>"))
00516                         {
00517                                 memset(b,0,255);file->getline(b,256,'\n');
00518                                 SetBackroundTexturing2(true,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture2>","<#BackroundTexture2>"));
00519                         }else 
00520                         {
00521                                 memset(b,0,255);file->getline(b,256,'\n');
00522                                 SetBackroundTexturing2(false,ExNihilo::ExtracValueFromSring(b,"<BackroundTexture2>","<#BackroundTexture2>"));
00523                         }
00524                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading BackroundIsTexturing2:"<<buffstring<<std::endl;} 
00525                 //READ TEXTURE IS MOUVING
00526                 memset(b,0,255);file->getline(b,256,'\n');
00527                 try
00528                 {
00529                         if(0!=ExNihilo::ExtractIntValueFromSring(b,"<TextureIsMouving>","<#TextureIsMouving>"))
00530                         {
00531                                 SetTextureIsMouving(true);
00532                         }else 
00533                         {
00534                                 SetTextureIsMouving(false);
00535                         }
00536                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading TextureIsMouving"<<std::endl;}
00537                 //READ TEXTURE MOUVING VEC
00538                 memset(b,0,255);file->getline(b,256,'\n');
00539                 try
00540                 {
00541                         buffstring=ExNihilo::ExtracValueFromSring(b,"<TextureMouvingVec>","<#TextureMouvingVec>");
00542                         SetTextureMouvingVec(ExCVec2D(ExNihilo::ExtractFloatValueFromSring(buffstring,"<X>","<#X>"),
00543                                 ExNihilo::ExtractFloatValueFromSring(buffstring,"<Y>","<#Y>")));
00544                 }catch(ExCExpStringNotFound){std::cout<<"Error Reading TextureMouvingVec:"<<buffstring<<std::endl;}
00545         }catch(...){throw ExCExpFileReadError();}
00546 UnGuard
00547 }

00054 {
00055 Guard(bool ExCObject::LoadFile(std::string FileName))
00056         return true;
00057 UnGuard
00058 }

00358 {
00359 Guard(bool ExCWindowObject::PointInWindow(ExCVec2D point))
00360         if(point.GetX()>=m_Position.GetX()&&point.GetX()<=m_Position.GetX()+m_WindowSize.GetX())
00361         {
00362                 if(point.GetY()>=m_Position.GetY()&&point.GetY()<=m_Position.GetY()+m_WindowSize.GetY())
00363                 return true;
00364         }
00365         return false;
00366 UnGuard
00367 }

00214 {m_Active=status;}

00169 {m_Blending=state;m_BackroundBlending=value;}

00168 {m_Blending=state;}

00191 {m_Blending=state;m_BackroundBlending=value;}

00190 {m_Blending=state;}

00170 {m_BackroundColor=Color;}

00192 {m_BackroundColor=Color;}

00175 {m_BorderColor=Color;}

00197 {m_BorderColor=Color;}

00173 {m_BorderSize=value;}

00195 {m_BorderSize=value;}

00206 {m_CanMouve=status;}

00098 {m_ObjectFileName = FileName;}

00067 {
00068         Consol=consol;
00069         FluxAction=action;
00070 }

00096 {m_ObjectId=Id;}

00048 {
00049         SetName(idname.second);
00050         SetId(idname.first);
00051 }

00370 {
00371 Guard(void ExCWindowObject::SetManagerTexture(ExManagerTexture * Texture))
00372         ManagerTexture = Texture;
00373         for(unsigned int i=0;i<m_VecWindowObject.size();i++)
00374         {
00375                 m_VecWindowObject.at(i)->SetManagerTexture(ManagerTexture);     
00376         }
00377 UnGuard
00378 }

00124 {ManagerWindow = Window;}

00142 {ManagerWindow = Window;}

00208 {m_Maximized=status;}

00204 {m_Mouving=status;}

00097 {m_ObjectName = Name;}

00149 {m_OldPosition=vec;}

00168 {m_OldPosition=vec;}

00147 {m_OldSize=vec;}

00166 {m_OldSize=vec;}

00126 {m_Parent=Parent;}

00144 {m_Parent=Parent;}

00248 {
00249 Guard(void ExCWindowObject::SetPosition(ExCVec2D Position))
00250         m_OldPosition=m_Position;
00251         m_Position=Position;
00252 UnGuard
00253 }

00210 {m_Reduced=status;}

00178 {m_ShowBorder=status;}

00200 {m_ShowBorder=status;}

00212 {m_ShowWindow=status;}

00162 {m_TextureIsMouving=state;}

00184 {m_TextureIsMouving=state;}

00163 {m_TextureMouvingVec=vec;}

00185 {m_TextureMouvingVec=vec;}

00170 {m_TitleBarSize=size;}

00099 {m_ObjectType = Type;}

00139 {m_WindowOldTitle=Title;}

00158 {m_WindowOldTitle=Title;}

00145 {m_WindowSize=vec;}

00164 {m_WindowSize=vec;}

00137 {m_WindowTitle=Title;}

00156 {m_WindowTitle=Title;}

00141 {m_WindowTitleColor=Color;}

00160 {m_WindowTitleColor=Color;}

00135 {m_ShowWindowTitle=state;}

00154 {m_ShowWindowTitle=state;}

Référence de la classe ExCWindowControl

Membres publics

Attributs Publics

Types Protégés

Attributs Protégés

Documentation des types imbriqués

Documentation des contructeurs et destructeurs

Documentation des méthodes

Documentation des données imbriquées


Membres publics
	ExCWindowControl (void)
	~ExCWindowControl (void)
void	Draw (void)
ExCAction	InputAction (ExCAction Action)
ExCAction	InputCommand (ExCCommand Command)
void	AddActionCommand (ExCAction Action, ExCCommand Command)
std::vector< CommandAction >	GetVecActionCommand (void)
	ExCWindowControl (void)
	~ExCWindowControl (void)
void	Draw (void)
ExCAction	InputAction (ExCAction Action)
ExCAction	InputCommand (ExCCommand Command)
void	AddActionCommand (ExCAction Action, ExCCommand Command)
std::vector< CommandAction >	GetVecActionCommand (void)
void	SetPosition (ExCVec2D Position)
void	SetPosition (ExCVec2D Position)
std::vector< ExCWindowObject * > *	GetVecWindowObject (void)
void	SetManagerTexture (ExManagerTexture *Texture)
void	SetManagerTexture (ExManagerTexture *Texture)
void	SetManagerWindow (ExManagerWindow *Window)
void	SetManagerWindow (ExManagerWindow *Window)
void	SetParrent (ExCWindowObject *Parent)
void	SetParrent (ExCWindowObject *Parent)
ExCWindowObject *	GetParrent (void)
ExCWindowObject *	GetParrent (void)
void	Init (void)
void	Init (void)
void	AddObjectControl (ExCWindowObject *object)
void	ShowWindowTitle (bool state)
void	ShowWindowTitle (bool state)
bool	IsShowWindowTitle (void)
bool	IsShowWindowTitle (void)
void	SetWindowTitle (std::string Title)
void	SetWindowTitle (std::string Title)
std::string	GetWindowTitle (void)
std::string	GetWindowTitle (void)
void	SetWindowOldTitle (std::string Title)
void	SetWindowOldTitle (std::string Title)
std::string	GetWindowOldTitle (void)
std::string	GetWindowOldTitle (void)
void	SetWindowTitleColor (ExCVec3D Color)
void	SetWindowTitleColor (ExCVec3D Color)
ExCVec3D	GetWindowTitleColor (void)
ExCVec3D	GetWindowTitleColor (void)
void	SetWindowSize (ExCVec2D vec)
void	SetWindowSize (ExCVec2D vec)
ExCVec2D	GetWindowSize (void)
ExCVec2D	GetWindowSize (void)
void	SetOldWindowSize (ExCVec2D vec)
void	SetOldWindowSize (ExCVec2D vec)
ExCVec2D	GetOldWindowSize (void)
ExCVec2D	GetOldWindowSize (void)
void	SetOldPosition (ExCVec2D vec)
void	SetOldPosition (ExCVec2D vec)
ExCVec2D	GetOldPosition (void)
ExCVec2D	GetOldPosition (void)
void	SetTitleBarSize (float size)
float	GetTitleBarSize (void)
bool	PointInWindow (ExCVec2D point)
bool	PointInWindow (ExCVec2D point)
bool	IsBackroundTexturing1 (void)
bool	IsBackroundTexturing1 (void)
void	SetBackroundTexturing1 (bool status, std::string texture)
void	SetBackroundTexturing1 (bool status, std::string texture)
std::string	GetBackroundTexture1 (void)
std::string	GetBackroundTexture1 (void)
bool	IsBackroundTexturing2 (void)
bool	IsBackroundTexturing2 (void)
void	SetBackroundTexturing2 (bool status, std::string texture)
void	SetBackroundTexturing2 (bool status, std::string texture)
std::string	GetBackroundTexture2 (void)
std::string	GetBackroundTexture2 (void)
bool	IsTextureIsMouving (void)
bool	IsTextureIsMouving (void)
void	SetTextureIsMouving (bool state)
void	SetTextureIsMouving (bool state)
void	SetTextureMouvingVec (ExCVec2D vec)
void	SetTextureMouvingVec (ExCVec2D vec)
ExCVec2D	GetTextureMouvingVec (void)
ExCVec2D	GetTextureMouvingVec (void)
bool	IsBackroundBlending (void)
bool	IsBackroundBlending (void)
float	GetBackroundBlending (void)
float	GetBackroundBlending (void)
void	SetBackroundBlending (bool state)
void	SetBackroundBlending (bool state, float value)
void	SetBackroundBlending (bool state)
void	SetBackroundBlending (bool state, float value)
void	SetBackroundColor (ExCVec3D Color)
void	SetBackroundColor (ExCVec3D Color)
ExCVec3D	GetBackroundColor (void)
ExCVec3D	GetBackroundColor (void)
void	SetBorderSize (float value)
void	SetBorderSize (float value)
float	GetBorderSize (void)
float	GetBorderSize (void)
void	SetBorderColor (ExCVec3D Color)
void	SetBorderColor (ExCVec3D Color)
ExCVec3D	GetBorderColor (void)
ExCVec3D	GetBorderColor (void)
bool	GetShowBorder (void)
bool	GetShowBorder (void)
void	SetShowBorder (bool status)
void	SetShowBorder (bool status)
bool	IsMouving (void)
void	SetMouving (bool status)
bool	GetCanMouve (void)
void	SetCanMouve (bool status)
bool	IsReduced (void)
void	SetMaximized (bool status)
bool	IsMaximized (void)
void	SetReduced (bool status)
bool	IsShowWindow (void)
void	SetShowWindow (bool status)
bool	IsActive (void)
void	SetActive (bool status)
void	Load (std::ifstream *file)
std::string	Load (std::string FileName)
ExCVec2D	GetPosition (void)
void	SetFlux (std::ostrstream consol, ExCFluxAction action)
virtual bool	LoadFile (std::string FileName)
void	SetIdName (ExNihilo::IdName idname)
ExNihilo::ExId	GetId (void)
std::string	GetName (void)
std::string	GetFileName (void)
std::string	GetType (void)
void	SetId (ExNihilo::ExId Id)
void	SetName (std::string Name)
void	SetFileName (std::string FileName)
void	SetType (std::string Type)
Attributs Publics
std::ostrstream *	Consol
ExCFluxAction *	FluxAction
Types Protégés
typedef std::pair< ExCCommand, ExCAction >	CommandAction
typedef std::pair< ExCCommand, ExCAction >	CommandAction
Attributs Protégés
std::vector< CommandAction >	m_VecCommandAction
std::vector< CommandAction >	m_VecCommandAction
ExManagerTexture *	ManagerTexture
ExManagerTexture *	ManagerTexture
ExManagerWindow *	ManagerWindow
ExManagerWindow *	ManagerWindow
ExCWindowObject *	m_Parent
ExCWindowObject *	m_Parent
ExCVec2D	m_OldMousePosition
bool	m_ShowWindowTitle
std::string	m_WindowTitle
std::string	m_WindowOldTitle
ExCVec3D	m_WindowTitleColor
ExCVec2D	m_WindowSize
ExCVec2D	m_OldSize
float	m_TitleBarSize
ExCVec2D	m_OldPosition
bool	m_Blending
ExCVec3D	m_BackroundColor
float	m_BackroundBlending
ExCVec3D	m_BorderColor
float	m_BorderSize
bool	m_ShowBorder
bool	m_BackroundIsTexturing1
std::string	m_BackroundTexture1
bool	m_BackroundIsTexturing2
std::string	m_BackroundTexture2
bool	m_TextureIsMouving
ExCVec2D	m_TextureMouvingVec
bool	m_CanMouve
bool	m_Mouving
bool	m_Reduced
bool	m_Maximized
bool	m_ShowWindow
bool	m_Active
bool	m_RequestFocus
std::vector< ExCWindowObject * >	m_VecWindowObject
ExCWindowObject *	m_LastObjectFocus
ExCWindowObject *	m_CurrentObjectFocus
ExCWindowObject *	m_ObjectRequestFocus
ExCVec2D	m_Position
ExNihilo::ExId	m_ObjectId
std::string	m_ObjectName
std::string	m_ObjectFileName
std::string	m_ObjectType