RenderWindow.hpp

/******************************************************************************
 
  nomlib - C++11 cross-platform game engine
 
Copyright (c) 2013, 2014 Jeffrey Carpenter <i8degrees@gmail.com>
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
******************************************************************************/
#ifndef NOMLIB_GRAPHICS_RENDER_WINDOW_HPP
#define NOMLIB_GRAPHICS_RENDER_WINDOW_HPP
 
#include <vector>
#include <memory>
 
#include <SDL.h>
 
#include "nomlib/config.hpp"
#include "nomlib/math/Rect.hpp"
#include "nomlib/math/Color4.hpp"
#include "nomlib/math/Point2.hpp"
#include "nomlib/graphics/DisplayMode.hpp"
#include "nomlib/graphics/Renderer.hpp"
#include "nomlib/graphics/Image.hpp"
#include "nomlib/system/SDL_helpers.hpp"
#include "nomlib/core/clock.hpp"
#include "nomlib/system/File.hpp"
 
namespace nom {

struct PixelsDeleter
{
  void operator()(void* ptr);
};
 
class RenderWindow: public Renderer
{
  public:
    typedef RenderWindow SelfType;
    typedef SelfType* RawPtr;
 
    static const Point2i DEFAULT_WINDOW_POS;
    static const Point2i WINDOW_POS_CENTERED;
    static const uint32 DEFAULT_WINDOW_FLAGS = 0;

    RenderWindow( void );

    ~RenderWindow( void );

    RenderWindow( const SelfType& copy ) = delete;

    SelfType& operator =( const SelfType& other ) = delete;

    bool create(  const std::string& window_title, const Size2i& res,
                  uint32 window_flags,
                  int rendering_driver = DEFAULT_RENDERING_DRIVER,
                  uint32 renderer_flags = DEFAULT_RENDERER_FLAGS );

    bool create(  const std::string& window_title, const Point2i& pos,
                  int display_index, const Size2i& res, uint32 window_flags,
                  int rendering_driver = DEFAULT_RENDERING_DRIVER,
                  uint32 renderer_flags = DEFAULT_RENDERER_FLAGS );

    RenderWindow::RawPtr get ( void );

    SDL_WINDOW::RawPtr window ( void ) const;

    SDL_SURFACE::RawPtr window_surface ( void ) const;

    bool valid( void ) const;

    bool window_valid( void ) const;

    Point2i position() const;

    Size2i size( void ) const;

    const uint8 bits_per_pixel ( void ) const;
 
    uint32 window_flags ( void ) const;
 
    uint32 pixel_format ( void ) const;

    const IntRect display_bounds ( void ) const;

    bool display_modes(DisplayModeList& modes) const;

    int refresh_rate() const;
 
    void set_size ( int32 width, int32 height );

    void set_position(const Point2i& window_pos);

    bool flip ( void ) const;

    bool fullscreen ( void ) const;

    void set_fullscreen ( bool state );

    bool toggle_fullscreen ( void );

    bool toggle_fullscreen ( uint32 flags );
 
    const std::string window_title ( void ) const;
 
    void set_window_title ( const std::string& title );

    bool set_window_icon ( const std::string& filename );

    uint32 window_id( void ) const;

    static SDL_WINDOW::RawPtr window_id( uint32 id );

    int window_display_id() const;

    static std::string display_name(int display_id);

    std::string display_name() const;

    SDL_Window* mouse_focus( void ) const;

    void enable_screensaver ( void );

    void disable_screensaver ( void );

    bool screen_saver ( void );

    void maximize_window ( void );

    void minimize_window ( void );

    void raise_window ( void );

    void restore_window ( void );

    void show_window ( void );

    void hide_window ( void );

    void set_window_grab(bool grab);

    void set_minimum_window_size ( int min_width, int min_height );

    void set_maximum_window_size ( int max_width, int max_height );

    bool save_png_file(const std::string& filename) const;

    bool save_screenshot(const std::string& filename) const;

    void make_current ( void );

    static SDL_Renderer* context( void );

    static int num_video_displays();
 
  private:
    static void set_context ( RenderWindow::RawPtr window );
 
    static SDL_Renderer* context_;
 
    SDL_WINDOW::UniquePtr window_;

    uint32 window_id_;

    int window_display_id_;

    bool enabled_;

    bool fullscreen_;
};
 
namespace priv {

extern RenderWindow* render_dev_;
 
} // namespace priv
 
RenderWindow* render_interface();
void set_render_interface(RenderWindow& win);
 
} // namespace nom
 
#endif // include guard defined