PlatformWindow Class Reference

#include <PlatformWindow.h>

Inheritance diagram for PlatformWindow:

Public Member Functions
	PlatformWindow (PlatformEnvironment *penv)
	Standard Constructor.
	~PlatformWindow ()
	Standard Destructor.
bool	Initialize (PEBLVideoMode mode, PEBLVideoDepth vdepth, bool windowed, bool resizeable, unsigned int width, unsigned int height)
	This method initiates everything needed to display the main window.
int	GetVideoFlags ()
bool	Resize (int w, int h)
bool	Draw ()
long int	DrawFor (unsigned int cycles)
SDL_Window *	GetSDLWindow ()
int	SaveScreenShot (int x, int y, int w, int h, const Variant fname)
	PlatformWindow (PlatformEnvironment *env)
virtual	~PlatformWindow ()
virtual bool	Draw ()
virtual std::string	ObjectName () const
virtual int	SaveScreenShot (int x, int y, int w, int h, const Variant fname)
virtual bool	Initialize (PEBLVideoMode mode, PEBLVideoDepth depth, bool windowed, bool resizeable, unsigned int width, unsigned int height)
virtual bool	Resize (int w, int h)
virtual long int	DrawFor (unsigned int cycles)
virtual bool	SetProperty (std::string name, Variant v)
virtual ObjectValidationError	ValidateProperty (std::string name, Variant v) const
virtual ObjectValidationError	ValidateProperty (std::string name) const
virtual pInt	GetWidth () const
virtual pInt	GetHeight () const
virtual void	SetPosition (pInt x, pInt y)
	This sets the widget's position on its parent widget.
virtual void	SetBackgroundColor (const PColor &color)
Public Member Functions inherited from PWindow
	PWindow (PEnvironment *penv)
virtual	~PWindow ()
virtual Variant	GetProperty (std::string) const
Public Member Functions inherited from PWidget
	PWidget ()
	PWidget (const PWidget &pw)
	PWidget (pInt x, pInt y, pInt width, pInt height, bool visible)
virtual	~PWidget ()
virtual void	SetParent (PWidget *widget)
	This unconditionally sets the parent widget.
virtual PWidget *	GetParent ()
virtual bool	IsParent (PWidget *parent)
virtual void	SetZoomX (pDouble x)
	This sets the widget's position on its parent widget.
virtual void	SetZoomY (pDouble x)
	This sets the widget's position on its parent widget.
virtual void	SetRotation (pDouble x)
	This sets the widget's position on its parent widget.
virtual void	SetWidth (pInt w)
virtual void	SetHeight (pInt h)
virtual pInt	GetX () const
virtual pInt	GetY () const
virtual PColor	GetBackgroundColor ()
virtual bool	AddSubWidget (PWidget *widget)
virtual bool	RemoveSubWidget (PWidget *widget)
virtual bool	RemoveLastSubWidget ()
	This is probably pretty useless.
virtual void	Show ()
virtual void	Hide ()
virtual bool	IsVisible () const
Public Member Functions inherited from PEBLObjectBase
	PEBLObjectBase ()
	Standard Constructor.
	PEBLObjectBase (ComplexDataType cdt)
	Standard Constructor.
	PEBLObjectBase (const PEBLObjectBase &pob)
virtual	~PEBLObjectBase ()
	Standard Destructor.
virtual bool	InitializeProperty (std::string name, Variant v)
Variant	GetProperty (std::string) const
ComplexDataType	GetType ()
virtual std::ostream &	PrintProperties (std::ostream &out)
virtual Variant	GetPropertyList ()
Public Member Functions inherited from PlatformWidget
	PlatformWidget ()
virtual	~PlatformWidget ()
virtual SDL_Texture *	GetSDL_Texture ()
	Used to extract an SDL surface from the widget. Used by children drawing themselves on their parent.
