changeset 27:27cdf475aa4b

more fiddling

--- a/ExpMessageOrganiser.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/ExpMessageOrganiser.h	Wed Oct 29 15:38:38 2014 +0000
@@ -20,8 +20,8 @@
     
 public:
     void init( PDSynthWrapper& cs, PDSynthWrapper& ts);
-    void setup();
-    void setupDefaultMapping();
+    void setup(controlPanelType whichInterfaceAreWeUsing);
+    
     vector<int> getMappingIDsFromSynths();
     void showCurrentSlot();
     void loadPreset(string pname);
@@ -30,7 +30,7 @@
 private:
     void loadDefaultSound();
     int numParamsToUse;
-    
+    Preset neutralPreset;
 };
 
 

--- a/ExpMessageOrganiser.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/ExpMessageOrganiser.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -12,35 +12,20 @@
     numParamsToUse = TOTAL_NUM_PARAMS;
     MessageOrganiser::init(cs,ts);
     
+}
+void ExpMessageOrganiser::setup(controlPanelType whichInterfaceAreWeUsing){
+
     
-}
-void ExpMessageOrganiser::setup(){
-    // do stuff like load first slot
-    setupDefaultMapping();
+    setupDefaultMapping(whichInterfaceAreWeUsing);
     expPresetManager.goToFirstEmptySlot();
     showCurrentSlot();
     instructionPanel->setLabel("Find a sound\n that expresses:");
     instructionPanel->show();
+    bottomPanel->show();
     okToGetMidi = true;
 }
 
 
-void ExpMessageOrganiser::setupDefaultMapping(){
-    vector<int> mappingIDsForChangeableParams = getMappingIDsFromSynths();
-    
-    controlPanelType cpt = REVISITABLE;
-    vector<controllerType> elemList;
-    for(int i = 0; i < numParamsToUse; i++){
-        elemList.push_back(SLIDER);
-    }
-    
-    vector<UIElement*> UIElemHandles = panel->generateControls(elemList, cpt);
-    
-    mapSlidersToParams(UIElemHandles, mappingIDsForChangeableParams);
-    
-    bottomPanel->show();
-}
-
 vector<int> ExpMessageOrganiser::getMappingIDsFromSynths(){
     vector<int> index;
     for(int i = 0; i < numParamsToUse; i++){

--- a/ExplorePresetManager.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/ExplorePresetManager.h	Wed Oct 29 15:38:38 2014 +0000
@@ -107,6 +107,8 @@
     
     vector<string> categories;
     vector<string> names;
+    
+    
 };
 
 #endif /* defined(__riftathon__ExplorePresetManager__) */

--- a/IntroViewController.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/IntroViewController.h	Wed Oct 29 15:38:38 2014 +0000
@@ -12,6 +12,7 @@
 
 @property (nonatomic, assign)       id theOFAppRef;
 @property (retain, nonatomic) IBOutlet UILabel *text;
+@property (nonatomic)               NSInteger interfaceSelection;
 
 -(IBAction)hide:(id)sender;
 -(IBAction)show:(id)sender;

--- a/IntroViewController.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/IntroViewController.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -10,6 +10,8 @@
 #import "testApp.h"
 @interface IntroViewController ()
 
+
+
 @end
 
 @implementation IntroViewController
@@ -19,6 +21,7 @@
     self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
     if (self) {
         // Custom initialization
+        self.interfaceSelection = 0;
     }
     return self;
 }
@@ -28,6 +31,12 @@
     [super viewDidLoad];
     // Do any additional setup after loading the view from its nib.
 }
+- (IBAction)oninterfaceSelect:(id)sender {
+    UISegmentedControl *seg = (UISegmentedControl *)sender;
+    self.interfaceSelection = seg.selectedSegmentIndex;
+
+
+}
 
 - (void)didReceiveMemoryWarning
 {
@@ -40,6 +49,7 @@
     
 }
 - (IBAction)enterExpMode:(id)sender {
+    ((testApp *)self.theOFAppRef)->interfaceSelected(self.interfaceSelection);
     ((testApp *)self.theOFAppRef)->introHidden(1);
 }
 - (IBAction)enterTrainMode:(id)sender {

--- a/IntroViewController.xib	Tue Oct 28 19:15:28 2014 +0000
+++ b/IntroViewController.xib	Wed Oct 29 15:38:38 2014 +0000
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <document type="com.apple.InterfaceBuilder3.CocoaTouch.iPad.XIB" version="3.0" toolsVersion="5056" systemVersion="14A389" targetRuntime="iOS.CocoaTouch.iPad" propertyAccessControl="none">
     <dependencies>
-        <deployment defaultVersion="1280" identifier="iOS"/>
+        <deployment defaultVersion="1552" identifier="iOS"/>
         <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="3733"/>
     </dependencies>
     <objects>
@@ -66,6 +66,17 @@
                     <color key="textColor" red="0.33826699840000002" green="0.9053322399" blue="1" alpha="1" colorSpace="calibratedRGB"/>
                     <nil key="highlightedColor"/>
                 </label>
+                <segmentedControl appearanceType="aqua" opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="top" segmentControlStyle="plain" selectedSegmentIndex="0" id="kLk-IB-COx">
+                    <rect key="frame" x="410" y="370" width="217" height="29"/>
+                    <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
+                    <segments>
+                        <segment title="SLIDERS"/>
+                        <segment title="LEAP"/>
+                    </segments>
+                    <connections>
+                        <action selector="oninterfaceSelect:" destination="-1" eventType="valueChanged" id="CA1-3J-YuB"/>
+                    </connections>
+                </segmentedControl>
             </subviews>
             <color key="backgroundColor" cocoaTouchSystemColor="darkTextColor"/>
             <simulatedOrientationMetrics key="simulatedOrientationMetrics" orientation="landscapeRight"/>

--- a/MessageOrganiser.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/MessageOrganiser.h	Wed Oct 29 15:38:38 2014 +0000
@@ -63,12 +63,11 @@
 public:
     void init(PDSynthWrapper& cs, PDSynthWrapper& ts);    // could template for ui element type??
     void mapButtonToAction(UIElement* control, int mappingID);
-    
+    void setupDefaultMapping(controlPanelType whichInterfaceAreWeUsing);
     void setControlPanel(SliderPanel* p);
     void setBottomPanel(ButtonPanel * ntb);
     void setIconPanel(IconPanel * ip);
     void setInstructionPanel(TextPanel * ip);
-    void setBox(Leap6DBox * box);
     //-----------------------------------------------------------------------------
     void hideMyPanels();
     void showMyPanels();
@@ -77,15 +76,14 @@
     PDSynthWrapper candidateSynth;
     PDSynthWrapper targetSynth;
     ButtonPanel* bottomPanel; // shows during test : play buttons and submit
-    SliderPanel* panel;
+    SliderPanel* controlPanel;
     
     IconPanel* presetIconPanel;
     TextPanel* instructionPanel;
-    Leap6DBox* box6D;
     
     map<int,UIElement*> currentMapping; // could get more sophisticated if not 1-1 ?
     
-
+    vector<int> getMappingIDsFromSynths();
     void triggerCandidateSound();
     void paramChangeCallback(int mappingID, int value);
     void sendSynthValuesAgain();

--- a/MessageOrganiser.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/MessageOrganiser.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -7,6 +7,38 @@
     
     onlyChangeCandidateOnTrigger = true;
 }
