SdlArs.cpp

Go to the documentation of this file.

#include <SdlArs.h>

#ifdef _DEBUG
#       pragma comment( lib , "sdld.lib" )
#       pragma comment( lib , "sdlmaind.lib" )
#       pragma comment( lib , "sdl_imaged.lib" )
#       pragma comment( lib , "sdl_mixerd.lib" )
#       pragma comment( lib , "smpegd.lib" )
//#     pragma comment( lib , "freetype214MD.lib" )
#else
#       pragma comment( lib , "sdl.lib" )
#       pragma comment( lib , "sdlmain.lib" )
#       pragma comment( lib , "sdl_image.lib" )
#       pragma comment( lib , "sdl_mixer.lib" )
#       pragma comment( lib , "smpeg.lib" )
//#     pragma comment( lib , "freetype214MD.lib" )
#endif
#pragma comment( lib , "libfreetype.lib" )
#pragma comment( lib , "libz.lib" )

ofstream        tron;

//void OutputDebugString( const char *lpOutputString );

Ars::RGBColor ArsText_color(  0,   0,   0 );
Ars::RGBColor ArsBack_color( 0xc0, 0xc0, 0xc0 );

Ars::ArsApplication *_mainApp_;

int     Ars::ArsApplication::scrW = 1280 , Ars::ArsApplication::scrH = 1024;

extern Ars::Window *cbObjCreate( const icstring &name );

// Static members
namespace Ars
{

extern SDL_mutex *rsrcMutex;

map<icstring,void *>    ArsApplication::lbGetter;
map<icstring,unsigned long>     ArsApplication::Mnemo_f , ArsApplication::Mnemo_s;
vector<cbObjCreateType> ArsApplication::objCreate;

ArsApplication  *ArsApplication::instance = 0;

ArsApplication::ArsApplication( const int Argc , char **Argv )
: argc( Argc ) , argv( Argv ) , exitCode( EXIT_FAILURE ) , frame( 0 )
, running( false ) , defaultFontEngine( 0 ) , keyFocusWindow( 0 )
{
        rsrcMutex = SDL_CreateMutex();

        instance = this;

        if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
                tron << "ArsApplication::ArsApplication : Could not initialize SDL: " << SDL_GetError() << "\n";;

        //Setting the keyboard repeat rate using the SDL Default rates
        if(SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL) == -1)
                tron << "ArsApplication::ArsApplication : Error setting SDL keyboard repeat rate.\n";

        Mix_OpenAudio( MIX_DEFAULT_FREQUENCY , MIX_DEFAULT_FORMAT , 2 , 4096 );

        Mnemo_f["F_NONE"] = F_NONE;
        Mnemo_f["F_SELECTABLE"] = F_SELECTABLE;
        Mnemo_f["F_EXIT"] = F_EXIT;
        Mnemo_f["F_EDITABLE"] = F_EDITABLE;
        Mnemo_f["F_HIDETREE"] = F_HIDETREE;
        Mnemo_f["F_INDIRECT"] = F_INDIRECT;
        Mnemo_f["F_PASSWORD"] = F_PASSWORD ;
        Mnemo_f["F_MULTISELECT"] = F_MULTISELECT;
        Mnemo_f["F_TABSTOP"] = F_TABSTOP;
        Mnemo_f["F_FOLLOWMOUSE"] = F_FOLLOWMOUSE;

        Mnemo_s["S_NONE"] = S_NONE;
        Mnemo_s["S_SELECTED"] = S_SELECTED;
        Mnemo_s["S_DISABLED"] = S_DISABLED;
        Mnemo_s["S_CHECKED"] = S_CHECKED;
        Mnemo_s["S_OUTLINED"] = S_OUTLINED;
        Mnemo_s["S_SHADOWED"] = S_SHADOWED;
        Mnemo_s["S_BORDER"] = S_BORDER;
        Mnemo_s["S_FOCUS"] = S_FOCUS;

        Mnemo_s["S_ALIGN_LEFT"] = S_ALIGN_LEFT;
        Mnemo_s["S_ALIGN_RIGHT"] = S_ALIGN_RIGHT;
        Mnemo_s["S_ALIGN_TOP"] = S_ALIGN_TOP;
        Mnemo_s["S_ALIGN_BOTTOM"] = S_ALIGN_BOTTOM;

