Merge branch 'master' into remunits

Build/vc2010/RocketCore.vcxproj.filters

@@ -531,6 +531,9 @@
     <ClCompile Include="..\..\Source\Core\StringCache.cpp">
       <Filter>String Cache</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\Source\Core\ElementStyleCache.cpp">
+      <Filter>Element</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\Source\Core\precompiled.h">
@@ -969,6 +972,9 @@
       <Filter>String Cache</Filter>
     </ClInclude>
     <ClInclude Include="..\..\Include\Rocket\Core.h" />
+    <ClInclude Include="..\..\Source\Core\ElementStyleCache.h">
+      <Filter>Element</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\Include\Rocket\Core\Element.inl">

Include/Rocket/Core/Debug.h

@@ -107,6 +107,6 @@ template <> struct STATIC_ASSERTION_FAILURE<true>{};
 	
 }
 }
-#define ROCKET_STATIC_ASSERT(cond, msg) Rocket::Core::STATIC_ASSERTION_FAILURE<cond> msg
+#define ROCKET_STATIC_ASSERT(cond, msg) Rocket::Core::STATIC_ASSERTION_FAILURE<cond> msg; (void)&msg;
 
 #endif

Include/Rocket/Core/StringBase.h

@@ -42,7 +42,7 @@ template< typename T >
 class StringBase
 {
 public:
-	typedef unsigned int size_type;
+	typedef size_t size_type;
 	static const size_type npos = (size_type)-1;
 
 	StringBase();

Include/Rocket/Core/Variant.h

@@ -143,7 +143,7 @@ public:
 private:
 	
 #ifdef ROCKET_ARCH_64
-		static const int LOCAL_DATA_SIZE = 32; // Required for Strings
+		static const int LOCAL_DATA_SIZE = 40; // Required for Strings
 #else
 		static const int LOCAL_DATA_SIZE = 24;
 #endif

Include/Rocket/Core/Variant.inl

@@ -75,11 +75,11 @@ bool Variant::GetInto(T& value) const
 		break;
 
 		case SCRIPTINTERFACE:
-			return TypeConverter< ScriptInterface*, T >::Convert((ScriptInterface*)data, value);			
+			return TypeConverter< ScriptInterface*, T >::Convert(*(ScriptInterface**)data, value);			
 		break;
 
 		case VOIDPTR:
-			return TypeConverter< void*, T >::Convert((void*)data, value);
+			return TypeConverter< void*, T >::Convert(*(void**)data, value);
 		break;
 
 		case NONE:

Samples/basic/drag/src/DragListener.cpp

@@ -42,7 +42,7 @@ void DragListener::ProcessEvent(Rocket::Core::Event& event)
 	{
 		Rocket::Core::Element* dest_container = event.GetCurrentElement();
 		Rocket::Core::Element* dest_element = event.GetTargetElement();
-		Rocket::Core::Element* drag_element = *static_cast< Rocket::Core::Element** >(event.GetParameter< void* >("drag_element", NULL));
+		Rocket::Core::Element* drag_element = static_cast< Rocket::Core::Element* >(event.GetParameter< void* >("drag_element", NULL));
 
 		if (dest_container == dest_element)
 		{

Samples/basic/sdl2/RenderInterfaceSDL2.cpp

@@ -0,0 +1,192 @@
+/*
+ * This source file is part of libRocket, the HTML/CSS Interface Middleware
+ *
+ * For the latest information, see http://www.librocket.com
+ *
+ * Copyright (c) 2008-2010 Nuno Silva
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include <Rocket/Core/Core.h>
+#include <SDL_image.h>
+
+#include "RenderInterfaceSDL2.h"
+
+#if !(SDL_VIDEO_RENDER_OGL)
+    #error "Only the opengl sdl backend is supported. To add support for others, see http://mdqinc.com/blog/2013/01/integrating-librocket-with-sdl-2/"
+#endif
+
+RocketSDL2Renderer::RocketSDL2Renderer(SDL_Renderer* renderer, SDL_Window* screen)
+{
+    mRenderer = renderer;
+    mScreen = screen;
+}
+
+// Called by Rocket when it wants to render geometry that it does not wish to optimise.
+void RocketSDL2Renderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
+{
+    // SDL uses shaders that we need to disable here  
+    glUseProgramObjectARB(0);
+    glPushMatrix();
+    glTranslatef(translation.x, translation.y, 0);
+ 
+    std::vector<Rocket::Core::Vector2f> Positions(num_vertices);
+    std::vector<Rocket::Core::Colourb> Colors(num_vertices);
+    std::vector<Rocket::Core::Vector2f> TexCoords(num_vertices);
+    float texw, texh;
+ 
+    SDL_Texture* sdl_texture = NULL;
+    if(texture)
+    {
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        sdl_texture = (SDL_Texture *) texture;
+        SDL_GL_BindTexture(sdl_texture, &texw, &texh);
+    }
+ 
+    for(int  i = 0; i < num_vertices; i++) {
+        Positions[i] = vertices[i].position;
+        Colors[i] = vertices[i].colour;
+        if (sdl_texture) {
+            TexCoords[i].x = vertices[i].tex_coord.x * texw;
+            TexCoords[i].y = vertices[i].tex_coord.y * texh;
+        }
+        else TexCoords[i] = vertices[i].tex_coord;
+    };
+ 
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, &Positions[0]);
+    glColorPointer(4, GL_UNSIGNED_BYTE, 0, &Colors[0]);
+    glTexCoordPointer(2, GL_FLOAT, 0, &TexCoords[0]);
+ 
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDrawElements(GL_TRIANGLES, num_indices, GL_UNSIGNED_INT, indices);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+ 
+    if (sdl_texture) {
+        SDL_GL_UnbindTexture(sdl_texture);
+        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    }
+ 
+    glColor4f(1.0, 1.0, 1.0, 1.0);
+    glPopMatrix();
+    /* Reset blending and draw a fake point just outside the screen to let SDL know that it needs to reset its state in case it wants to render a texture */
+    glDisable(GL_BLEND);
+    SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_NONE);
+    SDL_RenderDrawPoint(mRenderer, -1, -1);
+}
+
+
+// Called by Rocket when it wants to enable or disable scissoring to clip content.		
+void RocketSDL2Renderer::EnableScissorRegion(bool enable)
+{
+    if (enable)
+        glEnable(GL_SCISSOR_TEST);
+    else
+        glDisable(GL_SCISSOR_TEST);
+}
+
+// Called by Rocket when it wants to change the scissor region.		
+void RocketSDL2Renderer::SetScissorRegion(int x, int y, int width, int height)
+{
+    int w_width, w_height;
+    SDL_GetWindowSize(mScreen, &w_width, &w_height);
+    glScissor(x, w_height - (y + height), width, height);
+}
+
+// Called by Rocket when a texture is required by the library.		
+bool RocketSDL2Renderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle, Rocket::Core::Vector2i& texture_dimensions, const Rocket::Core::String& source)
+{
+
+    Rocket::Core::FileInterface* file_interface = Rocket::Core::GetFileInterface();
+    Rocket::Core::FileHandle file_handle = file_interface->Open(source);
+    if (!file_handle)
+        return false;
+
+    file_interface->Seek(file_handle, 0, SEEK_END);
+    size_t buffer_size = file_interface->Tell(file_handle);
+    file_interface->Seek(file_handle, 0, SEEK_SET);
+
+    char* buffer = new char[buffer_size];
+    file_interface->Read(buffer, buffer_size, file_handle);
+    file_interface->Close(file_handle);
+
+    size_t i;
+    for(i = source.Length() - 1; i > 0; i--)
+    {
+        if(source[i] == '.')
+            break;
+    }
+
+    Rocket::Core::String extension = source.Substring(i+1, source.Length()-i);
+
+    SDL_Surface* surface = IMG_LoadTyped_RW(SDL_RWFromMem(buffer, buffer_size), 1, extension.CString());
+
+    if (surface) {
+        SDL_Texture *texture = SDL_CreateTextureFromSurface(mRenderer, surface);
+
+        if (texture) {
+            texture_handle = (Rocket::Core::TextureHandle) texture;
+            texture_dimensions = Rocket::Core::Vector2i(surface->w, surface->h);
+            SDL_FreeSurface(surface);
+        }
+        else
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+// Called by Rocket when a texture is required to be built from an internally-generated sequence of pixels.
+bool RocketSDL2Renderer::GenerateTexture(Rocket::Core::TextureHandle& texture_handle, const Rocket::Core::byte* source, const Rocket::Core::Vector2i& source_dimensions)
+{
+    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
+        Uint32 rmask = 0xff000000;
+        Uint32 gmask = 0x00ff0000;
+        Uint32 bmask = 0x0000ff00;
+        Uint32 amask = 0x000000ff;
+    #else
+        Uint32 rmask = 0x000000ff;
+        Uint32 gmask = 0x0000ff00;
+        Uint32 bmask = 0x00ff0000;
+        Uint32 amask = 0xff000000;
+    #endif
+
+    SDL_Surface *surface = SDL_CreateRGBSurfaceFrom ((void*) source, source_dimensions.x, source_dimensions.y, 32, source_dimensions.x*4, rmask, gmask, bmask, amask);
+    SDL_Texture *texture = SDL_CreateTextureFromSurface(mRenderer, surface);
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_FreeSurface(surface);
+    texture_handle = (Rocket::Core::TextureHandle) texture;
+    return true;
+}
+
+// Called by Rocket when a loaded texture is no longer required.		
+void RocketSDL2Renderer::ReleaseTexture(Rocket::Core::TextureHandle texture_handle)
+{
+    SDL_DestroyTexture((SDL_Texture*) texture_handle);
+}

Samples/basic/sdl2/RenderInterfaceSDL2.h

@@ -0,0 +1,65 @@
+/*
+ * This source file is part of libRocket, the HTML/CSS Interface Middleware
+ *
+ * For the latest information, see http://www.librocket.com
+ *
+ * Copyright (c) 2008-2010 Nuno Silva
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#ifndef RENDERINTERFACESDL2_H
+#define RENDERINTERFACESDL2_H
+
+#include <Rocket/Core/RenderInterface.h>
+
+#include <SDL.h>
+#include <GL/glew.h>
+
+#if !(SDL_VIDEO_RENDER_OGL)
+    #error "Only the opengl sdl backend is supported. To add support for others, see http://mdqinc.com/blog/2013/01/integrating-librocket-with-sdl-2/"
+#endif
+
+
+class RocketSDL2Renderer : public Rocket::Core::RenderInterface
+{
+public:
+	RocketSDL2Renderer(SDL_Renderer* renderer, SDL_Window* screen);
+
+	/// Called by Rocket when it wants to render geometry that it does not wish to optimise.
+	virtual void RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation);
+
+	/// Called by Rocket when it wants to enable or disable scissoring to clip content.
+	virtual void EnableScissorRegion(bool enable);
+	/// Called by Rocket when it wants to change the scissor region.
+	virtual void SetScissorRegion(int x, int y, int width, int height);
+
+	/// Called by Rocket when a texture is required by the library.
+	virtual bool LoadTexture(Rocket::Core::TextureHandle& texture_handle, Rocket::Core::Vector2i& texture_dimensions, const Rocket::Core::String& source);
+	/// Called by Rocket when a texture is required to be built from an internally-generated sequence of pixels.
+	virtual bool GenerateTexture(Rocket::Core::TextureHandle& texture_handle, const Rocket::Core::byte* source, const Rocket::Core::Vector2i& source_dimensions);
+	/// Called by Rocket when a loaded texture is no longer required.
+	virtual void ReleaseTexture(Rocket::Core::TextureHandle texture_handle);
+
+private:
+    SDL_Renderer* mRenderer;
+    SDL_Window* mScreen;
+};
+
+#endif

Samples/basic/sdl2/SystemInterfaceSDL2.cpp

@@ -0,0 +1,441 @@
+/*
+ * This source file is part of libRocket, the HTML/CSS Interface Middleware
+ *
+ * For the latest information, see http://www.librocket.com
+ *
+ * Copyright (c) 2008-2010 Nuno Silva
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include <Rocket/Core.h>
+#include "SystemInterfaceSDL2.h"
+
+Rocket::Core::Input::KeyIdentifier RocketSDL2SystemInterface::TranslateKey(SDL_Keycode sdlkey)
+{
+    using namespace Rocket::Core::Input;
+
+
+    switch(sdlkey) {
+        case SDLK_UNKNOWN:
+            return KI_UNKNOWN;
+            break;
+        case SDLK_SPACE:
+            return KI_SPACE;
+            break;
+        case SDLK_0:
+            return KI_0;
+            break;
+        case SDLK_1:
+            return KI_1;
+            break;
+        case SDLK_2:
+            return KI_2;
+            break;
+        case SDLK_3:
+            return KI_3;
+            break;
+        case SDLK_4:
+            return KI_4;
+            break;
+        case SDLK_5:
+            return KI_5;
+            break;
+        case SDLK_6:
+            return KI_6;
+            break;
+        case SDLK_7:
+            return KI_7;
+            break;
+        case SDLK_8:
+            return KI_8;
+            break;
+        case SDLK_9:
+            return KI_9;
+            break;
+        case SDLK_a:
+            return KI_A;
+            break;
+        case SDLK_b:
+            return KI_B;
+            break;
+        case SDLK_c:
+            return KI_C;
+            break;
+        case SDLK_d:
+            return KI_D;
+            break;
+        case SDLK_e:
+            return KI_E;
+            break;
+        case SDLK_f:
+            return KI_F;
+            break;
+        case SDLK_g:
+            return KI_G;
+            break;
+        case SDLK_h:
+            return KI_H;
+            break;
+        case SDLK_i:
+            return KI_I;
+            break;
+        case SDLK_j:
+            return KI_J;
+            break;
+        case SDLK_k:
+            return KI_K;
+            break;
+        case SDLK_l:
+            return KI_L;
+            break;
+        case SDLK_m:
+            return KI_M;
+            break;
+        case SDLK_n:
+            return KI_N;
+            break;
+        case SDLK_o:
+            return KI_O;
+            break;
+        case SDLK_p:
+            return KI_P;
+            break;
+        case SDLK_q:
+            return KI_Q;
+            break;
+        case SDLK_r:
+            return KI_R;
+            break;
+        case SDLK_s:
+            return KI_S;
+            break;
+        case SDLK_t:
+            return KI_T;
+            break;
+        case SDLK_u:
+            return KI_U;
+            break;
+        case SDLK_v:
+            return KI_V;
+            break;
+        case SDLK_w:
+            return KI_W;
+            break;
+        case SDLK_x:
+            return KI_X;
+            break;
+        case SDLK_y:
+            return KI_Y;
+            break;
+        case SDLK_z:
+            return KI_Z;
+            break;
+        case SDLK_SEMICOLON:
+            return KI_OEM_1;
+            break;
+        case SDLK_PLUS:
+            return KI_OEM_PLUS;
+            break;
+        case SDLK_COMMA:
+            return KI_OEM_COMMA;
+            break;
+        case SDLK_MINUS:
+            return KI_OEM_MINUS;
+            break;
+        case SDLK_PERIOD:
+            return KI_OEM_PERIOD;
+            break;
+        case SDLK_SLASH:
+            return KI_OEM_2;
+            break;
+        case SDLK_BACKQUOTE:
+            return KI_OEM_3;
+            break;
+        case SDLK_LEFTBRACKET:
+            return KI_OEM_4;
+            break;
+        case SDLK_BACKSLASH:
+            return KI_OEM_5;
+            break;
+        case SDLK_RIGHTBRACKET:
+            return KI_OEM_6;
+            break;
+        case SDLK_QUOTEDBL:
+            return KI_OEM_7;
+            break;
+        case SDLK_KP_0:
+            return KI_NUMPAD0;
+            break;
+        case SDLK_KP_1:
+            return KI_NUMPAD1;
+            break;
+        case SDLK_KP_2:
+            return KI_NUMPAD2;
+            break;
+        case SDLK_KP_3:
+            return KI_NUMPAD3;
+            break;
+        case SDLK_KP_4:
+            return KI_NUMPAD4;
+            break;
+        case SDLK_KP_5:
+            return KI_NUMPAD5;
+            break;
+        case SDLK_KP_6:
+            return KI_NUMPAD6;
+            break;
+        case SDLK_KP_7:
+            return KI_NUMPAD7;
+            break;
+        case SDLK_KP_8:
+            return KI_NUMPAD8;
+            break;
+        case SDLK_KP_9:
+            return KI_NUMPAD9;
+            break;
+        case SDLK_KP_ENTER:
+            return KI_NUMPADENTER;
+            break;
+        case SDLK_KP_MULTIPLY:
+            return KI_MULTIPLY;
+            break;
+        case SDLK_KP_PLUS:
+            return KI_ADD;
+            break;
+        case SDLK_KP_MINUS:
+            return KI_SUBTRACT;
+            break;
+        case SDLK_KP_PERIOD:
+            return KI_DECIMAL;
+            break;
+        case SDLK_KP_DIVIDE:
+            return KI_DIVIDE;
+            break;
+        case SDLK_KP_EQUALS:
+            return KI_OEM_NEC_EQUAL;
+            break;
+        case SDLK_BACKSPACE:
+            return KI_BACK;
+            break;
+        case SDLK_TAB:
+            return KI_TAB;
+            break;
+        case SDLK_CLEAR:
+            return KI_CLEAR;
+            break;
+        case SDLK_RETURN:
+            return KI_RETURN;
+            break;
+        case SDLK_PAUSE:
+            return KI_PAUSE;
+            break;
+        case SDLK_CAPSLOCK:
+            return KI_CAPITAL;
+            break;
+        case SDLK_PAGEUP:
+            return KI_PRIOR;
+            break;
+        case SDLK_PAGEDOWN:
+            return KI_NEXT;
+            break;
+        case SDLK_END:
+            return KI_END;
+            break;
+        case SDLK_HOME:
+            return KI_HOME;
+            break;
+        case SDLK_LEFT:
+            return KI_LEFT;
+            break;
+        case SDLK_UP:
+            return KI_UP;
+            break;
+        case SDLK_RIGHT:
+            return KI_RIGHT;
+            break;
+        case SDLK_DOWN:
+            return KI_DOWN;
+            break;
+        case SDLK_INSERT:
+            return KI_INSERT;
+            break;
+        case SDLK_DELETE:
+            return KI_DELETE;
+            break;
+        case SDLK_HELP:
+            return KI_HELP;
+            break;
+        case SDLK_F1:
+            return KI_F1;
+            break;
+        case SDLK_F2:
+            return KI_F2;
+            break;
+        case SDLK_F3:
+            return KI_F3;
+            break;
+        case SDLK_F4:
+            return KI_F4;
+            break;
+        case SDLK_F5:
+            return KI_F5;
+            break;
+        case SDLK_F6:
+            return KI_F6;
+            break;
+        case SDLK_F7:
+            return KI_F7;
+            break;
+        case SDLK_F8:
+            return KI_F8;
+            break;
+        case SDLK_F9:
+            return KI_F9;
+            break;
+        case SDLK_F10:
+            return KI_F10;
+            break;
+        case SDLK_F11:
+            return KI_F11;
+            break;
+        case SDLK_F12:
+            return KI_F12;
+            break;
+        case SDLK_F13:
+            return KI_F13;
+            break;
+        case SDLK_F14:
+            return KI_F14;
+            break;
+        case SDLK_F15:
+            return KI_F15;
+            break;
+        case SDLK_NUMLOCKCLEAR:
+            return KI_NUMLOCK;
+            break;
+        case SDLK_SCROLLLOCK:
+            return KI_SCROLL;
+            break;
+        case SDLK_LSHIFT:
+            return KI_LSHIFT;
+            break;
+        case SDLK_RSHIFT:
+            return KI_RSHIFT;
+            break;
+        case SDLK_LCTRL:
+            return KI_LCONTROL;
+            break;
+        case SDLK_RCTRL:
+            return KI_RCONTROL;
+            break;
+        case SDLK_LALT:
+            return KI_LMENU;
+            break;
+        case SDLK_RALT:
+            return KI_RMENU;
+            break;
+        case SDLK_LGUI:
+            return KI_LMETA;
+            break;
+        case SDLK_RGUI:
+            return KI_RMETA;
+            break;
+        /*case SDLK_LSUPER:
+            return KI_LWIN;
+            break;
+        case SDLK_RSUPER:
+            return KI_RWIN;
+            break;*/
+        default:
+            return KI_UNKNOWN;
+            break;
+    }
+}
+
+int RocketSDL2SystemInterface::TranslateMouseButton(Uint8 button)
+{
+    switch(button)
+    {
+        case SDL_BUTTON_LEFT:
+            return 0;
+        case SDL_BUTTON_RIGHT:
+            return 1;
+        case SDL_BUTTON_MIDDLE:
+            return 2;
+        default:
+            return 3;
+    }
+}
+
+int RocketSDL2SystemInterface::GetKeyModifiers()
+{
+    SDL_Keymod sdlMods = SDL_GetModState();
+
+    int retval = 0;
+
+    if(sdlMods & KMOD_CTRL)
+        retval |= Rocket::Core::Input::KM_CTRL;
+
+    if(sdlMods & KMOD_SHIFT)
+        retval |= Rocket::Core::Input::KM_SHIFT;
+
+    if(sdlMods & KMOD_ALT)
+        retval |= Rocket::Core::Input::KM_ALT;
+
+    return retval;
+}
+
+float RocketSDL2SystemInterface::GetElapsedTime()
+{
+	return SDL_GetTicks() / 1000;
+}
+
+bool RocketSDL2SystemInterface::LogMessage(Rocket::Core::Log::Type type, const Rocket::Core::String& message)
+{
+	std::string Type;
+
+	switch(type)
+	{
+	case Rocket::Core::Log::LT_ALWAYS:
+		Type = "[Always]";
+		break;
+	case Rocket::Core::Log::LT_ERROR:
+		Type = "[Error]";
+		break;
+	case Rocket::Core::Log::LT_ASSERT:
+		Type = "[Assert]";
+		break;
+	case Rocket::Core::Log::LT_WARNING:
+		Type = "[Warning]";
+		break;
+	case Rocket::Core::Log::LT_INFO:
+		Type = "[Info]";
+		break;
+	case Rocket::Core::Log::LT_DEBUG:
+		Type = "[Debug]";
+		break;
+    case Rocket::Core::Log::LT_MAX:
+        break;
+	};
+
+	printf("%s - %s\n", Type.c_str(), message.CString());
+
+	return true;
+};

