Re-added arrow key adjustment during drags.

src/slop.cpp

     // We have no GL context, so the matrix is useless...
     glm::mat4 fake;
     // This is where we'll run through all of our stuffs
+    auto last = std::chrono::high_resolution_clock::now();
     while( memory.running ) {
         slop::mouse->update();
         if ( !options->nokeyboard ) {
             slop::keyboard->update();
         }
         // We move our statemachine forward.
-        memory.update( 1 );
+        auto current = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double, std::milli> frametime = current-last;
+        last = current;
+        memory.update( frametime.count()/1000.f );
 
         // We don't actually draw anything, but the state machine uses
         // this to know when to spawn the window.
 
     // This is where we'll run through all of our stuffs
     auto start = std::chrono::high_resolution_clock::now();
+    auto last = start;
     while( memory.running ) {
         slop::mouse->update();
         if ( !options->nokeyboard ) {
             slop::keyboard->update();
         }
         // We move our statemachine forward.
-        memory.update( 1 );
+        auto current = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double, std::milli> frametime = current-last;
+        last = current;
+        memory.update( frametime.count()/1000.f );
 
         // Then we draw our junk to a framebuffer.
         window->framebuffer->setShader( textured );
         memory.draw( window->camera );
         window->framebuffer->unbind();
 
-        auto end = std::chrono::high_resolution_clock::now();
-        std::chrono::duration<double, std::milli> elapsed = end-start;
+        std::chrono::duration<double, std::milli> elapsed = current-start;
         if ( shaders.size() > 1 ) {
             int i;
             // We have our clean buffer, now to slather it with some juicy shader chains.

src/slopstates.cpp

 
 void slop::SlopStartDrag::onEnter( SlopMemory& memory ) {
     memory.rectangle->setPoints(startPoint, startPoint);
+    repeatTimer = 0;
+    multiplier = 1;
 }
 
 void slop::SlopStartDrag::update( SlopMemory& memory, double dt ) {
     if ( !mouse->getButton( 1 ) ) {
         memory.setState( (SlopState*)new SlopEndDrag() );
     }
+    int arrows[2];
+    arrows[0] = keyboard->getKey(XK_Down)-keyboard->getKey(XK_Up);
+    arrows[1] = keyboard->getKey(XK_Right)-keyboard->getKey(XK_Left);
+    if ( arrows[0] || arrows[1] ) {
+        if ( repeatTimer == 0 || repeatTimer > .4 ) {
+            startPoint.y += arrows[0]*multiplier;
+            startPoint.x += arrows[1]*multiplier;
+        }
+        if ( repeatTimer > 1 ) {
+            multiplier += dt*2;
+        }
+        repeatTimer += dt;
+    } else {
+        repeatTimer = 0;
+        multiplier = 1;
+    }
 }
 
 void slop::SlopStartDrag::draw( SlopMemory& memory, glm::mat4 matrix ) {

src/slopstates.hpp

 #define N_SLOPSTATES_H_
 
 #include "mouse.hpp"
+#include "keyboard.hpp"
 #include "slop.hpp"
 
 #include "rectangle.hpp"
 class SlopStartDrag : SlopState {
 private:
     glm::vec2 startPoint;
+    float repeatTimer;
+    float multiplier;
 public:
     SlopStartDrag( glm::vec2 point );
     virtual void onEnter( SlopMemory& memory );