+
+
+void MessageOrganiser::setupDefaultMapping(controlPanelType whichInterfaceAreWeUsing){
+    vector<int> mappingIDsForChangeableParams = getMappingIDsFromSynths();
+    vector<controllerType> elemList;
+    
+    if (whichInterfaceAreWeUsing == ALL_SLIDERS){
+        
+        for(int i = 0; i < TOTAL_NUM_PARAMS; i++){
+            elemList.push_back(SLIDER);
+            
+        }
+    }else if (whichInterfaceAreWeUsing == LEAP6DOF){
+        elemList.push_back(LEAP6D);
+    }
+    vector<UIElement*> UIElemHandles = controlPanel->generateControls(elemList, whichInterfaceAreWeUsing);
+    
+    mapSlidersToParams(UIElemHandles, mappingIDsForChangeableParams);
+    
+}
+
+
+//----------------------------------------------------------------------------------------
+vector<int> MessageOrganiser::getMappingIDsFromSynths(){
+    vector<int> index;
+    for(int i = 0; i < TOTAL_NUM_PARAMS; i++){
+        index.push_back(i);
+    }
+    vector<int> mids = candidateSynth.getMappingIDForIndices(index);
+    
+    return mids;
+}
 // could template for ui element type??
 void MessageOrganiser::mapButtonToAction(UIElement* control, int mappingID){
     UICallbackFunction callbackF;
@@ -17,7 +49,7 @@
 
 
 void MessageOrganiser::setControlPanel(SliderPanel* p){ // a bit specific??
-    panel = p;
+    controlPanel = p;
     
 };
 void MessageOrganiser::setBottomPanel(ButtonPanel * ntb){
@@ -28,9 +60,7 @@
 void MessageOrganiser::setIconPanel(IconPanel * ip){
     presetIconPanel = ip;
 }
-void MessageOrganiser::setBox(Leap6DBox * box){
-    box6D = box;
-}
+
 void MessageOrganiser::setInstructionPanel(TextPanel * ip){
     instructionPanel = ip;
     instructionPanel->show();
@@ -42,13 +72,13 @@
     presetIconPanel->hide();
     instructionPanel->hide();
     bottomPanel->hide();
-    panel->hide();
+    controlPanel->hide();
 }
 void MessageOrganiser::showMyPanels(){
     presetIconPanel->show();
     instructionPanel->show();
     bottomPanel->show();
-    panel->show();
+    controlPanel->show();
 }
 
 void MessageOrganiser::triggerCandidateSound(){
@@ -57,7 +87,7 @@
     candidateSynth.trigger();
     eventLogger.logEvent(CANDIDATE_PLAYED);
     // flash panel?
-    panel->flash();
+    controlPanel->flash();
 }
 
 void MessageOrganiser::paramChangeCallback(int mappingID, int value){
@@ -91,22 +121,20 @@
     // theXY->setValueAndScale(candidateSynth.getParamValueForID(mids[i]), candidateSynth.getParamValueForID(mids[i+1]));
     UIElement* elem;
     // get the element
-    if(panel->subElements.size() <= index){
+    if(controlPanel->subElements.size() <= index){
         cout << "ERROR: index out of range for num sliders" << endl;
         return;
     }
-    elem = panel->subElements[index];
+    elem = controlPanel->subElements[index];
     if ( elem->getType() == SLIDER){
         ButtronSlider* theSlider = (ButtronSlider*)elem;
         theSlider->setValueAndScale(value);
         
-    }else{
-        cout << "ERROR ERROR: ui type not handled by setUIToParam!" << endl;
+    }else if ( elem->getType() == LEAP6D){
+        Leap6DBox* theBox = (Leap6DBox*)elem;
+        theBox->setValueAndScale(index, value);
     }
-    if (box6D->isShowing()){
-        box6D->setValueAndScale(index, value);
-    }
-    
+
 };
 
 

--- a/QuestionnaireViewController.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/QuestionnaireViewController.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -18,7 +18,7 @@
 @property (strong, nonatomic)       NSArray * questionArray;
 @property (nonatomic)               NSInteger currentQuestionIndex;
 @property (nonatomic, assign)       id theOFAppRef;
-
+@property (nonatomic)               NSInteger interfaceSelection;
 /*
 
 
@@ -42,6 +42,7 @@
         
         [self populateQuestionArray ];
         
+        self.interfaceSelection = 0;
     }
     return self;
 }

--- a/SearchMessageOrganiser.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/SearchMessageOrganiser.h	Wed Oct 29 15:38:38 2014 +0000
@@ -96,8 +96,8 @@
     };
     void countdownToNewTest(){
         
-        panel->hide();
-        panel->setActive(false);
+        controlPanel->hide();
+        controlPanel->setActive(false);
         scorePanel->hide();
         bottomPanel->hide();
         newTestButton->hide();
@@ -176,7 +176,7 @@
             candidateSynth.trigger();
             eventLogger.logEvent(CANDIDATE_PLAYED);
             // flash panel?
-            panel->flash();
+            controlPanel->flash();
             return;
         }
         if (mappingID == SUBMIT_CANDIDATE){
@@ -201,21 +201,21 @@
             if(showing){
                 cout << " showing"<<endl;
                 
-                panel->show();
+                controlPanel->show();
                 
             }else{
                 cout << " hiding"<<endl;
-                panel->hide();
+                controlPanel->hide();
             }
             showing = !showing;
         }
         if(mappingID == SHOW_HIDE_HINT){
             static bool showingHint;
             if(showingHint){
-                panel->showHint(false);
+                controlPanel->showHint(false);
                 showingHint = false;
             }else{
-                panel->showHint(true);
+                controlPanel->showHint(true);
                 showingHint = true;
             }
         }
@@ -260,7 +260,7 @@
     
 // protected methods
     void testsFinished(){
-        panel->hide();
+        controlPanel->hide();
         bottomPanel->hide();
         newTestButton->hide();
         
@@ -300,7 +300,7 @@
         
         vector<int> mappingIDsForChangeableParams = setSynthsUpForNewTest(newTest);
         
-        vector<UIElement*> UIElemHandles = panel->generateControls(testController->getCurrentListOfControls(), testController->getCurrentPanelType());
+        vector<UIElement*> UIElemHandles = controlPanel->generateControls(testController->getCurrentListOfControls(), testController->getCurrentPanelType());
         
         mapUIToNewTestParams(UIElemHandles, mappingIDsForChangeableParams);
         
@@ -312,10 +312,10 @@
         Test t = testController->getCurrentTest();
         
         countdownPanel->hide();
-        panel->show();
-        panel->setActive(true);
+        controlPanel->show();
+        controlPanel->setActive(true);
         if(t.isWithHint()){
-            panel->showHint(true);
+            controlPanel->showHint(true);
         }
         
         bottomPanel->show();
@@ -443,7 +443,7 @@
         }else{
             sendSynthValuesAgain(); // and again and again
             candidateSynth.trigger();
-            panel->flash();
+            controlPanel->flash();
             nextTime = alternationSpeed;
         }
         alt = !alt;
@@ -501,8 +501,8 @@
         
         
         // gui stuff - different controller?
-        panel->setActive(false);
-        panel->showHint(true); // add some encouraging feedback to hint
+        controlPanel->setActive(false);
+        controlPanel->showHint(true); // add some encouraging feedback to hint
         bottomPanel->hide();
         
         showScoreForTest(result);
@@ -539,7 +539,7 @@
             c = ofColor(150,235,200,255);
         }
         scorePanel->setColor(c);
-        panel->setHintColor(c);
+        controlPanel->setHintColor(c);
     };
  
     

--- a/SequenceController.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/SequenceController.h	Wed Oct 29 15:38:38 2014 +0000
@@ -18,7 +18,40 @@
 #define MAX_TEMPO   120
 #define NUM_TEMPO_STEPS 16
 #define NUM_PRESETS 8
+#define NO_GUIDES_LEVEL false
+class AnimStep{
 
+    
+public:
+    
+    AnimStep();
+    typedef enum {PREVIEW_NEUTRAL_COUNT,
+                MATCHING_NEUTRAL_COUNT,
+                PREVIEW_MOVE,
+                PREVIEW_HIT,
+                MATCHING_MOVE,
+                MATCHING_HIT}
+                stepType;
+    
+    stepType type;
+    
+    float getTimeBetweenTicks(){
+        return 1000. * (60.0/tempo);
+    }
+    int presetIndex;
+    int whichInSequence;
+    bool isLastOfAll;
+
+    int tempo;
+    int seqNumber;
+    int runNumber;
+    bool isLastOfSeq;
+    bool isLastOfRun;
+    
+    bool showsGuides; // depends on 'level'
+    
+    vector<int> thisSequence; // so that we can show the whole sequence at the top?
+};
 
 class Step{
 public:
@@ -67,7 +100,7 @@
 class SequenceController{
 public:
     SequenceController();
-    Step getNextStep();
+    AnimStep getNextStep();
     void setToStart();
     void stepForward();
     float getStartTickTime();
@@ -75,12 +108,12 @@
     void generateSteps();
     void generateCountIn(int countInLength);
     void generateARun(int run, int numInSequence);
-    
+    vector<int> randomSequence(int numInSequence);
     
     int getRandomButNot(int max, vector<int> notThese);
 protected:
-    vector<Step> steps;
-    vector<Step>::iterator currentStep;
+    vector<AnimStep> steps;
+    vector<AnimStep>::iterator currentStep;
     float tempoInc;
 };
 

--- a/SequenceController.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/SequenceController.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -7,7 +7,21 @@
 //
 
 #include "SequenceController.h"
-
+AnimStep::AnimStep(){
+    type = PREVIEW_NEUTRAL_COUNT;
+    presetIndex = -1;
+    seqNumber = -1;
+    runNumber = -1;
+    whichInSequence = -1;
+    
+    tempo = MIN_TEMPO;
+    
+    isLastOfSeq = false;
+    isLastOfRun = false;
+    isLastOfAll = false;
+    
+    showsGuides = false;
+}
 Step::Step(){
     type = COUNT_IN;
     
@@ -52,7 +66,8 @@
     type = PREVIEW_PREPARER;
     showsTargetIcon = true;
     showsControlSettings = false;
-    showsControlGuides = false;
+    showsControlGuides = true;
+    
     showsMatchResults = false;
     hidesSliders = true;
     isPreview = true;
@@ -137,7 +152,7 @@
     generateSteps();
     setToStart();
 };
-Step SequenceController::getNextStep(){
+AnimStep SequenceController::getNextStep(){
     
     currentStep++;
     if ((*currentStep).isLastOfRun){
@@ -149,16 +164,19 @@
     return (*currentStep);
     
 };
+//-------------------------------------------------------------------
 void SequenceController::setToStart(){
     currentStep = steps.begin();
 }
+//-------------------------------------------------------------------
 void SequenceController::stepForward(){
     currentStep++;
 };
+//-------------------------------------------------------------------
 float SequenceController::getStartTickTime(){
     return 1000. * (60.0/MIN_TEMPO);
 }
-
+//-------------------------------------------------------------------
 void SequenceController::generateSteps(){
     srand (time(NULL));
     
@@ -176,18 +194,41 @@
     }
     steps.back().isLastOfAll = true;
 };
+
+//-------------------------------------------------------------------
+
+
 void SequenceController::generateCountIn(int countInLength){
-    Step countStep;
+    AnimStep countStep;
     for (int i = 0; i < countInLength; i++){
-        countStep.numInSequence = countInLength - i + 1;
+        countStep.whichInSequence = countInLength - i + 1;
+        countStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
         steps.push_back(countStep);
         
     }
 };
+
+//-------------------------------------------------------------------
+
+
+vector<int> SequenceController::randomSequence(int numInSequence){
+    vector<int> stepPresetIndices;
+    // get some random ints
+    for(int n=0; n < numInSequence; n++){
+        int nextPreset = getRandomButNot(NUM_PRESETS,stepPresetIndices);
+        stepPresetIndices.push_back(nextPreset);
+        cout << nextPreset << ",";
+    }
+    
+    return stepPresetIndices;
+}
+
+//-------------------------------------------------------------------
+
 void SequenceController::generateARun(int run, int numInSequence){
     float curTempo = MIN_TEMPO;
     int seqNo = 0;
-    Step nextStep;
+    AnimStep nextStep;
     for(int tempoLevel = 0; tempoLevel < NUM_TEMPO_STEPS; tempoLevel++){
         
         
@@ -196,19 +237,15 @@
         nextStep.presetIndex = -1; // minus one means "blank"
         nextStep.runNumber = run;
         nextStep.seqNumber = seqNo;
-        nextStep.numInSequence = 0;
+        nextStep.whichInSequence = 0;
         nextStep.tempo = curTempo;
-        nextStep.setAsBlankCounter();
+        nextStep.showsGuides = true;
+        nextStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
+        steps.push_back(nextStep);
         
-        // generate a sequence
-        vector<int> stepPresetIndices;
-        
-        // get some random ints
-        for(int n=0; n < numInSequence; n++){
-            int nextPreset = getRandomButNot(NUM_PRESETS,stepPresetIndices);
-            stepPresetIndices.push_back(nextPreset);
-            cout << nextPreset << ",";
-        }
+        // generate a sequence of random preset indices
+        vector<int> stepPresetIndices = randomSequence(numInSequence);
+        nextStep.thisSequence = stepPresetIndices;
 
         // make preview sequence
         int n = 1;
@@ -218,21 +255,19 @@
             nextStep.presetIndex = *si;
             nextStep.runNumber = run;
             nextStep.seqNumber = seqNo;
-            nextStep.numInSequence = n;
+            nextStep.whichInSequence = n;
             nextStep.tempo = curTempo;
-            nextStep.setAsPreviewPreparer();
+            nextStep.showsGuides = true;
+            nextStep.type = AnimStep::PREVIEW_MOVE;
             steps.push_back(nextStep);
             
-            // put player
-            //
-            nextStep.setAsPreviewPlayer();
+            nextStep.type = AnimStep::PREVIEW_HIT;
             steps.push_back(nextStep);
             n++;
         }
-
-        // now we waqnt a matching preparation count in
-//        nextStep.setAsBlankCounter();
-//        steps.push_back(nextStep);
+        
+        nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
+        steps.push_back(nextStep);
         
         // put in matching sequence
         n = 0;
@@ -240,18 +275,20 @@
             // put loader
             
             nextStep.presetIndex = *si;
-            nextStep.numInSequence = n;
-
-            nextStep.setAsMatchingPreparer();
-            steps.push_back(nextStep);
-            
-            nextStep.setAsMatchingInteraction();
+            nextStep.whichInSequence = n;
+            if (NO_GUIDES_LEVEL){
+                nextStep.showsGuides = false;
+            }else{
+                nextStep.showsGuides = true;
+            }
+            nextStep.type = AnimStep::MATCHING_MOVE;
             steps.push_back(nextStep);
             n++;
             
-            nextStep.setAsMatchingFeedback();
+            nextStep.type = AnimStep::MATCHING_HIT;
             steps.push_back(nextStep);
             n++;
+
         }
         
         steps.back().isLastOfSeq = true;
@@ -260,10 +297,12 @@
         cout << endl;
         
     }
-    nextStep.setAsBlankCounter();
+    // ANIM nextStep.setAsBlankCounter();
+    nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
     steps.push_back(nextStep);
     
 }
+//-----------------------------------------------------------------------
 
 
 int SequenceController::getRandomButNot(int max, vector<int> notThese){

--- a/TrainingMessageOrganiser.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/TrainingMessageOrganiser.h	Wed Oct 29 15:38:38 2014 +0000
@@ -24,10 +24,11 @@
     int numParamsToUse;
     void init( PDSynthWrapper& cs, PDSynthWrapper& ts);
     void setMiddlePanel(TextPanel* tp);
-    void setupDefaultMapping();
+    void setup(controlPanelType whichInterfaceAreWeUsing);
     vector<int> getMappingIDsFromSynths();
-    void displayInstructions(Step s);
+    void displayInstructions(string text);
     void onNextTick(int tickNumber);
+    void onNextTickAnim(int tickNumber);
     
     void showMyPanels();
     void midiFromLeap(int ctl_num, int ctl_val);
@@ -43,7 +44,7 @@
         }
         cout << endl;
     }
-    
+    void updateCountdown(int n);
     void lastOfAll();
     void lastOfRun();
     void showCountdown();
@@ -51,6 +52,14 @@
     void showsTarget();
     
     
+    void previewNeutralCount(AnimStep newStep);
+    void previewMove(AnimStep newStep);
+    void previewHit(AnimStep newStep);
+    void matchingNeutralCount(AnimStep newStep);
+    void matchingMove(AnimStep newStep);
+    void matchingHit(AnimStep newStep);
+
+    
     ofColor interactableColor;
     ofColor nonInteractableColor;
     int downCounter;
@@ -59,5 +68,7 @@
     SequenceController sequenceController;
     TrainingScoreManager trainingScoreManager;
     
+    controlPanelType panelType;
+    
 };
 #endif /* defined(__riftathon__TrainingMessageOrganiser__) */

--- a/TrainingMessageOrganiser.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/TrainingMessageOrganiser.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -13,227 +13,39 @@
     MessageOrganiser::init(cs,ts);
     
     TickListenerFunction callback;
-    callback = boost::bind(&TrainingMessageOrganiser::onNextTick, this, _1);
+    callback = boost::bind(&TrainingMessageOrganiser::onNextTickAnim, this, _1);
     candidateSynth.registerForTicks(callback);
     
     numParamsToUse = TOTAL_NUM_PARAMS;
     
 }
 
+void TrainingMessageOrganiser::setup(controlPanelType whichInterfaceAreWeUsing){
+    
+    setupDefaultMapping(whichInterfaceAreWeUsing);
+    
+    
+}
+//----------------------------------------------------------------------------------------
 void TrainingMessageOrganiser::setMiddlePanel(TextPanel* tp){
     middlePanel = tp;
 }
 
-void TrainingMessageOrganiser::setupDefaultMapping(){
-    vector<int> mappingIDsForChangeableParams = getMappingIDsFromSynths();
-    
-    controlPanelType cpt = REVISITABLE;
-    vector<controllerType> elemList;
-    for(int i = 0; i < numParamsToUse; i++){
-        elemList.push_back(SLIDER);
-    }
-    
-    vector<UIElement*> UIElemHandles = panel->generateControls(elemList, cpt);
-    
-    mapSlidersToParams(UIElemHandles, mappingIDsForChangeableParams);
-    
-    bottomPanel->show();
-    
-    ofColor c = ofColor::yellow;
-    panel->setHintColor(c);
-}
-
-vector<int> TrainingMessageOrganiser::getMappingIDsFromSynths(){
-    vector<int> index;
-    for(int i = 0; i < numParamsToUse; i++){
-        index.push_back(i);
-    }
-    vector<int> mids = candidateSynth.getMappingIDForIndices(index);
-    
-    return mids;
-}
-
+//----------------------------------------------------------------------------------------
 void TrainingMessageOrganiser::showMyPanels(){
     presetIconPanel->show();
     instructionPanel->show();
     bottomPanel->show();
-    panel->hide();
+    controlPanel->show();
     middlePanel->show();
 }
 
 //-----------------------------------------------------------------------
-void TrainingMessageOrganiser::displayInstructions(Step s){
-    
-    
-    if (s.type == Step::COUNT_IN){
-        instructionPanel->setText("COUNT_IN" + ofToString(downCounter));
-        middlePanel->setText(ofToString(downCounter));
-    }
-    if (s.type == Step::PREVIEW_PREPARER){
-        instructionPanel->setText("PREVIEW_PREPARER");
-        panel->setColor(ofColor(0,0,0));
-    }
-    
-    if (s.type == Step::PREVIEW_DISPLAYER){
-        instructionPanel->setText("PREVIEW_DISPLAYER");
-        panel->setColor(ofColor(0,0,0));
-    }
-    if (s.type == Step::MATCHING_PREPARER){
-        instructionPanel->setText("MATCHING_PREPARER");
-        middlePanel->setText(ofToString(downCounter));
-        panel->setColor(ofColor(250,0,0));
-    }
-    if (s.type == Step::MATCHING_INTERACTION){
-        instructionPanel->setText("MATCHING_INTERACTION!!!!");
-        panel->setColor(ofColor(250,0,0));
-    }
-    if (s.type == Step::MATCHING_RESULT){
-        instructionPanel->setText("RESULT");
-        panel->setColor(ofColor(0,0,0));
-    }
-}
-//-----------------------------------------------------------------------
-void TrainingMessageOrganiser::onNextTick(int tickNumber){
-    static int showingCountdown = false;
-    cout << "TICK " << tickNumber << endl;
-    downCounter = 4 - tickNumber % 4;
-    
-    if (showingCountdown){
-        middlePanel->setColor(ofColor::white);
-        middlePanel->setText(ofToString(downCounter));
-    }
-    
-    // only first beat in bar is active one
-    if ( tickNumber % 4  != 0){
-        
-        return;
-    }
-    // load next target preset
-    
-    Step newStep = sequenceController.getNextStep();
-    displayInstructions(newStep);
-    
-    if(newStep.isLastOfAll){
-        // do finished run stuff, show summary
-        candidateSynth.stopMetronome();
-        cout << "FINISHED BLOCK" << endl;
-        panel->hide();
-        middlePanel->setColor(ofColor::white);
-        middlePanel->setText("FINISHED BLOCK");
-        return;
-    }
-    if(newStep.isLastOfRun){
-        // do finished run stuff, show summary
-        candidateSynth.stopMetronome();
-        cout << "FINISHED RUN" << endl;
-        panel->hide();
-        middlePanel->setColor(ofColor::white);
-        middlePanel->setText("FINISHED RUN");
-        middlePanel->show();
-        return;
-    }
+void TrainingMessageOrganiser::displayInstructions(string text){
 
-    candidateSynth.setMetroTime(newStep.getTimeBetweenTicks());
-    
-    if(newStep.showsCountDown){
-        // count in
-        showingCountdown = true;
-        middlePanel->show();
-    }else{
-        showingCountdown = false;
-    }
-    
-    Preset * currentTargetPreset;
-    
-    if(newStep.presetIndex >= 0 && newStep.presetIndex <= 8){
-        currentTargetPreset =  expPresetManager.getPresetAtIndex(newStep.presetIndex);
-    }else{
-        assert(newStep.type == Step::COUNT_IN);
-        // nothing happens here
-        return;
-    }
+    instructionPanel->setText("COUNT_IN" + ofToString(downCounter));
+    instructionPanel->show();
 
-    vector<int> newTargetValues = currentTargetPreset->getValues();
-    debugVals(newTargetValues);
-    
-    if(newStep.hidesSliders){
-        panel->hide();
-        middlePanel->setBackground(ofColor(255,0,0));
-        middlePanel->show();
-    }else{
-        panel->show();
-        middlePanel->hide();
-    }
-    
-    if(newStep.showsTargetIcon){
-        bool showTick = true;
-        presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), showTick);
-        presetIconPanel->show();
-        box6D->setHintTexture(currentTargetPreset->getImage());
-    }else{
-        presetIconPanel->hide();
-    }
-    
-    if(newStep.allowsCandidateControl){
-        setCandidateAndSlidersToRandom();
-        panel->setActive(true);
-        okToGetMidi = true;
-    }else{
-        panel->setActive(false);
-        okToGetMidi = false;
-    }
-    
-    if(newStep.showsControlSettings){
-        // actually alters the slider values
-        targetSynth.setAllParams(newTargetValues);
-        setAllSlidersToValues(newTargetValues);
-        box6D->setValues(newTargetValues);
-    }else{
-        
-        
-    }
-    
-    panel->setHintValues(newTargetValues);
-    box6D->setHintValues(newTargetValues);
-    
-    if(newStep.showsControlGuides){
-        // shows visual target lines on sliders (or target hand in VR)
-        
-        panel->showHint(true);
-        box6D->showHint(true);
-    }else{
-        panel->showHint(false);
-        box6D->showHint(false);
-    }
-    
-    
-    if(newStep.showsMatchResults){
-        // do something
-        //newStep->calculateResults();
-        TrainingTestResult result =
-            trainingScoreManager.getScoreForAnswer(candidateSynth.getAllParamValues(),
-                                                   newTargetValues,
-                                                   newStep.getTimeBetweenTicks());
-        
-        
-        //middlePanel->setLabel(result.displayText);
-        middlePanel->setColor(result.colorBand);
-        middlePanel->setText(result.displayText);
-        panel->setHintColor(result.colorBand);
-        panel->showHint(true);
-        middlePanel->show();
-    }else{
-        middlePanel->setText("");
-    }
-    
-    if(newStep.playsTarget){
-        targetSynth.setAllParams(newTargetValues);
-        targetSynth.trigger();
-    }
-    if(newStep.playsCandidate){
-        triggerCandidateSound();
-    }
-    
 }
 
 //-----------------------------------------------------------------------
@@ -286,3 +98,344 @@
     
 }
 //-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------