void	SetParent (PlatformWidget *parent)
SDL_Surface *	GetSurface ()
virtual bool	SetRenderer (SDL_Renderer *renderer)
SDL_Renderer *	GetRenderer ()
virtual bool	AddToParentWidget (PlatformWidget *parent)
virtual bool	AddSubWidget (PlatformWidget *widget)
virtual bool	RemoveSubWidget (PlatformWidget *widget)
virtual bool	RemoveSubWidgets ()
virtual bool	RotoZoom (double angle, double zoomx, double zoomy, int smooth)
	This uses the SDL_gfx package to 'rotozoom'.
bool	SetPoint (int x, int y, PColor col)
PColor	GetPixel (int x, int y)
	PlatformWidget ()
	PlatformWidget (pInt x, pInt y, pInt width, pInt height, bool visible)
virtual	~PlatformWidget ()
virtual bool	RotoZoom (pDouble angle, pDouble zoomx, pDouble zoomy, pInt smooth)
virtual bool	SetPoint (pInt x, pInt y, PColor col)
virtual PColor	GetPixel (pInt x, pInt y)

Protected Member Functions
virtual std::ostream &	SendToStream (std::ostream &out) const
	An inheritable printing class used by PEBLObjectBase::operator<<.
virtual std::string	ObjectName () const
virtual std::ostream &	SendToStream (std::ostream &out) const
	An inheritable printing class used by PEBLObjectBase::operator<<.
Protected Member Functions inherited from PlatformWidget
virtual void	PrintSubWidgets (std::ostream &out) const
virtual bool	LockSurface ()
	This needs to be used on some platforms/video cards.
virtual bool	UnlockSurface ()
	This needs to be used on some platforms/video cards.

Additional Inherited Members
Protected Attributes inherited from PWindow
PEnvironment *	mEnv
Protected Attributes inherited from PWidget
pInt	mX
pInt	mY
pInt	mDrawX
pInt	mDrawY
pInt	mWidth
pInt	mHeight
pDouble	mZoomX
pDouble	mZoomY
pDouble	mRotation
PColor	mBackgroundColor
	The background color of the widget. if alpha = 0, will not be painted.
std::list< PWidget * >	mSubWidgets
bool	mIsVisible
PWidget *	mParent
Protected Attributes inherited from PEBLObjectBase
ComplexDataType	mCDT
std::map< std::string, Variant >	mProperties
Protected Attributes inherited from PlatformWidget
pInt	mTextureWidth
pInt	mTextureHeight
bool	mNeedsTexture
SDL_Texture *	mTexture
SDL_Surface *	mSurface
SDL_Renderer *	mRenderer

Detailed Description

This class instantiates a PWindow using platform-specific code.

Headless platform window - no actual display Used for validation mode where no window is needed

Definition at line 48 of file sdl/PlatformWindow.h.

Constructor & Destructor Documentation

PlatformWindow() [1/2]

PlatformWindow::PlatformWindow

(

PlatformEnvironment *

penv

)

Standard Constructor.

Definition at line 56 of file sdl/PlatformWindow.cpp.

                                                        :
    mFlags(0),
    mWindow(NULL),
    PWindow(penv)
 
{
    mCDT=CDT_WINDOW;
    //    InitializeProperty("COLOR",Variant("grey"));//dummy property setting
    //    PWidget::SetBackgroundColor(PColor(200,200,200,255));
    PColor tmpColor = PColor(0,0,0,255);
    PWidget::SetBackgroundColor(tmpColor);
 
    //These don't get used for windows:
    mSurface = NULL;
    mTexture = NULL;
    mRenderer = NULL;
}

References CDT_WINDOW, PEBLObjectBase::mCDT, PlatformWidget::mRenderer, PlatformWidget::mSurface, PlatformWidget::mTexture, NULL, and PWidget::SetBackgroundColor().

~PlatformWindow() [1/2]

PlatformWindow::~PlatformWindow

(

)

Standard Destructor.

Definition at line 75 of file sdl/PlatformWindow.cpp.