Samples/basic/sdl2/SystemInterfaceSDL2.h

@@ -0,0 +1,44 @@
+/*
+ * This source file is part of libRocket, the HTML/CSS Interface Middleware
+ *
+ * For the latest information, see http://www.librocket.com
+ *
+ * Copyright (c) 2008-2010 Nuno Silva
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#ifndef SYSTEMINTEFACESDL2_H
+#define SYSTEMINTEFACESDL2_H
+
+#include <Rocket/Core/SystemInterface.h>
+#include <Rocket/Core/Input.h>
+
+#include <SDL.h>
+
+class RocketSDL2SystemInterface : public Rocket::Core::SystemInterface
+{
+public:
+    Rocket::Core::Input::KeyIdentifier TranslateKey(SDL_Keycode sdlkey);
+    int TranslateMouseButton(Uint8 button);
+	int GetKeyModifiers();
+	float GetElapsedTime();
+    bool LogMessage(Rocket::Core::Log::Type type, const Rocket::Core::String& message);
+};
+#endif

Samples/basic/sdl2/main.cpp

@@ -0,0 +1,159 @@
+/*
+ * This source file is part of libRocket, the HTML/CSS Interface Middleware
+ *
+ * For the latest information, see http://www.librocket.com
+ *
+ * Copyright (c) 2008-2010 Nuno Silva
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include <Rocket/Core.h>
+#include <Rocket/Core/Input.h>
+#include <Rocket/Debugger/Debugger.h>
+#include <ShellFileInterface.h>
+
+#include "SystemInterfaceSDL2.h"
+#include "RenderInterfaceSDL2.h"
+
+#include <SDL.h>
+
+#include <GL/glew.h>
+
+int main(int argc, char **argv)
+{
+    SDL_Init( SDL_INIT_VIDEO );
+    SDL_Window * screen = SDL_CreateWindow("LibRocket SDL2 test", 20, 20, 640, 480, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
+    SDL_GLContext glcontext = SDL_GL_CreateContext(screen);
+    int oglIdx = -1;
+    int nRD = SDL_GetNumRenderDrivers();
+    for(int i=0; i<nRD; i++)
+    {
+        SDL_RendererInfo info;
+        if(!SDL_GetRenderDriverInfo(i, &info))
+        {
+            if(!strcmp(info.name, "opengl"))
+            {
+                oglIdx = i;
+            }
+        }
+    }
+    SDL_Renderer * renderer = SDL_CreateRenderer(screen, oglIdx, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+
+    GLenum err = glewInit();
+
+    if(err != GLEW_OK)
+        fprintf(stderr, "GLEW ERROR: %s\n", glewGetErrorString(err));
+
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    glMatrixMode(GL_PROJECTION|GL_MODELVIEW);
+    glLoadIdentity();
+    glOrtho(0, 640, 480, 0, 0, 1);
+ 
+	RocketSDL2Renderer Renderer(renderer, screen);
+	RocketSDL2SystemInterface SystemInterface;
+	ShellFileInterface FileInterface("../Samples/assets/");
+
+	Rocket::Core::SetFileInterface(&FileInterface);
+	Rocket::Core::SetRenderInterface(&Renderer);
+    Rocket::Core::SetSystemInterface(&SystemInterface);
+
+	if(!Rocket::Core::Initialise())
+		return 1;
+
+	Rocket::Core::FontDatabase::LoadFontFace("Delicious-Bold.otf");
+	Rocket::Core::FontDatabase::LoadFontFace("Delicious-BoldItalic.otf");
+	Rocket::Core::FontDatabase::LoadFontFace("Delicious-Italic.otf");
+	Rocket::Core::FontDatabase::LoadFontFace("Delicious-Roman.otf");
+
+	Rocket::Core::Context *Context = Rocket::Core::CreateContext("default",
+		Rocket::Core::Vector2i(640, 480));
+
+	Rocket::Debugger::Initialise(Context);
+
+	Rocket::Core::ElementDocument *Document = Context->LoadDocument("demo.rml");
+
+	if(Document)
+	{
+		Document->Show();
+		Document->RemoveReference();
+		fprintf(stdout, "\nDocument loaded");
+	}
+	else
+	{
+		fprintf(stdout, "\nDocument is NULL");
+	}
+
+    bool done = false;
+
+	while(!done)
+	{
+        SDL_Event event;
+
+        SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
+        SDL_RenderClear(renderer);
+
+		Context->Render();
+        SDL_RenderPresent(renderer);
+
+        while(SDL_PollEvent(&event))
+        {
+            switch(event.type)
+            {
+                case SDL_QUIT:
+                    done = true;
+                    break;
+
+                case SDL_MOUSEMOTION:
+                    Context->ProcessMouseMove(event.motion.x, event.motion.y, SystemInterface.GetKeyModifiers());
+                    break;
+                
+                case SDL_MOUSEBUTTONDOWN:
+                    Context->ProcessMouseButtonDown(SystemInterface.TranslateMouseButton(event.button.button), SystemInterface.GetKeyModifiers());
+                    break;
+
+                case SDL_MOUSEBUTTONUP:
+                    Context->ProcessMouseButtonUp(SystemInterface.TranslateMouseButton(event.button.button), SystemInterface.GetKeyModifiers());
+                    break;
+
+                case SDL_MOUSEWHEEL:
+                    Context->ProcessMouseWheel(event.wheel.y, SystemInterface.GetKeyModifiers());
+                    break;
+
+                case SDL_KEYDOWN:
+                    Context->ProcessKeyDown(SystemInterface.TranslateKey(event.key.keysym.sym), SystemInterface.GetKeyModifiers());
+                    break;
+                default:
+                    break;
+            }
+        }
+        
+		Context->Update();
+	}
+
+    Context->RemoveReference();
+    Rocket::Core::Shutdown();
+
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(screen);
+    SDL_Quit();
+
+	return 0;
+};

Samples/basic/sfml2/SFML.vcproj

@@ -61,7 +61,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="RocketCore_d.lib RocketDebugger_d.lib sfml-system-s-d.lib sfml-window-s-d.lib sfml-graphics-s-d.lib"
+				AdditionalDependencies="opengl32.lib RocketCore_d.lib RocketDebugger_d.lib sfml-system-d.lib sfml-window-d.lib sfml-graphics-d.lib"
 				LinkIncremental="2"
 				AdditionalLibraryDirectories="..\..\..\..\sfml\lib;..\..\..\bin"
 				GenerateDebugInformation="true"

Samples/basic/sfml2/src/RenderInterfaceSFML.cpp

@@ -28,17 +28,11 @@
 #include <Rocket/Core/Core.h>
 #include "RenderInterfaceSFML.h"
 
-#ifdef ENABLE_GLEW
-#include <gl/glew.h>
-#endif
-
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
-// If built with the GL Easy Extension library we can compile geometry to VBO's
-// http://www.opengl.org/sdk/libs/GLee/
-#ifdef ENABLE_GLEW
 
+#ifdef ENABLE_GLEW
 class RocketSFMLRendererGeometryHandler
 {
 public:
@@ -61,7 +55,6 @@ public:
 		VertexID = IndexID = 0;
 	};
 };
-
 #endif
 
 struct RocketSFMLRendererVertex
@@ -88,37 +81,29 @@ sf::RenderWindow *RocketSFMLRenderer::GetWindow()
 
 void RocketSFMLRenderer::Resize()
 {
-	MyWindow->SetActive(true);
-	//MyWindow->SaveGLStates();
-
 	static sf::View View;
-	//View.SetFromRect(sf::FloatRect(0, (float)MyWindow->GetWidth(), (float)MyWindow->GetHeight(), 0));
-	View.SetViewport(sf::FloatRect(0, (float)MyWindow->GetWidth(), (float)MyWindow->GetHeight(), 0));
-	MyWindow->SetView(View);
+	View.setViewport(sf::FloatRect(0, (float)MyWindow->getSize().x, (float)MyWindow->getSize().y, 0));
+	MyWindow->setView(View);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
-	glOrtho(0, MyWindow->GetWidth(), MyWindow->GetHeight(), 0, -1, 1);
+	glOrtho(0, MyWindow->getSize().x, MyWindow->getSize().y, 0, -1, 1);
 	glMatrixMode(GL_MODELVIEW);
 
-	glViewport(0, 0, MyWindow->GetWidth(), MyWindow->GetHeight());
-
-	//MyWindow->RestoreGLStates();
+	glViewport(0, 0, MyWindow->getSize().x, MyWindow->getSize().y);
 };
 
 // Called by Rocket when it wants to render geometry that it does not wish to optimise.
 void RocketSFMLRenderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
 {
-	MyWindow->SetActive();
-
-	glPushMatrix();
+	MyWindow->pushGLStates();
 	glTranslatef(translation.x, translation.y, 0);
 
 	std::vector<Rocket::Core::Vector2f> Positions(num_vertices);
 	std::vector<Rocket::Core::Colourb> Colors(num_vertices);
 	std::vector<Rocket::Core::Vector2f> TexCoords(num_vertices);
 
-	for(int  i = 0; i < num_vertices; i++)
+	for(int i = 0; i < num_vertices; i++)
 	{
 		Positions[i] = vertices[i].position;
 		Colors[i] = vertices[i].colour;
@@ -136,11 +121,11 @@ void RocketSFMLRenderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	sf::Image *image = (sf::Image *)texture;
+	sf::Texture *sfTexture = (sf::Texture *)texture;
 
-	if(image)
+	if(sfTexture)
 	{
-		image->Bind();
+		sf::Texture::bind(sfTexture);
 	}
 	else
 	{
@@ -156,21 +141,13 @@ void RocketSFMLRenderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_
 
 	glColor4f(1, 1, 1, 1);
 
-	glPopMatrix();
+	MyWindow->popGLStates();
 }
 
 // Called by Rocket when it wants to compile geometry it believes will be static for the forseeable future.		
-Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket::Core::Vertex* vertices,
-																		   int num_vertices, int* indices,
-																		   int num_indices,
-																		   const Rocket::Core::TextureHandle texture)
+Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture)
 {
 #ifdef ENABLE_GLEW
-	MyWindow->SetActive();
-
-	//if(!GLEE_VERSION_2_0)
-		//return (Rocket::Core::CompiledGeometryHandle) NULL;
-
 	std::vector<RocketSFMLRendererVertex> Data(num_vertices);
 
 	for(unsigned long i = 0; i < Data.size(); i++)
@@ -199,7 +176,7 @@ Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket:
 
 	return (Rocket::Core::CompiledGeometryHandle)Geometry;
 #else
-	return NULL;
+	return (Rocket::Core::CompiledGeometryHandle)NULL;
 #endif
 }
 
@@ -207,20 +184,18 @@ Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket:
 void RocketSFMLRenderer::RenderCompiledGeometry(Rocket::Core::CompiledGeometryHandle geometry, const Rocket::Core::Vector2f& translation)
 {
 #ifdef ENABLE_GLEW
-	MyWindow->SetActive();
-
 	RocketSFMLRendererGeometryHandler *RealGeometry = (RocketSFMLRendererGeometryHandler *)geometry;
 
-	glPushMatrix();
+	MyWindow->pushGLStates();
 	glTranslatef(translation.x, translation.y, 0);
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	sf::Image *image = (sf::Image *)RealGeometry->Texture;
+	sf::Texture *texture = (sf::Texture *)RealGeometry->Texture;
 
-	if(image)
+	if(texture)
 	{
-		image->Bind();
+		sf::Texture::bind(texture);
 	}
 	else
 	{
@@ -249,9 +224,9 @@ void RocketSFMLRenderer::RenderCompiledGeometry(Rocket::Core::CompiledGeometryHa
 
 	glColor4f(1, 1, 1, 1);
 
-	glPopMatrix();
+	MyWindow->popGLStates();
 #else
-	ROCKET_ASSERT(false /*& "Not Implemented"*/);
+	ROCKET_ASSERT(false);
 #endif
 }
 