+void TrainingMessageOrganiser::onNextTick(int tickNumber){
+    static int showingCountdown = false;
+    cout << "TICK " << tickNumber << endl;
+    downCounter = 4 - tickNumber % 4;
+    
+    if (showingCountdown){
+        middlePanel->setColor(ofColor::white);
+        middlePanel->setText(ofToString(downCounter));
+    }
+    
+    // only first beat in bar is active one
+    if ( tickNumber % 4  != 0){
+        
+        return;
+    }
+    // load next target preset
+    
+    //Step newStep = sequenceController.getNextStep();
+    
+    /*
+     displayInstructions(newStep);
+     
+     if(newStep.isLastOfAll){
+     // do finished run stuff, show summary
+     candidateSynth.stopMetronome();
+     cout << "FINISHED BLOCK" << endl;
+     controlPanel->hide();
+     middlePanel->setColor(ofColor::white);
+     middlePanel->setText("FINISHED BLOCK");
+     return;
+     }
+     if(newStep.isLastOfRun){
+     // do finished run stuff, show summary
+     candidateSynth.stopMetronome();
+     cout << "FINISHED RUN" << endl;
+     controlPanel->hide();
+     middlePanel->setColor(ofColor::white);
+     middlePanel->setText("FINISHED RUN");
+     middlePanel->show();
+     return;
+     }
+     
+     candidateSynth.setMetroTime(newStep.getTimeBetweenTicks());
+     
+     if(newStep.showsCountDown){
+     // count in
+     showingCountdown = true;
+     middlePanel->show();
+     }else{
+     showingCountdown = false;
+     }
+     
+     Preset * currentTargetPreset;
+     
+     if(newStep.presetIndex >= 0 && newStep.presetIndex <= 8){
+     currentTargetPreset =  expPresetManager.getPresetAtIndex(newStep.presetIndex);
+     }else{
+     assert(newStep.type == Step::COUNT_IN);
+     // nothing happens here
+     return;
+     }
+     
+     vector<int> newTargetValues = currentTargetPreset->getValues();
+     debugVals(newTargetValues);
+     
+     if(newStep.hidesSliders){
+     controlPanel->hide();
+     middlePanel->setBackground(ofColor(255,0,0));
+     middlePanel->show();
+     }else{
+     controlPanel->show();
+     middlePanel->hide();
+     }
+     
+     if(newStep.showsTargetIcon){
+     bool showTick = true;
+     presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), showTick);
+     presetIconPanel->show();
+     box6D->setHintTexture(currentTargetPreset->getImage());
+     }else{
+     presetIconPanel->hide();
+     }
+     
+     if(newStep.allowsCandidateControl){
+     setCandidateAndSlidersToRandom();
+     controlPanel->setActive(true);
+     okToGetMidi = true;
+     }else{
+     controlPanel->setActive(false);
+     okToGetMidi = false;
+     }
+     
+     if(newStep.showsControlSettings){
+     // actually alters the slider values
+     targetSynth.setAllParams(newTargetValues);
+     setAllSlidersToValues(newTargetValues);
+     box6D->setValues(newTargetValues);
+     }else{
+     
+     
+     }
+     
+     controlPanel->setHintValues(newTargetValues);
+     box6D->setHintValues(newTargetValues);
+     
+     if(newStep.showsControlGuides){
+     // shows visual target lines on sliders (or target hand in VR)
+     
+     controlPanel->showHint(true);
+     box6D->showHint(true);
+     }else{
+     controlPanel->showHint(false);
+     box6D->showHint(false);
+     }
+     
+     
+     if(newStep.showsMatchResults){
+     // do something
+     //newStep->calculateResults();
+     TrainingTestResult result =
+     trainingScoreManager.getScoreForAnswer(candidateSynth.getAllParamValues(),
+     newTargetValues,
+     newStep.getTimeBetweenTicks());
+     
+     
+     //middlePanel->setLabel(result.displayText);
+     middlePanel->setColor(result.colorBand);
+     middlePanel->setText(result.displayText);
+     controlPanel->setHintColor(result.colorBand);
+     controlPanel->showHint(true);
+     middlePanel->show();
+     }else{
+     middlePanel->setText("");
+     }
+     
+     if(newStep.playsTarget){
+     targetSynth.setAllParams(newTargetValues);
+     targetSynth.trigger();
+     }
+     if(newStep.playsCandidate){
+     triggerCandidateSound();
+     }
+     */
+    
+}
+void TrainingMessageOrganiser::lastOfRun(){
+    candidateSynth.stopMetronome();
+    cout << "FINISHED RUN" << endl;
+    controlPanel->hide();
+    middlePanel->setColor(ofColor::white);
+    middlePanel->setText("FINISHED RUN");
+    middlePanel->show();
+}
+void TrainingMessageOrganiser::lastOfAll(){
+    candidateSynth.stopMetronome();
+    cout << "FINISHED RUN" << endl;
+    controlPanel->hide();
+    middlePanel->setColor(ofColor::white);
+    middlePanel->setText("FINISHED RUN");
+    middlePanel->show();
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::onNextTickAnim(int tickNumber){
+    
+    cout << "TICK " << tickNumber << endl;
+    downCounter = 4 - tickNumber % 4;
+    
+    updateCountdown(downCounter);
+    // only first beat in bar is active one (at the moment)
+    if ( tickNumber % 4  != 0) return;
+    
+    
+    AnimStep newStep = sequenceController.getNextStep();
+    
+    if(newStep.isLastOfAll){
+        lastOfAll();
+        return;
+    }
+    if(newStep.isLastOfRun){
+        lastOfRun();
+        return;
+    }
+    
+    candidateSynth.setMetroTime(newStep.getTimeBetweenTicks());
+    
+    switch (newStep.type){
+        case AnimStep::PREVIEW_NEUTRAL_COUNT :
+            previewNeutralCount(newStep);
+            break;
+        case AnimStep::PREVIEW_MOVE :
+            previewMove(newStep);
+            break;
+        case AnimStep::PREVIEW_HIT :
+            previewHit( newStep);
+            break;
+        case AnimStep::MATCHING_NEUTRAL_COUNT :
+            matchingNeutralCount( newStep);
+            break;
+        case AnimStep::MATCHING_MOVE :
+            matchingMove( newStep);
+            break;
+        case AnimStep::MATCHING_HIT :
+            matchingHit( newStep);
+            break;
+    }
+    
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::updateCountdown(int n){
+    
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::previewNeutralCount(AnimStep newStep){
+    Preset * currentTargetPreset;
+    
+    // show eveything at start?
+    showMyPanels();
+    // your 'hand' is hidden
+    controlPanel->showValueIndicators(false);
+    
+    
+    // guide is set to neutral values
+    currentTargetPreset = expPresetManager.getNeutralPreset();
+    vector<int> newTargetValues = currentTargetPreset->getValues();
+    presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), false);
+    presetIconPanel->show();
+    
+    controlPanel->setAndShowHint(newTargetValues, currentTargetPreset->getImage());
+
+    
+    targetSynth.setAllParams(newTargetValues);
+    candidateSynth.setAllParams(newTargetValues);
+    
+    displayInstructions("previewNeutralCount");
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::previewMove(AnimStep newStep){
+    Preset * currentTargetPreset;
+    currentTargetPreset =  expPresetManager.getPresetAtIndex(newStep.presetIndex);
+    vector<int> newTargetValues = currentTargetPreset->getValues();
+    
+    targetSynth.setAllParams(newTargetValues);
+    
+    presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), false);
+    presetIconPanel->show();
+    controlPanel->show();
+    // your hand is hidden
+    controlPanel->showValueIndicators(false);
+    // guide animates to next target
+
+    controlPanel->setAndShowHint(newTargetValues, currentTargetPreset->getImage());
+
+    displayInstructions("previewMove");
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::previewHit(AnimStep newStep){
+    Preset * currentTargetPreset;
+    currentTargetPreset =  expPresetManager.getPresetAtIndex(newStep.presetIndex);
+    vector<int> newTargetValues = currentTargetPreset->getValues();
+    
+    targetSynth.setAllParams(newTargetValues);
+    
+    // your hand hidden
+    controlPanel->showValueIndicators(false);
+    //
+    presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), false);
+    presetIconPanel->show();
+    
+    controlPanel->setAndShowHint(newTargetValues, currentTargetPreset->getImage());
+
+    
+    targetSynth.trigger();
+    
+    displayInstructions("Preview HIT");
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::matchingNeutralCount(AnimStep newStep){
+    Preset * currentTargetPreset = expPresetManager.getNeutralPreset();
+    vector<int> newTargetValues = currentTargetPreset->getValues();
+    // if showing guides show all the targets as transparent ghosts
+    if (newStep.showsGuides){
+        controlPanel->setAndShowHint(newTargetValues, currentTargetPreset->getImage());
+
+    }else{
+        controlPanel->showHint(false);
+    }
+    
+    // show your hand and allow movement
+    controlPanel->showValueIndicators(true);
+    okToGetMidi = true;
+    
+        displayInstructions("Match Count");
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::matchingMove(AnimStep newStep){
+    Preset * currentTargetPreset;
+    currentTargetPreset =  expPresetManager.getPresetAtIndex(newStep.presetIndex);
+    vector<int> newTargetValues = currentTargetPreset->getValues();
+    
+    targetSynth.setAllParams(newTargetValues);
+    
+    // if showing guides show all the targets as transparent ghosts
+    if (newStep.showsGuides){
+        presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), false);
+        presetIconPanel->show();
+        
+        controlPanel->setAndShowHint(newTargetValues, currentTargetPreset->getImage());
+    }
+    
+    // show your hand and allow movement
+    //controlPanel->showIndicator(true);
+    okToGetMidi = true;
+    
+    displayInstructions("Match MOVE");
+}
+//-----------------------------------------------------------------------------
+void TrainingMessageOrganiser::matchingHit(AnimStep newStep){
+    Preset * currentTargetPreset;
+    currentTargetPreset =  expPresetManager.getPresetAtIndex(newStep.presetIndex);
+    vector<int> newTargetValues = currentTargetPreset->getValues();
+    
+    if (newStep.showsGuides){
+        presetIconPanel->setTextAndImage(currentTargetPreset->name, currentTargetPreset->getImage(), false);
+        presetIconPanel->show();
+       
+        controlPanel->setAndShowHint(newTargetValues, currentTargetPreset->getImage());
+    }
+    
+    // show your hand and allow movement (so you can set off to next target??)
+    //box6D->showIndicator(true);
+    okToGetMidi = true;
+    
+    targetSynth.setAllParams(newTargetValues);
+    candidateSynth.trigger();
+    
+    displayInstructions("Match HIT");
+}
+
+//-----------------------------------------------------------------------------
\ No newline at end of file

