Web alhem.net

SDLControl.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <SDL.h>
#include "guitypedefs.h"
#ifdef _WIN32
#pragma warning(push)

#include <yvals.h> // warning numbers get enabled in yvals.h 

#pragma warning(disable: 4251)  
#pragma warning(disable: 4786)  // identifier was truncated to 'number' characters in the debug information

// BUG: C4786 Warning Is Not Disabled with #pragma Warning
// STATUS: Microsoft has confirmed this to be a bug in the Microsoft product. This warning can be ignored.
// This occured only in the <map> container.

#include <sge.h>

#pragma warning(pop)
#else
#include <sge.h>
#endif
//#include <iotm/Mutex.h>

#include "SDLControl.h"

#ifdef _DEBUG
#define DEB(x) x
#else
#define DEB(x)
#endif

#define NUM_COLORS 256

namespace gui
{


SDLControl::SDLControl(int argc,char *argv[],int x,int y,int b)
:m_ok(false)
,m_screen(NULL)
,m_width(x)
,m_height(y)
,m_bpp(b)
,m_hw(false)
,m_hwpalette(false)
,m_noframe(false)
,m_fullscreen(false)
,m_videoflags(SDL_SWSURFACE)
//,m_timerThread(NULL)
{
        // Command line
        DEB(printf("read_config()\n");)
        read_config(argc,argv);

        // Init SDL
        DEB(printf("Init_SDL()\n");)
        Init_SDL();

        if (!m_ok)
        {
                DEB(printf("Ej OK\n");)
                return;
        }

        // Set window title 
        DEB(printf("Set window title\n");)
        SDL_WM_SetCaption("Client Window", "input");

        // check flags
        if (m_hw)
        {
                m_videoflags |= SDL_HWSURFACE;
        }
        if (m_hwpalette)
        {
                m_videoflags |= SDL_HWPALETTE;
        }
        if (m_noframe)
        {
                m_videoflags |= SDL_NOFRAME;
        }
        if (m_fullscreen)
        {
                m_videoflags |= SDL_FULLSCREEN;
        }

        // Set a video mode 
        int bpp = m_bpp;
        if ( (m_bpp = SDL_VideoModeOK(m_width, m_height, m_bpp, m_videoflags) ) == 0)
        {
                fprintf(stderr,"Video mode not supported: %s\n", SDL_GetError());
                m_ok = false;
//              return NULL;
        }
        else
        {
                DEB(printf("SDL is recommending %dbpp.  Using %dbpp.\n", m_bpp, m_bpp);)
        }

        m_bpp = bpp;
        if ( (m_screen = SDL_SetVideoMode(m_width, m_height, m_bpp, m_videoflags) ) == NULL)
        {
                fprintf(stderr,"Could not initialize SDL: %s.\n", SDL_GetError());
                m_ok = false;
//              return NULL;
        }

        DEB(printf("SDLControl():\n");)
        status();
        
//      m_timerThread = new TimerThread;
}


SDLControl::~SDLControl()
{
/*
        if (m_timerThread)
        {
                m_timerThread -> SetRunning(false);
                SDL_Delay(250);
                delete m_timerThread;
        }
*/
        // DeInit SDL
        if (m_ok)
        {
                SDL_Quit();
        }
}


void SDLControl::read_config(int argc,char *argv[])
{
        // See if we try to get a hardware colormap 
        for (int loop = 1; loop < argc; loop++)
        {
                if (!strcmp(argv[loop],"-width") && loop < argc - 1)
                {
                        m_width = atoi(argv[loop + 1]);
                        loop++;
                } 
                else
                if (!strcmp(argv[loop],"-height") && loop < argc - 1)
                {
                        m_height = atoi(argv[loop + 1]);
                        loop++;
                } 
                else
                if (!strcmp(argv[loop],"-bpp") && loop < argc - 1)
                {
                        m_bpp = atoi(argv[loop + 1]);
                        loop++;
                } 
                else
                if (!strcmp(argv[loop],"-hw"))
                {
                        m_hw = true;
                } 
                else
                if (!strcmp(argv[loop],"-hwpalette"))
                {
                        m_hwpalette = true;
                } 
                else
                if (!strcmp(argv[loop],"-noframe"))
                {
                        m_noframe = true;
                } 
                else
                if (!strcmp(argv[loop],"-fullscreen"))
                {
                        m_fullscreen = true;
                } 
                else 
                {
                        fprintf(stderr,"'%s'?\n",argv[loop]);
                        fprintf(stderr,"Usage: %s [-width xx] [-height xx] [-bpp xx]\n",*argv);
                        fprintf(stderr,"          [-hw] [-hwpalette] [-noframe] [-fullscreen]\n");
                }
        }
}


void SDLControl::Init_SDL()
{
        DEB(printf("SDL_Init()\n");)
        if (SDL_Init( SDL_INIT_TIMER|SDL_INIT_VIDEO ) < 0)
        {
                DEB(printf("SDL_Init() ej ok\n");)
                fprintf(stderr,"SDL error: %s\n",SDL_GetError() );
        }
        else
        {
                DEB(printf("SDL_Init() OK\n");)
                m_ok = true;
        }
}


/*
void SDLControl::CreateScreen()
{
        int i;
        SDL_Color palette[NUM_COLORS];
        Uint8 *buffer;

        // Set the video mode 
        m_screen = SDL_SetVideoMode(m_width, m_height, m_bpp, m_videoflags);
        if ( m_screen == NULL ) 
        {
                fprintf(stderr, "Couldn't set display mode: %s\n",SDL_GetError());
                return;
        }
        DEB(printf("Screen is in %s mode\n",(m_screen->flags & SDL_FULLSCREEN) ? "fullscreen" : "windowed");)

        // Set a gray colormap, reverse order from white to black 
        for ( i=0; i<NUM_COLORS; ++i ) 
        {
                palette[i].r = (NUM_COLORS-1)-i * (256 / NUM_COLORS);
                palette[i].g = (NUM_COLORS-1)-i * (256 / NUM_COLORS);
                palette[i].b = (NUM_COLORS-1)-i * (256 / NUM_COLORS);
        }
        SDL_SetColors(m_screen, palette, 0, NUM_COLORS);

        // Set the surface pixels and refresh! 
        if ( SDL_LockSurface(m_screen) < 0 ) 
        {
                fprintf(stderr, "Couldn't lock display surface: %s\n",SDL_GetError());
                return;
        }
        buffer = (Uint8 *)m_screen->pixels;
        for ( i=0; i<m_screen->h; ++i ) 
        {
                memset(buffer,(i*(NUM_COLORS-1))/m_screen->h, m_screen->w);
                buffer += m_screen->pitch;
        }
        SDL_UnlockSurface(m_screen);
        SDL_UpdateRect(m_screen, 0, 0, 0, 0);
}
*/


void SDLControl::Update8bitPalette()
{
//      SDL_SetColors(m_screen, gui::Color::m_palette, 0, gui::Color::m_qcolors);
}


void SDLControl::ToggleFullscreen()
{
        m_fullscreen = !m_fullscreen;
        m_videoflags ^= SDL_FULLSCREEN;
//      m_mutex.Lock();

//      CreateScreen();
        if ( (m_screen = SDL_SetVideoMode(m_width, m_height, m_bpp, m_videoflags) ) == NULL)
        {
                fprintf(stderr,"Could not initialize SDL: %s.\n", SDL_GetError());
                m_ok = false;
//              return NULL;
        }

//      m_mutex.Unlock();
}


SDL_Surface *SDLControl::GetScreen()
{
        return m_screen;
}


short SDLControl::GetBpp()
{
        return m_bpp;
}


bool SDLControl::IsOK()
{
DEB(    if (m_ok)
        {
                printf("m_ok is true\n");
        }
        else
        {
                printf("m_ok is false\n");
        })
        return m_ok;
}


void SDLControl::SetOK(bool ok)
{
        DEB(printf("SetOK = %s\n",ok ? "TRUE" : "FALSE");)
        m_ok = ok;
}


void SDLControl::LockMutex()
{
//      m_mutex.Lock();
}


void SDLControl::UnlockMutex()
{
//      m_mutex.Unlock();
}


void SDLControl::lockSurface() //bool bClearRects)
{
/*
        if (bClearRects)
        {
                while (m_rects.size())
                {
                        m_rects.erase(m_rects.begin());
                }
        }
*/
        if ( SDL_MUSTLOCK(m_screen) ) 
        {
                if ( SDL_LockSurface(m_screen) < 0 ) 
                {
                        fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
                        return;
                }
        }
}


/*
void SDLControl::AddRect(SDL_Rect &rect)
{
        // check outer bounds here
        coord_t xmax = m_screen -> w;
        coord_t ymax = m_screen -> h;

        // kontroll utanfor ytan
        if (rect.x + rect.w > xmax)
        {
                rect.w -= rect.x + rect.w - xmax;
        }
        if (rect.y + rect.h > ymax)
        {
                rect.h -= rect.y + rect.h - ymax;
        }
        //
        m_rects.insert(m_rects.end(), rect);
}
*/


void SDLControl::unlockSurface() //bool bUpdateRects)
{
        if ( SDL_MUSTLOCK(m_screen) ) 
        {
                SDL_UnlockSurface(m_screen);
        }
/*
        if (bUpdateRects && m_rects.size())
        {
                SDL_Rect *rects = new SDL_Rect[m_rects.size()];
                int i = 0;
                rectvector_t::iterator it;

                for (it = m_rects.begin(); it != m_rects.end(); it++)
                {
                        rects[i] = (*it);
                        i++;
                }
                SDL_UpdateRects(m_screen, i, rects);
                delete rects;
        }
*/
}


void SDLControl::status()
{
DEB(    printf("m_ok: %s\n", m_ok ? "true" : "false");
        printf("m_width: %d\n", m_width);
        printf("m_height: %d\n", m_height);
        printf("m_bpp: %d\n", m_bpp);
        printf("m_hw: %s\n", m_hw ? "true" : "false");
        printf("m_hwpalette: %s\n", m_hwpalette ? "true" : "false");
        printf("m_noframe: %s\n", m_noframe ? "true" : "false");
        printf("m_fullscreen: %s\n", m_fullscreen ? "true" : "false");)
}


/*
TimerThread *SDLControl::GetTimerThread()
{
        return m_timerThread;
}
*/


} // namespace

---

www.TV-friendship.com The matchmaking service with an all new twist.

Quantum 'Teleportation' Some thoughts

Page, code, and content Copyright (C) 2004 by Anders Hedström