{
 
 
    SDL_DestroyWindow(mWindow);
    mWindow = NULL;
 
}

References NULL.

PlatformWindow() [2/2]

PlatformWindow::PlatformWindow

(

PlatformEnvironment *

env

)

~PlatformWindow() [2/2]

virtual PlatformWindow::~PlatformWindow ( )

virtual

Member Function Documentation

Draw() [1/2]

bool PlatformWindow::Draw ( )

virtual

This draws the subwidgets. It doesn't need a 'parent' argument, because 'this' is it.

Reimplemented from PWindow.

Definition at line 427 of file sdl/PlatformWindow.cpp.

{
 
 
 
    //if (SDL_MUSTLOCK(mSurface)) SDL_LockSurface(mSurface);
 
 
    // Get background color from property system (in case it was modified via nested properties)
    Variant backgroundColor = PEBLObjectBase::GetProperty("BGCOLOR");
    PColor* bgColor = nullptr;
    if(backgroundColor.GetComplexData())
    {
        bgColor = dynamic_cast<PColor*>(backgroundColor.GetComplexData()->GetObject().get());
    }
 
    // Use property color if available, otherwise fall back to mBackgroundColor
    if(!bgColor)
    {
        bgColor = &mBackgroundColor;
    }
 
#ifdef SDL2_DELETE
    //First, draw the background
    SDL_FillRect(mSurface, NULL, SDL_MapRGBA(mSurface->format,
                                            bgColor->GetRed(),
                                            bgColor->GetGreen(),
                                            bgColor->GetBlue(),
                                            bgColor->GetAlpha()));
#endif
 
 
 int result=   SDL_SetRenderDrawColor(mRenderer,
                           bgColor->GetRed(),
                           bgColor->GetGreen(),
                           bgColor->GetBlue(),
                           bgColor->GetAlpha());
 
 
    //    while(p != mSubWidgets.begin())
    //        {
    //            p--;
            //cout << "------drawing Subwidget on window:" << *p <<  "[" << **p << "]" << endl;
 
    //        }
 
    SDL_RenderClear(mRenderer);//clear the window
 if(result < 0)
     {
         PError::SignalFatalError("Unable to clear window");
         std::cerr <<SDL_GetError() << endl;
     }
 
 
    //cout << "Number of subwidgets: " << mSubWidgets.size() << endl;
    //This handles drawing each subwidget.
    std::list<PWidget *>::iterator p = mSubWidgets.end();
 
    while(p != mSubWidgets.begin())
        {
            //cout <<"Size"<< mSubWidgets.size() << endl;
 
 
            //decrement iterator--moving backward so we draw things in
            //reverse order.
            p--;
 
            //Draw the subwidget
            if((*p)->IsVisible())
                {
                    (*p)->Draw();
                }
 
        }
 
    SDL_RenderPresent(mRenderer);//draw the window.
 
 
#ifdef PEBL_EMSCRIPTEN
 //    int result = SDL_Flip(mSurface);
#else
//    int result = SDL_Flip(mSurface);
#endif
 
 
 return true;
}

References counted_ptr< X >::get(), PColor::GetAlpha(), PColor::GetBlue(), Variant::GetComplexData(), PColor::GetGreen(), PComplexData::GetObject(), PEBLObjectBase::GetProperty(), PColor::GetRed(), PWidget::mBackgroundColor, PlatformWidget::mRenderer, PWidget::mSubWidgets, PlatformWidget::mSurface, NULL, and PError::SignalFatalError().

Referenced by DrawFor(), and Initialize().

Draw() [2/2]

virtual bool PlatformWindow::Draw ( )

virtual

This draws the subwidgets. It doesn't need a 'parent' argument, because 'this' is it.

Reimplemented from PWindow.

DrawFor() [1/2]

long int PlatformWindow::DrawFor

(

unsigned int

cycles

)

Definition at line 521 of file sdl/PlatformWindow.cpp.

