X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=Presets.pde;fp=Presets.pde;h=91598ac2078e04dff0f2805575ddd77bd96bfee2;hb=cc9e8c8be45767207e09c434bad100b0156877e6;hp=0000000000000000000000000000000000000000;hpb=fdb2c3cbacdba5d9527712ef7f75decea919ab32;p=SugarCubes.git

diff --git a/Presets.pde b/Presets.pde
new file mode 100644
index 0000000..91598ac
--- /dev/null
+++ b/Presets.pde
@@ -0,0 +1,229 @@
+interface PresetListener {
+  public void onPresetSelected(LXDeck deck, Preset preset);
+  public void onPresetStored(LXDeck deck, Preset preset);
+  public void onPresetDirty(LXDeck deck, Preset preset);
+}
+
+class PresetManager {
+  
+  public static final int NUM_PRESETS = 8;
+  public static final String FILENAME = "data/presets.txt";
+  public static final String DELIMITER = "\t";
+  
+  class DeckState implements LXParameterListener {
+    
+    final LXDeck deck;
+    LXPattern selectedPattern = null;    
+    Preset selectedPreset = null;
+    boolean isDirty = false;
+
+    DeckState(LXDeck deck) {
+      this.deck = deck;
+      deck.addListener(new LXDeck.AbstractListener() {
+        public void patternDidChange(LXDeck deck, LXPattern pattern) {
+          if (selectedPattern != pattern) {
+            onDirty();
+          }
+        }
+      });
+    }
+
+    private void onSelect(Preset preset, LXPattern pattern) {
+      if ((selectedPattern != pattern) && (selectedPattern != null)) {
+        for (LXParameter p : selectedPattern.getParameters()) {
+          ((LXListenableParameter) p).removeListener(this);
+        }
+      }
+      selectedPreset = preset;
+      selectedPattern = pattern;
+      isDirty = false;
+      for (LXParameter p : pattern.getParameters()) {
+        ((LXListenableParameter) p).addListener(this);
+      }
+      for (PresetListener listener : listeners) {
+        listener.onPresetSelected(deck, preset);
+      }
+    }
+    
+    private void onStore(Preset preset, LXPattern pattern) {
+      selectedPreset = preset;
+      selectedPattern = pattern;
+      isDirty = false;
+      for (PresetListener listener : listeners) {
+        listener.onPresetStored(deck, preset);
+      }
+    }
+    
+    private void onDirty() {
+      if (selectedPreset != null) {
+        isDirty = true;
+        for (PresetListener listener : listeners) {
+          listener.onPresetDirty(deck, selectedPreset);
+        }
+      }
+    }
+    
+    public void onParameterChanged(LXParameter parameter) {
+      onDirty();
+    }
+  }
+  
+  private final DeckState[] deckState = new DeckState[lx.engine.getDecks().size()];
+  private final Preset[] presets = new Preset[NUM_PRESETS];
+  private final List<PresetListener> listeners = new ArrayList<PresetListener>();
+  
+  PresetManager() {
+    for (int i = 0; i < presets.length; ++i) {
+      presets[i] = new Preset(this, i);
+    }
+    String[] values = loadStrings(FILENAME);
+    if (values == null) {
+      write();
+    } else {
+      int i = 0;
+      for (String serialized : values) {
+        presets[i++].load(serialized);
+        if (i >= NUM_PRESETS) {
+          break;
+        }
+      }
+    }
+    for (LXDeck deck : lx.engine.getDecks()) {
+      deckState[deck.index] = new DeckState(deck);
+    }
+  }
+  
+  public void addListener(PresetListener listener) {
+    listeners.add(listener);
+  }
+  
+  public void select(LXDeck deck, int index) {
+    presets[index].select(deck);
+  }
+
+  public void store(LXDeck deck, int index) {
+    presets[index].store(deck);
+  }
+  
+  public void dirty(LXDeck deck) {
+    deckState[deck.index].onDirty();
+  }
+  
+  public void dirty(LXPattern pattern) {
+    dirty(pattern.getDeck());
+  }
+
+  public void onStore(LXDeck deck, Preset preset, LXPattern pattern) {
+    deckState[deck.index].onStore(preset, pattern);
+  }
+  
+  public void onSelect(LXDeck deck, Preset preset, LXPattern pattern) {
+    deckState[deck.index].onSelect(preset, pattern);
+  }
+    
+  public void write() {
+    String[] lines = new String[NUM_PRESETS];
+    int i = 0;
+    for (Preset preset : presets) {
+      lines[i++] = preset.serialize(); 
+    }
+    saveStrings(FILENAME, lines);
+  }
+}
+
+class Preset {
+  
+  final PresetManager manager;
+  final int index;
+  
+  String className;
+  final Map<String, Float> parameters = new HashMap<String, Float>();
+  
+  Preset(PresetManager manager, int index) {
+    this.manager = manager;
+    this.index = index;
+  }
+  
+  public void load(String serialized) {
+    className = null;
+    parameters.clear();
+    try {
+      String[] parts = serialized.split(PresetManager.DELIMITER);
+      className = parts[0];
+      int i = 1;
+      while (i < parts.length - 1) {
+        parameters.put(parts[i], Float.parseFloat(parts[i+1]));
+        i += 2;
+      }
+    } catch (Exception x) {
+      className = null;
+      parameters.clear();
+    }
+  }
+  
+  public String serialize() {
+    if (className == null) {
+      return "null";
+    }
+    String val = className + PresetManager.DELIMITER;
+    for (String pKey : parameters.keySet()) {
+      val += pKey + PresetManager.DELIMITER + parameters.get(pKey) + PresetManager.DELIMITER;
+    }
+    return val;
+  }
+  
+  public void store(LXDeck deck) {
+    LXPattern pattern = deck.getActivePattern();
+    className = pattern.getClass().getName();
+    parameters.clear();
+    for (LXParameter p : pattern.getParameters()) {
+      parameters.put(p.getLabel(), p.getValuef());
+    }
+    if (pattern instanceof DPat) {
+      DPat dpattern = (DPat) pattern;
+      for (DBool bool : dpattern.bools) {
+        parameters.put(bool.tag, bool.b ? 1.f : 0.f);
+      }
+      for (Pick pick : dpattern.picks) {
+        parameters.put(pick.tag, pick.CurRow + pick.CurCol/100.f);
+      }
+    }
+    manager.write();
+    manager.onStore(deck, this, pattern);
+  }
+  
+  public void select(LXDeck deck) {
+    for (LXPattern pattern : deck.getPatterns()) {
+      if (pattern.getClass().getName().equals(className)) {
+        for (String pLabel : parameters.keySet()) {
+          for (LXParameter p : pattern.getParameters()) {
+            if (p.getLabel().equals(pLabel)) {
+              p.setValue(parameters.get(pLabel));
+            }
+          }
+          if (pattern instanceof DPat) {
+            DPat dpattern = (DPat) pattern;
+            for (DBool bool : dpattern.bools) {
+              if (bool.tag.equals(pLabel)) {
+                bool.set(bool.row, bool.col, parameters.get(pLabel) > 0);
+              }
+            }
+            for (Pick pick : dpattern.picks) {
+              if (pick.tag.equals(pLabel)) {
+                float f = parameters.get(pLabel);
+                pick.set((int) floor(f), (int) round((f%1)*100.));
+              }
+            }
+          }
+        }
+        deck.goPattern(pattern);
+        if (pattern instanceof DPat) {
+          ((DPat)pattern).updateLights();
+        }
+        manager.onSelect(deck, this, pattern);
+        break;
+      }
+    }
+  }
+}
+