gosu 0.7.50 → 0.8.0.pre1

data/GosuImpl/TextInput.cpp

@@ -0,0 +1,239 @@
+#include <Gosu/TextInput.hpp>
+#include <Gosu/Input.hpp>
+#include <Gosu/Utility.hpp>
+#include <SDL2/SDL.h>
+#include <cwctype>
+
+struct Gosu::TextInput::Impl
+{
+    // These two strings contain UTF-8 data.
+    // See this Wiki page for an overview of what is going on here:
+    // http://wiki.libsdl.org/Tutorials/TextInput#CandidateList
+    std::wstring text, composition;
+    unsigned caretPos, selectionStart;
+    
+    Impl()
+    : caretPos(0), selectionStart(0)
+    {
+    }
+    
+    void insertText(const std::wstring& newText)
+    {
+        // Stop IME composition.
+        composition.clear();
+
+        // Delete (overwrite) previous selection.
+        if (caretPos != selectionStart) {
+            unsigned min = std::min(caretPos, selectionStart);
+            unsigned max = std::max(caretPos, selectionStart);
+            text.erase(text.begin() + min, text.begin() + max);
+            caretPos = selectionStart = min;
+        }
+        
+        text.insert(text.begin() + caretPos, newText.begin(), newText.end());
+        caretPos += newText.size();
+        selectionStart = caretPos;
+    }
+    
+    void moveLeft(bool modifySelection)
+    {
+        if (caretPos > 0)
+            caretPos -= 1;
+        
+        if (modifySelection)
+            selectionStart = caretPos;
+    }
+    
+    void moveRight(bool modifySelection)
+    {
+        if (caretPos < text.length())
+            caretPos += 1;
+        
+        if (modifySelection)
+            selectionStart = caretPos;
+    }
+    
+    void moveWordLeft(bool modifySelection)
+    {
+        if (caretPos == text.length())
+            --caretPos;
+        
+        while (caretPos > 0 && std::iswspace(text.at(caretPos - 1)))
+            --caretPos;
+        
+        while (caretPos > 0 && !std::iswspace(text.at(caretPos - 1)))
+            --caretPos;
+        
+        if (modifySelection)
+            selectionStart = caretPos;
+    }
+
+    void moveWordRight(bool modifySelection)
+    {
+        while (caretPos < text.length() && std::iswspace(text.at(caretPos)))
+            ++caretPos;
+        
+        while (caretPos < text.length() && !std::iswspace(text.at(caretPos)))
+            ++caretPos;
+        
+        if (modifySelection)
+            selectionStart = caretPos;
+    }
+    
+    void moveToBeginningOfLine(bool modifySelection)
+    {
+        caretPos = 0;
+        
+        if (modifySelection)
+            selectionStart = caretPos;
+    }
+    
+    void moveToEndOfLine(bool modifySelection)
+    {
+        caretPos = static_cast<unsigned>(text.length());
+        
+        if (modifySelection)
+            selectionStart = caretPos;
+    }
+    
+    void deleteBackward()
+    {
+        if (selectionStart != caretPos) {
+            unsigned min = std::min(caretPos, selectionStart);
+            unsigned max = std::max(caretPos, selectionStart);
+            text.erase(text.begin() + min, text.begin() + max);
+            selectionStart = caretPos = min;
+        }
+        else if (caretPos > 0) {
+            unsigned oldCaret = caretPos;
+            caretPos -= 1;
+            text.erase(text.begin() + caretPos, text.begin() + oldCaret);
+            selectionStart = caretPos;
+        }
+    }
+    
+    void deleteForward()
+    {
+        if (selectionStart != caretPos) {
+            unsigned min = std::min(caretPos, selectionStart);
+            unsigned max = std::max(caretPos, selectionStart);
+            text.erase(text.begin() + min, text.begin() + max);
+            selectionStart = caretPos = min;
+        }
+        else if (caretPos < text.length()) {
+            unsigned oldCaret = caretPos;
+            caretPos += 1;
+            text.erase(text.begin() + oldCaret, text.begin() + caretPos);
+            selectionStart = caretPos = oldCaret;
+        }
+        
+    }
+};
+
+Gosu::TextInput::TextInput()
+: pimpl(new Impl)
+{
+}
+
+Gosu::TextInput::~TextInput()
+{
+}
+
+std::wstring Gosu::TextInput::text() const
+{
+    std::wstring composedText = pimpl->text;
+    if (! pimpl->composition.empty()) {
+        composedText.insert(pimpl->caretPos, pimpl->composition);
+    }
+    return composedText;
+}
+
+void Gosu::TextInput::setText(const std::wstring& text)
+{
+	pimpl->text = text;
+    pimpl->composition.clear();
+	pimpl->caretPos = pimpl->selectionStart = static_cast<unsigned>(text.length());
+}
+
+unsigned Gosu::TextInput::caretPos() const
+{
+    return static_cast<unsigned>(pimpl->caretPos);
+}
+
+void Gosu::TextInput::setCaretPos(unsigned pos)
+{
+    pimpl->caretPos = pos;
+}
+
+unsigned Gosu::TextInput::selectionStart() const
+{
+    return static_cast<unsigned>(pimpl->selectionStart);
+}
+
+void Gosu::TextInput::setSelectionStart(unsigned pos)
+{
+    pimpl->selectionStart = pos;
+}
+
+bool Gosu::TextInput::feedSDLEvent(void* event)
+{
+    const SDL_Event* e = static_cast<SDL_Event*>(event);
+    
+    switch (e->type) {
+        // Direct text input, and sent after IME composition completes.
+        case SDL_TEXTINPUT: {
+            std::wstring textToInsert = utf8ToWstring(e->text.text);
+            textToInsert = filter(textToInsert);
+            pimpl->insertText(textToInsert);
+            return true;
+        }
+        // IME composition in progress.
+        case SDL_TEXTEDITING: {
+            pimpl->composition = utf8ToWstring(e->edit.text);
+            return true;
+        }
+        // Emulate "standard" Windows/X11 keyboard behavior.
+        case SDL_KEYDOWN: {
+            // ...but not if the IME is currently compositing.
+            if (! pimpl->composition.empty()) {
+                return false;
+            }
+            
+            bool ctrlDown = (e->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL));
+            bool shiftDown = (e->key.keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT));
+            SDL_Keycode key = e->key.keysym.sym;
+            
+            switch (key) {
+                case SDLK_LEFT:
+                    if (ctrlDown)
+                        pimpl->moveWordLeft(! shiftDown);
+                    else
+                        pimpl->moveLeft(! shiftDown);
+                    return true;
+                case SDLK_RIGHT:
+                    if (ctrlDown)
+                        pimpl->moveWordRight(! shiftDown);
+                    else
+                        pimpl->moveRight(! shiftDown);
+                    return true;
+                case SDLK_HOME:
+                    pimpl->moveToBeginningOfLine(! shiftDown);
+                    return true;
+                case SDLK_END:
+                    pimpl->moveToEndOfLine(! shiftDown);
+                    return true;
+                case SDLK_BACKSPACE:
+                    pimpl->deleteBackward();
+                    return true;
+                case SDLK_DELETE:
+                    pimpl->deleteForward();
+                    return true;
+            }
+            break;
+        }
+            
+        // TODO: Handle copy & paste.
+    }
+    
+    return false;
+}