@@ -259,19 +234,15 @@ void RocketSFMLRenderer::RenderCompiledGeometry(Rocket::Core::CompiledGeometryHa
 void RocketSFMLRenderer::ReleaseCompiledGeometry(Rocket::Core::CompiledGeometryHandle geometry)
 {
 #ifdef ENABLE_GLEW
-	MyWindow->SetActive();
-
 	delete (RocketSFMLRendererGeometryHandler *)geometry;
 #else
-	ROCKET_ASSERT(false /*& "Not Implemented"*/);
+	ROCKET_ASSERT(false);
 #endif
 }
 
 // Called by Rocket when it wants to enable or disable scissoring to clip content.		
 void RocketSFMLRenderer::EnableScissorRegion(bool enable)
 {
-	MyWindow->SetActive();
-
 	if (enable)
 		glEnable(GL_SCISSOR_TEST);
 	else
@@ -281,16 +252,12 @@ void RocketSFMLRenderer::EnableScissorRegion(bool enable)
 // Called by Rocket when it wants to change the scissor region.		
 void RocketSFMLRenderer::SetScissorRegion(int x, int y, int width, int height)
 {
-	MyWindow->SetActive();
-
-	glScissor(x, MyWindow->GetHeight() - (y + height), width, height);
+	glScissor(x, MyWindow->getSize().y - (y + height), width, height);
 }
 
 // Called by Rocket when a texture is required by the library.		
 bool RocketSFMLRenderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle, Rocket::Core::Vector2i& texture_dimensions, const Rocket::Core::String& source)
 {
-	MyWindow->SetActive();
-
 	Rocket::Core::FileInterface* file_interface = Rocket::Core::GetFileInterface();
 	Rocket::Core::FileHandle file_handle = file_interface->Open(source);
 	if (file_handle == NULL)
@@ -304,19 +271,19 @@ bool RocketSFMLRenderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle
 	file_interface->Read(buffer, buffer_size, file_handle);
 	file_interface->Close(file_handle);
 
-	sf::Image *image = new sf::Image();
+	sf::Texture *texture = new sf::Texture();
 
-	if(!image->LoadFromMemory(buffer, buffer_size))
+	if(!texture->loadFromMemory(buffer, buffer_size))
 	{
 		delete buffer;
-		delete image;
+		delete texture;
 
 		return false;
 	};
 	delete buffer;
 
-	texture_handle = (Rocket::Core::TextureHandle) image;
-	texture_dimensions = Rocket::Core::Vector2i(image->GetWidth(), image->GetHeight());
+	texture_handle = (Rocket::Core::TextureHandle) texture;
+	texture_dimensions = Rocket::Core::Vector2i(texture->getSize().x, texture->getSize().y);
 
 	return true;
 }
@@ -324,18 +291,15 @@ bool RocketSFMLRenderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle
 // Called by Rocket when a texture is required to be built from an internally-generated sequence of pixels.
 bool RocketSFMLRenderer::GenerateTexture(Rocket::Core::TextureHandle& texture_handle, const Rocket::Core::byte* source, const Rocket::Core::Vector2i& source_dimensions)
 {
-	MyWindow->SetActive();
-
-	sf::Image *image = new sf::Image();
-
-	if(!image->LoadFromPixels(source_dimensions.x, source_dimensions.y, source))
-	{
-		delete image;
+	sf::Texture *texture = new sf::Texture();
 
+	if (!texture->create(source_dimensions.x, source_dimensions.y)) {
+		delete texture;
 		return false;
-	};
+	}
 
-	texture_handle = (Rocket::Core::TextureHandle)image;
+	texture->update(source, source_dimensions.x, source_dimensions.y, 0, 0);
+	texture_handle = (Rocket::Core::TextureHandle)texture;
 
 	return true;
 }
@@ -343,7 +307,5 @@ bool RocketSFMLRenderer::GenerateTexture(Rocket::Core::TextureHandle& texture_ha
 // Called by Rocket when a loaded texture is no longer required.		
 void RocketSFMLRenderer::ReleaseTexture(Rocket::Core::TextureHandle texture_handle)
 {
-	MyWindow->SetActive();
-
-	delete (sf::Image *)texture_handle;
+	delete (sf::Texture *)texture_handle;
 }

Samples/basic/sfml2/src/RenderInterfaceSFML.h

@@ -27,11 +27,25 @@
 #ifndef RENDERINTERFACESFML_H
 #define RENDERINTERFACESFML_H
 
+// NOTE: uncomment this only when you want to use the
+// OpenGL Extension Wrangler Library (GLEW)
+//#define ENABLE_GLEW
+
+// if the OpenGL Extension Wrangler Library (GLEW) should be used include it
+#ifdef ENABLE_GLEW
+#include <GL/glew.h>
+#endif
 
 #include <Rocket/Core/RenderInterface.h>
 #include <SFML/Graphics.hpp>
 
-#define ENABLE_GLEW
+// if the OpenGL Extension Wrangler Library (GLEW) should not be used
+// include the standard OpenGL library
+#ifndef ENABLE_GLEW
+// NOTE: add this if you receive a lot of errors in gl.h
+//#include <windows.h>
+#include <GL/gl.h>
+#endif
 
 class RocketSFMLRenderer : public Rocket::Core::RenderInterface
 {

Samples/basic/sfml2/src/SystemInterfaceSFML.cpp

@@ -31,272 +31,272 @@ int RocketSFMLSystemInterface::GetKeyModifiers(sf::Window *Window)
 {
 	int Modifiers = 0;
 
-	if(Window->GetInput().IsKeyDown(sf::Key::LShift) ||
-		Window->GetInput().IsKeyDown(sf::Key::RShift))
+	if(sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) ||
+		sf::Keyboard::isKeyPressed(sf::Keyboard::RShift))
 		Modifiers |= Rocket::Core::Input::KM_SHIFT;
 
-	if(Window->GetInput().IsKeyDown(sf::Key::LControl) ||
-		Window->GetInput().IsKeyDown(sf::Key::RControl))
+	if(sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) ||
+		sf::Keyboard::isKeyPressed(sf::Keyboard::RControl))
 		Modifiers |= Rocket::Core::Input::KM_CTRL;
 
-	if(Window->GetInput().IsKeyDown(sf::Key::LAlt) ||
-		Window->GetInput().IsKeyDown(sf::Key::RAlt))
+	if(sf::Keyboard::isKeyPressed(sf::Keyboard::LAlt) ||
+		sf::Keyboard::isKeyPressed(sf::Keyboard::RAlt))
 		Modifiers |= Rocket::Core::Input::KM_ALT;
 
 	return Modifiers;
 };
 
-Rocket::Core::Input::KeyIdentifier RocketSFMLSystemInterface::TranslateKey(sf::Key::Code Key)
+Rocket::Core::Input::KeyIdentifier RocketSFMLSystemInterface::TranslateKey(sf::Keyboard::Key Key)
 {
 	switch(Key)
 	{
-	case sf::Key::A:
+	case sf::Keyboard::A:
 		return Rocket::Core::Input::KI_A;
 		break;
-	case sf::Key::B:
+	case sf::Keyboard::B:
 		return Rocket::Core::Input::KI_B;
 		break;
-	case sf::Key::C:
+	case sf::Keyboard::C:
 		return Rocket::Core::Input::KI_C;
 		break;
-	case sf::Key::D:
+	case sf::Keyboard::D:
 		return Rocket::Core::Input::KI_D;
 		break;
-	case sf::Key::E:
+	case sf::Keyboard::E:
 		return Rocket::Core::Input::KI_E;
 		break;
-	case sf::Key::F:
+	case sf::Keyboard::F:
 		return Rocket::Core::Input::KI_F;
 		break;
-	case sf::Key::G:
+	case sf::Keyboard::G:
 		return Rocket::Core::Input::KI_G;
 		break;
-	case sf::Key::H:
+	case sf::Keyboard::H:
 		return Rocket::Core::Input::KI_H;
 		break;
-	case sf::Key::I:
+	case sf::Keyboard::I:
 		return Rocket::Core::Input::KI_I;
 		break;
-	case sf::Key::J:
+	case sf::Keyboard::J:
 		return Rocket::Core::Input::KI_J;
 		break;
-	case sf::Key::K:
+	case sf::Keyboard::K:
 		return Rocket::Core::Input::KI_K;
 		break;
-	case sf::Key::L:
+	case sf::Keyboard::L:
 		return Rocket::Core::Input::KI_L;
 		break;
-	case sf::Key::M:
+	case sf::Keyboard::M:
 		return Rocket::Core::Input::KI_M;
 		break;
-	case sf::Key::N:
+	case sf::Keyboard::N:
 		return Rocket::Core::Input::KI_N;
 		break;
-	case sf::Key::O:
+	case sf::Keyboard::O:
 		return Rocket::Core::Input::KI_O;
 		break;
-	case sf::Key::P:
+	case sf::Keyboard::P:
 		return Rocket::Core::Input::KI_P;
 		break;
-	case sf::Key::Q:
+	case sf::Keyboard::Q:
 		return Rocket::Core::Input::KI_Q;
 		break;
-	case sf::Key::R:
+	case sf::Keyboard::R:
 		return Rocket::Core::Input::KI_R;
 		break;
-	case sf::Key::S:
+	case sf::Keyboard::S:
 		return Rocket::Core::Input::KI_S;
 		break;
-	case sf::Key::T:
+	case sf::Keyboard::T:
 		return Rocket::Core::Input::KI_T;
 		break;
-	case sf::Key::U:
+	case sf::Keyboard::U:
 		return Rocket::Core::Input::KI_U;
 		break;
-	case sf::Key::V:
+	case sf::Keyboard::V:
 		return Rocket::Core::Input::KI_V;
 		break;
-	case sf::Key::W:
+	case sf::Keyboard::W:
 		return Rocket::Core::Input::KI_W;
 		break;
-	case sf::Key::X:
+	case sf::Keyboard::X:
 		return Rocket::Core::Input::KI_X;
 		break;
-	case sf::Key::Y:
+	case sf::Keyboard::Y:
 		return Rocket::Core::Input::KI_Y;
 		break;
-	case sf::Key::Z:
+	case sf::Keyboard::Z:
 		return Rocket::Core::Input::KI_Z;
 		break;
-	case sf::Key::Num0:
+	case sf::Keyboard::Num0:
 		return Rocket::Core::Input::KI_0;
 		break;
-	case sf::Key::Num1:
+	case sf::Keyboard::Num1:
 		return Rocket::Core::Input::KI_1;
 		break;
-	case sf::Key::Num2:
+	case sf::Keyboard::Num2:
 		return Rocket::Core::Input::KI_2;
 		break;
-	case sf::Key::Num3:
+	case sf::Keyboard::Num3:
 		return Rocket::Core::Input::KI_3;
 		break;
-	case sf::Key::Num4:
+	case sf::Keyboard::Num4:
 		return Rocket::Core::Input::KI_4;
 		break;
-	case sf::Key::Num5:
+	case sf::Keyboard::Num5:
 		return Rocket::Core::Input::KI_5;
 		break;
-	case sf::Key::Num6:
+	case sf::Keyboard::Num6:
 		return Rocket::Core::Input::KI_6;
 		break;
-	case sf::Key::Num7:
+	case sf::Keyboard::Num7:
 		return Rocket::Core::Input::KI_7;
 		break;
-	case sf::Key::Num8:
+	case sf::Keyboard::Num8:
 		return Rocket::Core::Input::KI_8;
 		break;
-	case sf::Key::Num9:
+	case sf::Keyboard::Num9:
 		return Rocket::Core::Input::KI_9;
 		break;
-	case sf::Key::Numpad0:
+	case sf::Keyboard::Numpad0:
 		return Rocket::Core::Input::KI_NUMPAD0;
 		break;
-	case sf::Key::Numpad1:
+	case sf::Keyboard::Numpad1:
 		return Rocket::Core::Input::KI_NUMPAD1;
 		break;
-	case sf::Key::Numpad2:
+	case sf::Keyboard::Numpad2:
 		return Rocket::Core::Input::KI_NUMPAD2;
 		break;
-	case sf::Key::Numpad3:
+	case sf::Keyboard::Numpad3:
 		return Rocket::Core::Input::KI_NUMPAD3;
 		break;
-	case sf::Key::Numpad4:
+	case sf::Keyboard::Numpad4:
 		return Rocket::Core::Input::KI_NUMPAD4;
 		break;
-	case sf::Key::Numpad5:
+	case sf::Keyboard::Numpad5:
 		return Rocket::Core::Input::KI_NUMPAD5;
 		break;
-	case sf::Key::Numpad6:
+	case sf::Keyboard::Numpad6:
 		return Rocket::Core::Input::KI_NUMPAD6;
 		break;
-	case sf::Key::Numpad7:
+	case sf::Keyboard::Numpad7:
 		return Rocket::Core::Input::KI_NUMPAD7;
 		break;
-	case sf::Key::Numpad8:
+	case sf::Keyboard::Numpad8:
 		return Rocket::Core::Input::KI_NUMPAD8;
 		break;
-	case sf::Key::Numpad9:
+	case sf::Keyboard::Numpad9:
 		return Rocket::Core::Input::KI_NUMPAD9;
 		break;
-	case sf::Key::Left:
+	case sf::Keyboard::Left:
 		return Rocket::Core::Input::KI_LEFT;
 		break;
-	case sf::Key::Right:
+	case sf::Keyboard::Right:
 		return Rocket::Core::Input::KI_RIGHT;
 		break;
-	case sf::Key::Up:
+	case sf::Keyboard::Up:
 		return Rocket::Core::Input::KI_UP;
 		break;
-	case sf::Key::Down:
+	case sf::Keyboard::Down:
 		return Rocket::Core::Input::KI_DOWN;
 		break;
-	case sf::Key::Add:
+	case sf::Keyboard::Add:
 		return Rocket::Core::Input::KI_ADD;
 		break;
-	case sf::Key::Back:
+	case sf::Keyboard::BackSpace:
 		return Rocket::Core::Input::KI_BACK;
 		break;
-	case sf::Key::Delete:
+	case sf::Keyboard::Delete:
 		return Rocket::Core::Input::KI_DELETE;
 		break;
-	case sf::Key::Divide:
+	case sf::Keyboard::Divide:
 		return Rocket::Core::Input::KI_DIVIDE;
 		break;
-	case sf::Key::End:
+	case sf::Keyboard::End:
 		return Rocket::Core::Input::KI_END;
 		break;
-	case sf::Key::Escape:
+	case sf::Keyboard::Escape:
 		return Rocket::Core::Input::KI_ESCAPE;
 		break;
-	case sf::Key::F1:
+	case sf::Keyboard::F1:
 		return Rocket::Core::Input::KI_F1;
 		break;
-	case sf::Key::F2:
+	case sf::Keyboard::F2:
 		return Rocket::Core::Input::KI_F2;
 		break;
-	case sf::Key::F3:
+	case sf::Keyboard::F3:
 		return Rocket::Core::Input::KI_F3;
 		break;
-	case sf::Key::F4:
+	case sf::Keyboard::F4:
 		return Rocket::Core::Input::KI_F4;
 		break;
-	case sf::Key::F5:
+	case sf::Keyboard::F5:
 		return Rocket::Core::Input::KI_F5;
 		break;
-	case sf::Key::F6:
+	case sf::Keyboard::F6:
 		return Rocket::Core::Input::KI_F6;
 		break;
-	case sf::Key::F7:
+	case sf::Keyboard::F7:
 		return Rocket::Core::Input::KI_F7;
 		break;
-	case sf::Key::F8:
+	case sf::Keyboard::F8:
 		return Rocket::Core::Input::KI_F8;
 		break;
-	case sf::Key::F9:
+	case sf::Keyboard::F9:
 		return Rocket::Core::Input::KI_F9;
 		break;
-	case sf::Key::F10:
+	case sf::Keyboard::F10:
 		return Rocket::Core::Input::KI_F10;
 		break;
-	case sf::Key::F11:
+	case sf::Keyboard::F11:
 		return Rocket::Core::Input::KI_F11;
 		break;
-	case sf::Key::F12:
+	case sf::Keyboard::F12:
 		return Rocket::Core::Input::KI_F12;
 		break;
-	case sf::Key::F13:
+	case sf::Keyboard::F13:
 		return Rocket::Core::Input::KI_F13;
 		break;
-	case sf::Key::F14:
+	case sf::Keyboard::F14:
 		return Rocket::Core::Input::KI_F14;
 		break;
-	case sf::Key::F15:
+	case sf::Keyboard::F15:
 		return Rocket::Core::Input::KI_F15;
 		break;
-	case sf::Key::Home:
+	case sf::Keyboard::Home:
 		return Rocket::Core::Input::KI_HOME;
 		break;
-	case sf::Key::Insert:
+	case sf::Keyboard::Insert:
 		return Rocket::Core::Input::KI_INSERT;
 		break;
-	case sf::Key::LControl:
+	case sf::Keyboard::LControl:
 		return Rocket::Core::Input::KI_LCONTROL;
 		break;
-	case sf::Key::LShift:
+	case sf::Keyboard::LShift:
 		return Rocket::Core::Input::KI_LSHIFT;
 		break;
-	case sf::Key::Multiply:
+	case sf::Keyboard::Multiply:
 		return Rocket::Core::Input::KI_MULTIPLY;
 		break;
-	case sf::Key::Pause:
+	case sf::Keyboard::Pause:
 		return Rocket::Core::Input::KI_PAUSE;
 		break;
-	case sf::Key::RControl:
+	case sf::Keyboard::RControl:
 		return Rocket::Core::Input::KI_RCONTROL;
 		break;
-	case sf::Key::Return:
+	case sf::Keyboard::Return:
 		return Rocket::Core::Input::KI_RETURN;
 		break;
-	case sf::Key::RShift:
+	case sf::Keyboard::RShift:
 		return Rocket::Core::Input::KI_RSHIFT;
 		break;
-	case sf::Key::Space:
+	case sf::Keyboard::Space:
 		return Rocket::Core::Input::KI_SPACE;
 		break;
-	case sf::Key::Subtract:
+	case sf::Keyboard::Subtract:
 		return Rocket::Core::Input::KI_SUBTRACT;
 		break;
-	case sf::Key::Tab:
+	case sf::Keyboard::Tab:
 		return Rocket::Core::Input::KI_TAB;
 		break;
 	};
@@ -306,7 +306,7 @@ Rocket::Core::Input::KeyIdentifier RocketSFMLSystemInterface::TranslateKey(sf::K
 
 float RocketSFMLSystemInterface::GetElapsedTime()
 {
-	return timer.GetElapsedTime();
+	return timer.getElapsedTime().asSeconds();
 };
 
 bool RocketSFMLSystemInterface::LogMessage(Rocket::Core::Log::Type type, const Rocket::Core::String& message)

Samples/basic/sfml2/src/SystemInterfaceSFML.h

@@ -35,7 +35,7 @@ class RocketSFMLSystemInterface : public Rocket::Core::SystemInterface
 {
 public:
 
-	Rocket::Core::Input::KeyIdentifier TranslateKey(sf::Key::Code Key);
+	Rocket::Core::Input::KeyIdentifier TranslateKey(sf::Keyboard::Key Key);
 	int GetKeyModifiers(sf::Window *Window);
 	float GetElapsedTime();
 	bool LogMessage(Rocket::Core::Log::Type type, const Rocket::Core::String& message);

Samples/basic/sfml2/src/main.cpp

@@ -25,7 +25,17 @@
  *
  */
 
-#include <gl/glew.h>
+/*
+ * Modifed 2013 by Megavolt2013 in order to get the SFML2 sample working
+ * with the revised libraries of SFML2
+ * Please check the comments starting with NOTE in the files "main.cpp" and
+ * "RenderInterfaceSFML.h" if you have trouble building this sample
+ */
+
+// NOTE: uncomment this only when you want to use the
+// OpenGL Extension Wrangler Library (GLEW)
+//#include <GL/glew.h>
+
 #include <Rocket/Core.h>
 #include "SystemInterfaceSFML.h"
 #include "RenderInterfaceSFML.h"
@@ -35,8 +45,10 @@
 
 int main(int argc, char **argv)
 {
-	sf::RenderWindow MyWindow(sf::VideoMode(800, 600), "libRocket with SFML");
+	sf::RenderWindow MyWindow(sf::VideoMode(800, 600), "libRocket with SFML2", sf::Style::Close);
+	MyWindow.setVerticalSyncEnabled(true);
 
+#ifdef ENABLE_GLEW
 	GLenum err = glewInit();
 	if (GLEW_OK != err)
 	{
@@ -45,12 +57,16 @@ int main(int argc, char **argv)
 	  //...
 	}
 	fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
+#endif
 
 	RocketSFMLRenderer Renderer;
 	RocketSFMLSystemInterface SystemInterface;
-	ShellFileInterface FileInterface("../Samples/assets/");
 
-	if(!MyWindow.IsOpened())
+	// NOTE: if fonts and rml are not found you'll probably have to adjust
+	// the path information in the string
+	ShellFileInterface FileInterface("../../assets/");
+
+	if(!MyWindow.isOpen())
 		return 1;
 
 	Renderer.SetWindow(&MyWindow);
@@ -59,6 +75,7 @@ int main(int argc, char **argv)
 	Rocket::Core::SetRenderInterface(&Renderer);
 	Rocket::Core::SetSystemInterface(&SystemInterface);
 
+
 	if(!Rocket::Core::Initialise())
 		return 1;
 
@@ -68,7 +85,7 @@ int main(int argc, char **argv)
 	Rocket::Core::FontDatabase::LoadFontFace("Delicious-Roman.otf");
 
 	Rocket::Core::Context *Context = Rocket::Core::CreateContext("default",
-		Rocket::Core::Vector2i(MyWindow.GetWidth(), MyWindow.GetHeight()));
+		Rocket::Core::Vector2i(MyWindow.getSize().x, MyWindow.getSize().y));
 
 	Rocket::Debugger::Initialise(Context);
 
@@ -85,52 +102,56 @@ int main(int argc, char **argv)
 		fprintf(stdout, "\nDocument is NULL");
 	}
 
-	while(MyWindow.IsOpened())
+	while(MyWindow.isOpen())
 	{
 		static sf::Event event;
 
-		MyWindow.Clear();
+		MyWindow.clear();
 		Context->Render();
-		MyWindow.Display();
+		MyWindow.display();
 
-		while(MyWindow.GetEvent(event))
+		while(MyWindow.pollEvent(event))
 		{
-			switch(event.Type)
+			switch(event.type)
 			{
 			case sf::Event::Resized:
 				Renderer.Resize();
 				break;
 			case sf::Event::MouseMoved:
-				Context->ProcessMouseMove(event.MouseMove.X, event.MouseMove.Y,
+				Context->ProcessMouseMove(event.mouseMove.x, event.mouseMove.y,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::MouseButtonPressed:
-				Context->ProcessMouseButtonDown(event.MouseButton.Button,
+				Context->ProcessMouseButtonDown(event.mouseButton.button,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::MouseButtonReleased:
-				Context->ProcessMouseButtonUp(event.MouseButton.Button,
+				Context->ProcessMouseButtonUp(event.mouseButton.button,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::MouseWheelMoved:
-				Context->ProcessMouseWheel(event.MouseWheel.Delta,
+				Context->ProcessMouseWheel(-event.mouseWheel.delta,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::TextEntered:
-				if (event.Text.Unicode > 32)
-					Context->ProcessTextInput(event.Text.Unicode);
+				if (event.text.unicode > 32)
+					Context->ProcessTextInput(event.text.unicode);
 				break;
 			case sf::Event::KeyPressed:
-				Context->ProcessKeyDown(SystemInterface.TranslateKey(event.Key.Code),
+				Context->ProcessKeyDown(SystemInterface.TranslateKey(event.key.code),
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::KeyReleased:
-				if(event.Key.Code == sf::Key::F8)
+				if(event.key.code == sf::Keyboard::F8)
 				{
 					Rocket::Debugger::SetVisible(!Rocket::Debugger::IsVisible());
 				};
 
-				Context->ProcessKeyUp(SystemInterface.TranslateKey(event.Key.Code),
+				if(event.key.code == sf::Keyboard::Escape) {
+					MyWindow.close();
+				}
+
+				Context->ProcessKeyUp(SystemInterface.TranslateKey(event.key.code),
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::Closed:

Source/Controls/ElementDataGrid.cpp

@@ -279,7 +279,7 @@ void ElementDataGrid::GetInnerRML(Rocket::Core::String& content) const
 	// The only content we have is the columns, and inside them the header elements.
 	for (size_t i = 0; i < columns.size(); i++)
 	{
-		Core::Element* header_element = header->GetChild(i);		
+		Core::Element* header_element = header->GetChild((int)i);
 
 		Rocket::Core::String column_fields;
 		for (size_t j = 0; j < columns[i].fields.size(); j++)

Source/Controls/ElementDataGridRow.cpp

@@ -571,7 +571,7 @@ void ElementDataGridRow::LoadChildren(float time_slice)
 			any_dirty_children = true;
 			if (data_query_offset == -1)
 			{
-				data_query_offset = i;
+				data_query_offset = (int)i;
 				data_query_limit = 1;
 			}
 			else

Source/Controls/ElementTabSet.cpp

@@ -47,14 +47,16 @@ void ElementTabSet::SetTab(int tab_index, const Rocket::Core::String& rml)
 	Core::Element* element = Core::Factory::InstanceElement(NULL, "*", "tab", Rocket::Core::XMLAttributes());
 	Core::Factory::InstanceElementText(element, rml);
 	SetTab(tab_index, element);
+	element->RemoveReference();
 }
 
 // Sets the specifed tab index's tab panel RML.
 void ElementTabSet::SetPanel(int tab_index, const Rocket::Core::String& rml)
 {
-	Core::Element* element = Core::Factory::InstanceElement(NULL, "*", "tab", Rocket::Core::XMLAttributes());
+	Core::Element* element = Core::Factory::InstanceElement(NULL, "*", "panel", Rocket::Core::XMLAttributes());
 	Core::Factory::InstanceElementText(element, rml);
 	SetPanel(tab_index, element);
+	element->RemoveReference();
 }
 
 // Set the specifed tab index's title element.

Source/Controls/WidgetDropDown.cpp

@@ -293,7 +293,7 @@ void WidgetDropDown::ProcessEvent(Core::Event& event)
 				{
 					if (options[i].IsSelectable())
 					{
-						SetSelection(i);
+						SetSelection((int)i);
 						event.StopPropagation();
 
 						ShowSelectBox(false);
@@ -333,10 +333,10 @@ void WidgetDropDown::ProcessEvent(Core::Event& event)
 		switch (key_identifier)
 		{
 			case Core::Input::KI_UP:
-				SetSelection( (selected_option - 1 + options.size()) % options.size() );
+				SetSelection((selected_option - 1 + (int)options.size()) % (int)options.size());
 				break;
 			case Core::Input::KI_DOWN:		
-				SetSelection( (selected_option + 1) % options.size() );
+				SetSelection((selected_option + 1) % (int)options.size());
 				break;
 			default:
 				break;

Source/Controls/WidgetTextInput.cpp

@@ -351,7 +351,7 @@ void WidgetTextInput::ProcessEvent(Core::Event& event)
     				for (size_t i = 0; i < clipboard_content.Length(); ++i)
     				{
     					if (max_length > 0 &&
-    						(int) Core::WString(GetElement()->GetAttribute< Rocket::Core::String >("value", "")).Length() < max_length)
+    						(int) Core::WString(GetElement()->GetAttribute< Rocket::Core::String >("value", "")).Length() > max_length)
     						break;
 
     					AddCharacter(clipboard_content[i]);
@@ -558,8 +558,8 @@ void WidgetTextInput::UpdateAbsoluteCursor()
 
 	for (int i = 0; i < cursor_line_index; i++)
 	{
-		absolute_cursor_index += lines[i].content.Length();
-		edit_index += lines[i].content.Length() + lines[i].extra_characters;
+		absolute_cursor_index += (int)lines[i].content.Length();
+		edit_index += (int)lines[i].content.Length() + lines[i].extra_characters;
 	}
 }
 
@@ -818,7 +818,7 @@ Rocket::Core::Vector2f WidgetTextInput::FormatText()
 
 			selection_vertices.resize(selection_vertices.size() + 4);
 			selection_indices.resize(selection_indices.size() + 6);
-			Core::GeometryUtilities::GenerateQuad(&selection_vertices[selection_vertices.size() - 4], &selection_indices[selection_indices.size() - 6], line_position, Rocket::Core::Vector2f((float) selection_width, (float) line_height), selection_colour, selection_vertices.size() - 4);
+			Core::GeometryUtilities::GenerateQuad(&selection_vertices[selection_vertices.size() - 4], &selection_indices[selection_indices.size() - 6], line_position, Rocket::Core::Vector2f((float)selection_width, (float)line_height), selection_colour, (int)selection_vertices.size() - 4);
 
 			line_position.x += selection_width;
 		}

Source/Core/BaseXMLParser.cpp

@@ -137,7 +137,7 @@ void BaseXMLParser::ReadBody()
 			// Bail if we've hit the end of the XML data.
 			if (open_tag_depth == 0)
 			{
-				xml_source->Seek((read - buffer) - buffer_used, SEEK_CUR);
+				xml_source->Seek((long)((read - buffer) - buffer_used), SEEK_CUR);
 				break;
 			}
 		}
@@ -434,7 +434,7 @@ bool BaseXMLParser::PeekString(const unsigned char* string, bool consume)
 		// overflow buffer.
 		if ((peek_read - buffer) + i >= buffer_used)
 		{
-			int peek_offset = peek_read - read;
+			int peek_offset = (int)(peek_read - read);
 			FillBuffer();
 			peek_read = read + peek_offset;
 
@@ -442,7 +442,7 @@ bool BaseXMLParser::PeekString(const unsigned char* string, bool consume)
 			{
 				// Wierd, seems our buffer is too small, realloc it bigger.
 				buffer_size *= 2;
-				int read_offset = read - buffer;
+				int read_offset = (int)(read - buffer);
 				buffer = (unsigned char*) realloc(buffer, buffer_size);
 
 				// Restore the read pointers.
@@ -494,7 +494,7 @@ bool BaseXMLParser::FillBuffer()
 	
 	read = buffer;
 	size_t bytes_read = xml_source->Read(&buffer[bytes_remaining], bytes_free);
-	buffer_used = bytes_read + bytes_remaining;
+	buffer_used = (int)(bytes_read + bytes_remaining);
 
 	return bytes_read > 0;
 }

Source/Core/DecoratorNone.cpp

@@ -38,7 +38,7 @@ DecoratorNone::~DecoratorNone()
 // Called on a decorator to generate any required per-element data for a newly decorated element.
 DecoratorDataHandle DecoratorNone::GenerateElementData(Element* ROCKET_UNUSED(element))
 {
-	return NULL;
+	return 0;
 }
 
 // Called to release element data generated by this decorator.

Source/Core/Element.cpp

@@ -783,7 +783,7 @@ float Element::GetClientHeight()
 // Returns the element from which all offset calculations are currently computed.
 Element* Element::GetOffsetParent()
 {
-	return parent;
+	return offset_parent;
 }
 
 // Gets the distance from this element's left border to its offset parent's left border.

Source/Core/ElementDecoration.cpp

@@ -199,7 +199,7 @@ bool ElementDecoration::IterateDecorators(int& index, PseudoClassList& pseudo_cl
 		// This is the one we're looking for.
 		name = index_iterator->first;
 
-		int relative_index = index - count;
+		int relative_index = index - (int)count;
 		pseudo_classes = decorator_index_list[relative_index].first;
 
 		const DecoratorHandle& decorator_handle = decorators[decorator_index_list[relative_index].second];

Source/Core/ElementStyleCache.cpp

@@ -38,7 +38,7 @@ ElementStyleCache::ElementStyleCache(ElementStyle *style) : style(style),
 	padding_top(NULL), padding_bottom(NULL), padding_left(NULL), padding_right(NULL),
 	width(NULL), height(NULL),
 	local_width(NULL), local_height(NULL), have_local_width(false), have_local_height(false),
-	overflow_x(NULL), overflow_y(NULL),
+	overflow_x(-1), overflow_y(-1),
 	position(-1), float_(-1), display(-1), whitespace(-1),
 	line_height(NULL), text_align(-1), text_transform(-1), vertical_align(NULL)
 {

Source/Core/ElementTextDefault.cpp

@@ -102,11 +102,11 @@ void ElementTextDefault::OnRender()
 	Vector2i clip_dimensions;
 	if (GetContext()->GetActiveClipRegion(clip_origin, clip_dimensions))
 	{
-		float clip_top = clip_origin.y;
-		float clip_left = clip_origin.x;
-		float clip_right = (clip_origin.x + clip_dimensions.x);
-		float clip_bottom = (clip_origin.y + clip_dimensions.y);
-		float line_height = GetFontFaceHandle()->GetLineHeight();
+		float clip_top = (float)clip_origin.y;
+		float clip_left = (float)clip_origin.x;
+		float clip_right = (float)(clip_origin.x + clip_dimensions.x);
+		float clip_bottom = (float)(clip_origin.y + clip_dimensions.y);
+		float line_height = (float)GetFontFaceHandle()->GetLineHeight();
 		
 		render = false;
 		for (size_t i = 0; i < lines.size(); ++i)
@@ -225,7 +225,7 @@ bool ElementTextDefault::GenerateLine(WString& line, int& line_length, float& li
 		// The token can fit on the end of the line, so add it onto the end and increment our width and length
 		// counters.
 		line += token;
-		line_length += (next_token_begin - token_begin);
+		line_length += (int)(next_token_begin - token_begin);
 		line_width += token_width;
 
 		// Break out of the loop if an endline was forced.

Source/Core/EventDispatcher.cpp

@@ -131,7 +131,7 @@ bool EventDispatcher::DispatchEvent(Element* target_element, const String& name,
 	event->SetPhase(Event::PHASE_CAPTURE);
 	// Capture phase - root, to target (only events that have registered as capture events)
 	// Note: We walk elements in REVERSE as they're placed in the list from the elements parent to the root
-	for (int i = elements.size() - 1; i >= 0 && event->IsPropagating(); i--) 
+	for (int i = (int)elements.size() - 1; i >= 0 && event->IsPropagating(); i--) 
 	{
 		EventDispatcher* dispatcher = elements[i]->GetEventDispatcher();
 		event->SetCurrentElement(elements[i]);

Source/Core/FileInterface.cpp

@@ -45,7 +45,7 @@ size_t FileInterface::Length(FileHandle file)
     size_t current_position = Tell(file);
     Seek( file, 0, SEEK_END);
     size_t length = Tell( file);
-    Seek( file, current_position, SEEK_SET);
+    Seek( file, (long)current_position, SEEK_SET);
     return length;
 }
 

Source/Core/FontDatabase.cpp

@@ -288,7 +288,7 @@ void* FontDatabase::LoadFace(const String& file_name)
 	file_interface->Read(buffer, length, handle);
 	file_interface->Close(handle);
 
-	return LoadFace(buffer, length, file_name, true);
+	return LoadFace(buffer, (int)length, file_name, true);
 }
 
 // Loads a FreeType face from memory.

Source/Core/FontFaceHandle.cpp

@@ -55,6 +55,8 @@ FontFaceHandle::FontFaceHandle()
 	underline_position = 0;
 	underline_thickness = 0;
 
+	ft_face = NULL;
+
 	base_layer = NULL;
 }
 
@@ -87,6 +89,8 @@ bool FontFaceHandle::Initialise(FT_Face ft_face, const String& _charset, int _si
 		return false;
 	}
 
+	this->ft_face = ft_face;
+
 	// find the maximum character we are interested in
 	max_codepoint = 0;
 	for (size_t i = 0; i < charset.size(); ++i)
@@ -95,12 +99,10 @@ bool FontFaceHandle::Initialise(FT_Face ft_face, const String& _charset, int _si
 	// Construct the list of the characters specified by the charset.
 	glyphs.resize(max_codepoint+1, FontGlyph());
 	for (size_t i = 0; i < charset.size(); ++i)
-		BuildGlyphMap(ft_face, charset[i]);
+		BuildGlyphMap(charset[i]);
 
 	// Generate the metrics for the handle.
-	GenerateMetrics(ft_face);
-
-	BuildKerning(ft_face);
+	GenerateMetrics();
 
 	// Generate the default layer and layer configuration.
 	base_layer = GenerateLayer(NULL);
@@ -330,7 +332,7 @@ void FontFaceHandle::GenerateLine(Geometry* geometry, const Vector2f& position,
 
 	line_vertices.resize(line_vertices.size() + 4);
 	line_indices.resize(line_indices.size() + 6);
-	GeometryUtilities::GenerateQuad(&line_vertices[0] + (line_vertices.size() - 4), &line_indices[0] + (line_indices.size() - 6), Vector2f(position.x, position.y + offset), Vector2f((float) width, underline_thickness), colour, line_vertices.size() - 4);
+	GeometryUtilities::GenerateQuad(&line_vertices[0] + (line_vertices.size() - 4), &line_indices[0] + (line_indices.size() - 6), Vector2f(position.x, position.y + offset), Vector2f((float) width, underline_thickness), colour, (int)line_vertices.size() - 4);
 }
 
 // Returns the font face's raw charset (the charset range as a string).
@@ -351,7 +353,7 @@ void FontFaceHandle::OnReferenceDeactivate()
 	delete this;
 }
 
-void FontFaceHandle::GenerateMetrics(FT_Face ft_face)
+void FontFaceHandle::GenerateMetrics()
 {
 	line_height = ft_face->size->metrics.height >> 6;
 	baseline = line_height - (ft_face->size->metrics.ascender >> 6);
@@ -384,7 +386,7 @@ void FontFaceHandle::GenerateMetrics(FT_Face ft_face)
 		x_height = 0;
 }
 
-void FontFaceHandle::BuildGlyphMap(FT_Face ft_face, const UnicodeRange& unicode_range)
+void FontFaceHandle::BuildGlyphMap(const UnicodeRange& unicode_range)
 {
 	for (word character_code = (word) (Math::Max< unsigned int >(unicode_range.min_codepoint, 32)); character_code <= unicode_range.max_codepoint; ++character_code)
 	{
@@ -496,48 +498,22 @@ void FontFaceHandle::BuildGlyph(FontGlyph& glyph, FT_GlyphSlot ft_glyph)
 		glyph.bitmap_data = NULL;
 }
 
-void FontFaceHandle::BuildKerning(FT_Face ft_face)
-{
-	// Compile the kerning information for this character if the font includes it.
-	if (FT_HAS_KERNING(ft_face))
-	{
-		kerning.resize(max_codepoint+1, GlyphKerningList(max_codepoint+1, 0));
-
-		for (size_t i = 0; i < charset.size(); ++i)
-		{
-			for (word rhs = (word) (Math::Max< unsigned int >(charset[i].min_codepoint, 32)); rhs <= charset[i].max_codepoint; ++rhs)
-			{
-				GlyphKerningList glyph_kerning(max_codepoint+1, 0);
-
-				for (size_t j = 0; j < charset.size(); ++j)
-				{
-					for (word lhs = (word) (Math::Max< unsigned int >(charset[j].min_codepoint, 32)); lhs <= charset[j].max_codepoint; ++lhs)
-					{
-						FT_Vector ft_kerning;
-						FT_Get_Kerning(ft_face, FT_Get_Char_Index(ft_face, lhs), FT_Get_Char_Index(ft_face, rhs), FT_KERNING_DEFAULT, &ft_kerning);
-
-						int kerning = ft_kerning.x >> 6;
-						if (kerning != 0)
-							glyph_kerning[lhs] = kerning;
-					}
-				}
-
-				kerning[rhs] = glyph_kerning;
-			}
-		}
-	}
-}
-
 int FontFaceHandle::GetKerning(word lhs, word rhs) const
 {
-	if (rhs >= kerning.size())
+	if (!FT_HAS_KERNING(ft_face))
 		return 0;
 
-	const GlyphKerningList &kerning_map = kerning[rhs];
-	if (lhs >= kerning_map.size())
+	FT_Vector ft_kerning;
+
+	FT_Error ft_error = FT_Get_Kerning(ft_face, 
+		FT_Get_Char_Index(ft_face, lhs), FT_Get_Char_Index(ft_face, rhs),
+		FT_KERNING_DEFAULT, &ft_kerning);
+
+	if (ft_error != 0)
 		return 0;
 
-	return kerning_map[lhs];
+	int kerning = ft_kerning.x >> 6;
+	return kerning;
 }
 
 // Generates (or shares) a layer derived from a font effect.

Source/Core/FontFaceHandle.h

@@ -127,12 +127,11 @@ protected:
 	virtual void OnReferenceDeactivate();
 
 private:
-	void GenerateMetrics(FT_Face ft_face);
+	void GenerateMetrics(void);
 
-	void BuildGlyphMap(FT_Face ft_face, const UnicodeRange& unicode_range);
+	void BuildGlyphMap(const UnicodeRange& unicode_range);
 	void BuildGlyph(FontGlyph& glyph, FT_GlyphSlot ft_glyph);
 
-	void BuildKerning(FT_Face ft_face);
 	int GetKerning(word lhs, word rhs) const;
 
 	// Generates (or shares) a layer derived from a font effect.
@@ -141,8 +140,9 @@ private:
 	typedef std::vector< int > GlyphKerningList;
 	typedef std::vector< GlyphKerningList > FontKerningList;
 
+	FT_Face ft_face;
+
 	FontGlyphList glyphs;
-	FontKerningList kerning;
 
 	typedef std::map< const FontEffect*, FontFaceLayer* > FontLayerMap;
 	typedef std::map< String, FontFaceLayer* > FontLayerCache;

Source/Core/FontFaceLayer.h

@@ -88,7 +88,7 @@ public:
 
 		character_vertices.resize(character_vertices.size() + 4);
 		character_indices.resize(character_indices.size() + 6);
-		GeometryUtilities::GenerateQuad(&character_vertices[0] + (character_vertices.size() - 4), &character_indices[0] + (character_indices.size() - 6), Vector2f(position.x + character.origin.x, position.y + character.origin.y), character.dimensions, colour, character.texcoords[0], character.texcoords[1], character_vertices.size() - 4);
+		GeometryUtilities::GenerateQuad(&character_vertices[0] + (character_vertices.size() - 4), &character_indices[0] + (character_indices.size() - 6), Vector2f(position.x + character.origin.x, position.y + character.origin.y), character.dimensions, colour, character.texcoords[0], character.texcoords[1], (int)character_vertices.size() - 4);
 	}
 
 	/// Returns the effect used to generate the layer.

Source/Core/Geometry.cpp

@@ -47,7 +47,7 @@ Geometry::Geometry(Element* _host_element)
 
 	fixed_texcoords = false;
 	compile_attempted = false;
-	compiled_geometry = NULL;
+	compiled_geometry = 0;
 }
 
 Geometry::Geometry(Context* _host_context)
@@ -61,7 +61,7 @@ Geometry::Geometry(Context* _host_context)
 
 	fixed_texcoords = false;
 	compile_attempted = false;
-	compiled_geometry = NULL;
+	compiled_geometry = 0;
 }
 
 Geometry::~Geometry()
@@ -128,7 +128,7 @@ void Geometry::Render(const Vector2f& translation)
 			}
 
 			compile_attempted = true;
-			compiled_geometry = render_interface->CompileGeometry(&vertices[0], (int) vertices.size(), &indices[0], (int) indices.size(), texture != NULL ? texture->GetHandle(GetRenderInterface()) : NULL);
+			compiled_geometry = render_interface->CompileGeometry(&vertices[0], (int) vertices.size(), &indices[0], (int) indices.size(), texture != NULL ? texture->GetHandle(GetRenderInterface()) : 0);
 
 			// If we managed to compile the geometry, we can clear the local copy of vertices and indices and
 			// immediately render the compiled version.
@@ -141,7 +141,7 @@ void Geometry::Render(const Vector2f& translation)
 
 		// Either we've attempted to compile before (and failed), or the compile we just attempted failed; either way,
 		// render the uncompiled version.
-		render_interface->RenderGeometry(&vertices[0], (int) vertices.size(), &indices[0], (int) indices.size(), texture != NULL ? texture->GetHandle(GetRenderInterface()) : NULL, translation);
+		render_interface->RenderGeometry(&vertices[0], (int) vertices.size(), &indices[0], (int) indices.size(), texture != NULL ? texture->GetHandle(GetRenderInterface()) : 0, translation);
 	}
 }
 
@@ -175,7 +175,7 @@ void Geometry::Release(bool clear_buffers)
 	if (compiled_geometry)
 	{
 		GetRenderInterface()->ReleaseCompiledGeometry(compiled_geometry);
-		compiled_geometry = NULL;
+		compiled_geometry = 0;
 	}
 
 	compile_attempted = false;

Source/Core/PropertyDictionary.cpp

@@ -64,7 +64,7 @@ const Property* PropertyDictionary::GetProperty(const String& name) const
 // Returns the number of properties in the dictionary.
 int PropertyDictionary::GetNumProperties() const
 {
-	return properties.size();
+	return (int)properties.size();
 }
 
 // Returns the map of properties in the dictionary.

Source/Core/PropertyParserColour.cpp

@@ -113,7 +113,7 @@ bool PropertyParserColour::ParseValue(Property& property, const String& value, c
 	{
 		StringList values;
 
-		int find = value.Find("(") + 1;
+		int find = (int)value.Find("(") + 1;
 		StringUtilities::ExpandString(values, value.Substring(find, value.RFind(")") - find), ',');
 
 		// Check if we're parsing an 'rgba' or 'rgb' colour declaration.

Source/Core/RenderInterface.cpp

@@ -44,7 +44,7 @@ RenderInterface::~RenderInterface()
 // Called by Rocket when it wants to compile geometry it believes will be static for the forseeable future.
 CompiledGeometryHandle RenderInterface::CompileGeometry(Vertex* ROCKET_UNUSED(vertices), int ROCKET_UNUSED(num_vertices), int* ROCKET_UNUSED(indices), int ROCKET_UNUSED(num_indices), TextureHandle ROCKET_UNUSED(texture))
 {
-	return NULL;
+	return 0;
 }
 
 // Called by Rocket when it wants to render application-compiled geometry.

Source/Core/Stream.cpp

@@ -70,7 +70,7 @@ size_t Stream::Peek(void* buffer, size_t bytes) const
 {
 	size_t pos = Tell();
 	size_t read = Read( buffer, bytes );
-	Seek( pos, SEEK_SET );
+	Seek( (long)pos, SEEK_SET );
 	return read;
 }
 
@@ -130,7 +130,7 @@ size_t Stream::PushBack(const void* buffer, size_t bytes)
 	size_t pos = Tell();
 	Seek(0, SEEK_END);
 	size_t wrote = Write(buffer, bytes);
-	Seek(pos, SEEK_SET);
+	Seek((long)pos, SEEK_SET);
 	return wrote;
 }
 

Source/Core/StreamFile.cpp

@@ -35,7 +35,7 @@ namespace Core {
 
 StreamFile::StreamFile()
 {
-	file_handle = NULL;
+	file_handle = 0;
 	length = 0;
 }
 
@@ -74,7 +74,7 @@ void StreamFile::Close()
 	if (file_handle)
 	{
 		GetFileInterface()->Close(file_handle);
-		file_handle = NULL;
+		file_handle = 0;
 	}
 
 	length = 0;

Source/Core/String.cpp

@@ -64,7 +64,7 @@ StringBase<char>::StringBase(StringBase<char>::size_type max_size, const char* f
 	va_list argument_list;
 	va_start(argument_list, fmt);
 
-	RocketStringFormatString(*this, max_size, fmt, argument_list);
+	RocketStringFormatString(*this, (int)max_size, fmt, argument_list);
 
 	va_end(argument_list);
 }
@@ -75,7 +75,7 @@ int StringBase<char>::FormatString(StringBase<char>::size_type max_size, const c
 	va_list argument_list;
 	va_start(argument_list, fmt);
 
-	int length = RocketStringFormatString(*this, max_size, fmt, argument_list);
+	int length = RocketStringFormatString(*this, (int)max_size, fmt, argument_list);
 
 	va_end(argument_list);
 

Source/Core/StyleSheetParser.cpp

@@ -95,7 +95,7 @@ bool StyleSheetParser::ParseProperties(PropertyDictionary& parsed_properties, co
 
 bool StyleSheetParser::ReadProperties(PropertyDictionary& properties)
 {
-	int rule_line_number = line_number;
+	int rule_line_number = (int)line_number;
 	String name;
 	String value;
 

Source/Core/Texture.cpp

@@ -75,7 +75,7 @@ String Texture::GetSource() const
 TextureHandle Texture::GetHandle(RenderInterface* render_interface) const
 {
 	if (resource == NULL)
-		return NULL;
+		return 0;
 
 	return resource->GetHandle(render_interface);
 }

Source/Core/XMLParseTools.cpp

@@ -40,7 +40,7 @@ namespace Core {
 // NOTE: tag *MUST* be in lowercase
 const char* XMLParseTools::FindTag(const char* tag, const char* string, bool closing_tag)
 {
-	int length = strlen(tag);
+	int length = (int)strlen(tag);
 	const char* ptr = string;
 	bool found_closing = false;
 

Source/Debugger/Geometry.cpp

@@ -58,7 +58,7 @@ void Geometry::RenderOutline(const Core::Vector2f& origin, const Core::Vector2f&
 	Core::GeometryUtilities::GenerateQuad(vertices + 8, indices + 12, Core::Vector2f(0, 0), Core::Vector2f(width, dimensions.y), colour, 8);
 	Core::GeometryUtilities::GenerateQuad(vertices + 12, indices + 18, Core::Vector2f(dimensions.x - width, 0), Core::Vector2f(width, dimensions.y), colour, 12);
 
-	render_interface->RenderGeometry(vertices, 4 * 4, indices, 6 * 4, NULL, origin);
+	render_interface->RenderGeometry(vertices, 4 * 4, indices, 6 * 4, 0, origin);
 }
 
 // Renders a box.
@@ -74,7 +74,7 @@ void Geometry::RenderBox(const Core::Vector2f& origin, const Core::Vector2f& dim
 
 	Core::GeometryUtilities::GenerateQuad(vertices, indices, Core::Vector2f(0, 0), Core::Vector2f(dimensions.x, dimensions.y), colour, 0);
 
-	render_interface->RenderGeometry(vertices, 4, indices, 6, NULL, origin);
+	render_interface->RenderGeometry(vertices, 4, indices, 6, 0, origin);
 }
 
 // Renders a box with a hole in the middle.

how_to_build_for_mingw.txt

@@ -5,22 +5,38 @@ Direct link:
 	
 Extract to Dependencies\freetype
 
-Go into the Build folder and run:
+Go into the Build folder and run cmake. However, notice:
 
-	cmake -G "MinGW Makefiles" -D CMAKE_MAKE_PROGRAM="C:\MinGW\bin\make.exe" -D FREETYPE_INCLUDE_DIRS="..\Dependencies\freetype\include;..\Dependencies\freetype\include\freetype2" -D FREETYPE_LIBRARY="..\Dependencies\freetype\lib\libfreetype.dll.a" .
+** REPLACE C:\MinGW\bin\mingw32-make.exe with the path to your MinGW make.exe file.
+** You have to have the C:\MinGW\bin in the path (or cmake will complain for missing libgmp-10.dll, etc).
+** You must not have msys/bin in the path, it doesn't work with cmake
+** Use -DSTATIC_LIB if static libs are wanted. However, you will also need -DSTATIC_LIB to your own application when including Rocket files.
+** Notice that the generator "MinGW Makefiles" match the mingw32-make.exe, while the generator "msys Makefiles" match the msys/bin/make.exe. The first combination is used for 
 
-N.B. ** REPLACE C:\MinGW\bin\make.exe with the path to your MinGW make.exe file. **
+compiling from the DOS prompt, and the second one for compiling from a MinGW shell.
+
+cmake -G "MinGW Makefiles" -D CMAKE_MAKE_PROGRAM="c:\MinGW\bin\mingw32-make.exe" -D FREETYPE_INCLUDE_DIRS="..\Dependencies\freetype\include;..\Dependencies\freetype\include
+
+\freetype2" -D FREETYPE_LIBRARY="..\Dependencies\freetype\lib\libfreetype.dll.a" .
 
 
 Once cmake completes successfully, run make
 
 	make
 
-
-The project will compile and three libraries will be generated in the Build folder:
+The project will compile and three libraries will be generated in the Build folder, use them to link with your project.
 	libRocket.dll.a
 	libRocketControls.dll.a
 	libRocketDebugger.dll.a
 
+The corresponding dll files are also created, and need to be available when running your application (if not linked statically):
+	libRocket.a
+	libRocketControls.a
+	libRocketDebugger.a
+
+From Dependencies/freetype/bin, get the file:
+	freetype6.dll
+
+If you get the cryptic error message "Can't correctly start the application (0xc000007b)", then zlib1.dll is also needed (from elsewhere).
 
 Done!