        Mnemo_s["S_RAISED"] = S_RAISED;
        Mnemo_s["S_SUNKEN"] = S_SUNKEN;
        Mnemo_s["S_TRANSPARENT"] = S_TRANSPARENT;
        Mnemo_s["S_HIGHLIGHT"] = S_HIGHLIGHT;
        Mnemo_s["S_INVERTONFOLLOW"] = S_INVERTONFOLLOW;

        objCreate.push_back( (cbObjCreateType)::cbObjCreate );

        atexit( SDL_Quit );
}

ArsApplication::~ArsApplication(void)
{
        SDL_DestroyMutex( rsrcMutex );

        if( frame )
                delete frame;
        frame = 0;

        for( std::map<std::pair<std::string, unsigned char>, FontEngine*>::iterator iter = begin() ; iter != end() ; ++iter )
        {
                if (iter->second)
                {
                        delete iter->second;
                        iter->second = 0;
                }
        }
        clear();

        while( !Cfg::Empty() )
        Cfg::Pop();

        Ars::Graf::ResetImage();
        Ars::Graf::ResetCursors();
        Ars::UnloadSounds();

}

void ArsApplication::GenDefaultCfg( void )
{
        Cfg::Handler &h = Cfg::GetCfg();

        h.SetCfgColorHex( "Ars" , "text_color" , ArsText_color );
        h.SetCfgColorHex( "Ars" , "back_color" , ArsBack_color );

        h.SetCfgFile( "Paths" , "Fonts" , "./data/Fonts/Fonts.cfg" );
        h.SetCfgFile( "Paths" , "Dialogs" , "./data/dialogs.cfg" );
        h.SetCfgFile( "Paths" , "Menu" , "./data/menu.cfg" );
        h.SetCfgFile( "Paths" , "Images" , "./data/images/images.cfg" );

        h.Flush();
}

void ArsApplication::Init(void)
{
        if( Cfg::GetCfg().GetSize() == 0 )
                ((ArsApplication *)this)->GenDefaultCfg();

        Cfg::Push( "Ars.Cfg" );

        MessageServer::Instance().RegisterMessageClient( this , Message::APP_EXIT );
        SDL_EnableUNICODE( 1 );

        Cfg::Handler &h = Cfg::GetCfg();

        ArsText_color = h.GetCfgColorHex( "Ars" , "text_color" , RGBColor(  0,   0,   0) );
        ArsBack_color = h.GetCfgColorHex( "Ars" , "back_color" , RGBColor(223, 223, 223) );

        Cfg::Handler    &fnt = Cfg::Push( h.GetCfgString( "Paths" , "Fonts" ) );
        SetDefaultFontEngine( GetFontEngine( fnt.GetCfgFile( "" , "Font0" ) , 16 ) );
}

void ArsApplication::SetKeyFocus( MessageClient *pWindow )
{
        // notify the window that's losing focus to repaint itself
        if( keyFocusWindow != pWindow )
        {
                if( keyFocusWindow )
                        ArsPostMessage( CtrlMessage( Message::LOST_FOCUS , keyFocusWindow , pWindow ) );
                ArsPostMessage( Message( Message::SET_FOCUS , pWindow ) );
        }
        keyFocusWindow = pWindow;
}

void ArsApplication::Exec(void)
{
        frame->Init( EmptyString );
        while( !MessageServer::Instance().empty() )
                MessageServer::Instance().ProcessMessage();

        running = true;
        frame->MainLoop();
}

string ArsApplication::GetCoordStr( void )
{
        char    temp[10];
        string ans( itoa( scrW , temp , 10 ) );
        ans += "x";
        ans += itoa( scrH , temp , 10 );
        return ans;
}

const bool ArsApplication::wmExit( const Message &msg )
{
        // push an event into the SDL queue so the SDLEventLoopThread can exit
        // the actual contents of the event are not a concern as it serves just to trigger the SDL_WaitEvent
        SDL_Event user_event;
        user_event.type=SDL_USEREVENT;
        user_event.user.code=0;
        user_event.user.data1=0;
        user_event.user.data2=0;
//      DEBUG_ONLY(int iResult =) SDL_PushEvent(&user_event);
//      TraceIf(EXIT_SUCCESS == -1, "ArsApplication::ApplicationExit - Unable to push SDL user_event.");
        exitCode = EXIT_SUCCESS;
        running = false;
        
        return true;
}