{
 
    //Do an initial syncing flip.
    int result = 0;// = SDL_Flip(mSurface);
 
    //    cout << "Drawforing cycles: " << cycles << endl;
 
    //Now, draw the subwidgets.
 
    unsigned int cyclesleft = cycles;
    unsigned int tstart = SDL_GetTicks();
 
    while(cyclesleft > 0 )
        {
            //Get the time *AFTER* the first cycle.
            //This method will only really work on a platform wher SDL_Flip blocks.
 
            //result = SDL_Flip(mSurface);
            Draw();
            //            cout << ".";
            cyclesleft--;
        }
 
    unsigned int tend = SDL_GetTicks();
    //cout << "\n";
        result = tend-tstart;
 
    //If the return value is positive, it is the time that
    //this was displayed.  Otherwise, it is an error code.
    return result;
 
}

References Draw().

Referenced by PEBLObjects::DrawFor().

DrawFor() [2/2]

virtual long int PlatformWindow::DrawFor ( unsigned int  cycles )

inlinevirtual

Definition at line 45 of file validator/PlatformWindow.h.

{ return 0; }

GetHeight()

virtual pInt PlatformWindow::GetHeight ( ) const

inlinevirtual

Reimplemented from PWidget.

Definition at line 60 of file validator/PlatformWindow.h.

{ return PWindow::GetHeight(); }

References PWidget::GetHeight().

Referenced by PEBLStream::WritePNG().

GetSDLWindow()

SDL_Window * PlatformWindow::GetSDLWindow ( )

inline

Definition at line 72 of file sdl/PlatformWindow.h.

{return mWindow;};

Referenced by SDLUtility::PopupErrorBox().

GetVideoFlags()

int PlatformWindow::GetVideoFlags

(

)

Definition at line 92 of file sdl/PlatformWindow.cpp.

{
    return 0;
 
}

GetWidth()

virtual pInt PlatformWindow::GetWidth ( ) const

inlinevirtual

Reimplemented from PWidget.

Definition at line 59 of file validator/PlatformWindow.h.

{ return PWindow::GetWidth(); }

References PWidget::GetWidth().

Referenced by PEBLStream::WritePNG().

Initialize() [1/2]

virtual bool PlatformWindow::Initialize ( PEBLVideoMode  mode, PEBLVideoDepth  depth, bool  windowed, bool  resizeable, unsigned int  width, unsigned int  height  )

inlinevirtual

Definition at line 43 of file validator/PlatformWindow.h.

{ return true; }

Initialize() [2/2]

bool PlatformWindow::Initialize	(	PEBLVideoMode	mode,
		PEBLVideoDepth	vdepth,
		bool	windowed,
		bool	resizeable,
		unsigned int	width,
		unsigned int	height
	)

This method initiates everything needed to display the main window.

This shouldn't be necessary, but if we specify the same screensize as the window, it goes to fake fullscreen mode.

Definition at line 102 of file sdl/PlatformWindow.cpp.