--- a/UI code/6Dbox.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/6Dbox.h	Wed Oct 29 15:38:38 2014 +0000
@@ -38,7 +38,9 @@
     void setValues(vector<int> vals);
     
     void draw();
-    
+    void showValueIndicator(bool showing){
+        indicatorShowing = showing;
+    };
   
 private:
 
@@ -62,6 +64,7 @@
     float hw, hh, hl, scale;
     float hintRoll, hintPitch, hintYaw;
     float minAngVal, maxAngVal;
+    bool indicatorShowing;
 };
 
 

--- a/UI code/6Dbox.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/6Dbox.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -221,6 +221,8 @@
 }
 
 void Leap6DBox::draw(){
+    
+    ofEnableDepthTest();
     if(hidden)return;
     if(on){
         ofSetColor(foregroundHi);
@@ -251,6 +253,8 @@
     drawIndicator();
     ofPopMatrix();
     
+    ofDisableDepthTest();
+    
     drawLabels();
 };
 
@@ -263,10 +267,9 @@
     }
     
     // draw indicator
-    draw3DCrossHairs(xVal,yVal,zVal, indicatorColor);
-    // put light in indicateor
-    //
-    
+    if(indicatorShowing){
+        draw3DCrossHairs(xVal,yVal,zVal, indicatorColor);
+    }
     
     if (hintShowing && hintZ <= zVal){
         hintColor = calculateHintColor();

--- a/UI code/ButtronSlider.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/ButtronSlider.h	Wed Oct 29 15:38:38 2014 +0000
@@ -37,8 +37,10 @@
     void init();
     void draw(){
         Buttron::draw();
+        ofDisableDepthTest();
         drawIndicator(value);
         if(hintShowing) drawHintIndicator();
+        ofEnableDepthTest();
     }
     
     void setHintValue(double hval){
@@ -63,7 +65,9 @@
         // scale appropriately to 0-1   (maxVal - minVal)*prop + minVal
         value =  (avalue - minVal)/(maxVal - minVal);
     };
-
+    void showValueIndicator(bool show){
+        indicatorShowing = show;
+    }
     virtual bool handleMyTouch(int x, int y, touchType ttype, int touchID);
     
     void setRange(float lo, float hi){
@@ -80,6 +84,7 @@
     float value; // [0. 1.]
     float hintValue;
     bool hintShowing;
+    bool indicatorShowing;
     ofColor hintColor;
 };
 

--- a/UI code/ButtronSlider.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/ButtronSlider.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -49,6 +49,7 @@
 // 
 //---------------------------------------------------------------------
 void ButtronSlider::drawIndicator(double proportion){
+    if(!indicatorShowing) return;
     if(on){
         ofSetColor(foregroundHi);
     }else{

--- a/UI code/UIElement.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/UIElement.h	Wed Oct 29 15:38:38 2014 +0000
@@ -116,25 +116,6 @@
         setZLayer(e->getZLayer() + 1);
     }
 protected:
-    
-    float x;
-    float y;
-    float width;
-    float height;
-    bool on;
-    int myParamID;
-    list<int> myTouchIDs;
-    
-    ofColor background;
-    
-    string labelName;
-    ofTrueTypeFont verdana16;
-    ofTrueTypeFont bigFont;
-    ofTrueTypeFont smallFont;
-    controllerType myType;
-    
-    bool hidden; // don't draw dont touch
-    bool inactive;  // dont touch, draw dimmed
 
     void init();
     
@@ -171,5 +152,27 @@
     
     int zLayer;
     
+// protected members:
+    
+    float x;
+    float y;
+    float width;
+    float height;
+    bool on;
+    int myParamID;
+    list<int> myTouchIDs;
+    
+    ofColor background;
+    
+    string labelName;
+    ofTrueTypeFont verdana16;
+    ofTrueTypeFont bigFont;
+    ofTrueTypeFont smallFont;
+    controllerType myType;
+    
+    bool hidden; // don't draw dont touch
+    bool inactive;  // dont touch, draw dimmed
+
+    
 };
 #endif /* defined(__emptyExample__UIElement__) */

--- a/UI code/sliderPanel.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/sliderPanel.h	Wed Oct 29 15:38:38 2014 +0000
@@ -22,8 +22,11 @@
 #include "ButtronXY.h"
 #include "3Dbox.h"
 #include "3DboxGL.h"
+#include "6Dbox.h"
 #include "ButtronSlider.h"
 // panel with sliders and xy pads
+
+// AND 6DOF BOXES !!!!!
 class SliderPanel : public UIElementContainer{
     
 public:
@@ -33,80 +36,25 @@
                 float aheight,
                 const UIProps& aprops,
                 vector<controllerType> elemList);
-    //------------------------
-    void showHint(bool value){
-        vector<UIElement *>::iterator UIitr;
-        for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-            
-            ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
-            thisSlider->showHint(value);
-        }
-    }
+ 
+    void setAndShowHint(vector<int> values, ofImage* texture);
+    
+    void showHint(bool value);
     //
