*******************************************************************************/
-#include <stdexcept>
-
-#include <SDL/SDL_image.h>
-
-#include "Dispatcher.hh"
+#include "Dispatch.hh"
+#include "Engine.hh"
+#include "Exception.hh"
+#include "Image.hh"
#include "Log.hh"
#include "Settings.hh"
#include "Video.hh"
Video::Video()
{
- init(attribs_);
+ init(mAttribs);
}
Video::Video(const Attributes& attribs)
Video::Video(const std::string& caption, const std::string& icon)
{
- if (attribs_.caption == "Untitled")
+ if (mAttribs.caption == "Untitled")
{
- attribs_.caption = caption;
+ mAttribs.caption = caption;
}
- if (attribs_.icon == "")
+ if (mAttribs.icon == "")
{
- attribs_.icon = icon;
+ mAttribs.icon = icon;
}
- init(attribs_);
+ init(mAttribs);
}
void Video::init(const Attributes& attribs)
{
- context_ = 0;
- flags_ = 0;
- attribs_ = attribs;
+ // make sure the engine is initialized before setting up the video
+ Engine::getInstance();
+
+ mContext = 0;
+ mFlags = 0;
+ mAttribs = attribs;
setFull(attribs.fullscreen);
setResizable(attribs.resizable);
void Video::recreateContext()
{
- SDL_FreeSurface(context_);
- context_ = 0;
- setVideoMode(attribs_.mode);
+ SDL_FreeSurface(mContext);
+ mContext = 0;
+ setVideoMode(mAttribs.mode);
}
void Video::setOpenGLAttributes()
{
- SDL_GL_SetAttribute(SDL_GL_RED_SIZE, attribs_.colorBuffer[0]);
- SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, attribs_.colorBuffer[1]);
- SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, attribs_.colorBuffer[2]);
- SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, attribs_.colorBuffer[3]);
- SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, attribs_.frameBuffer);
- SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, attribs_.doubleBuffer);
- SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, attribs_.depthBuffer);
- SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, attribs_.stencilBuffer);
- SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, attribs_.accumBuffer[0]);
- SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, attribs_.accumBuffer[1]);
- SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, attribs_.accumBuffer[2]);
- SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, attribs_.accumBuffer[3]);
- SDL_GL_SetAttribute(SDL_GL_STEREO, attribs_.stereo);
- SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, attribs_.multisampleBuffers);
- SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, attribs_.multisampleSamples);
- SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, attribs_.swapControl);
- SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, attribs_.hardwareonly);
+ SDL_GL_SetAttribute(SDL_GL_RED_SIZE, mAttribs.colorBuffer[0]);
+ SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, mAttribs.colorBuffer[1]);
+ SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, mAttribs.colorBuffer[2]);
+ SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, mAttribs.colorBuffer[3]);
+ SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, mAttribs.frameBuffer);
+ SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, mAttribs.doubleBuffer);
+ SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, mAttribs.depthBuffer);
+ SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, mAttribs.stencilBuffer);
+ SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, mAttribs.accumBuffer[0]);
+ SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, mAttribs.accumBuffer[1]);
+ SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, mAttribs.accumBuffer[2]);
+ SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, mAttribs.accumBuffer[3]);
+ SDL_GL_SetAttribute(SDL_GL_STEREO, mAttribs.stereo);
+ SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, mAttribs.multisampleBuffers);
+ SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mAttribs.multisampleSamples);
+ SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, mAttribs.swapControl);
+ SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, mAttribs.hardwareonly);
}
Video::~Video()
{
- SDL_FreeSurface(context_);
+ SDL_FreeSurface(mContext);
}
void Video::setVideoMode(const long mode[3])
{
- if (mode != attribs_.mode || !context_)
+ if (mode != mAttribs.mode || !mContext)
{
- if (context_) SDL_FreeSurface(context_);
+ if (mContext) SDL_FreeSurface(mContext);
- context_ = SDL_SetVideoMode(mode[0], mode[1], mode[2],
- SDL_OPENGL | flags_);
+ mContext = SDL_SetVideoMode(mode[0], mode[1], mode[2],
+ SDL_OPENGL | mFlags);
- if (context_)
+ if (mContext)
{
- attribs_.mode[0] = mode[0];
- attribs_.mode[1] = mode[1];
- attribs_.mode[2] = mode[2];
+ mAttribs.mode[0] = mode[0];
+ mAttribs.mode[1] = mode[1];
+ mAttribs.mode[2] = mode[2];
-#if defined(_WIN32) || defined (_WIN64) || defined(__WIN32__)
+#if defined(_WIN32) || defined(__WIN32__)
// on win32, creating a new context via SDL_SetVideoMode will wipe
// out the GL state, so we gotta notify everyone to reload their
// state after the change
- Mf::dispatcher::dispatch("video.context_recreated");
+ Engine::getInstance().dispatch("video.newcontext");
+
logInfo("video context recreated");
#endif
}
- else throw Exception(Exception::SDL_ERROR);
+ else throw Exception(ErrorCode::SDL_VIDEOMODE);
}
}
Video::Attributes Video::getAttributes() const
{
- return attribs_;
+ return mAttribs;
}
void Video::resize(int width, int height)
{
- long mode[] = {width, height, attribs_.mode[2]};
+ long mode[] = {width, height, mAttribs.mode[2]};
setVideoMode(mode);
}
void Video::setCaption(const std::string& caption)
{
- attribs_.caption = caption;
+ mAttribs.caption = caption;
SDL_WM_SetCaption(caption.c_str(), 0);
}
void Video::setIcon()
{
- if (attribs_.icon != "")
+ if (mAttribs.icon != "")
{
- SDL_Surface* icon = IMG_Load(attribs_.icon.c_str());
- if (icon)
- {
- SDL_WM_SetIcon(icon, 0);
- SDL_FreeSurface(icon);
- }
+ Image icon(mAttribs.icon);
+ icon.setAsIcon();
}
}
std::string Video::getCaption() const
{
- return attribs_.caption;
+ return mAttribs.caption;
+}
+
+const std::string& Video::getIcon() const
+{
+ return mAttribs.icon;
}
void Video::setFull(bool full)
{
- if (full != isFull() || !context_)
+ if (full != isFull() || !mContext)
{
- if (context_)
+ if (mContext)
{
- flags_ ^= SDL_FULLSCREEN;
+ mFlags ^= SDL_FULLSCREEN;
#if defined(linux) || defined(__linux) || defined(__linux__)
- if (SDL_WM_ToggleFullScreen(context_) == 0)
+ if (SDL_WM_ToggleFullScreen(mContext) == 0)
#endif
recreateContext();
}
else
{
- if (full) flags_ |= SDL_FULLSCREEN;
- else flags_ &= ~SDL_FULLSCREEN;
+ if (full) mFlags |= SDL_FULLSCREEN;
+ else mFlags &= ~SDL_FULLSCREEN;
}
}
}
bool Video::isFull() const
{
- return flags_ & SDL_FULLSCREEN;
+ return mFlags & SDL_FULLSCREEN;
}
void Video::setResizable(bool resizable)
{
- if (resizable != isResizable() || !context_)
+ if (resizable != isResizable() || !mContext)
{
- if (context_)
+ if (mContext)
{
- flags_ ^= SDL_RESIZABLE;
+ mFlags ^= SDL_RESIZABLE;
recreateContext();
}
else
{
- if (resizable) flags_ |= SDL_RESIZABLE;
- else flags_ &= ~SDL_RESIZABLE;
+ if (resizable) mFlags |= SDL_RESIZABLE;
+ else mFlags &= ~SDL_RESIZABLE;
}
}
}
bool Video::isResizable() const
{
- return flags_ & SDL_RESIZABLE;
+ return mFlags & SDL_RESIZABLE;
}
}
-void Video::makeActive()
-{
- // NOP until the day SDL supports more than only one window.
- // Still waiting...
-}
-
void Video::swap()
{
SDL_GL_SwapBuffers();
int Video::getWidth() const
{
- return context_->w;
+ return mContext->w;
}
int Video::getHeight() const
{
- return context_->h;
+ return mContext->h;
}