changeset 5:5ee5ef99e117

presets have "icons" and save OK. Snapping works. move velocity still frustrating.

--- a/eventLogger.h	Tue Dec 04 18:36:00 2012 +0000
+++ b/eventLogger.h	Wed Dec 05 18:42:02 2012 +0000
@@ -21,19 +21,47 @@
 #include <string>
 #include <map>
 #include "2dvector.h"
-enum leventType {SAVE_PRESET, SAVE_DESET, SCROLL, ZOOM, CHANGE_SLIDER, SWAP_VIEW};
+enum leventType {SAVE_PRESET, SAVE_DESET, SCROLL, SCROLL_STOPPED, ZOOM, CHANGE_SLIDER, SWAP_VIEW, SET_MIN_ZOOM, SET_MAX_ZOOM};
 
 class lEvent{
-
+public:
     // try and make this as compact as possible.
     leventType eventType;
     double val1; // x coord, scale if zoom
     double val2; // y coord, 0 if zoom
     int sliderID;
+    lEvent(leventType eType, double v1, double v2 = 0.0,int sID = 0){
+        eventType = eType;
+        val1 = v1;
+        val2 = v2;
+        sliderID = sID;
+    }
+};
+//---------------------------------------------------------------------------
+inline istream& operator>>(istream & is, lEvent& e){
+    is.setf(ios_base::fixed,ios_base::floatfield);
+    is.precision(1);
     
-};
+    char delim;
+    int eType;
 
+    is >> eType >> delim >> e.val1 >> delim >> e.val2 >> delim >> e.sliderID;
+    
+    e.eventType = (leventType)eType;
+    
+    return is;
+}
 
+//---------------------------------------------------------------------------
+inline ostream& operator<<(ostream & os, const lEvent& e){
+    os.setf(ios_base::fixed,ios_base::floatfield);
+    os.precision(1);
+    
+    os << e.eventType << ',' << e.val1 << ',' << e.val2 << ',' << e.sliderID << '\n';
+    
+    return os;
+    }
+ //---------------------------------------------------------------------------   
 
 class EventLogger{
 public:
@@ -41,14 +69,28 @@
     /*
      time, type, value
      */
+    bool loggingEnabled;
+    
     vector<lEvent> theEvents;
     
     string userID; // get something from hardware??
     
     EventLogger();
-    void logEvent(const leventType& evtType,const TwoVector& centre, const double& scale, const int& sliderID);
+    void logEvent(const leventType& evtType,const TwoVector& centre = TwoVector(), const double& scale = 1.0, const int& sliderID = -1, const double& sliderVal = 0.0);
+    void logEvent(const leventType& evtType,const int& sliderID, const double& sliderVal);
     void sendHttp();
+    
+    void printAll(){
+        cout << "ALL LOGGED EVENTS!: \n";
+        vector<lEvent>::iterator evIter;
+        for(evIter = theEvents.begin(); evIter < theEvents.end(); evIter++){
+            cout << *evIter;
+            
+        }
+    };
 };
 
 
+    
+
 #endif /* defined(__oscSenderExample__eventLogger__) */

--- a/eventLogger.mm	Tue Dec 04 18:36:00 2012 +0000
+++ b/eventLogger.mm	Wed Dec 05 18:42:02 2012 +0000
@@ -15,7 +15,8 @@
 EventLogger::EventLogger(){
     
     // if first time opened request a user ID from the server... use time?
-
+    loggingEnabled = true;
+    
     double timemsd = [NSDate timeIntervalSinceReferenceDate];
     long long timems = (long long)(timemsd*1000);
     cout << "Time (ms) = " << timems << "\n";
@@ -24,10 +25,13 @@
     CFUUIDRef theUUID = CFUUIDCreate(NULL);
     CFStringRef tstring = CFUUIDCreateString(NULL, theUUID);
     CFRelease(theUUID);
-
+    
+    
+    
+    
 }
 