-    void setHintValues(vector<int> vals){
-        int i = 0;
-        for(auto UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-            ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
-            thisSlider->setHintValue(vals[i]);
-            i++;
-        }
-    }
-    void setHintColor(ofColor c){
-        vector<UIElement *>::iterator UIitr;
-        for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-            (*UIitr)->setHintColor(c);
-        }
-    }
-    void setSliderColors(ofColor c){
-        for(auto UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-            ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
-            thisSlider->setColor(c);
-        }
-    }
-    //------------------------
-    void flash(){
-        // turn hilight on and off
-        if (!flashing){
-            vector<UIElement *>::iterator UIitr;
-            for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-                (*UIitr)->setHighlight(true);
-            }
-            // set up timer
-            TimerCallbackFunction tcb;
-            tcb = boost::bind(&SliderPanel::flash, this);
-            timeController.scheduleEvent(tcb, 250);
-            flashing = true;
-        }else{
-            vector<UIElement *>::iterator UIitr;
-            for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-                (*UIitr)->setHighlight(false);
-            }
-            flashing = false;
-        }
-        
-    }
-    //------------------------
-    void setBgColor(ofColor c){
-        vector<UIElement *>::iterator UIitr;
-        for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
-            (*UIitr)->setColor(c);
-        }
-    }
-    //------------------------
+    void setHintValues(vector<int> vals);
+    void setHintColor(ofColor c);
+    void setSliderColors(ofColor c);
+    void flash();
+    void setBgColor(ofColor c);
     vector<UIElement*> generateControls(vector<controllerType> elemList, controlPanelType panelType);