data/GosuImpl/Window.cpp

@@ -0,0 +1,215 @@
+#include <Gosu/Gosu.hpp>
+#include <SDL2/SDL.h>
+#include <cstdlib>
+#include <memory>
+#include <stdexcept>
+
+using namespace std::tr1::placeholders;
+
+namespace Gosu
+{
+    namespace FPS
+    {
+        void registerFrame();
+    }
+    
+    SDL_DisplayMode desktopDisplayMode = { 0, 0 };
+}
+
+unsigned Gosu::screenWidth()
+{
+    // TODO - not thread-safe
+    if (desktopDisplayMode.w == 0) {
+        SDL_GetDesktopDisplayMode(0, &desktopDisplayMode);
+    }
+    return desktopDisplayMode.w;
+}
+
+unsigned Gosu::screenHeight()
+{
+    // TODO - not thread-safe
+    if (desktopDisplayMode.h == 0) {
+        SDL_GetDesktopDisplayMode(0, &desktopDisplayMode);
+    }
+    return desktopDisplayMode.h;
+}
+
+struct Gosu::Window::Impl
+{
+    SDL_Window *window;
+    SDL_GLContext context;
+    double updateInterval;
+    
+    std::auto_ptr<Graphics> graphics;
+    std::auto_ptr<Input> input;
+};
+
+Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double updateInterval)
+: pimpl(new Impl)
+{
+    if (SDL_Init(SDL_INIT_VIDEO) < 0)
+        throw std::runtime_error("Failed to initialize SDL Video");
+    
+    unsigned actualWidth = width;
+    unsigned actualHeight = height;
+    double scaleFactor = 1.0;
+    double blackBarWidth = 0;
+    double blackBarHeight = 0;
+    
+    if (fullscreen) {
+        actualWidth = Gosu::screenWidth();
+        actualHeight = Gosu::screenHeight();
+
+        double scaleX = 1.0 * actualWidth / width;
+        double scaleY = 1.0 * actualHeight / height;
+        scaleFactor = std::min(scaleX, scaleY);
+
+        if (scaleX < scaleY) {
+            blackBarHeight = (actualHeight / scaleX - height) / 2;
+        }
+        else if (scaleY < scaleX) {
+            blackBarWidth = (actualWidth / scaleY - width) / 2;
+        }
+    }
+    else {
+        // TODO - get platform-specific best width/height we could get
+        
+        double maxWidth = Gosu::screenWidth() * 0.9;
+        double maxHeight = Gosu::screenHeight() * 0.8;
+        
+        if (width > maxWidth || height > maxHeight) {
+            scaleFactor = std::min(maxWidth / width, maxHeight / height);
+            actualWidth = width * scaleFactor;
+            actualHeight = height * scaleFactor;
+        }
+    }
+    
+    pimpl->window = SDL_CreateWindow("",
+        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+        actualWidth, actualHeight,
+        SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI |
+            (fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
+    pimpl->context = SDL_GL_CreateContext(pimpl->window);
+    SDL_GL_MakeCurrent(pimpl->window, pimpl->context);
+    SDL_GL_SetSwapInterval(1);
+    
+    pimpl->graphics.reset(new Graphics(actualWidth, actualHeight, fullscreen));
+    pimpl->graphics->setResolution(width, height, blackBarWidth, blackBarHeight);
+    pimpl->input.reset(new Input());
+    pimpl->input->setMouseFactors(1 / scaleFactor, 1 / scaleFactor, blackBarWidth, blackBarHeight);
+    input().onButtonDown = std::tr1::bind(&Window::buttonDown, this, _1);
+    input().onButtonUp = std::tr1::bind(&Window::buttonUp, this, _1);
+    pimpl->updateInterval = updateInterval;
+}
+
+Gosu::Window::~Window()
+{
+    SDL_GL_DeleteContext(pimpl->context);
+    SDL_DestroyWindow(pimpl->window);
+    
+    SDL_QuitSubSystem(SDL_INIT_VIDEO);
+}
+
+std::wstring Gosu::Window::caption() const
+{
+    return utf8ToWstring(SDL_GetWindowTitle(pimpl->window));
+}
+
+void Gosu::Window::setCaption(const std::wstring& caption)
+{
+    std::string utf8 = wstringToUTF8(caption);
+    SDL_SetWindowTitle(pimpl->window, utf8.c_str());
+}
+
+double Gosu::Window::updateInterval() const
+{
+    return pimpl->updateInterval;
+}
+
+namespace GosusDarkSide
+{
+    // TODO: Find a way for this to fit into Gosu's design.
+    // This can point to a function that wants to be called every
+    // frame, e.g. rb_thread_schedule.
+    typedef void (*HookOfHorror)();
+    HookOfHorror oncePerTick = 0;
+}
+
+void Gosu::Window::show()
+{
+    while (true) {
+        unsigned long startTime = milliseconds();
+        
+        SDL_Event e;
+        while (SDL_PollEvent(&e)) {
+            if (e.type == SDL_QUIT)
+                return;
+            else
+                input().feedSDLEvent(&e);
+		}
+        
+        Song::update();
+        
+        input().update();
+        
+        update();
+        
+        if (graphics().begin()) {
+            draw();
+            graphics().end();
+            FPS::registerFrame();
+        }
+	    
+        SDL_GL_SwapWindow(pimpl->window);
+        
+        if (GosusDarkSide::oncePerTick) GosusDarkSide::oncePerTick();
+        
+        // Sleep to keep this loop from eating 100% CPU.
+        unsigned int frameTime = milliseconds() - startTime;
+        if (frameTime > 0 && frameTime < pimpl->updateInterval) {
+            sleep(pimpl->updateInterval - frameTime);
+        }
+    }
+}
+
+void Gosu::Window::close()
+{
+    SDL_Event e;
+    e.type = SDL_QUIT;
+    SDL_PushEvent(&e);
+}
+
+const Gosu::Graphics& Gosu::Window::graphics() const
+{
+    return *pimpl->graphics;
+}
+
+Gosu::Graphics& Gosu::Window::graphics()
+{
+    return *pimpl->graphics;
+}
+
+const Gosu::Input& Gosu::Window::input() const
+{
+    return *pimpl->input;
+}
+
+Gosu::Input& Gosu::Window::input()
+{
+    return *pimpl->input;
+}
+
+// Deprecated.
+
+class Gosu::Audio {};
+namespace { Gosu::Audio dummyAudio; }
+
+const Gosu::Audio& Gosu::Window::audio() const
+{
+    return dummyAudio;
+}
+
+Gosu::Audio& Gosu::Window::audio()
+{
+    return dummyAudio;
+}