{
 
    cerr << "Initializing " << width << "--" << height << endl;
    SDLUtility::GetDriverList(); //print out driver information.
    Variant v = 0;
 
    Evaluator * myEval = new Evaluator(v,"Window");
    //gVideoWidth and gVideoHeight may have been set by the user
    //in the script.  First, get these values, and try them.
 
    Variant vDp =  0;
    bool vsync = true;
    bool softrender = false;
 
 
 
 
    if(myEval->gGlobalVariableMap.Exists("gVideoDepth"))
        vDp =   myEval->gGlobalVariableMap.RetrieveValue("gVideoDepth");
 
 
    if(myEval->gGlobalVariableMap.Exists("gVSync"))
        {
            vsync = (int)((myEval->gGlobalVariableMap.RetrieveValue("gVsync"))) != 0;
 
        }
    //cout <<" vsync state: " << vsync <<"\n";
 
    if(myEval->gGlobalVariableMap.Exists("gSoftRender"))
        {
            softrender = (int)((myEval->gGlobalVariableMap.RetrieveValue("gSoftRender"))) != 0;
        }
 
 
 
 
    //Should be direct3d (windows), opengl, opengles2 opengles,software.
    if(myEval->gGlobalVariableMap.Exists("gDriverHint"))
        {
            SDL_SetHint("SDL_HINT_RENDER_DRIVER",
                        ( myEval->gGlobalVariableMap.RetrieveValue("gDriverHint").GetString().c_str()));
        }
 
 
    //some other hints available via SDL
    //SDL_SetHint("SDL_HINT_VIDEO_ALLOW_SCREENSAVER","0");
    if(!windowed)
        {
            //this might not be the best approach.
            SDL_SetHint("SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES","1");
        }
 
 
   if(vsync)
   {
       SDL_SetHint("SDL_HINT_RENDER_VSYNC","1");
   }
 
 
   SDL_SetHint("SDL_HINT_MOUSE_RELATIVE_MODE_WARP","1");
 
    //Set the renderer flags.  We are by default accelerated.
    //there we could bump up to vsync, or down to software.
    //If you try to specify both vsync and software, it will just use software.
 
    int rflags = SDL_RENDERER_TARGETTEXTURE;
    if(softrender)
        {
            rflags |=  SDL_RENDERER_SOFTWARE;
        }else
        {
 
            rflags |= SDL_RENDERER_ACCELERATED;
 
#ifndef PEBL_EMSCRIPTEN
            if(vsync)
                {
                    rflags |= SDL_RENDERER_PRESENTVSYNC;
 
                }
#endif
        }
 
 
    int depth  = vDp;
 
    //    cout << width << "----" << height << " in platformwindow\n";
 
 
 
    if(!(depth > 0))
        depth = (int)vdepth;
 
 
 
    int vflags = 0;//GetVideoFlags();
 
    if(!windowed)
        {
            vflags |=  SDL_WINDOW_FULLSCREEN ;       // Enable fullscreen
        }
 
    if(resizeable)
        {
            vflags |= SDL_WINDOW_RESIZABLE;         //IS the window resizeable?
        }
 
    //Re-store the values
    myEval->gGlobalVariableMap.AddVariable("gVideoWidth", (long unsigned int)width);
    myEval->gGlobalVariableMap.AddVariable("gVideoHeight", (long unsigned int)height);
    myEval->gGlobalVariableMap.AddVariable("gVideoDepth", depth);
 
    PWidget::SetProperty("WIDTH",(long unsigned int)width);
    PWidget::SetProperty("HEIGHT",(long unsigned int)height);
 
    delete myEval;
 
    bool success = 0;
    //INitialize the SDL surface with the appropriate flags.
 
    Variant scriptname = "PEBL Application";
    if(myEval->gGlobalVariableMap.Exists("gScriptName"))
        {
            scriptname = myEval->gGlobalVariableMap.RetrieveValue("gScriptName");
        }
 
    std::string sname = scriptname;
    int x= SDL_WINDOWPOS_CENTERED;
    int y= 15;//SDL_WINDOWPOS_CENTERED;
    if(!windowed)
    {
        x = SDL_WINDOWPOS_UNDEFINED;
        y = SDL_WINDOWPOS_UNDEFINED;
    }
 
    mWindow =SDL_CreateWindow(sname.c_str(),x,y,
                              //SDL_WINDOWPOS_UNDEFINED,
                              //SDL_WINDOWPOS_UNDEFINED,
                              width,height, vflags);
 
 
    mRenderer = SDL_CreateRenderer(mWindow, -1,rflags);
//    mRenderer = SDL_CreateRenderer(mWindow,-1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE|SDL_RENDERER_PRESENTVSYNC);
    //mRenderer = SDL_CreateSoftwareRenderer(SDL_GetWindowSurface(mWindow));
    //mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE);
 
    if(mRenderer)
        {
            success = true;
        }else{
        PError::SignalFatalError("Failed to create renderer in PlatformWindow\n");
     }
 
 
    mFlags = vflags;
#ifdef SDL2_DELETE
    // mSurface = SDL_SetVideoMode(width,height,depth,SDL_HWACCEL | SDL_FULLSCREEN | SDL_DOUBLEBUF);
    if ( mSurface == NULL )
        {
            //If we fail, try to do our best.
            cerr << "Unable to set " << width << "x" << height << ": " << depth << " video mode: " << SDL_GetError() << endl;
 
            //This needs to be reworked because of new API that handles multi-screens, etc.
 
            //Get a list of available resolutions and try these out.
            SDL_Rect** modes = SDL_ListModes(NULL,vflags);
            if(modes == (SDL_Rect**)0)
                {
                    cerr << "No Video Modes Available" << endl;
                } else{
                for(int i=0; modes[i];++i)
                    {
                        width=modes[i]->w;
                        height=modes[i]->h;
 
 
                        cerr << "Trying resolution:" << width << "x" << height << ": " << depth << " video mode:\n ";
                        mSurface = SDL_SetVideoMode(width,height,depth,vflags);
                        if(mSurface)
                            {
                                cerr << "Using resolution:" << width << "x" << height << ": " << depth << " video mode:\n ";
 
                                success = true;
                                break;
                            }else{
                            cerr << "..........Resolution failed\n";
                        }
                    }
 
                cerr<< "Resolution may not be optimal.  Alternate resolutions available on system include:\n";
 
                modes =SDL_ListModes(NULL,vflags);
                for(int ii=0; modes[ii]; ++ii)
                    {
                        cerr << ii<< ". gVideoWidth <-"<< modes[ii]->w<<"; gVideoHeight<- " << modes[ii]->h <<"\n";
                    }
}
 
 
 
 
            if(success)
                {
                    //something worked out!
                    myEval->gGlobalVariableMap.AddVariable("gVideoWidth", width);
                    myEval->gGlobalVariableMap.AddVariable("gVideoHeight", height);
                    myEval->gGlobalVariableMap.AddVariable("gVideoDepth", depth);
                }else{
 
                //None of the resolutions worked out.
                return false;
            }
 
 
        }else{
        success = true;
    }
#endif
    if(success)
        {
            cerr << "\n\n--------------------------------------------------------------------------------\n";
            cerr << " Application settings:" << endl;
 
            cerr << "Script name:                               [" << sname << "]\n";
            cerr << PEBLEnvironment::TimeStamp(Variant(0))  << endl;
            cerr << "--------------------------------------------------------------------------------\n";
 
            cerr << "Display Mode:  Width  (pixels)                    [" << width << "]\n";
            cerr << "Display Mode:  Height (pixels)                    [" << height << "]\n";
            cerr << "Display Mode:  Color Depth (bits)                 [" << depth << "]\n";
            cerr << "vsync mode:                                       [" << vsync << "]\n";
            cerr << "Software renderer mode:                           [" <<softrender << "]\n";
            cerr << "Windowed:                                         ["<<windowed<< "]\n";
            cerr << "Resizeable:                                       ["<<resizeable<< "]\n";
 
            cerr << "Driver hint (gDriverHint):                        ";
 
            if(myEval->gGlobalVariableMap.Exists("gDriverHint"))
                {
 
                    cerr << "["<<myEval->gGlobalVariableMap.RetrieveValue("gDriverHint") << "]\n";
                }
            else
                {
                    cerr << "[none]\n";
                }
 
 
 
            cerr << "Base font (gPEBLBaseFont):                        ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gPEBLBaseFont") << "]\n";
 
            cerr << "Base Mono font (gPEBLBaseFontMono):               ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gPEBLBaseFontMono") << "]\n";
 
            cerr << "Base serif (gPEBLBaseFontSerif):                  ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gPEBLBaseFontSerif") << "]\n";
 
            cerr << "Language (gLanguage):                             ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gLanguage") << "]\n";
 
            cerr << "Parameter file (gParamFile):                      ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gParamFile") << "]\n";
 
            cerr << "Busy/Easy wait: (gSleepEasy):                     ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gSleepEasy") << "]\n";
 
 
            cerr << "Executable name: (gExecutableName):               ["<<
                myEval->gGlobalVariableMap.RetrieveValue("gExecutableName") << "]\n";
 
 
            cerr << "Resource path: (gPEBLResourcePath):               [" <<
                myEval->gGlobalVariableMap.RetrieveValue("gPEBLResourcePath") << "]\n";
 
 
            cerr << "Resource path: (gPEBLBasePath):                   [" <<
            myEval->gGlobalVariableMap.RetrieveValue("gPEBLBasePath") << "]\n";
 
            cerr << "Working directory: (gWorkingDirectory):           [" <<
            myEval->gGlobalVariableMap.RetrieveValue("gWorkingDirectory") << "]\n";
 
 
 
            SDL_RendererInfo drinfo;
            cerr << "Renderer information:\n";
            SDL_GetRendererInfo(mRenderer, &drinfo);
            cerr << "Driver name:                                      [" << drinfo.name << "]\n";;
 
            std::cerr << "Software fallback:                                [";
 
            if (drinfo.flags & SDL_RENDERER_SOFTWARE)
                std::cerr << "yes]\n"; else          std::cerr << "no]\n";
 
            std::cerr << "Hardware acceleration:                            [";
 
            if (drinfo.flags & SDL_RENDERER_ACCELERATED)
                std::cerr << "yes]\n";  else        std::cerr << "no]\n";
 
            std::cerr << "Vsync with refresh rate:                          [";
            if (drinfo.flags & SDL_RENDERER_PRESENTVSYNC)
                std::cerr << "yes]\n"; else std::cerr << "no]\n";
 
            std::cerr << "Rendering to texture support                      [";
 
            if (drinfo.flags & SDL_RENDERER_TARGETTEXTURE)
                std::cerr << "yes]\n"; else std::cerr << "no]\n";
 
            cerr << "--------------------------------------------------------------------------------\n\n";
 
            //Do an initial Draw()
            Draw();
            return true;
        }
    return false;
}