-    //------------------------
-    UIElement* getSlider(int index){
-        if (index < subElements.size()){
-            return subElements[index];
-        }else{
-            cout << "ERROR: index too big for sldiers" << endl;
-            return NULL;
-        }
-    };
-    // TODO override touch thing to make revisitable
+
+    UIElement* getSlider(int index);
+    void setHintTexture(ofImage* texture);
+
+    void showValueIndicators(bool show);
 private:
     bool flashing;
-    controlPanelType panelType;
+    controlPanelType thisPanelType;
 };
 
 #endif /* defined(__tweakathlon__sliderPanel__) */

--- a/UI code/sliderPanel.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/UI code/sliderPanel.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -21,8 +21,115 @@
 
     // generateControls(elemList);// called from messageorganiser
 }
+//--------------------------------------------------------------------------------
 
-// NOT GENERIC
+void SliderPanel::showHint(bool value){
+    if (thisPanelType == ALL_SLIDERS){
+        vector<UIElement *>::iterator UIitr;
+        for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+            
+            
+            ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
+            thisSlider->showHint(value);
+        }
+    }else if(thisPanelType == LEAP6DOF){
+        if (subElements[0]->getType() == LEAP6D){
+            Leap6DBox * box = (Leap6DBox*)subElements[0];
+            
+            box->showHint(value);
+        }
+    }
+}
+//------------------------
+void SliderPanel::setHintColor(ofColor c){
+    vector<UIElement *>::iterator UIitr;
+    for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+        (*UIitr)->setHintColor(c);
+    }
+}
+//------------------------
+void SliderPanel::setSliderColors(ofColor c){
+    for(auto UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+        ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
+        thisSlider->setColor(c);
+    }
+}
+//------------------------
+void SliderPanel::flash(){
+    // turn hilight on and off
+    if (!flashing){
+        vector<UIElement *>::iterator UIitr;
+        for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+            (*UIitr)->setHighlight(true);
+        }
+        // set up timer
+        TimerCallbackFunction tcb;
+        tcb = boost::bind(&SliderPanel::flash, this);
+        timeController.scheduleEvent(tcb, 250);
+        flashing = true;
+    }else{
+        vector<UIElement *>::iterator UIitr;
+        for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+            (*UIitr)->setHighlight(false);
+        }
+        flashing = false;
+    }
+    
+}
+//------------------------
+void SliderPanel::setBgColor(ofColor c){
+    vector<UIElement *>::iterator UIitr;
+    for(UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+        (*UIitr)->setColor(c);
+    }
+}
+//------------------------
+//------------------------
+UIElement* SliderPanel::getSlider(int index){
+    if (index < subElements.size()){
+        return subElements[index];
+    }else{
+        cout << "ERROR: index too big for sldiers" << endl;
+        return NULL;
+    }
+};
+//------------------------
+void SliderPanel::showValueIndicators(bool show){
+    
+    
+    if (thisPanelType == LEAP6DOF){ // yeuch
+        if (subElements[0]->getType() == LEAP6D){
+            Leap6DBox * box = (Leap6DBox*)subElements[0];
+            
+            box->showValueIndicator(show);
+        }
+        
+    }else if(thisPanelType == ALL_SLIDERS){
+        for(auto UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+            ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
+            thisSlider->showValueIndicator(show);
+        }
+    }
+}
+//------------------------
+void SliderPanel::setHintValues(vector<int> vals){
+    if (thisPanelType == LEAP6DOF){ // yeuch
+        if (subElements[0]->getType() == LEAP6D){
+            Leap6DBox * box = (Leap6DBox*)subElements[0];
+            
+            box->setHintValues(vals);
+        }
+    }else if(thisPanelType == ALL_SLIDERS){
+    int i = 0;
+    for(auto UIitr = subElements.begin(); UIitr < subElements.end(); UIitr++){
+        ButtronSlider* thisSlider = (ButtronSlider *)(*UIitr);
+        thisSlider->setHintValue(vals[i]);
+        i++;
+    }
+    }
+}
+
+
 //-----------------------------------------------------------------------------
 vector<UIElement*> SliderPanel::generateControls(vector<controllerType> elemList, controlPanelType panelType){
     removeAllSubelements();
@@ -82,6 +189,16 @@
             
             subElements.push_back(l3d);
             n++;
+        }else if(*i == LEAP6D){
+            // add a threed box
+            float c = x+width*0.5;
+            float left = c - myProps.XYsize;
+
+            Leap6DBox * l6d = new Leap6DBox(left , top+50 , myProps.XYsize*0.75,myProps.XYsize*0.75,150,50, myProps);
+
+            
+            subElements.push_back(l6d);
+            n++;
         
         }else{
             cout << "ERROR: slider panel only handles xy pads and sliders" << endl;
@@ -89,11 +206,29 @@
         
 
     }