FontEngine* ArsApplication::GetFontEngine( std::string sFontFileName , unsigned char iFontSize )
{
        std::map< std::pair< std::string, unsigned char>, FontEngine *>::iterator iterFontEngine = find(std::make_pair(sFontFileName, iFontSize));
        FontEngine* pFontEngine = 0;

        if (iterFontEngine == end())
        {
                // Requested font engine doesn't exist, so create one and add it to the map
                pFontEngine = new FontEngine(sFontFileName, iFontSize);
                insert(std::make_pair(std::make_pair(sFontFileName, iFontSize), pFontEngine));
        }
        else
                pFontEngine = iterFontEngine->second;

        return pFontEngine;
}

const bool ArsApplication::MainLoop( void )
{
        SDL_Event event;
        if( IsRunning() )
        {
                while( SDL_PollEvent( &event ) )
                        HandleSDLEvent( event );

                while( MessageServer::Instance().empty() )
                {
                        while( SDL_PollEvent( &event ) )
                                HandleSDLEvent( event );
                        SDL_Delay( 10 );
                }
                MessageServer::Instance().ProcessMessage();

                if( !SDL_PollEvent( &event ) )
                {
                        if( MessageServer::Instance().empty() )
                                frame->IdleProcess();
                }
                else
                        HandleSDLEvent( event );
        }
        return IsRunning();
}

XPoint ArsApplication::mousexy;

void ArsApplication::HandleSDLEvent( SDL_Event Event )
{
        // this will turn an SDL event into a wGui message
        switch (Event.type)
        {
        case SDL_VIDEORESIZE:
                ArsPostMessage( ResizeMessage( Message::CTRL_RESIZE, 0, 0, XPoint(Event.resize.w, Event.resize.h ) ) );
                break;
        case SDL_KEYDOWN:
                ArsPostMessage( KeyboardMessage( Message::KEYBOARD_KEYDOWN, GetKeyFocus(),Event.key.keysym.scancode, Event.key.keysym.mod,Event.key.keysym.sym, Event.key.keysym.unicode ) );
                break;
        case SDL_KEYUP:
                ArsPostMessage( KeyboardMessage( Message::KEYBOARD_KEYUP, GetKeyFocus(),Event.key.keysym.scancode, Event.key.keysym.mod,Event.key.keysym.sym, Event.key.keysym.unicode ) );
                break;
        case SDL_MOUSEBUTTONDOWN:
                mousexy = XPoint(Event.button.x, Event.button.y);
                ArsPostMessage( MouseMessage( Message::MOUSE_BUTTONDOWN, 0, XPoint(Event.button.x, Event.button.y), XPoint() , MouseMessage::TranslateSDLButton( Event.button.button ) ) );
                break;
        case SDL_MOUSEBUTTONUP:
                mousexy = XPoint(Event.button.x, Event.button.y);
                ArsPostMessage( MouseMessage( Message::MOUSE_BUTTONUP, 0, XPoint(Event.button.x, Event.button.y), XPoint() ,MouseMessage::TranslateSDLButton(Event.button.button) ) );
                break;
        case SDL_MOUSEMOTION:
                mousexy = XPoint(Event.motion.x, Event.motion.y);
                ArsPostMessage( MouseMessage( Message::MOUSE_MOVE, 0, XPoint(Event.motion.x, Event.motion.y) , XPoint(Event.motion.xrel, Event.motion.yrel), MouseMessage::TranslateSDLButtonState(Event.motion.state) ) );
                break;
        case SDL_QUIT:
                ArsPostMessage( Message( Message::APP_EXIT, 0 ) );
                break;
        }
}

}
extern const int TofMain( const int argc , char **argv );

#ifdef LINUX
#       define SDL_main main
#endif

int main(int argc, char **argv)
{
        string  s = argv[0];
        s = s.substr( 0 , s.find_last_of( '.' ) );
        s += ".log";
        tron.open( s.c_str() , ios::app );

        time_t  t;
        time( &t );
        struct tm       *tm = localtime( &t );
        tron << endl << argv[0] << endl;
        s.assign( (int)strlen( argv[0] ) , '=' );
        tron << s << endl << "started at " << asctime( tm ) << endl << endl;

        int iExitCode = EXIT_FAILURE;
        iExitCode = TofMain( argc , argv );

        t;
        time( &t );
        tm = localtime( &t );
        tron << endl << "finished at " << asctime( tm ) << endl << endl;

        exit(iExitCode);
}

---