Main Page   Namespace List   Class Hierarchy   Alphabetical List   Data Structures   File List   Namespace Members   Data Fields   Globals  

ExManagerConsole.cpp

Go to the documentation of this file.
00001 /*
00002  * ExNihilo 3D Engine
00003  * 
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU Library General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017  *
00018  * Please read AUTHORS file !!!
00019  * 
00020  * $Id: ExManagerConsole.cpp,v 1.42 2002/11/24 11:58:57 data Exp $
00021  *
00022  */
00023 
00024 #include "ExManagerConsole.h"
00025 
00026 bool ExManagerConsole::m_flag = false; 
00027 ExManagerConsole* ExManagerConsole::m_instance = NULL; 
00028 
00029 ExManagerConsole* ExManagerConsole::CreateSingleton(void){
00030 Guard(ExManagerConsole* ExManagerConsole::CreateSingleton(void))
00031         if(!m_flag)
00032         {
00033                 m_flag = true; // We are creating the error log now, so set flag to true
00034                 m_instance = new ExManagerConsole; // Create the error log
00035         }else
00036         {
00037                 std::cout<<"Error singleton already created"<<std::endl;
00038         }
00039         return m_instance; 
00040 UnGuard
00041 }
00042 
00043 ExManagerConsole::ExManagerConsole(void)
00044 {
00045 Guard(ExManagerConsole::ExManagerConsole(void))
00046         m_ConsoleState=HIDE;
00047         m_LineCounter=2;
00048         PosIntoBuffOldCommand=0;
00049         m_ConsoleTransPalier=20;
00050         m_fBlending=0.3f;
00051         m_fBackGroundBlue=1.0f;
00052         m_fBackGroundRed=1.0f;
00053         m_fBackGroundGreen=1.0f;
00054         console_move = false;
00055         m_BackGroundTextureState=true;
00056         m_Blending = false;
00057         LogConsol =true;
00058         m_AskForCommand=true;
00059         m_Move=0;
00060         #ifdef UNIX_SRC
00061         logfilecsl.open("/tmp/logConsol.txt",ios::out);
00062         #else
00063         logfilecsl.open("logConsol.txt",ios::out);
00064         #endif
00065         logfilecsl.close();
00066         SetStatus(false);
00067         SetAskForCommand(false);
00068         SetAskForExclusifCommand(false);
00069 UnGuard
00070 }
00071 
00072 
00073 void ExManagerConsole::Reset(void)
00074 {
00075 Guard(ExManagerConsole::Reset(void))
00076         m_ConsoleState=HIDE;
00077         m_LineCounter=2;
00078         PosIntoBuffOldCommand=0;
00079         m_ConsoleTransPalier=20;
00080         //m_BufferConsol.clear();
00081         m_VecStringAction.clear();
00082 //      SetConsoleBackGroudTexture("back2.tga");
00083         console_move = false;
00084 UnGuard
00085 }
00086 
00087 ExManagerConsole::~ExManagerConsole(void)
00088 {
00089 Guard(ExManagerConsole::~ExManagerConsole(void))
00090 UnGuard
00091 }
00092 
00093 void ExManagerConsole::Init(void)
00094 {
00095 Guard(void ExManagerConsole::init(void))
00096         SetConsoleBackGroudTexture("back.bmp");
00097 UnGuard
00098 }
00099 
00100 
00101 void ExManagerConsole::SetConsoleBackGroudTexture(std::string   FileName)
00102 {
00103 Guard(void ExManagerConsole::SetConsoleBackGroudTexture(std::string     FileName))
00104         if(ManagerTexture->Add(FileName))m_BackGroundTexture=FileName;  
00105 UnGuard
00106 }
00107 void ExManagerConsole::Draw(void)
00108 {
00109 Guard(void ExManagerConsole::Draw(void))
00110         if(!GetStatus())return;
00111         int i=0;
00112         float   textcoordy=0;
00113         float   cordy=0;
00114         char buffer[80];
00115         sprintf(buffer,"version %s ",VERSION);
00116         
00117         char bufferdata[255];
00118         sprintf(bufferdata,"]%s",m_BuffCommand.data());
00119 
00120         switch(m_ConsoleState)
00121         {
00122         case HIDE:
00123                 SetStatus(false);
00124                 break;
00125 
00126         case HALF:
00127                 textcoordy=0.5f;
00128                 cordy=ManagerWindow->GetResolutionY()/2;
00129                 break;
00130 
00131         case FULL:
00132                 textcoordy=1.0f;
00133                 cordy=ManagerWindow->GetResolutionY();
00134                 break;
00135 
00136         case HIDETOHALF:
00137                 //cout<<"Draw hide to half "<<endl;
00138                 textcoordy=(1.0f/m_ConsoleTransPalier)*m_ConsoleTrans;
00139                 cordy=(ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans;
00140                 m_ConsoleTrans++;
00141                 if(cordy>((ManagerWindow->GetResolutionY()/2)-(ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)))
00142                 {
00143                         m_ConsoleState=m_NextConsoleState;
00144                 }
00145                 break;
00146 
00147         case HIDETOFULL:
00148                 //cout<<"Draw hide to full "<<endl;
00149                 textcoordy=((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00150                 cordy=(ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans;
00151                 m_ConsoleTrans++;
00152                 if(cordy>(ManagerWindow->GetResolutionY()))
00153                 {
00154                         m_ConsoleState=m_NextConsoleState;
00155                 }
00156                 break;
00157 
00158         case HALFTOFULL:
00159                 //cout<<"Draw half to full"<<endl;
00160                 textcoordy=((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans)+0.5f;
00161                 cordy=((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans)+ManagerWindow->GetResolutionY()/2;
00162                 m_ConsoleTrans++;
00163                 if(cordy>(ManagerWindow->GetResolutionY()))
00164                 {
00165                         m_ConsoleState=m_NextConsoleState;
00166                 }
00167                 break;
00168 
00169         case FULLTOHIDE:
00170                 //cout<<"Draw full to hide"<<endl;
00171                 textcoordy=1.0f-((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00172                 cordy=ManagerWindow->GetResolutionY()-((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans);
00173                 m_ConsoleTrans++;
00174                 if(cordy<0)
00175                 {
00176                         m_ConsoleState=m_NextConsoleState;
00177                 }
00178                 break;
00179 
00180         case FULLTOHALF:
00181                 //cout<<"Draw full to half"<<endl;
00182                 textcoordy=1.0f-((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00183                 cordy=(ManagerWindow->GetResolutionY())-((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans);
00184                 m_ConsoleTrans++;
00185                 if(cordy<ManagerWindow->GetResolutionY()/2)
00186                 {
00187                         m_ConsoleState=m_NextConsoleState;
00188                 }
00189                 break;
00190  
00191         case HALFTOHIDE:
00192                 //cout<<"Draw half to hide"<<endl;
00193                 textcoordy=0.5f-((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00194                 cordy=(ManagerWindow->GetResolutionY()/2)-((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans);
00195                 m_ConsoleTrans++;
00196                 if(cordy<0)
00197                 {
00198                         m_ConsoleState=m_NextConsoleState;
00199                 }
00200                 break;
00201         }
00202         //-------------------
00203         //Draw back console
00204         //-------------------
00205         if(m_Move>0)LineUp();
00206         if(m_Move<0)LineDown();
00207 
00208         ExNihilo::EnterOrthoMode();
00209         glPushAttrib(GL_ALL_ATTRIB_BITS);
00210         if(m_BackGroundTextureState)glEnable(GL_TEXTURE_2D);
00211         glDisable(GL_LIGHTING);
00212         glDisable(GL_DEPTH_TEST);
00213         ManagerTexture->SetCurrentObject(m_BackGroundTexture);
00214         if(m_Blending)
00215         {
00216                 glColor4f(m_fBackGroundRed,m_fBackGroundGreen,m_fBackGroundBlue,m_fBlending);
00217                 glEnable(GL_BLEND);
00218                 glEnable(GL_ALPHA);
00219                 glBlendFunc(GL_ONE,GL_ONE);
00220                 glEnable(GL_ALPHA_TEST);
00221                 glAlphaFunc(GL_GREATER,0);
00222                 glDisable(GL_LIGHTING);
00223                 glBegin(GL_QUADS);
00224                         glTexCoord2f(0.0f, textcoordy);         glVertex2f(0, 0);
00225                         glTexCoord2f(0.0f, 0.0f);                       glVertex2f(0,cordy );
00226                         glTexCoord2f(1.0f, 0.0f);                       glVertex2f(ManagerWindow->GetResolutionX(),cordy);
00227                         glTexCoord2f(1.0f, textcoordy );        glVertex2f(ManagerWindow->GetResolutionX(),0);
00228                 glEnd();
00229         }else
00230         {
00231                 glColor4f(1,1,1,1);
00232                 glBegin(GL_QUADS);
00233                         glTexCoord2f(0.0f, textcoordy);         glVertex2f(0, 0);
00234                         glTexCoord2f(0.0f, 0.0f);                       glVertex2f(0,cordy );
00235                         glTexCoord2f(1.0f, 0.0f);                       glVertex2f(ManagerWindow->GetResolutionX(),cordy);
00236                         glTexCoord2f(1.0f, textcoordy );        glVertex2f(ManagerWindow->GetResolutionX(),0);
00237                 glEnd();
00238         }
00239         glPopAttrib();
00240 
00241     //-------------------
00242         //Draw credits
00243         //-------------------
00244         glColor4f(0,0,1,1);
00245         
00246         ExNihilo::RenderBitmapString(ManagerWindow->GetResolutionX()-160,cordy-40,GLUT_BITMAP_8_BY_13,"ExNihilo Engine ");
00247         ExNihilo::RenderBitmapString(ManagerWindow->GetResolutionX()-160,cordy-30,GLUT_BITMAP_8_BY_13,buffer);
00248         ExNihilo::RenderBitmapString(ManagerWindow->GetResolutionX()-160,cordy-20,GLUT_BITMAP_8_BY_13,"Plok Software");
00249         //-------------------
00250         //Draw buffer console
00251         //-------------------
00252         glColor3f(0.5,0,0);
00253         
00254         std::string             bufferstring,bufferstring2;
00255         
00256         bufferstring=Consol->rdbuf( )->str();
00257         Consol->freeze(false);
00258         Consol->clear();
00259         Consol->flush();
00260         m_LineInConsol=0;
00261         do
00262         {
00263                 bufferstring2 = bufferstring.substr(0,bufferstring.find ( "\n" ,0));
00264                 bufferstring.erase(0,bufferstring.find ( "\n" ,0)+1);
00265                 do
00266                 {
00267                         if(bufferstring2.size()>(unsigned)(ManagerWindow->GetResolutionX()/8)-1)
00268                         {
00269                                 m_BufferConsol.push_back(bufferstring2.substr(0,((int)(ManagerWindow->GetResolutionX()/8))-1));
00270                                 bufferstring2=bufferstring2.substr(((int)(ManagerWindow->GetResolutionX()/8))-1,bufferstring2.size());
00271                                 m_LineInConsol++;
00272             }else
00273                         {
00274                                 m_BufferConsol.push_back(bufferstring2);
00275                                 m_LineInConsol++;
00276                                 break;
00277                         }
00278                 }while(1);
00279         }while((unsigned)-1 != bufferstring.find( "\n" ,0));
00280 
00281         if(LogConsol=true)
00282         {
00283                 #ifdef UNIX_SRC
00284                 logfilecsl.open("/tmp/logConsol.txt",ios::out);
00285                 #else
00286                 logfilecsl.open("logConsol.txt",ios::out);
00287                 #endif
00288                 i=0;
00289                 for(m_ItBufferConsol=m_BufferConsol.begin();m_ItBufferConsol!=m_BufferConsol.end();m_ItBufferConsol++,i++)
00290                 {
00291                         logfilecsl<<i<<"::"<<m_ItBufferConsol->data()<<std::endl;                                       
00292                 }
00293                 logfilecsl.close();
00294         }
00295         i=0;
00296 
00297         for(m_RItBufferConsol=m_BufferConsol.rbegin();i<m_LineToStar;i++)
00298         {
00299                 m_RItBufferConsol++;    
00300         }
00301 
00302         for(i=0;m_RItBufferConsol!=m_BufferConsol.rend();m_RItBufferConsol++,i++)
00303         {
00304                 ExNihilo::RenderBitmapString(10,cordy-(10*i)-20,GLUT_BITMAP_8_BY_13,m_RItBufferConsol->data()); 
00305                 if(i*10>cordy)break;
00306         }
00307         m_BufferConsol.clear();
00308         
00309         ExNihilo::RenderBitmapString(10,cordy-10,GLUT_BITMAP_8_BY_13,bufferdata);
00310         glEnable(GL_DEPTH_TEST);
00311         glEnable(GL_LIGHTING);
00312         glDisable(GL_TEXTURE_2D);
00313         ExNihilo::LeaveOrthoMode();     
00314         
00315         if (m_ConsoleState == m_NextConsoleState && console_move == true) {
00316                 console_move = false;
00317         }
00318         
00319         //DrawBuffer(); 
00320 UnGuard
00321 }
00322 
00323 void ExManagerConsole::LineUp(void)
00324 {
00325         m_LineToStar++;
00326         if(m_LineToStar>m_LineInConsol)m_LineToStar=m_LineInConsol;
00327 }
00328 void ExManagerConsole::LineDown(void)
00329 {
00330         m_LineToStar--;
00331         if(m_LineToStar<0){m_LineToStar=0;}
00332 }
00333 
00334 void ExManagerConsole::ConsoleMove (bool p) {
00335         console_move = p;
00336 }
00337 
00338 void ExManagerConsole::SetConsoleState(int state)
00339 {
00340 Guard(void ExManagerConsole::SetConsoleState(int state))
00341         //cout<<"set console state :"<<state<<endl;
00342         SetStatus(true);
00343         switch(m_ConsoleState)
00344         {
00345         case HIDE:
00346                 m_NextConsoleState=state;
00347                 switch(state)
00348                 {
00349                 case HALF:
00350                         m_ConsoleState=HIDETOHALF;
00351                         break;
00352                 case FULL:
00353                         m_ConsoleState=HIDETOFULL;
00354                         break;
00355                 }
00356                 break;
00357         case HALF:
00358                 m_NextConsoleState=state;
00359                 switch(state)
00360                 {
00361                 case FULL:
00362                         m_ConsoleState=HALFTOFULL;
00363                         break;
00364                 case HIDE:
00365                         m_ConsoleState=HALFTOHIDE;
00366                         break;
00367                 }
00368                 break;
00369         case FULL:
00370                 m_NextConsoleState=state;
00371                 switch(state)
00372                 {
00373                 case HALF:
00374                         m_ConsoleState=FULLTOHALF;
00375                         break;
00376                 case HIDE:
00377                         m_ConsoleState=FULLTOHIDE;
00378                         break;
00379                 }
00380                 break;
00381         }
00382         m_ConsoleTrans=1;
00383 UnGuard
00384 }
00385 
00386 int ExManagerConsole::NextAviableState(void) {
00387 Guard(int ExManagerConsole::NextAviableState(void))
00388         switch(m_ConsoleState) {
00389                 case HIDE: return HALF;
00390                 case HALF: return FULL;
00391                 case FULL: return HIDE;
00392                 case HIDETOHALF : return HALF;
00393                 case HIDETOFULL : return FULL;
00394                 case HALFTOFULL : return FULL;
00395                 case FULLTOHALF : return HALF;
00396                 case FULLTOHIDE : return HIDE;
00397                 case HALFTOHIDE : return HIDE;
00398                 default: return HALF;
00399         }
00400 UnGuard
00401 }
00402 
00403 void ExManagerConsole::Write(const char *Label)
00404 {
00405 Guard(void ExManagerConsole::Write(const char *Label))
00406         //*Consol<<"<<==================Write to consol===========================>>"<<std::endl;
00407         *Consol << Label << std::endl;
00408         //*Consol<<"<<============================================================>>"<<std::endl;
00409 UnGuard
00410 }
00411 
00412 ExCAction ExManagerConsole::InputCommand(ExCCommand Command)
00413 {
00414 Guard(ExCAction ExManagerConsole::InputCommand(ExCCommand Command))
00415         //std::cout<<"ManagerConsol::Input Command consol:"<<Command.m_Command<<std::endl;
00416         switch(Command.m_Command)
00417         {
00418         case KEYBOARD_DOWN_EXP:
00419                 InputAction(CONSOL_NEXT_AVIABLE_STATE);
00420                 return NOTHING; 
00421         
00422         case KEYBOARD_DOWN_ESC: 
00423                 InputAction(HIDE_CONSOL);
00424                 return NOTHING; 
00425 
00426         case KEYBOARD_DOWN_A:
00427                 m_BuffCommand.append("a"); 
00428                 return NOTHING;
00429         
00430         case KEYBOARD_DOWN_Z:
00431                 m_BuffCommand.append("z");
00432                 return NOTHING;
00433         
00434         case KEYBOARD_DOWN_E:
00435                 m_BuffCommand.append("e");
00436                 return NOTHING;
00437         
00438         case KEYBOARD_DOWN_R:
00439                 m_BuffCommand.append("r");
00440                 return NOTHING;
00441         
00442         case KEYBOARD_DOWN_T:
00443                 m_BuffCommand.append("t");
00444                 return NOTHING;
00445         
00446         case KEYBOARD_DOWN_Y:
00447                 m_BuffCommand.append("y");
00448                 return NOTHING;
00449         
00450         case KEYBOARD_DOWN_U:
00451                 m_BuffCommand.append("u");
00452                 return NOTHING;
00453         case KEYBOARD_DOWN_I:
00454                 m_BuffCommand.append("i");
00455                 return NOTHING;
00456 
00457         case KEYBOARD_DOWN_O:
00458                 m_BuffCommand.append("o");
00459                 return NOTHING;
00460 
00461         case KEYBOARD_DOWN_P:
00462                 m_BuffCommand.append("p");
00463                 return NOTHING;
00464 
00465         case KEYBOARD_DOWN_Q:
00466                 m_BuffCommand.append("q");
00467                 return NOTHING;
00468 
00469         case KEYBOARD_DOWN_S:
00470                 m_BuffCommand.append("s");
00471                 return NOTHING;
00472 
00473         case KEYBOARD_DOWN_D:
00474                 m_BuffCommand.append("d");
00475                 return NOTHING;
00476 
00477         case KEYBOARD_DOWN_F:
00478                 m_BuffCommand.append("f");
00479                 return NOTHING;
00480 
00481         case KEYBOARD_DOWN_G:
00482                 m_BuffCommand.append("g");
00483                 return NOTHING;
00484 
00485         case KEYBOARD_DOWN_H:
00486                 m_BuffCommand.append("h");
00487                 return NOTHING;
00488 
00489         case KEYBOARD_DOWN_J:
00490                 m_BuffCommand.append("j");
00491                 return NOTHING;
00492 
00493         case KEYBOARD_DOWN_K:
00494                 m_BuffCommand.append("k");
00495                 return NOTHING;
00496 
00497         case KEYBOARD_DOWN_L:
00498                 m_BuffCommand.append("l");
00499                 return NOTHING;
00500 
00501         case KEYBOARD_DOWN_M:
00502                 m_BuffCommand.append("m");
00503                 return NOTHING;
00504 
00505         case KEYBOARD_DOWN_W:
00506                 m_BuffCommand.append("w");
00507                 return NOTHING;
00508 
00509         case KEYBOARD_DOWN_X:
00510                 m_BuffCommand.append("x");
00511                 return NOTHING;
00512 
00513         case KEYBOARD_DOWN_C:
00514                 m_BuffCommand.append("c");
00515                 return NOTHING;
00516 
00517         case KEYBOARD_DOWN_V:
00518                 m_BuffCommand.append("v");
00519                 return NOTHING;
00520 
00521         case KEYBOARD_DOWN_B:
00522                 m_BuffCommand.append("b");
00523                 return NOTHING;
00524 
00525         case KEYBOARD_DOWN_N:
00526                 m_BuffCommand.append("n");
00527                 return NOTHING;
00528         
00529         case KEYBOARD_DOWN_M_A:
00530                 m_BuffCommand.append("A"); 
00531                 return NOTHING;
00532         
00533         case KEYBOARD_DOWN_M_Z:
00534                 m_BuffCommand.append("Z");
00535                 return NOTHING;
00536         
00537         case KEYBOARD_DOWN_M_E:
00538                 m_BuffCommand.append("E");
00539                 return NOTHING;
00540         
00541         case KEYBOARD_DOWN_M_R:
00542                 m_BuffCommand.append("R");
00543                 return NOTHING;
00544         
00545         case KEYBOARD_DOWN_M_T:
00546                 m_BuffCommand.append("T");
00547                 return NOTHING;
00548         
00549         case KEYBOARD_DOWN_M_Y:
00550                 m_BuffCommand.append("Y");
00551                 return NOTHING;
00552         
00553         case KEYBOARD_DOWN_M_U:
00554                 m_BuffCommand.append("U");
00555                 return NOTHING;
00556         case KEYBOARD_DOWN_M_I:
00557                 m_BuffCommand.append("I");
00558                 return NOTHING;
00559 
00560         case KEYBOARD_DOWN_M_O:
00561                 m_BuffCommand.append("O");
00562                 return NOTHING;
00563 
00564         case KEYBOARD_DOWN_M_P:
00565                 m_BuffCommand.append("P");
00566                 return NOTHING;
00567 
00568         case KEYBOARD_DOWN_M_Q:
00569                 m_BuffCommand.append("Q");
00570                 return NOTHING;
00571 
00572         case KEYBOARD_DOWN_M_S:
00573                 m_BuffCommand.append("S");
00574                 return NOTHING;
00575 
00576         case KEYBOARD_DOWN_M_D:
00577                 m_BuffCommand.append("D");
00578                 return NOTHING;
00579 
00580         case KEYBOARD_DOWN_M_F:
00581                 m_BuffCommand.append("F");
00582                 return NOTHING;
00583 
00584         case KEYBOARD_DOWN_M_G:
00585                 m_BuffCommand.append("G");
00586                 return NOTHING;
00587 
00588         case KEYBOARD_DOWN_M_H:
00589                 m_BuffCommand.append("H");
00590                 return NOTHING;
00591 
00592         case KEYBOARD_DOWN_M_J:
00593                 m_BuffCommand.append("J");
00594                 return NOTHING;
00595 
00596         case KEYBOARD_DOWN_M_K:
00597                 m_BuffCommand.append("K");
00598                 return NOTHING;
00599 
00600         case KEYBOARD_DOWN_M_L:
00601                 m_BuffCommand.append("L");
00602                 return NOTHING;
00603 
00604         case KEYBOARD_DOWN_M_M:
00605                 m_BuffCommand.append("M");
00606                 return NOTHING;
00607 
00608         case KEYBOARD_DOWN_M_W:
00609                 m_BuffCommand.append("W");
00610                 return NOTHING;
00611 
00612         case KEYBOARD_DOWN_M_X:
00613                 m_BuffCommand.append("X");
00614                 return NOTHING;
00615 
00616         case KEYBOARD_DOWN_M_C:
00617                 m_BuffCommand.append("C");
00618                 return NOTHING;
00619 
00620         case KEYBOARD_DOWN_M_V:
00621                 m_BuffCommand.append("V");
00622                 return NOTHING;
00623 
00624         case KEYBOARD_DOWN_M_B:
00625                 m_BuffCommand.append("B");
00626                 return NOTHING;
00627 
00628         case KEYBOARD_DOWN_M_N:
00629                 m_BuffCommand.append("N");
00630                 return NOTHING;
00631 
00632         case KEYBOARD_DOWN_0:
00633                 m_BuffCommand.append("0");
00634                 return NOTHING;
00635 
00636         case KEYBOARD_DOWN_1:
00637                 m_BuffCommand.append("1");
00638                 return NOTHING;
00639 
00640         case KEYBOARD_DOWN_2:
00641                 m_BuffCommand.append("2");
00642                 return NOTHING;
00643 
00644         case KEYBOARD_DOWN_3:
00645                 m_BuffCommand.append("3");
00646                 return NOTHING;
00647 
00648         case KEYBOARD_DOWN_4:
00649                 m_BuffCommand.append("4");
00650                 return NOTHING;
00651 
00652         case KEYBOARD_DOWN_5:
00653                 m_BuffCommand.append("5");
00654                 return NOTHING;
00655 
00656         case KEYBOARD_DOWN_6:
00657                 m_BuffCommand.append("6");
00658                 return NOTHING;
00659 
00660         case KEYBOARD_DOWN_7:
00661                 m_BuffCommand.append("7");
00662                 return NOTHING;
00663 
00664         case KEYBOARD_DOWN_8:
00665                 m_BuffCommand.append("8");
00666                 return NOTHING;
00667 
00668         case KEYBOARD_DOWN_9:
00669                 m_BuffCommand.append("9");
00670                 return NOTHING;
00671 
00672         case KEYBOARD_DOWN__:
00673                 m_BuffCommand.append("_");
00674                 return NOTHING;
00675 
00676         case KEYBOARD_DOWN_2POINTS:
00677                 m_BuffCommand.append(":");
00678                 return NOTHING;
00679 
00680         case KEYBOARD_DOWN_POINT:
00681                 m_BuffCommand.append(".");
00682                 return NOTHING;
00683 
00684         case KEYBOARD_DOWN_PAGE_UP:
00685                 m_Move=-1;
00686                 return NOTHING;
00687         
00688         case KEYBOARD_DOWN_PAGE_DOWN:
00689                 m_Move=1;
00690                 return NOTHING;
00691 
00692         case KEYBOARD_UP_PAGE_UP:
00693                 m_Move=0;
00694                 return NOTHING;
00695         
00696         case KEYBOARD_UP_PAGE_DOWN:
00697                 m_Move=0;
00698                 return NOTHING;
00699 
00700         case KEYBOARD_DOWN_SPACE:
00701                 m_BuffCommand.append(" ");
00702                 return NOTHING;
00703 
00704         case KEYBOARD_DOWN_ENTER:
00705                 return ApplyBuffCommand();
00706         
00707         case KEYBOARD_DOWN_TAB: {
00708                 std::vector<std::string> vec_tmp;
00709                 std::vector<std::string>::iterator i_tmp;
00710                 
00711                 vec_tmp.push_back ("load");
00712                 vec_tmp.push_back ("cmd");
00713                 vec_tmp.push_back ("help");
00714                 vec_tmp.push_back ("clear");
00715                 vec_tmp.push_back ("quit");
00716                 
00717                 for (m_ItVecStringAction = m_VecStringAction.begin(); m_ItVecStringAction != m_VecStringAction.end(); m_ItVecStringAction++) {
00718                         vec_tmp.push_back (m_ItVecStringAction->first);
00719                 }
00720                 
00721                 i_tmp = vec_tmp.begin ();
00722                 std::string tmp;
00723                 
00724                 while (i_tmp != vec_tmp.end ()) {
00725                         tmp = *i_tmp++;
00726                 
00727                         if (tmp.find (m_BuffCommand) == 0) {
00728                                 if (tmp.find (' ') < tmp.length ())
00729                                         m_BuffCommand = tmp.substr (0, tmp.find (' '));
00730                                 else m_BuffCommand = tmp;
00731                                 //m_BuffCommand += ' '; // this add a space after command
00732                                 // but it sucks with some commands like quit :/
00733                         }
00734                 }
00735                 return NOTHING;
00736         }
00737         case KEYBOARD_DOWN_CTRL_U:
00738                 m_BuffCommand = ""; 
00739                 return NOTHING;
00740         
00741         case KEYBOARD_UP_ARROW_DOWN:
00742                 PosIntoBuffOldCommand++;
00743                 if(PosIntoBuffOldCommand<(int)m_BuffOldCommand.size()&&PosIntoBuffOldCommand>=-1)
00744                 {
00745                         m_BuffCommand=m_BuffOldCommand.at(PosIntoBuffOldCommand);                       
00746                 }else
00747                 {
00748                         PosIntoBuffOldCommand=0;
00749                 }
00750 
00751 
00752                 return NOTHING;
00753         
00754         case KEYBOARD_UP_ARROW_UP:
00755                 PosIntoBuffOldCommand--;
00756                 if(PosIntoBuffOldCommand<(int)m_BuffOldCommand.size()&&PosIntoBuffOldCommand>=0)
00757                 {
00758                         m_BuffCommand=m_BuffOldCommand.at(PosIntoBuffOldCommand);                       
00759                 }else
00760                 {
00761                         PosIntoBuffOldCommand=0;
00762                 }
00763                 return NOTHING;
00764         
00765         case KEYBOARD_UP_ARROW_LEFT:
00766                 if(m_BuffCommand.size()>0)
00767                 {
00768                         m_BuffCommand.erase(m_BuffCommand.end()-1,m_BuffCommand.end());
00769                 }
00770                 return NOTHING;
00771         
00772         case KEYBOARD_UP_BACKSPACE:
00773                 if(m_BuffCommand.size()>0)
00774                 {
00775                         m_BuffCommand.erase(m_BuffCommand.end()-1,m_BuffCommand.end());
00776                 }
00777                 return NOTHING;
00778 
00779         default :return NOTHING;
00780         }
00781 UnGuard
00782 }
00783 
00784 void ExManagerConsole::ListConsoleCommand(void)
00785 {
00786 Guard(void ExManagerConsole::ListConsoleCommand(void))
00787         *Consol<<"*******************************"<<std::endl;
00788         *Consol<<"*List of all available command*"<<std::endl;
00789         *Consol<<"*******************************"<<std::endl;
00790         *Consol<<"load 'FILENAME'"<<std::endl;
00791         *Consol<<"cmd 'number of command'"<<std::endl;;
00792         *Consol<<"help 'command'"<<std::endl;
00793         *Consol<<"clear 'clear console screen'"<<std::endl;
00794         *Consol<<"quit 'exit ExNihilo'"<<std::endl;
00795         int i=PREDIFINEDCOMMAND;
00796         for(m_ItVecStringAction=m_VecStringAction.begin(); m_ItVecStringAction != m_VecStringAction.end(); m_ItVecStringAction++, i++) 
00797         {
00798                 *Consol<<m_ItVecStringAction->first.data()<<std::endl;
00799         }
00800         *Consol<<"*****************************"<<std::endl;
00801 UnGuard
00802 }
00803 
00804 ExCAction ExManagerConsole::ApplyBuffCommand(void)
00805 {
00806 Guard(ExCAction ExManagerConsole::ApplyBuffCommand(void))
00807 bool findaction=false;
00808         ExCAction Action;
00809         Action.m_StartingLife=(double)((double)glutGet(GLUT_ELAPSED_TIME)/1000);
00810         *Consol<<m_BuffCommand.data()<<std::endl;
00811         for(m_ItVecStringAction=m_VecStringAction.begin();m_ItVecStringAction!=m_VecStringAction.end();m_ItVecStringAction++)
00812         {
00813                 if(m_BuffCommand.find(m_ItVecStringAction->first.data())==0)
00814                 {                        
00815                         findaction=true;
00816                         char buffer[255];
00817                         memset(buffer,0,255);
00818                         Action.m_Action=m_ItVecStringAction->second;
00819                         m_BuffCommand.copy(buffer,(m_BuffCommand.size())-(strlen(m_ItVecStringAction->first.data())),strlen(m_ItVecStringAction->first.data()));
00820                         Action.SetParam(buffer);
00821                         m_BuffOldCommand.push_back(m_BuffCommand);
00822                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00823                 }           
00824         }
00825         if(!findaction)
00826         {
00827                 if(strcmp(m_BuffCommand.data(),"clear")==0)
00828                 {
00829                         m_BuffOldCommand.push_back(m_BuffCommand);
00830                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00831                         m_BufferConsol.clear();
00832                         ClearConsol();
00833                         Action.m_Action= NOTHING;
00834                         return Action;
00835                 }
00836                 
00837                 if(m_BuffCommand.find("help")==0)
00838                 {
00839                         ListConsoleCommand();
00840                         m_BuffOldCommand.push_back(m_BuffCommand);
00841                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00842                         Action.m_Action= NOTHING;
00843                         return Action;
00844                 }
00845                 if(m_BuffCommand.find("cmd ")==0)
00846                 {
00847                         int cmd=0;
00848                         char *SBuffer;
00849                         SBuffer=new char[strlen(m_BuffCommand.data())-5] ;
00850                         memset(SBuffer,0,strlen(m_BuffCommand.data()));
00851                         m_BuffCommand.copy(SBuffer,m_BuffCommand.size()-4,4);
00852                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00853                         try
00854                         {
00855                                 cmd=atoi(SBuffer);
00856                                 Action.m_Action= m_VecStringAction.at(cmd-PREDIFINEDCOMMAND).second;
00857                         }catch(...)
00858                         {
00859                                 *Consol<<"Bad argument use list to show command list"<<std::endl;
00860                                 Action.m_Action= NOTHING;
00861                                 return Action;
00862                         }
00863                 }
00864 
00865                 if(strcmp(m_BuffCommand.data(),"quit")==0)
00866                 {
00867                         m_BuffOldCommand.push_back(m_BuffCommand);
00868                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00869                         Action.m_Action= QUIT;
00870                         return Action;
00871                 }
00872                 
00873                 if(strcmp(m_BuffCommand.data(),"reset")==0)
00874                 {
00875                         m_BuffOldCommand.push_back(m_BuffCommand);
00876                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00877                         Action.m_Action= RESET;
00878                         return Action;
00879                 }
00880 
00881                 if(m_BuffCommand.find("load")!=(unsigned)-1)
00882                 {
00883                         char buffer[255];
00884                         memset(buffer,0,255);
00885                         Action.m_Action=LOAD_FILE;
00886                         m_BuffCommand.copy(buffer,m_BuffCommand.size()-4,4);
00887                         Action.SetParam(buffer);
00888                         m_BuffOldCommand.push_back(m_BuffCommand);
00889                         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00890                         return Action;
00891                 }
00892                 
00893                 *Consol<<"Unknow command"<<std::endl;
00894                 m_BuffOldCommand.push_back(m_BuffCommand);
00895                 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00896                 Action.m_Action= NOTHING;
00897         }
00898         return Action;
00899 UnGuard
00900 }
00901 
00902 void ExManagerConsole::AddStringAction(std::string String,int Action)
00903 {
00904 Guard(void ExManagerConsole::AddStringAction(std::string String,int Action))
00905         StringAction ac;
00906         ac.first=String;
00907         ac.second=Action;
00908         m_VecStringAction.push_back(ac);
00909         *Consol<<"Add new command to console command:"<<String<<" Action:"<<Action<<std::endl;
00910 UnGuard
00911 }
00912 
00913 void ExManagerConsole::AddStringAction(StringAction StrAction)
00914 {
00915 Guard(void ExManagerConsole::AddStringAction(StringAction StrAction))
00916         AddStringAction(StrAction.first.data(),StrAction.second);
00917 UnGuard
00918 }
00919 
00920 void ExManagerConsole::AddStringAction(ExCFileDataAction p) {
00921 Guard(void ExManagerConsole::AddStringAction(ExCFileDataAction p))
00922         StringAction foo;
00923         foo.first = p.getAction();
00924         foo.second = p.getCommand();
00925         AddStringAction(foo);
00926 UnGuard
00927 }
00928 
00929 void ExManagerConsole::LoadStringActionFile(const char *FileName)
00930 {
00931 Guard(void ExManagerConsole::LoadStringActionFile(const char *FileName))
00932     char                        buffer[255];
00933         
00934 #ifdef UNIX_SRC
00935         sprintf(buffer, PREFIX "/ExNihilo/Data/Console/%s", FileName);
00936 #else
00937         sprintf(buffer, "../Data/Console/%s", FileName);
00938 #endif
00939         StringAction BuffStringAction;
00940         std::ifstream fin;
00941         std::string buffstring;
00942         char b[256];
00943         fin.open(buffer,std::ios::in);
00944         if(fin.is_open())
00945         {
00946                 try
00947                 {
00948                         do
00949                         {
00950                                 memset(b,0,255);
00951                                 fin.getline(b,256,'\n');
00952                                 try
00953                                 {
00954                                         buffstring=ExNihilo::ExtracValueFromSring(b,"<consolcommand>","<#consolcommand>");
00955                                         AddStringAction(ExNihilo::ExtracValueFromSring(buffstring,"<string>","<#string>")
00956                                                 ,ExNihilo::ExtractIntValueFromSring(buffstring,"<action>","<#action>"));
00957                                 }catch(ExCExpStringNotFound){}
00958                         }while(!fin.eof());
00959                         fin.close();
00960                 }catch(...){throw ExCExpFileReadError();}
00961         }else throw   ExCExpFileNotFound();
00962 UnGuard
00963 }
00964 
00965 void ExManagerConsole::ClearConsol(void)
00966 {
00967 Guard(void ExManagerConsole::ClearConsol(void))
00968         m_BuffOldCommand.push_back(m_BuffCommand);
00969         m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00970         m_BufferConsol.clear();
00971 UnGuard
00972 }
00973 
00974 
00975 ExCAction ExManagerConsole::InputAction(ExCAction Action)
00976 {
00977 Guard(ExCAction ExManagerConsole::InputAction(ExCAction Action))
00978         //std::cout<<"ManagerConsol::Input action :"<<Action<<std::endl;
00979         switch(Action.m_Action)
00980         {
00981         case CONSOL_LINE_UP:LineUp();break;
00982         case CONSOL_LINE_DOWN:LineDown();break;
00983     case SHOW_HALF_CONSOL:                                              
00984                 if (!isConsoleMove ()) 
00985                 {
00986                         ConsoleMove (true);
00987                         SetStatus(true);
00988                         SetAskForCommand(true);
00989                         SetAskForExclusifCommand(true);
00990                         SetConsoleState(HALF);
00991                 }
00992                 break;
00993         case SHOW_FULL_CONSOL:
00994                 if (!isConsoleMove ()) 
00995                 {
00996                         ConsoleMove (true);
00997                         SetStatus(true);
00998                         SetAskForCommand(true);
00999                         SetAskForExclusifCommand(true);
01000                         SetConsoleState(FULL);
01001                 }
01002                 break;
01003         case HIDE_CONSOL:       
01004                 if (!isConsoleMove ()) 
01005                 {
01006                         ConsoleMove (true);
01007                         SetStatus(false);
01008                         SetConsoleState(HIDE);
01009                         SetAskForCommand(false);
01010                         SetAskForExclusifCommand(false);
01011                 }
01012                 break;
01013         case CONSOL_NEXT_AVIABLE_STATE:
01014                 switch(NextAviableState())
01015                 {
01016                 case HIDE:
01017                 case FULLTOHIDE:
01018                 case HALFTOHIDE:
01019                         if (!isConsoleMove ()) 
01020                         {
01021                                 ConsoleMove (true);
01022                                 SetStatus(false);
01023                                 SetConsoleState(HIDE);
01024                                 SetAskForCommand(false);
01025                                 SetAskForExclusifCommand(false);
01026                         }
01027                         break;
01028                 case HALF:
01029                 case HIDETOHALF:
01030                 case FULLTOHALF:
01031                         if (!isConsoleMove ()) 
01032                         {
01033                                 ConsoleMove (true);
01034                                 SetStatus(true);
01035                                 SetAskForCommand(true);
01036                                 SetAskForExclusifCommand(true);
01037                                 SetConsoleState(HALF);
01038                         }
01039                         break;
01040                 case FULL:
01041                 case HIDETOFULL:
01042                 case HALFTOFULL:
01043                         if (!isConsoleMove ()) 
01044                         {
01045                                 ConsoleMove (true);
01046                                 SetStatus(true);
01047                                 SetAskForCommand(true);
01048                                 SetAskForExclusifCommand(true);
01049                                 SetConsoleState(FULL);
01050                         }
01051                         break;
01052                 }
01053                 break;
01054 
01055         case SET_CONSOL_BACKGROUND_TEXURE:SetConsoleBackGroudTexture(Action.m_Param);break;
01056         case ENABLE_CONSOL_BACKGROUND_TEXTURE:SetConsoleBackGroudTextureState(true);break;
01057         case DISABLE_CONSOL_BACKGROUND_TEXTURE:SetConsoleBackGroudTextureState(false);break;
01058         case SET_CONSOL_BACKGROUND_COLOR:break;
01059         case SET_CONSOL_BACKGROUND_COLOR_BLUE:
01060                 try
01061                 {
01062                         SetConsoleBackGroudColorBlue(atof(Action.m_Param.data()));
01063                 }catch(...)
01064                 {
01065                         *Consol<<"Enter a float value"<<std::endl;
01066                 }
01067                 break;
01068         case SET_CONSOL_BACKGROUND_COLOR_GREEN:
01069                 try
01070                 {
01071                         SetConsoleBackGroudColorGreen(atof(Action.m_Param.data()));
01072                 }catch(...)
01073                 {
01074                         *Consol<<"Enter a float value"<<std::endl;
01075                 }
01076                 break;
01077         case SET_CONSOL_BACKGROUND_COLOR_RED:
01078                 try
01079                 {
01080                         SetConsoleBackGroudColorRed(atof(Action.m_Param.data()));
01081                 }catch(...)
01082                 {
01083                         *Consol<<"Enter a float value"<<std::endl;
01084                 }
01085         case ENABLE_CONSOL_BACKGROUND_BLENDING:SetConsoleBackGroudBlendingState(true);break;
01086         case DISABLE_CONSOL_BACKGROUND_BLENDING:SetConsoleBackGroudBlendingState(false);break;
01087         case SET_CONSOL_BACKGROUND_BLENDING:
01088                 try
01089                 {
01090                         SetConsoleBackGroudBlending(atof(Action.m_Param.data()));
01091                 }catch(...)
01092                 {
01093                         *Consol<<"Enter a float value"<<std::endl;
01094                 }
01095                 break;
01096         }       
01097     if(Action.m_NextAction){return *Action.m_NextAction;}
01098         else{return NOTHING;}
01099 UnGuard
01100 }
01101 

Generated on Tue Dec 10 18:20:06 2002 for ExNihilo by doxygen1.3-rc1