-    
+    thisPanelType = panelType;
     autoArrangeRow(); // will set positions
     
 
 
     return subElements;
 }
+//-----------------------------------------------------------------------
+void SliderPanel::setAndShowHint(vector<int> values, ofImage* texture){
+    setHintValues(values);
+    setHintTexture(texture);
+    showHint(true);
 
+}
+//------------------------------------------
+void SliderPanel::setHintTexture(ofImage* texture){
+    if (thisPanelType == LEAP6DOF){ // yeuch
+        if (subElements[0]->getType() == LEAP6D){
+            Leap6DBox * box = (Leap6DBox*)subElements[0];
+            
+            box->setHintTexture(texture);
+        }
+        
+    }
+}
+

--- a/algorithms.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/algorithms.h	Wed Oct 29 15:38:38 2014 +0000
@@ -20,10 +20,6 @@
     return vec;
 }
 
-void randomise(int& n){
-    n = ofRandom(0,127);
-    
-}
 
 //-------------------------------------------------------------
 //-------------------------------------------------------------

--- a/globalVariables.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/globalVariables.h	Wed Oct 29 15:38:38 2014 +0000
@@ -36,8 +36,8 @@
 
 typedef enum {FAMILIARISATION, EXPRESS, TRAINING, SEARCH} testStages;
 