References VariableMap::AddVariable(), Draw(), VariableMap::Exists(), SDLUtility::GetDriverList(), Variant::GetString(), Evaluator::gGlobalVariableMap, PlatformWidget::mRenderer, PlatformWidget::mSurface, myEval, NULL, VariableMap::RetrieveValue(), PWidget::SetProperty(), PError::SignalFatalError(), and PEBLEnvironment::TimeStamp().

Referenced by main(), and PEBLObjects::MakeWindow().

ObjectName() [1/2]

virtual std::string PlatformWindow::ObjectName ( ) const

inlineprotectedvirtual

Reimplemented from PWindow.

Definition at line 78 of file sdl/PlatformWindow.h.

{return "PlatformWindow";};

ObjectName() [2/2]

virtual std::string PlatformWindow::ObjectName ( ) const

inlinevirtual

Reimplemented from PWindow.

Definition at line 41 of file validator/PlatformWindow.h.

{ return "PlatformWindow (validator)"; }

Resize() [1/2]

bool PlatformWindow::Resize	(	int	w,
		int	h
	)

Definition at line 555 of file sdl/PlatformWindow.cpp.

{
 //Resize the screen
 
    //    screen = SDL_SetVideoMode( event.resize.w, event.resize.h, SCREEN_BPP, SDL_SWSURFACE | SDL_RESIZABLE );
    Variant vDp =   myEval->gGlobalVariableMap.RetrieveValue("gVideoDepth");
 
//rework this for SDL2:
#ifdef SDL2_DELETE
    mSurface = SDL_SetVideoMode(w,h,(int)vDp,mFlags);
 
    if(mSurface)
        {
            myEval->gGlobalVariableMap.AddVariable("gVideoWidth", w);
            myEval->gGlobalVariableMap.AddVariable("gVideoHeight", h);
        }
 
#endif
    return true;
}

