mxwnd.cpp

/*
        MX library.

        http://lostsidedead.com/svn


        libmx written by jared bruni, it is wrappers around SDL
and other api's to provide a set of classes and functions
to produce multi media applications, using object oriented
techniques.

        (C) 2008 LostSideDead
*/


#include "mxwnd.h"
#include<ctime>



namespace mx
{

        mxWnd *mxWnd::mxwnd = 0;

        mxWnd::mxWnd( Size window,  Size s, Uint32 flags, SDL_Surface *ico)
        {
                initWnd(window.width,window.height,flags,ico,false);
                createSizedBackground( s );
        }


        mxWnd::mxWnd(int w, int h, Uint32 flags, SDL_Surface *ico, bool opengl_init)
        {
                initWnd(w,h,flags,ico,opengl_init);
        }

        void mxWnd::initWnd(int w, int h, Uint32 flags, SDL_Surface *ico, bool opengl_init)
        {
                err_Type = 0;
                active = false;
                mxwnd = this;
                if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK) < 0) {
                        err_Type = 1;
                        return;
                }

                        if(ico != 0)
                                SDL_WM_SetIcon(ico, 0);

                        opengl_ = false;

                        const SDL_VideoInfo *vi = SDL_GetVideoInfo();

                        Uint8 bpp=0;

                        bpp = vi->vfmt->BitsPerPixel;

                        bool hw_ = true;

                        if(vi->hw_available != 0)
                                flags |= SDL_HWSURFACE;
                        else {
                                flags |= SDL_SWSURFACE;
                                hw_ = false;
                        }

                        if(vi->blit_hw)
                                flags |= SDL_HWACCEL;


                        if(opengl_init == true)
                        {
                                SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
                                d_type = ORTHO;
                        }


                        if(w == -1)
                        {
                                w = vi->current_w;
                                h = vi->current_h;
                                flags |= SDL_FULLSCREEN;
                        }

                        if(opengl_init == true) {
                                flags |= SDL_OPENGL;
                                opengl_ = true;
                        }
                        // set a icon here

                        SDL_Surface *temp = SDL_SetVideoMode(w,h,32,flags);

                        if(!temp) {
                                err_Type = 2;
                                return;
                        }

                        front = temp;
                        vid_flags = flags;
                        front.noZero(true); // no zero here , because the surface is freed by the call to SDL Quit



                        std::cout << "application activated @ ";

                        time_t the_time;
                        struct tm *time_info;

                        time(&the_time);

                        time_info = localtime(&the_time);
                        std::cout << asctime(time_info);
                        std::cout << "SDL: subsystem initalized\n";
                        std::cout << "Video " << front.width() << "x" << front.height() << "x" << int(front.getSurface()->format->BitsPerPixel) << "\n";
                        std::cout << "Render Mode: " <<  ((hw_ == true) ? "Direct Rendering" : "Software Rendering")   << "\n";
                        std::cout << "Hardware Blit Acceleration: " << ((vi->blit_hw == 0) ? "No": "Yes") << "\n";
                        sizevar = Size(front.width(), front.height());
        }

        void mxWnd::createSizedBackground ( Size &s )
        {
                background.createSurface( s );
        }

        mxWnd::~mxWnd()
        {

                SDL_Quit();
                std::cout << "application shutdown @ ";
                time_t the_time;
                struct tm *time_info;
                time(&the_time);
                time_info = localtime(&the_time);
                std::cout << asctime(time_info);
                std::cout << "SDL: subsystem shutdown\n";

        }


        int mxWnd::messageLoop()
        {

                if(err_Type != 0) {

                        switch(err_Type) {
                        case 1:
                                throw mx::mxException<std::string>("Error could not init SDL: " + std::string(SDL_GetError()) + "\n");
                                break;
                        case 2:
                                throw mx::mxException<std::string>("Error could not set video mode: " + std::string(SDL_GetError()) + "\n");
                                break;
                        }

                }

                static SDL_Event e;

                active = true;

                while(active == true)
                {

                        while(SDL_PollEvent(&e))
                        {


                                switch(e.type) {
                                        case SDL_VIDEORESIZE:
                                        {
                                                const SDL_VideoInfo *vi = SDL_GetVideoInfo();
                                                Uint8 bpp = vi->vfmt->BitsPerPixel;
                                                front = SDL_SetVideoMode( e.resize.w, e.resize.h, bpp, vid_flags );
                                                resizeWindow(e.resize.w, e.resize.h);

                                        }
                                        break;
                                }


                                eventPassed(e);
                        }

                        renderScreen();

                }

                return EXIT_SUCCESS;
        }

        void mxWnd::quit()
        {
                active = false;
                std::cout << "System: A Quit Signal has been sent\n\n";
        }


        void mxWnd::eventPassed(SDL_Event &e)
        {
                if(e.type == SDL_QUIT) active = false;
                else if(e.type == SDL_KEYDOWN && e.key.keysym.sym == SDLK_ESCAPE) active = false;
        }



        void mxWnd::renderScreen()
        {

                SDL_FillRect(front, 0, SDL_MapRGB(front.getSurface()->format, 255, 255, 255));
                front.Flip();


                if(opengl_) {

                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                        SDL_GL_SwapBuffers();
                }

        }

        void mxWnd::setTitle(string title) const
        {
                SDL_WM_SetCaption(title.c_str(), 0);
        }

        void mxWnd::minimizeWindow() const
        {
                SDL_WM_IconifyWindow();
        }

        void mxWnd::pumpEvents() const
        {
                SDL_PumpEvents();
        }


        void mxWnd::enableKeyRepeat(int code, int interval)
        {
                SDL_EnableKeyRepeat(code, interval);
        }

        Size &mxWnd::size()
        {

                return sizevar;

        }

        void mxWnd::sizedFlip() {
                front.copyResizeSurface( background );
                front.Flip();
        }

        void mxWnd::resizeWindow(int w, int h)
        {
                if(opengl_ == false) return;


                if(d_type == ORTHO) {

                        GLfloat range = 100.0f;

                        if(h == 0) h = 1;

                        glViewport(0,0,w,h);

                        glMatrixMode(GL_PROJECTION);
                        glLoadIdentity();

                        if(w<=h)
                                glOrtho( -range, range, -range*h/w, range*h/w, -range, range);
                        else
                                glOrtho( -range*w/h, range*w/h, -range, range, -range, range);

                        glMatrixMode(GL_MODELVIEW);
                        glLoadIdentity();

                }
                else {

                        if(h == 0)
                                        h = 1;

                        GLfloat ratio = 0.0f;
                        ratio = static_cast<GLfloat>( w / h );
                        glViewport( 0, 0, static_cast<GLsizei>(w), static_cast<GLsizei>(h));
                        glMatrixMode(GL_PROJECTION);
                        glLoadIdentity();
                        gluPerspective(45.0f, ratio, 0.1f, 200.0f);
                        glMatrixMode(GL_MODELVIEW);
                        glLoadIdentity();
                }

        }

        void mxWnd::setMode(enum lookType type) {
                this->d_type = type;
        }

}

---