-typedef enum {SLIDER, XYPAD, BUTTON, LEAP3D} controllerType;
-typedef enum {SEQUENTIAL, REVISITABLE, SIMULTANEOUS, MULTI_SIMPLE, MULTI_COMPLEX} controlPanelType;
+typedef enum {SLIDER, XYPAD, BUTTON, LEAP3D, LEAP6D} controllerType;
+typedef enum {SEQUENTIAL, REVISITABLE, SIMULTANEOUS, MULTI_SIMPLE, MULTI_COMPLEX, ALL_SLIDERS, LEAP6DOF} controlPanelType;
 
 typedef enum {FILL,LINE, BLOB} SliderType;
 

--- a/presetManager.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/presetManager.h	Wed Oct 29 15:38:38 2014 +0000
@@ -38,6 +38,8 @@
     //bool isFilled;
     PresetIconView* iconView;
     // from save button press
+    Preset(){};
+    
     Preset(vector<int> aCCValues,
            string aname,
            int aID,
@@ -141,6 +143,7 @@
     void exitAndSaveAll(); // save stuff to the json file
     void printAll();
     void clearAll();
+    Preset* getNeutralPreset();
     
     Preset* getPresetAtIndex(int index);
     int getNumberOfPresets(){return thePresets.size();};
@@ -150,13 +153,15 @@
     int timesOpened;
     bool presetAlertShowing;
     void showOverwriteDialog();
-    vector<Preset *> thePresets; 
+    vector<Preset *> thePresets;
+
 
     Json::Value  allPresetsToJson();
     void loadPresetsFromJsonFile(const string &jsonFile);
     void updatePresetFile();
     void showNameDialog();
     
+    Preset neutralPreset;
 };
 
     

--- a/presetManager.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/presetManager.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -45,6 +45,22 @@
     
     cout << "ofGetTimestampString: " << ts << '\n';
 }
+//-------------------------------------------------------------------------
+Preset* PresetManager::getNeutralPreset(){
+    
+    vector<int> middleVals;
+    for(int i = 0; i < TOTAL_NUM_PARAMS ; i++){
+        middleVals.push_back(64);
+    }
+    neutralPreset = Preset(middleVals,
+                       "Neutral",
+                       999,
+                       "whocares",
+                       999,
+                       "buttron.png");
+    
+    return &neutralPreset;
+}
 //---------------------------------------------------------------------------
 Json::Value PresetManager::allPresetsToJson(){
     Json::Value root;
@@ -205,6 +221,7 @@
     
     if (index >= thePresets.size()){
         cout << "ERROR: index " << index << " exceeds number of presets " << thePresets.size() << endl;
+        cout << " YOU HAVENT DONE EXP STAGE??" << endl;
         return NULL;
     }else{
         return thePresets[index];

--- a/testApp.h	Tue Oct 28 19:15:28 2014 +0000
+++ b/testApp.h	Wed Oct 29 15:38:38 2014 +0000
@@ -126,7 +126,7 @@
     void helpHidden();
     void setupNewUser();
     void appModeChange(interfaceType mode);
-
+    void interfaceSelected(int interfaceSelection);
     void sendParametersToPD();
     
     void sendMidiParams();
@@ -175,6 +175,7 @@
     void rotateToLandscapeRight(){};
     void toggleAutoRotation(){};
 
+    controlPanelType whichInterfaceAreWeUsing;
 };
 
 // should be off split into

--- a/testApp.mm	Tue Oct 28 19:15:28 2014 +0000
+++ b/testApp.mm	Wed Oct 29 15:38:38 2014 +0000
@@ -40,6 +40,7 @@
     ofEnableDepthTest();
     glEnable(GL_DEPTH_TEST);
 //    ofEnableAlphaBlending();
+    whichInterfaceAreWeUsing = ALL_SLIDERS;
 
 
     //--------------------------------------
@@ -66,7 +67,6 @@
     }
     paused = false;
     
-    
     eventLogger.logEvent(APP_LOADED);
 
     ofSoundStreamStart();
@@ -265,12 +265,12 @@
     controlPanel->showBorder(true);
     controlPanel->hide();
     
-    Leap6DBox * box = new Leap6DBox(400 , 210 , (*props).XYsize*0.75,(*props).XYsize*0.75,150,50, *props);
-    searchMessageOrganiser.setBox(box);
-    trainingMessageOrganiser.setBox(box);
-    expMessageOrganiser.setBox(box);
-    UIElements.push_back(box);
-    box->show();
+//    Leap6DBox * box = new Leap6DBox(400 , 210 , (*props).XYsize*0.75,(*props).XYsize*0.75,150,50, *props);
+//    searchMessageOrganiser.setBox(box);
+//    trainingMessageOrganiser.setBox(box);
+//    expMessageOrganiser.setBox(box);
+//    UIElements.push_back(box);
+//    box->show();
 }
 //--------------------------------------------------------------
 void testApp::setupUIElements(){
@@ -441,6 +441,14 @@
     }
     
 }
+//-------------------------------
+void testApp::interfaceSelected(int interfaceSelection){
+    if (interfaceSelection == 0){
+        whichInterfaceAreWeUsing = ALL_SLIDERS;
+    }else{
+        whichInterfaceAreWeUsing = LEAP6DOF;
+    }
+}
 //--------------------------------------------------------------
 void testApp::usernameEntered(){
 
@@ -457,11 +465,11 @@
     // do countdown etc
     
     trainingMessageOrganiser.hideMyPanels();
-    searchMessageOrganiser.hideMyPanels();
-    expMessageOrganiser.setup();
-    //expMessageOrganiser.showMyPanels();
-    // TODO how is testApp going to kknow whichInterfaceShowing ???
+    //searchMessageOrganiser.hideMyPanels();
+    expMessageOrganiser.setup(whichInterfaceAreWeUsing);
     
+    expMessageOrganiser.showMyPanels();
+
     currentStage = EXPRESS;
     
 }
@@ -479,7 +487,7 @@
 void testApp::startTheTrainingTests(){
     eventLogger.logEvent(START_THE_TRAINING_TESTS);
     
-    trainingMessageOrganiser.setupDefaultMapping();
+    trainingMessageOrganiser.setup(whichInterfaceAreWeUsing);
     trainingMessageOrganiser.showMyPanels();
     currentStage = TRAINING;
 }