References VariableMap::AddVariable(), Evaluator::gGlobalVariableMap, PlatformWidget::mSurface, myEval, and VariableMap::RetrieveValue().

Referenced by PEBLObjects::ResizeWindow().

Resize() [2/2]

virtual bool PlatformWindow::Resize ( int  w, int  h  )

inlinevirtual

Definition at line 44 of file validator/PlatformWindow.h.

{ return true; }

SaveScreenShot() [1/2]

int PlatformWindow::SaveScreenShot	(	int	x,
		int	y,
		int	w,
		int	h,
		const Variant	fname
	)

Definition at line 578 of file sdl/PlatformWindow.cpp.

{
 
    SDL_Rect rect;
    rect.x = x;
    rect.y = y;
    rect.w = w;
    rect.h = h;
 
    return SDLUtility::WritePNG(mRenderer,&rect,fname);
    
 
}

References PlatformWidget::mRenderer, and SDLUtility::WritePNG().

Referenced by PEBLStream::WritePNG().

SaveScreenShot() [2/2]

virtual int PlatformWindow::SaveScreenShot ( int  x, int  y, int  w, int  h, const Variant  fname  )

inlinevirtual

Definition at line 42 of file validator/PlatformWindow.h.

{ return 0; }

SendToStream() [1/2]