-void EventLogger::logEvent(const leventType& evtType,const TwoVector& centre, const double& scale = 1.0, const int& sliderID = -1){
+void EventLogger::logEvent(const leventType& evtType,const TwoVector& centre, const double& scale, const int& sliderID, const double& sliderVal){
     //cout << "log: " << evtType << "\n";
     
     // scroll has 2 double coords
@@ -38,21 +42,27 @@
     
     // get time for key index
     
+    // thinFactor
+    if(!loggingEnabled) return;
     switch ( evtType ) {
         case SAVE_PRESET:
+            theEvents.push_back(lEvent(evtType,centre.x,centre.y));
             // Code
             break;
         case SAVE_DESET:
-            // Code
+            theEvents.push_back(lEvent(evtType,centre.x,centre.y));
             break;
         case SCROLL:
-            // Code
+            theEvents.push_back(lEvent(evtType,centre.x,centre.y));
+            break;
+        case SCROLL_STOPPED:
+            theEvents.push_back(lEvent(evtType,centre.x,centre.y));
             break;
         case ZOOM:
-            // Code
+            theEvents.push_back(lEvent(evtType,scale));
             break;
         case CHANGE_SLIDER:
-            // Code
+            theEvents.push_back(lEvent(evtType,sliderVal , 0.0 , sliderID));
             break;
         default:
             // Code
@@ -61,10 +71,21 @@
 
     
 }
-
+void EventLogger::logEvent(const leventType& evtType,const int& sliderID, const double& sliderVal){
+    if(!loggingEnabled) return;
+    // sliderThinFactor
+    switch ( evtType ) {
+        case CHANGE_SLIDER:
+            theEvents.push_back(lEvent(evtType,sliderVal , 0.0 , sliderID));
+            break;
+        default:
+            // Code
+            break;
+    }
+}
 void EventLogger::sendHttp(){
     
-    string url = "http://www.rootnot.co.uk/cgi-bin/";
+    string url = "http://www.rootnot.co.uk/cgi-bin/zoomlogs.cgi";
     ofURLFileLoader fileLoader;
     ofHttpResponse resp;
     resp = fileLoader.get(url);

--- a/grid.h	Tue Dec 04 18:36:00 2012 +0000
+++ b/grid.h	Wed Dec 05 18:42:02 2012 +0000
@@ -26,11 +26,18 @@
     int codeLength; // the 1d size of the code, determines max extent of single tile, related to params per dim
     const int paramBitDepth; // number of bits for the parameter control data - i.e. always 7 for midi CC
     
+
+    
     TwoVector topLeft; // top left corner of view, surface coords
     TwoVector bottomRight;
     TwoVector size;     // size of view, surface coords
     TwoVector pixSize; // size of view pixels (ie screen size!)
     TwoVector centre;
+    
+    
+    TwoVector snapCentre;
+    TwoVector snapDist; // number of pixels to snap to
+    
     bool maxZoom, minZoom;
     int cubeWidth;    // side of hypercube. 2 for binary coding.
 
@@ -46,8 +53,6 @@
     void viewWasChanged();
     void checkConsistencies();
     
-
-    
     vector<bool> intToGray(int num, int dimToTravel=3) const;
     vector<int> coordTobase32(double coord) const;
     vector<int> grayToMidi(vector<vector <bool> > grayCodes) const;
@@ -64,23 +69,28 @@
     void drawPresets();
     
     void setCoord(TwoVector coord);
-    TwoVector coordToPixel(TwoVector coord);
+    void drawCrossHairs();
+    void snapCheck();
 public:
+
     Grid();
     ~Grid();
     void init();
     void move(TwoVector moveP); // shift view by pixels
     void zoom(float factor);
-    
+    bool snapped;
     void draw();    // draw lines
     
     void update(); // change according to zoom
     
     vector<int> calculateParamsFromCoord(TwoVector coord) const;
     TwoVector calculateCoordFromParams(vector<int> params) const;
-    
+    TwoVector coordToPixel(TwoVector coord);
     vector<int> getParams();
     TwoVector getCoord();
+    void setMinZoom();
+    void setMaxZoom();
+   
     // the inverse stuff
     void setParams(vector<int>);
     

--- a/grid.mm	Tue Dec 04 18:36:00 2012 +0000
+++ b/grid.mm	Wed Dec 05 18:42:02 2012 +0000
@@ -34,8 +34,9 @@
  
     //set scale and position to mid way
     scale = pow(32.0,6.0);
+    snapDist = TwoVector(10,10);
+    snapped = false;
     
-
     size.setCoord(pixSize.x*scale, pixSize.y*scale);
     centre.setCoord(maxValue/2 , maxValue/2);
     topLeft.setCoord(centre.x - size.x/2, centre.y - size.y/2);
@@ -61,7 +62,7 @@
 template <typename T> int sgn(T val) {
     return (T(0) < val) - (val < T(0));
 }
-
+//--------------------------------------------------------------
 void Grid::makeCode(){
  
     ////////////////////////////////~~~,,,,,,,,.........
@@ -330,12 +331,7 @@
     ////////-------/////////
     
     // draw centre cross hairs
-    ofSetColor(255, 0, 0);
-    ofNoFill();
-    ofLine(pixSize.x/2-20, pixSize.y/2, pixSize.x/2+20, pixSize.y/2);
-	ofLine(pixSize.x/2, pixSize.y/2-20, pixSize.x/2, pixSize.y/2+20);
-    ofEllipse(pixSize.x/2, pixSize.y/2, 20, 20);
-    ofFill();
+    drawCrossHairs();
     ////////-------////////
     /*
     ostringstream temp;
@@ -344,6 +340,24 @@
     ofDrawBitmapString( s, pixSize.x/2+10, pixSize.y/2+10 );
     */
 }
+//-----------------------------------------------------------------------
+void Grid::drawCrossHairs(){
+    // snapping
+    TwoVector pos;
+    if(snapped){
+        pos = coordToPixel(snapCentre);
+    }else{
+        pos = coordToPixel(centre);
+        
+    }
+    ofSetColor(255, 0, 0);
+    ofNoFill();
+    ofLine(pos.x-20, pos.y, pos.x+20, pos.y);
+    ofLine(pos.x, pos.y-20, pos.x, pos.y+20);
+    ofEllipse(pos.x, pos.y, 20, 20);
+    ofFill();
+}
+//-----------------------------------------------------------------------
 TwoVector Grid::coordToPixel(TwoVector coord){
     TwoVector pix;
     pix.x = (coord.x - topLeft.x)/scale;
@@ -354,16 +368,7 @@
 
 //-----------------------------------------------------------------------
 void Grid::drawPresets(){
-    vector<TwoVector> points;
-    TwoVector pos;
-    points = presetManager.getPresetsInRange(topLeft, topLeft + size);
-    vector<TwoVector>::iterator piter;
-    for(piter = points.begin(); piter < points.end(); piter++){
-        ofSetColor(255, 255, 255, 200);
-        pos = coordToPixel(*piter);
-        ofCircle(pos.x, pos.y, 2);
-        
-    }
+    presetManager.drawPresetsInRange(topLeft, topLeft + size);
 }
 
 //-----------------------------------------------------------------------
@@ -413,6 +418,7 @@
 
 
 }
+
 //--------------------------------------------------------------
 void Grid::move(TwoVector moveP){
     // numspacing, pixelspacing stay the same
@@ -425,11 +431,13 @@
     centre = centre - moveS;
     
     viewWasChanged();
-    eventLogger.logEvent(-1, centre, scale);
+    eventLogger.logEvent(SCROLL, centre, scale);
     
 }
 //--------------------------------------------------------------
 void Grid::zoom(float factor){
+    if(snapped)centre = (centre + snapCentre)*0.5; // clunky
+    
     if(maxZoom && factor > 1.0){
         return;
         
@@ -454,33 +462,74 @@
     
     
     viewWasChanged();
-    eventLogger.logEvent(-2, centre, scale);
+    eventLogger.logEvent(ZOOM, centre, scale);
 
-} 
-void setMaxZoom(){ // got to smallest (white)
+}
+//--------------------------------------------------------------
+void Grid::snapCheck(){
+    // check environs for presets.
+    Preset * closestPreset;
+    vector<Preset *> closePresets = presetManager.getPresetsInRange(centre - snapDist*scale, centre + snapDist*scale);
+    if(closePresets.size() > 0){
+        snapped = true;
+        // find closest
+        double dist, mindist = maxValue;
+        closestPreset = closePresets[0];
+        
+        for(vector<Preset *>::iterator piter = closePresets.begin(); piter < closePresets.end(); piter++){
+            dist = (*piter)->coordinates.distanceTo(centre);
+            
+            if(dist < mindist){
+                mindist = dist;
+                closestPreset = *piter;
+            }
+        }
+        snapCentre = closestPreset->coordinates;
+        
+    }else{
+        snapped = false;
+        snapCentre = centre;
+    }
+
     
 }
 //--------------------------------------------------------------
-void setMinZoom(){ // go to entire space (orange)
-    
+void Grid::setMaxZoom(){ // got to smallest (white)
+    if(snapped)centre = snapCentre;
+    size.x = maxValue*2.0;
+    scale = size.x/pixSize.x;
+    size.y = scale * pixSize.y;
+    viewWasChanged();
+}
+//--------------------------------------------------------------
+void Grid::setMinZoom(){ // go to entire space (orange)
+    if(snapped)centre = snapCentre;
+    size.x = minValue*2.0;
+    scale = size.x/pixSize.x;
+    size.y = scale * pixSize.y;
+    viewWasChanged();
 }
 //--------------------------------------------------------------
 void Grid::viewWasChanged(){
+    snapCheck();
     checkLimits();
-    // and calculate new params?
-    
-    vector<int> params = calculateParamsFromCoord(centre);
+    // calculate new params?
+    vector<int> params;
+    if(snapped){
+        params = calculateParamsFromCoord(snapCentre);
+    }else{
+        params = calculateParamsFromCoord(centre);
+    }
     for(int i = 0;i<2*paramsPerDim;i++){
         midiCC[i] = params[i];
     }
-    // update sliders if nec.
 
 }
 
 //--------------------------------------------------------------
 void Grid::checkLimits(){
     // check for maximum zoom level
-    // TODO: DODGY
+    
 
     if(size.x > maxValue*2.0){
         cout << "maxZoom\n";
@@ -550,11 +599,15 @@
 void Grid::setCoord(TwoVector coord){
     
     centre = coord;
+    
     viewWasChanged();
 }
 //--------------------------------------------------------------
 TwoVector Grid::getCoord(){
-    
+    // return read point crosshairs
+    if(snapped){
+        return snapCentre;
+    }
     return centre;
 }
 //--------------------------------------------------------------
@@ -582,6 +635,12 @@
 
 }
 //--------------------------------------------------------------
+//--------------------------------------------------------------
+//--------------------------------------------------------------
+//--------------------------------------------------------------
+//--------------------------------------------------------------
+#pragma mark const utils
+
 TwoVector Grid::calculateCoordFromParams(vector<int> params) const{
 
     vector<int> ccValueX(paramsPerDim);
@@ -757,7 +816,6 @@
 }
 //--------------------------------------------------------------
 
-// WHY HERE XCODE?
 vector<int> Grid::codesToBase32(vector<vector<bool> > inCodes) const{
     vector<int> result;
     for(int i=0;i<paramBitDepth;i++){

--- a/presetManager.h	Tue Dec 04 18:36:00 2012 +0000
+++ b/presetManager.h	Wed Dec 05 18:42:02 2012 +0000
@@ -24,17 +24,21 @@
     int presetID;
     string name;
     long long savetime;
+    vector<ofColor> pixVals;
     double timemsd = [NSDate timeIntervalSinceReferenceDate];
     
     TwoVector coordinates;
     
-    Preset(TwoVector acoord, string aname,int aID){
+    // from save button press
+    Preset(TwoVector acoord, string aname,int aID, const vector<ofColor> & pixCols){
         coordinates = acoord;
         name = aname;
         presetID = aID;
         
         timemsd = [NSDate timeIntervalSinceReferenceDate];
         savetime = (long long)(timemsd*1000);
+        pixVals = pixCols;
+        
 
     };
     Preset(int aID){
@@ -46,13 +50,17 @@
         
     };
 
-    Preset(TwoVector acoord, string aname,int aID, long long stime){
+    // from file load
+    Preset(TwoVector acoord, string aname,int aID, long long stime, const vector<ofColor> & pixCols){
         coordinates = acoord;
         name = aname;
         presetID = aID;
         savetime = stime;
+        pixVals = pixCols;
         
     };
+    
+    void draw();
 
 };
 
@@ -72,12 +80,14 @@
     
     TwoVector recallPreset(int presetID); // by name ? id?
     TwoVector recallPreset(string name); // by name ? id?
-    vector<TwoVector > getPresetsInRange(TwoVector min, TwoVector max);
+    vector<Preset *>  getPresetsInRange(TwoVector min, TwoVector max);
+    void drawPresetsInRange(const TwoVector min, const TwoVector max);
+    vector<ofColor> makePresetPicture(TwoVector coord);
     void printAll();
     
     void startupLoadAll();  // get stuff from XML
     void exitAndSaveAll();  // save to XML, delete presets array (?)
-    void deleteAll();
+    void clearAll();
     
     PresetManager();
 };
@@ -113,7 +123,6 @@
         }
         TwoVector pcoord(px,py);
         int n = p.loadPreset(pcoord, pname, stime);
-        cout << "read preset : " << n << '\n';
         return(is);
     }
     

--- a/presetManager.mm	Tue Dec 04 18:36:00 2012 +0000
+++ b/presetManager.mm	Wed Dec 05 18:42:02 2012 +0000
@@ -12,24 +12,61 @@
 extern Grid theGridView;
 PresetManager presetManager;
 //---------------------------------------------------------------------------
-
-
+void Preset::draw(){
+    //
+    int sz = 2;
+    TwoVector pos = theGridView.coordToPixel(coordinates); // euch -rely on grid view?
+    
+    if(pixVals.size() < 9){
+        cout << "NO PRESET PIC\n";
+        return;
+    }
+    //middle row
+    // centre
+    ofSetColor(pixVals[0]);
+    ofRect(pos.x, pos.y,sz,sz);
+    // right
+    ofSetColor(pixVals[1]);
+    ofRect(pos.x+sz, pos.y,sz,sz);
+    // left
+    ofSetColor(pixVals[2]);
+    ofRect(pos.x-sz, pos.y,sz,sz);
+    
+    //top
+    // centre
+    ofSetColor(pixVals[3]);
+    ofRect(pos.x, pos.y+sz,sz,sz);
+    // right
+    ofSetColor(pixVals[4]);
+    ofRect(pos.x+sz, pos.y+sz,sz,sz);
+    // left
+    ofSetColor(pixVals[5]);
+    ofRect(pos.x-sz, pos.y+sz,sz,sz);
+    
+    // bottom
+    // centre
+    ofSetColor(pixVals[6]);
+    ofRect(pos.x, pos.y-sz,sz,sz);
+    // right
+    ofSetColor(pixVals[7]);
+    ofRect(pos.x+sz, pos.y-sz,sz,sz);
+    // left
+    ofSetColor(pixVals[8]);
+    ofRect(pos.x-sz, pos.y-sz,sz,sz);
+};
+//---------------------------------------------------------------------------
 PresetManager::PresetManager(){
     timesOpened = 0;
     nextID = 0;
-    startupLoadAll();
-  
+
 }
-//---------------------------------------------------------------------------
-void PresetManager::deleteAll(){
-    thePresets.clear();
-}
+
 //---------------------------------------------------------------------------
 void PresetManager::printAll(){
     cout << "ALL PRESETS: \n";
     vector<Preset *>::iterator presetIter;
     for(presetIter = thePresets.begin(); presetIter < thePresets.end(); presetIter++){
-        cout << **presetIter << "\n";
+        cout << **presetIter;
         
     }
 }
@@ -54,40 +91,67 @@
         
     }
     
-    
-    // check for same coords (!?!)
-    thePresets.push_back(new Preset(coord, name,nextID));
+    // make piccy
+    vector<ofColor> presetPicture = makePresetPicture(coord);
+    thePresets.push_back(new Preset(coord, name,nextID, presetPicture));
     
     // if ok
     return nextID++;
 }
 //---------------------------------------------------------------------------
+vector<ofColor> PresetManager::makePresetPicture(TwoVector coord){
+    // convert midi parameters to a nice piccy
+    vector<int> params = theGridView.calculateParamsFromCoord(coord);
+    vector<ofColor> pixCols;
+    
+    ofColor col(255,0,0);
+    for(int i=0; i<9;i++){
+        col.setHue(params[i]*2);
+        pixCols.push_back(col);
+    }
+    return pixCols;
+}
+//---------------------------------------------------------------------------
 
 int PresetManager::loadPreset(const TwoVector coord, const string name, long long stime){
-    
-
-    thePresets.push_back(new Preset(coord, name,nextID, stime));
+    vector<ofColor> presetPicture = makePresetPicture(coord); // or just store it??
+    thePresets.push_back(new Preset(coord, name,nextID, stime, presetPicture));
+   
      // if ok
     return nextID++;
 }
 //---------------------------------------------------------------------------
-vector<TwoVector > PresetManager::getPresetsInRange(const TwoVector min, const TwoVector max){
+vector<Preset *> PresetManager::getPresetsInRange(const TwoVector min, const TwoVector max){
     //return all the coordinates. oh and names (displayed at certain scales?).
     
     // TODO INEFFICIENT FOR LOTS OF PRESETS. CALLED EVERY GRAPHICS UPDATE!
     // so: put burden on saving rather than retrieving, make into list and index using coordinates
     
-    vector<TwoVector > results;
+    vector<Preset *> results;
     vector<Preset *>::iterator presetIter;
     for(presetIter = thePresets.begin(); presetIter < thePresets.end(); presetIter++){
         if( ((*presetIter)->coordinates.x > min.x ) && ((*presetIter)->coordinates.y > min.y ) && ((*presetIter)->coordinates.x < max.x ) && ((*presetIter)->coordinates.y < max.y )){
-            results.push_back((*presetIter)->coordinates);
+            results.push_back(*presetIter);
         }
 
     }
     return results;
     
 }
+
+
+//---------------------------------------------------------------------------
+void PresetManager::drawPresetsInRange(const TwoVector min, const TwoVector max){
+    vector<Preset *> pInRange = getPresetsInRange(min, max);
+    vector<Preset *>::iterator piter;
+    int i = 0;
+    for(piter = pInRange.begin(); piter < pInRange.end(); piter++){
+
+        (*piter)->draw();
+        i++;
+    }
+ 
+}
 //---------------------------------------------------------------------------
 void PresetManager::startupLoadAll(){
   // get stuff from file
@@ -97,19 +161,15 @@
     ifstream presetFile(fname.c_str());
 
     // simply prints file
-    int i= 0;
+
     if(!presetFile){
         cout<<"no preset file";
         return;
     }
-    while(presetFile >> *this){
-        cout << "loaded" << i++ << " presets\n";
-        // parse line
-        
-    }
+    while(presetFile >> *this);
+    
     presetFile.close();
 
-
     timesOpened++;
 }
 //---------------------------------------------------------------------------
@@ -125,8 +185,16 @@
         presetFile << **presetIter << "\n";
     }
     presetFile.close();
+    
+    // TODO dleete all the new events??
+    
 
 }
+
+//---------------------------------------------------------------------------
+void PresetManager::clearAll(){
+    thePresets.clear();
+}
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------

--- a/testApp.h	Tue Dec 04 18:36:00 2012 +0000
+++ b/testApp.h	Wed Dec 05 18:42:02 2012 +0000
@@ -32,9 +32,9 @@
     TwoVector touch1;
     TwoVector prevTouch0;
     TwoVector prevTouch1;
-    
+
     bool xLocked, yLocked;
-    
+    int framesSinceLastScroll;
     
     TwoVector moveVel; // velocity at which we were moving the grid
     
@@ -43,7 +43,7 @@
     double slowFactor;
     double zoomVel; // do the same
      double prevZoom, prevZoom2;
-     TwoVector prevMove, prevMove2;
+     TwoVector move, prevMove, prevMove2;
     
     vector<int> sliderVals;
     vector<int> freqIndexes;

--- a/testApp.mm	Tue Dec 04 18:36:00 2012 +0000
+++ b/testApp.mm	Wed Dec 05 18:42:02 2012 +0000
@@ -17,7 +17,7 @@
 	sender.setup( HOST, PORT );
     ofSetFrameRate(30);
     // reciever
-    
+    framesSinceLastScroll = 0;
     
     prevTouchX = 0;
     prevTouchY = 0;
@@ -84,6 +84,8 @@
 	// setup OF sound stream
 	ofSoundStreamSetup(2, 1, this, 44100, ofxPd::blockSize()*ticksPerBuffer, 3);
     
+    presetManager.startupLoadAll();
+    
 }
 #pragma mark GUI
 //--------------------------------------------------------------
@@ -130,6 +132,7 @@
             string name = n.str();
             
             presetManager.addPreset(theGridView.getCoord(),name);
+            eventLogger.logEvent(SAVE_PRESET, theGridView.getCoord());
         }
         /*
         if(!keyboard->isKeyboardShowing()){
@@ -149,23 +152,33 @@
             cout << "LOCK SEQUENCE (X)\n";
             // lock
             xLocked = !xLocked;
+        presetManager.clearAll();
 
     }else if(e.widget->getName() == "LOCK SYNTH (Y)")
     {
         
         cout << "LOCK SYNTH (Y)\n";
         // lock
-        
-        yLocked = !yLocked;
+        if(((ofxUIButton *)e.widget)->getValue()){
+            yLocked = true;
+        }else{
+            yLocked = false;
+            
+        }
     }else if(e.widget->getName() == "ZOOM MIN")
     {
         if(((ofxUIButton *)e.widget)->getValue()){
         cout << "ZOOM MIN\n";
+            theGridView.setMinZoom();
+            eventLogger.logEvent(SET_MIN_ZOOM);
         }
     }else if(e.widget->getName() == "ZOOM MAX")
     {
         if(((ofxUIButton *)e.widget)->getValue()){
         cout << "ZOOM MAX\n";
+            theGridView.setMaxZoom();
+            eventLogger.logEvent(SET_MAX_ZOOM);
+            //eventLogger.printAll();
         }
     }else{
         cout << "GUI error :  unknown event recieved\n";
@@ -225,6 +238,8 @@
             ofxUISlider *slider = (ofxUISlider *) e.widget;
             sliderMoved(i-1,slider->getScaledValue()); // internal array 0 indexed
             
+            
+            
         }
     }
     
@@ -240,6 +255,9 @@
     // TODO if <5 do frequencer stuff and send list to PD
     // if > 5 send control value to PD
     sendParametersToPD();
+    
+    eventLogger.logEvent(CHANGE_SLIDER, which , value);
+    
 }
 //--------------------------------------------------------------
 void testApp::setAllGUISliders(vector<int> vals){
@@ -295,23 +313,24 @@
 		sender.sendMessage( m );
 	}
     
-    // continiue to move at velocity
+    // continiue to move at velocity, unless snapped
     
     if (numActiveTouches == 0){ // no touches, use momentum
         // TODO set velocity to 0 when hits walls
 
-        if(moveVel.norm() > 0.1){
+        if(moveVel.norm() > 0.3 && !theGridView.snapped){
             theGridView.move(moveVel);
             moveVel = moveVel*slowFactor;
          
          // and get new parameter values
-            if(standardGUIShowing)setAllGUISliders(theGridView.getParams());
+            setAllGUISliders(theGridView.getParams());
             sendParametersToPD();
-        }else if(moveVel.norm() > 0.01){
+        }else if(moveVel.norm() > 0.01 || theGridView.snapped){
             // stop it
             moveVel.setCoord(0.0,0.0);
-            if(standardGUIShowing)setAllGUISliders(theGridView.getParams());
+            setAllGUISliders(theGridView.getParams());
             sendParametersToPD();
+            eventLogger.logEvent(SCROLL_STOPPED, theGridView.getCoord() );
         }else{
             // stopped - do nothing
         }
@@ -322,6 +341,7 @@
         theGridView.zoom(zoomVel + 1.0); // +1 because zoomVel factor is + or - , wheras zoom is a multiplier near 1 
         zoomVel = zoomVel*slowFactor;
     }
+    framesSinceLastScroll++;
 }
 //--------------------------------------------------------------
 void testApp::sendOSCParams(){
@@ -428,20 +448,31 @@
    
     
 }
+
 //--------------------------------------------------------------
 void testApp::handleScroll(){
+ 
     
     TwoVector move = touch0 - prevTouch0;
-    moveVel = move*0.3 + prevMove*0.34 + prevMove2*0.38; // broke?
+    if(yLocked){
+        move.y = 0.0;
+    }
+    if(xLocked){
+        move.x = 0.0;
+    }
+
+    moveVel = (move*0.3 + prevMove*0.34 + prevMove2*0.38)* (1.0/(float)framesSinceLastScroll); // use the time
+
     prevMove2 = prevMove;
     prevMove = move;
     
+
     theGridView.move(move);
     
     // and get new parameter values
     setAllGUISliders(theGridView.getParams());
     sendParametersToPD();
-    
+    framesSinceLastScroll = 0;
 }
 //--------------------------------------------------------------
 void testApp::handleZoom(){