std::ostream & PlatformWindow::SendToStream ( std::ostream &  out ) const

protectedvirtual

An inheritable printing class used by PEBLObjectBase::operator<<.

Reimplemented from PWindow.

Definition at line 45 of file validator/PlatformWindow.cpp.

                                                              {
    out << "PlatformWindow (validator)";
    return out;
}

SendToStream() [2/2]

virtual std::ostream & PlatformWindow::SendToStream ( std::ostream &  out ) const

protectedvirtual

An inheritable printing class used by PEBLObjectBase::operator<<.

Reimplemented from PWindow.

SetBackgroundColor()

virtual void PlatformWindow::SetBackgroundColor ( const PColor &  color )

inlinevirtual

Reimplemented from PWidget.

Definition at line 64 of file validator/PlatformWindow.h.

{ PWindow::SetBackgroundColor(color); }

References PWidget::SetBackgroundColor().

Referenced by main(), and PEBLObjects::MakeWindow().

SetPosition()

virtual void PlatformWindow::SetPosition ( pInt  x, pInt  y  )

inlinevirtual

This sets the widget's position on its parent widget.

Sets the location of the upper left-hand corner of the image on the parent widget; unless overridden

Reimplemented from PWidget.

Definition at line 63 of file validator/PlatformWindow.h.

{ PWindow::SetPosition(x, y); }

References PWidget::SetPosition().

SetProperty()

virtual bool PlatformWindow::SetProperty ( std::string  name, Variant  v  )

inlinevirtual

Reimplemented from PWindow.

Definition at line 48 of file validator/PlatformWindow.h.

                                                        {
        return PWindow::SetProperty(name, v);
    }

References PWindow::SetProperty().

ValidateProperty() [1/2]

virtual ObjectValidationError PlatformWindow::ValidateProperty ( std::string  name ) const

inlinevirtual

Reimplemented from PWindow.

Definition at line 54 of file validator/PlatformWindow.h.

                                                                         {
        return PWindow::ValidateProperty(name);
    }

References PWindow::ValidateProperty().

ValidateProperty() [2/2]

virtual ObjectValidationError PlatformWindow::ValidateProperty ( std::string  name, Variant  v  ) const

inlinevirtual

Reimplemented from PWindow.

Definition at line 51 of file validator/PlatformWindow.h.

                                                                                    {
        return PWindow::ValidateProperty(name, v);
    }

References PWindow::ValidateProperty().

---

The documentation for this class was generated from the following files:

• sdl/PlatformWindow.h
• validator/PlatformWindow.h
• sdl/PlatformWindow.cpp
• validator/PlatformWindow.cpp